@proto-kit/protocol 0.1.1-develop.153

package/dist/model/network/NetworkState.d.ts

@@ -0,0 +1,64 @@
+import { Field, UInt64 } from "snarkyjs";
+declare const CurrentBlock_base: (new (value: {
+    height: UInt64;
+}) => {
+    height: UInt64;
+}) & {
+    _isStruct: true;
+} & import("snarkyjs/dist/node/snarky").ProvablePure<{
+    height: UInt64;
+}> & {
+    toInput: (x: {
+        height: UInt64;
+    }) => {
+        fields?: import("snarkyjs/dist/node/lib/field").Field[] | undefined;
+        packed?: [import("snarkyjs/dist/node/lib/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        height: UInt64;
+    }) => {
+        height: string;
+    };
+    fromJSON: (x: {
+        height: string;
+    }) => {
+        height: UInt64;
+    };
+};
+export declare class CurrentBlock extends CurrentBlock_base {
+}
+declare const NetworkState_base: (new (value: {
+    block: CurrentBlock;
+}) => {
+    block: CurrentBlock;
+}) & {
+    _isStruct: true;
+} & import("snarkyjs/dist/node/snarky").ProvablePure<{
+    block: CurrentBlock;
+}> & {
+    toInput: (x: {
+        block: CurrentBlock;
+    }) => {
+        fields?: import("snarkyjs/dist/node/lib/field").Field[] | undefined;
+        packed?: [import("snarkyjs/dist/node/lib/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        block: CurrentBlock;
+    }) => {
+        block: {
+            height: string;
+        };
+    };
+    fromJSON: (x: {
+        block: {
+            height: string;
+        };
+    }) => {
+        block: CurrentBlock;
+    };
+};
+export declare class NetworkState extends NetworkState_base {
+    hash(): Field;
+}
+export {};
+//# sourceMappingURL=NetworkState.d.ts.map

package/dist/model/network/NetworkState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NetworkState.d.ts","sourceRoot":"","sources":["../../../src/model/network/NetworkState.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAoB,MAAM,EAAE,MAAM,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE3D,qBAAa,YAAa,SAAQ,iBAEhC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,YAAa,SAAQ,iBAEhC;IACO,IAAI,IAAI,KAAK;CAKrB"}

package/dist/model/network/NetworkState.js

@@ -0,0 +1,14 @@
+import { Poseidon, Struct, UInt64 } from "snarkyjs";
+export class CurrentBlock extends Struct({
+    height: UInt64,
+}) {
+}
+export class NetworkState extends Struct({
+    block: CurrentBlock,
+}) {
+    hash() {
+        return Poseidon.hash([
+            ...CurrentBlock.toFields(this.block)
+        ]);
+    }
+}

package/dist/model/transaction/ProtocolTransaction.d.ts

@@ -0,0 +1,70 @@
+import { Bool, Field, PublicKey, Signature, UInt64 } from "snarkyjs";
+declare const ProtocolTransaction_base: (new (value: {
+    methodId: import("snarkyjs/dist/node/lib/field").Field;
+    nonce: UInt64;
+    sender: PublicKey;
+    argsHash: import("snarkyjs/dist/node/lib/field").Field;
+    signature: Signature;
+}) => {
+    methodId: import("snarkyjs/dist/node/lib/field").Field;
+    nonce: UInt64;
+    sender: PublicKey;
+    argsHash: import("snarkyjs/dist/node/lib/field").Field;
+    signature: Signature;
+}) & {
+    _isStruct: true;
+} & import("snarkyjs/dist/node/snarky").ProvablePure<{
+    methodId: import("snarkyjs/dist/node/lib/field").Field;
+    nonce: UInt64;
+    sender: PublicKey;
+    argsHash: import("snarkyjs/dist/node/lib/field").Field;
+    signature: Signature;
+}> & {
+    toInput: (x: {
+        methodId: import("snarkyjs/dist/node/lib/field").Field;
+        nonce: UInt64;
+        sender: PublicKey;
+        argsHash: import("snarkyjs/dist/node/lib/field").Field;
+        signature: Signature;
+    }) => {
+        fields?: import("snarkyjs/dist/node/lib/field").Field[] | undefined;
+        packed?: [import("snarkyjs/dist/node/lib/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        methodId: import("snarkyjs/dist/node/lib/field").Field;
+        nonce: UInt64;
+        sender: PublicKey;
+        argsHash: import("snarkyjs/dist/node/lib/field").Field;
+        signature: Signature;
+    }) => {
+        methodId: string;
+        nonce: string;
+        sender: string;
+        argsHash: string;
+        signature: any;
+    };
+    fromJSON: (x: {
+        methodId: string;
+        nonce: string;
+        sender: string;
+        argsHash: string;
+        signature: any;
+    }) => {
+        methodId: import("snarkyjs/dist/node/lib/field").Field;
+        nonce: UInt64;
+        sender: PublicKey;
+        argsHash: import("snarkyjs/dist/node/lib/field").Field;
+        signature: Signature;
+    };
+};
+export declare class ProtocolTransaction extends ProtocolTransaction_base {
+    static getSignatureData(args: {
+        methodId: Field;
+        nonce: UInt64;
+        argsHash: Field;
+    }): Field[];
+    getSignatureData(): Field[];
+    validateSignature(): Bool;
+}
+export {};
+//# sourceMappingURL=ProtocolTransaction.d.ts.map

package/dist/model/transaction/ProtocolTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtocolTransaction.d.ts","sourceRoot":"","sources":["../../../src/model/transaction/ProtocolTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,EAAU,MAAM,EAAE,MAAM,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE7E,qBAAa,mBAAoB,SAAQ,wBAMvC;WACc,gBAAgB,CAAC,IAAI,EAAE;QACnC,QAAQ,EAAE,KAAK,CAAC;QAChB,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,KAAK,CAAC;KACjB,GAAG,KAAK,EAAE;IAIJ,gBAAgB,IAAI,KAAK,EAAE;IAI3B,iBAAiB,IAAI,IAAI;CAGjC"}

package/dist/model/transaction/ProtocolTransaction.js

@@ -0,0 +1,18 @@
+import { Field, PublicKey, Signature, Struct, UInt64 } from "snarkyjs";
+export class ProtocolTransaction extends Struct({
+    methodId: Field,
+    nonce: UInt64,
+    sender: PublicKey,
+    argsHash: Field,
+    signature: Signature,
+}) {
+    static getSignatureData(args) {
+        return [args.methodId, ...args.nonce.toFields(), args.argsHash];
+    }
+    getSignatureData() {
+        return ProtocolTransaction.getSignatureData(this);
+    }
+    validateSignature() {
+        return this.signature.verify(this.sender, this.getSignatureData());
+    }
+}

package/dist/model/transaction/RuntimeTransaction.d.ts

@@ -0,0 +1,55 @@
+import { Field, PublicKey, UInt64 } from "snarkyjs";
+import { ProtocolTransaction } from "./ProtocolTransaction";
+declare const RuntimeTransaction_base: (new (value: {
+    nonce: UInt64;
+    sender: PublicKey;
+    argsHash: import("snarkyjs/dist/node/lib/field").Field;
+}) => {
+    nonce: UInt64;
+    sender: PublicKey;
+    argsHash: import("snarkyjs/dist/node/lib/field").Field;
+}) & {
+    _isStruct: true;
+} & import("snarkyjs/dist/node/snarky").ProvablePure<{
+    nonce: UInt64;
+    sender: PublicKey;
+    argsHash: import("snarkyjs/dist/node/lib/field").Field;
+}> & {
+    toInput: (x: {
+        nonce: UInt64;
+        sender: PublicKey;
+        argsHash: import("snarkyjs/dist/node/lib/field").Field;
+    }) => {
+        fields?: import("snarkyjs/dist/node/lib/field").Field[] | undefined;
+        packed?: [import("snarkyjs/dist/node/lib/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        nonce: UInt64;
+        sender: PublicKey;
+        argsHash: import("snarkyjs/dist/node/lib/field").Field;
+    }) => {
+        nonce: string;
+        sender: string;
+        argsHash: string;
+    };
+    fromJSON: (x: {
+        nonce: string;
+        sender: string;
+        argsHash: string;
+    }) => {
+        nonce: UInt64;
+        sender: PublicKey;
+        argsHash: import("snarkyjs/dist/node/lib/field").Field;
+    };
+};
+/**
+ * This struct is used to expose transaction information to the runtime method
+ * execution. This class has not all data included in transactions on purpose.
+ * For example, we don't want to expose the signature or args as fields.
+ */
+export declare class RuntimeTransaction extends RuntimeTransaction_base {
+    static fromProtocolTransaction({ nonce, sender, argsHash, }: ProtocolTransaction): RuntimeTransaction;
+    hash(): Field;
+}
+export {};
+//# sourceMappingURL=RuntimeTransaction.d.ts.map

package/dist/model/transaction/RuntimeTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuntimeTransaction.d.ts","sourceRoot":"","sources":["../../../src/model/transaction/RuntimeTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAY,SAAS,EAAU,MAAM,EAAE,MAAM,UAAU,CAAC;AAEtE,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE5D;;;;GAIG;AACH,qBAAa,kBAAmB,SAAQ,uBAItC;WACc,uBAAuB,CAAC,EACpC,KAAK,EACL,MAAM,EACN,QAAQ,GACT,EAAE,mBAAmB,GAAG,kBAAkB;IAQpC,IAAI,IAAI,KAAK;CAOrB"}

package/dist/model/transaction/RuntimeTransaction.js

@@ -0,0 +1,26 @@
+import { Field, Poseidon, PublicKey, Struct, UInt64 } from "snarkyjs";
+/**
+ * This struct is used to expose transaction information to the runtime method
+ * execution. This class has not all data included in transactions on purpose.
+ * For example, we don't want to expose the signature or args as fields.
+ */
+export class RuntimeTransaction extends Struct({
+    nonce: UInt64,
+    sender: PublicKey,
+    argsHash: Field,
+}) {
+    static fromProtocolTransaction({ nonce, sender, argsHash, }) {
+        return new RuntimeTransaction({
+            nonce,
+            sender,
+            argsHash,
+        });
+    }
+    hash() {
+        return Poseidon.hash([
+            ...this.nonce.toFields(),
+            ...this.sender.toFields(),
+            this.argsHash,
+        ]);
+    }
+}

package/dist/protocol/Protocol.d.ts

@@ -0,0 +1,37 @@
+import { ModuleContainer, ModulesRecord, StringKeyOf, TypedClass } from "@proto-kit/common";
+import { DependencyContainer } from "tsyringe";
+import { BlockProvable, BlockProverPublicInput, BlockProverPublicOutput } from "../prover/block/BlockProvable";
+import { StateTransitionProver } from "../prover/statetransition/StateTransitionProver";
+import { StateTransitionProvable, StateTransitionProverPublicInput, StateTransitionProverPublicOutput } from "../prover/statetransition/StateTransitionProvable";
+import { BlockProver } from "../prover/block/BlockProver";
+import { ProtocolModule } from "./ProtocolModule";
+export type GenericProtocolModuleRecord = ModulesRecord<TypedClass<ProtocolModule<any, any>>>;
+interface BlockProverType extends ProtocolModule<BlockProverPublicInput, BlockProverPublicOutput>, BlockProvable {
+}
+interface StateTransitionProverType extends ProtocolModule<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>, StateTransitionProvable {
+}
+export interface ProtocolCustomModulesRecord {
+    BlockProver: TypedClass<BlockProverType>;
+    StateTransitionProver: TypedClass<StateTransitionProverType>;
+}
+export interface ProtocolModulesRecord extends GenericProtocolModuleRecord, ProtocolCustomModulesRecord {
+}
+export interface ProtocolDefinition<Modules extends ProtocolModulesRecord> {
+    modules: Modules;
+}
+export declare class Protocol<Modules extends ProtocolModulesRecord> extends ModuleContainer<Modules> {
+    static from<Modules extends ProtocolModulesRecord>(modules: ProtocolDefinition<Modules>): Protocol<Modules>;
+    protected decorateModule(moduleName: StringKeyOf<Modules>, containedModule: InstanceType<Modules[StringKeyOf<Modules>]>): void;
+    get dependencyContainer(): DependencyContainer;
+    private isModule;
+    get blockProver(): BlockProvable;
+    get stateTransitionProver(): StateTransitionProvable;
+}
+export declare const VanillaProtocol: {
+    create(): Protocol<{
+        StateTransitionProver: typeof StateTransitionProver;
+        BlockProver: typeof BlockProver;
+    }>;
+};
+export {};
+//# sourceMappingURL=Protocol.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Protocol.d.ts","sourceRoot":"","sources":["../../src/protocol/Protocol.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,eAAe,EAEf,aAAa,EACb,WAAW,EACX,UAAU,EACX,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAE/C,OAAO,EACL,aAAa,EACb,sBAAsB,EACtB,uBAAuB,EACxB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,qBAAqB,EAAE,MAAM,iDAAiD,CAAC;AACxF,OAAO,EACL,uBAAuB,EACvB,gCAAgC,EAChC,iCAAiC,EAClC,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAE1D,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,MAAM,MAAM,2BAA2B,GAAG,aAAa,CACrD,UAAU,CAAC,cAAc,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CACrC,CAAC;AAEF,UAAU,eACR,SAAQ,cAAc,CAAC,sBAAsB,EAAE,uBAAuB,CAAC,EACrE,aAAa;CAAG;AAEpB,UAAU,yBACR,SAAQ,cAAc,CAClB,gCAAgC,EAChC,iCAAiC,CAClC,EACD,uBAAuB;CAAG;AAE9B,MAAM,WAAW,2BAA2B;IAC1C,WAAW,EAAE,UAAU,CAAC,eAAe,CAAC,CAAC;IACzC,qBAAqB,EAAE,UAAU,CAAC,yBAAyB,CAAC,CAAC;CAC9D;AAED,MAAM,WAAW,qBACf,SAAQ,2BAA2B,EACjC,2BAA2B;CAAG;AAElC,MAAM,WAAW,kBAAkB,CAAC,OAAO,SAAS,qBAAqB;IACvE,OAAO,EAAE,OAAO,CAAC;CAElB;AAED,qBAAa,QAAQ,CACnB,OAAO,SAAS,qBAAqB,CACrC,SAAQ,eAAe,CAAC,OAAO,CAAC;WAElB,IAAI,CAAC,OAAO,SAAS,qBAAqB,EACtD,OAAO,EAAE,kBAAkB,CAAC,OAAO,CAAC;IAsBtC,SAAS,CAAC,cAAc,CACtB,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,EAChC,eAAe,EAAE,YAAY,CAAC,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC;IAQ9D,IAAW,mBAAmB,IAAI,mBAAmB,CAEpD;IAED,OAAO,CAAC,QAAQ;IAMhB,IAAW,WAAW,IAAI,aAAa,CAMtC;IAED,IAAW,qBAAqB,IAAI,uBAAuB,CAI1D;CACF;AAED,eAAO,MAAM,eAAe;cAChB,SAAS;QACjB,uBAAuB,4BAA4B,CAAC;QACpD,aAAa,kBAAkB,CAAC;KACjC,CAAC;CAQH,CAAC"}

package/dist/protocol/Protocol.js

@@ -0,0 +1,50 @@
+import { log, ModuleContainer, } from "@proto-kit/common";
+import { StateTransitionProver } from "../prover/statetransition/StateTransitionProver";
+import { BlockProver } from "../prover/block/BlockProver";
+export class Protocol extends ModuleContainer {
+    // .from() to create Protocol
+    static from(modules) {
+        const protocol = new Protocol(modules);
+        // Set empty config for all modules, since we don't have that feature yet
+        // eslint-disable-next-line max-len
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment
+        const emptyConfig = Object.keys(modules.modules).reduce((agg, item) => {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            agg[item] = {};
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            return agg;
+        }, {});
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        protocol.configure(emptyConfig);
+        return protocol;
+    }
+    decorateModule(moduleName, containedModule) {
+        log.debug(`Decorated ${moduleName}`);
+        containedModule.protocol = this;
+        super.decorateModule(moduleName, containedModule);
+    }
+    get dependencyContainer() {
+        return this.container;
+    }
+    isModule(moduleName) {
+        return this.definition.modules[moduleName] !== undefined;
+    }
+    get blockProver() {
+        // Why do I resolve directly here?
+        // I don't know exactly but generics don't let me use .resolve()
+        return this.container.resolve("BlockProver");
+    }
+    get stateTransitionProver() {
+        return this.container.resolve("StateTransitionProver");
+    }
+}
+export const VanillaProtocol = {
+    create() {
+        return Protocol.from({
+            modules: {
+                StateTransitionProver,
+                BlockProver,
+            },
+        });
+    },
+};

package/dist/protocol/ProtocolModule.d.ts

@@ -0,0 +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>;
+    get appChain(): AreProofsEnabled | undefined;
+    constructor();
+}
+//# sourceMappingURL=ProtocolModule.d.ts.map

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

@@ -0,0 +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;AAGlE,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;IAElD,IAAW,QAAQ,IAAI,gBAAgB,GAAG,SAAS,CAIlD;;CAKF"}

package/dist/protocol/ProtocolModule.js

@@ -0,0 +1,10 @@
+import { ZkProgrammable, } from "@proto-kit/common";
+export class ProtocolModule extends ZkProgrammable {
+    get appChain() {
+        return this.protocol?.dependencyContainer.resolve("AppChain");
+    }
+    constructor() {
+        super();
+        this.config = {};
+    }
+}

package/dist/prover/block/BlockProvable.d.ts

@@ -0,0 +1,149 @@
+import { Proof } from "snarkyjs";
+import { StateTransitionProof } from "../statetransition/StateTransitionProvable";
+import { MethodPublicOutput } from "../../model/MethodPublicOutput";
+import { ZkProgrammable } from "@proto-kit/common";
+import { ProtocolTransaction } from "../../model/transaction/ProtocolTransaction";
+import { NetworkState } from "../../model/network/NetworkState";
+declare const BlockProverPublicInput_base: (new (value: {
+    transactionsHash: import("snarkyjs/dist/node/lib/field").Field;
+    stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+    networkStateHash: import("snarkyjs/dist/node/lib/field").Field;
+}) => {
+    transactionsHash: import("snarkyjs/dist/node/lib/field").Field;
+    stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+    networkStateHash: import("snarkyjs/dist/node/lib/field").Field;
+}) & {
+    _isStruct: true;
+} & import("snarkyjs/dist/node/snarky").ProvablePure<{
+    transactionsHash: import("snarkyjs/dist/node/lib/field").Field;
+    stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+    networkStateHash: import("snarkyjs/dist/node/lib/field").Field;
+}> & {
+    toInput: (x: {
+        transactionsHash: import("snarkyjs/dist/node/lib/field").Field;
+        stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+        networkStateHash: import("snarkyjs/dist/node/lib/field").Field;
+    }) => {
+        fields?: import("snarkyjs/dist/node/lib/field").Field[] | undefined;
+        packed?: [import("snarkyjs/dist/node/lib/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        transactionsHash: import("snarkyjs/dist/node/lib/field").Field;
+        stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+        networkStateHash: import("snarkyjs/dist/node/lib/field").Field;
+    }) => {
+        transactionsHash: string;
+        stateRoot: string;
+        networkStateHash: string;
+    };
+    fromJSON: (x: {
+        transactionsHash: string;
+        stateRoot: string;
+        networkStateHash: string;
+    }) => {
+        transactionsHash: import("snarkyjs/dist/node/lib/field").Field;
+        stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+        networkStateHash: import("snarkyjs/dist/node/lib/field").Field;
+    };
+};
+export declare class BlockProverPublicInput extends BlockProverPublicInput_base {
+}
+declare const BlockProverPublicOutput_base: (new (value: {
+    transactionsHash: import("snarkyjs/dist/node/lib/field").Field;
+    stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+}) => {
+    transactionsHash: import("snarkyjs/dist/node/lib/field").Field;
+    stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+}) & {
+    _isStruct: true;
+} & import("snarkyjs/dist/node/snarky").ProvablePure<{
+    transactionsHash: import("snarkyjs/dist/node/lib/field").Field;
+    stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+}> & {
+    toInput: (x: {
+        transactionsHash: import("snarkyjs/dist/node/lib/field").Field;
+        stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+    }) => {
+        fields?: import("snarkyjs/dist/node/lib/field").Field[] | undefined;
+        packed?: [import("snarkyjs/dist/node/lib/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        transactionsHash: import("snarkyjs/dist/node/lib/field").Field;
+        stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+    }) => {
+        transactionsHash: string;
+        stateRoot: string;
+    };
+    fromJSON: (x: {
+        transactionsHash: string;
+        stateRoot: string;
+    }) => {
+        transactionsHash: import("snarkyjs/dist/node/lib/field").Field;
+        stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+    };
+};
+export declare class BlockProverPublicOutput extends BlockProverPublicOutput_base {
+}
+export type BlockProverProof = Proof<BlockProverPublicInput, BlockProverPublicOutput>;
+declare const BlockProverExecutionData_base: (new (value: {
+    transaction: ProtocolTransaction;
+    networkState: NetworkState;
+}) => {
+    transaction: ProtocolTransaction;
+    networkState: NetworkState;
+}) & {
+    _isStruct: true;
+} & import("snarkyjs/dist/node/snarky").ProvablePure<{
+    transaction: ProtocolTransaction;
+    networkState: NetworkState;
+}> & {
+    toInput: (x: {
+        transaction: ProtocolTransaction;
+        networkState: NetworkState;
+    }) => {
+        fields?: import("snarkyjs/dist/node/lib/field").Field[] | undefined;
+        packed?: [import("snarkyjs/dist/node/lib/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        transaction: ProtocolTransaction;
+        networkState: NetworkState;
+    }) => {
+        transaction: {
+            methodId: string;
+            nonce: string;
+            sender: string;
+            argsHash: string;
+            signature: any;
+        };
+        networkState: {
+            block: {
+                height: string;
+            };
+        };
+    };
+    fromJSON: (x: {
+        transaction: {
+            methodId: string;
+            nonce: string;
+            sender: string;
+            argsHash: string;
+            signature: any;
+        };
+        networkState: {
+            block: {
+                height: string;
+            };
+        };
+    }) => {
+        transaction: ProtocolTransaction;
+        networkState: NetworkState;
+    };
+};
+export declare class BlockProverExecutionData extends BlockProverExecutionData_base {
+}
+export interface BlockProvable extends ZkProgrammable<BlockProverPublicInput, BlockProverPublicOutput> {
+    proveTransaction: (publicInput: BlockProverPublicInput, stateProof: StateTransitionProof, appProof: Proof<void, MethodPublicOutput>, executionData: BlockProverExecutionData) => BlockProverPublicOutput;
+    merge: (publicInput: BlockProverPublicInput, proof1: BlockProverProof, proof2: BlockProverProof) => BlockProverPublicOutput;
+}
+export {};
+//# sourceMappingURL=BlockProvable.d.ts.map

package/dist/prover/block/BlockProvable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockProvable.d.ts","sourceRoot":"","sources":["../../../src/prover/block/BlockProvable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,EAAkB,MAAM,UAAU,CAAC;AAExD,OAAO,EAAE,oBAAoB,EAAE,MAAM,4CAA4C,CAAC;AAClF,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,mBAAmB,EAAE,MAAM,6CAA6C,CAAC;AAClF,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEhE,qBAAa,sBAAuB,SAAQ,2BAI1C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,uBAAwB,SAAQ,4BAG3C;CAAG;AAEL,MAAM,MAAM,gBAAgB,GAAG,KAAK,CAClC,sBAAsB,EACtB,uBAAuB,CACxB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEF,qBAAa,wBAAyB,SAAQ,6BAI5C;CAAG;AAEL,MAAM,WAAW,aACf,SAAQ,cAAc,CAAC,sBAAsB,EAAE,uBAAuB,CAAC;IACvE,gBAAgB,EAAE,CAChB,WAAW,EAAE,sBAAsB,EACnC,UAAU,EAAE,oBAAoB,EAChC,QAAQ,EAAE,KAAK,CAAC,IAAI,EAAE,kBAAkB,CAAC,EACzC,aAAa,EAAE,wBAAwB,KACpC,uBAAuB,CAAC;IAE7B,KAAK,EAAE,CACL,WAAW,EAAE,sBAAsB,EACnC,MAAM,EAAE,gBAAgB,EACxB,MAAM,EAAE,gBAAgB,KACrB,uBAAuB,CAAC;CAC9B"}

package/dist/prover/block/BlockProvable.js

@@ -0,0 +1,20 @@
+import { Field, Struct } from "snarkyjs";
+import { ProtocolTransaction } from "../../model/transaction/ProtocolTransaction";
+import { NetworkState } from "../../model/network/NetworkState";
+export class BlockProverPublicInput extends Struct({
+    transactionsHash: Field,
+    stateRoot: Field,
+    networkStateHash: Field,
+}) {
+}
+export class BlockProverPublicOutput extends Struct({
+    transactionsHash: Field,
+    stateRoot: Field,
+}) {
+}
+export class BlockProverExecutionData extends Struct({
+    transaction: ProtocolTransaction,
+    networkState: NetworkState,
+    // accountstate
+}) {
+}

package/dist/prover/block/BlockProver.d.ts

@@ -0,0 +1,48 @@
+import { Field, type Proof } from "snarkyjs";
+import { PlainZkProgram, WithZkProgrammable, ZkProgrammable } from "@proto-kit/common";
+import { MethodPublicOutput } from "../../model/MethodPublicOutput";
+import { ProtocolModule } from "../../protocol/ProtocolModule";
+import { StateTransitionProof, StateTransitionProverPublicInput, StateTransitionProverPublicOutput } from "../statetransition/StateTransitionProvable";
+import { BlockProvable, BlockProverExecutionData, BlockProverProof, BlockProverPublicInput, BlockProverPublicOutput } from "./BlockProvable";
+export interface BlockProverState {
+    stateRoot: Field;
+    /**
+     * The current commitment of the transaction-list which
+     * will at the end equal the bundle hash
+     */
+    transactionsHash: Field;
+    /**
+     * The network state which gives access to values such as blockHeight
+     * This value is the same for the whole batch (L2 block)
+     */
+    networkStateHash: Field;
+}
+/**
+ * BlockProver class, which aggregates a AppChainProof and
+ * a StateTransitionProof into a single BlockProof, that can
+ * then be merged to be committed to the base-layer contract
+ */
+export declare class BlockProver extends ProtocolModule<BlockProverPublicInput, BlockProverPublicOutput> implements BlockProvable {
+    private readonly stateTransitionProver;
+    private readonly runtime;
+    constructor(stateTransitionProver: ZkProgrammable<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>, runtime: WithZkProgrammable<void, MethodPublicOutput>);
+    /**
+     * Applies and checks the two proofs and applies the corresponding state
+     * changes to the given state
+     *
+     * @param state The from-state of the BlockProver
+     * @param stateTransitionProof
+     * @param appProof
+     * @returns The new BlockProver-state to be used as public output
+     */
+    applyTransaction(state: BlockProverState, stateTransitionProof: Proof<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>, appProof: Proof<void, MethodPublicOutput>, { transaction, networkState }: BlockProverExecutionData): BlockProverState;
+    proveTransaction(publicInput: BlockProverPublicInput, stateProof: StateTransitionProof, appProof: Proof<void, MethodPublicOutput>, executionData: BlockProverExecutionData): BlockProverPublicOutput;
+    merge(publicInput: BlockProverPublicInput, proof1: BlockProverProof, proof2: BlockProverProof): BlockProverPublicOutput;
+    /**
+     * Creates the BlockProver ZkProgram.
+     * Recursive linking of proofs is done via the previously
+     * injected StateTransitionProver and the required AppChainProof class
+     */
+    zkProgramFactory(): PlainZkProgram<BlockProverPublicInput, BlockProverPublicOutput>;
+}
+//# sourceMappingURL=BlockProver.d.ts.map

package/dist/prover/block/BlockProver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockProver.d.ts","sourceRoot":"","sources":["../../../src/prover/block/BlockProver.ts"],"names":[],"mappings":"AACA,OAAO,EAAgB,KAAK,EAAE,KAAK,KAAK,EAAuB,MAAM,UAAU,CAAC;AAEhF,OAAO,EACL,cAAc,EAEd,kBAAkB,EAClB,cAAc,EACf,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EACL,oBAAoB,EACpB,gCAAgC,EAChC,iCAAiC,EAClC,MAAM,4CAA4C,CAAC;AAGpD,OAAO,EACL,aAAa,EACb,wBAAwB,EACxB,gBAAgB,EAChB,sBAAsB,EACtB,uBAAuB,EACxB,MAAM,iBAAiB,CAAC;AAiBzB,MAAM,WAAW,gBAAgB;IAE/B,SAAS,EAAE,KAAK,CAAC;IAEjB;;;OAGG;IACH,gBAAgB,EAAE,KAAK,CAAC;IAExB;;;OAGG;IACH,gBAAgB,EAAE,KAAK,CAAC;CACzB;AAED;;;;GAIG;AACH,qBACa,WACX,SAAQ,cAAc,CAAC,sBAAsB,EAAE,uBAAuB,CACtE,YAAW,aAAa;IAItB,OAAO,CAAC,QAAQ,CAAC,qBAAqB;IAKtC,OAAO,CAAC,QAAQ,CAAC,OAAO;gBALP,qBAAqB,EAAE,cAAc,CACpD,gCAAgC,EAChC,iCAAiC,CAClC,EAEgB,OAAO,EAAE,kBAAkB,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAKxE;;;;;;;;OAQG;IACI,gBAAgB,CACrB,KAAK,EAAE,gBAAgB,EACvB,oBAAoB,EAAE,KAAK,CACzB,gCAAgC,EAChC,iCAAiC,CAClC,EACD,QAAQ,EAAE,KAAK,CAAC,IAAI,EAAE,kBAAkB,CAAC,EACzC,EAAE,WAAW,EAAE,YAAY,EAAE,EAAE,wBAAwB,GACtD,gBAAgB;IAyEZ,gBAAgB,CACrB,WAAW,EAAE,sBAAsB,EACnC,UAAU,EAAE,oBAAoB,EAChC,QAAQ,EAAE,KAAK,CAAC,IAAI,EAAE,kBAAkB,CAAC,EACzC,aAAa,EAAE,wBAAwB,GACtC,uBAAuB;IAgBnB,KAAK,CACV,WAAW,EAAE,sBAAsB,EACnC,MAAM,EAAE,gBAAgB,EACxB,MAAM,EAAE,gBAAgB,GACvB,uBAAuB;IA8B1B;;;;OAIG;IACI,gBAAgB,IAAI,cAAc,CACvC,sBAAsB,EACtB,uBAAuB,CACxB;CAkEF"}