Protocol circuit sideloading

packages/common/src/compiling/services/ChildVerificationKeyService.ts

@@ -23,4 +23,12 @@ export class ChildVerificationKeyService {
     }
     return artifact.verificationKey;
   }
+
+  public getAsConstant(name: string) {
+    const vk = this.getVerificationKey(name);
+    if (!vk.hash.isConstant()) {
+      throw new Error("Sanity check - vk hash has to be constant");
+    }
+    return vk;
+  }
 }

packages/protocol/src/prover/block/BlockProvable.ts

@@ -1,7 +1,19 @@
-import { Bool, Field, Poseidon, Proof, Provable, Struct } from "o1js";
+// eslint-disable-next-line max-classes-per-file
+import {
+  Bool,
+  DynamicProof,
+  Field,
+  Poseidon,
+  Proof,
+  Provable,
+  Struct,
+} from "o1js";
 import { CompilableModule, WithZkProgrammable } from "@proto-kit/common";
 
-import { StateTransitionProof } from "../statetransition/StateTransitionProvable";
+import {
+  StateTransitionProverPublicInput,
+  StateTransitionProverPublicOutput,
+} from "../statetransition/StateTransitionProvable";
 import { NetworkState } from "../../model/network/NetworkState";
 import { TransactionHashList } from "../accumulators/TransactionHashList";
 import { MinaActionsHashList } from "../../utils/MinaPrefixedProvableHashList";
@@ -10,7 +22,10 @@ import {
   WitnessedRootHashList,
   WitnessedRootWitness,
 } from "../accumulators/WitnessedRootHashList";
-import { TransactionProof } from "../transaction/TransactionProvable";
+import {
+  TransactionProverPublicInput,
+  TransactionProverPublicOutput,
+} from "../transaction/TransactionProvable";
 import { BundleHashList, FieldTransition } from "../accumulators/BlockHashList";
 import { NonMethods } from "../../utils/utils";
 import { Constants } from "../../Constants";
@@ -345,6 +360,28 @@ export class BlockProverState {
   }
 }
 
+export class DynamicSTProof extends DynamicProof<
+  StateTransitionProverPublicInput,
+  StateTransitionProverPublicOutput
+> {
+  static publicInputType = StateTransitionProverPublicInput;
+
+  static publicOutputType = StateTransitionProverPublicOutput;
+
+  static maxProofsVerified = 2 as const;
+}
+
+export class DynamicTransactionProof extends DynamicProof<
+  TransactionProverPublicInput,
+  TransactionProverPublicOutput
+> {
+  static publicInputType = TransactionProverPublicInput;
+
+  static publicOutputType = TransactionProverPublicOutput;
+
+  static maxProofsVerified = 2 as const;
+}
+
 export type BlockProof = Proof<BlockProverPublicInput, BlockProverPublicOutput>;
 
 export interface BlockProvable
@@ -368,8 +405,8 @@ export interface BlockProvable
     batch: BlockArgumentsBatch,
     deferSTProof: Bool,
     deferTransactionProof: Bool,
-    stateTransitionProof: StateTransitionProof,
-    transactionProof: TransactionProof
+    stateTransitionProof: DynamicSTProof,
+    transactionProof: DynamicTransactionProof
   ) => Promise<BlockProverPublicOutput>;
 
   merge: (

packages/protocol/src/prover/block/BlockProver.ts

@@ -2,6 +2,7 @@ import { Bool, Field, Provable, SelfProof, ZkProgram } from "o1js";
 import { container, inject, injectable, injectAll } from "tsyringe";
 import {
   AreProofsEnabled,
+  ChildVerificationKeyService,
   CompilableModule,
   CompileArtifact,
   CompileRegistry,
@@ -16,7 +17,6 @@ import {
 
 import { ProtocolModule } from "../../protocol/ProtocolModule";
 import {
-  StateTransitionProof,
   StateTransitionProvable,
   StateTransitionProverPublicInput,
   StateTransitionProverPublicOutput,
@@ -35,7 +35,6 @@ import { assertEqualsIf } from "../../utils/utils";
 import { StateServiceProvider } from "../../state/StateServiceProvider";
 import { executeHooks } from "../utils";
 import {
-  TransactionProof,
   TransactionProvable,
   TransactionProverPublicInput,
   TransactionProverPublicOutput,
@@ -51,6 +50,8 @@ import {
   BlockProverPublicOutput,
   BlockProverState,
   BlockProverStateInput,
+  DynamicSTProof,
+  DynamicTransactionProof,
 } from "./BlockProvable";
 import {
   BlockHashMerkleTreeWitness,
@@ -74,16 +75,9 @@ export class BlockProverProgrammable extends ZkProgrammable<
 > {
   public constructor(
     private readonly prover: BlockProver,
-    public readonly stateTransitionProver: ZkProgrammable<
-      StateTransitionProverPublicInput,
-      StateTransitionProverPublicOutput
-    >,
-    public readonly transactionProver: ZkProgrammable<
-      TransactionProverPublicInput,
-      TransactionProverPublicOutput
-    >,
     private readonly blockHooks: ProvableBlockHook<unknown>[],
-    private readonly stateServiceProvider: StateServiceProvider
+    private readonly stateServiceProvider: StateServiceProvider,
+    private readonly childVerificationKeyService: ChildVerificationKeyService
   ) {
     super();
   }
@@ -141,7 +135,7 @@ export class BlockProverProgrammable extends ZkProgrammable<
   }
 
   public includeSTProof(
-    stateTransitionProof: StateTransitionProof,
+    stateTransitionProof: DynamicSTProof,
     apply: Bool,
     stateRoot: Field,
     pendingSTBatchesHash: Field,
@@ -224,7 +218,7 @@ export class BlockProverProgrammable extends ZkProgrammable<
 
   private verifySTProof(
     state: BlockProverState,
-    stateTransitionProof: StateTransitionProof,
+    stateTransitionProof: DynamicSTProof,
     deferSTProof: Bool
   ) {
     // Verify ST Proof only if STs have been emitted,
@@ -233,7 +227,12 @@ export class BlockProverProgrammable extends ZkProgrammable<
     const batchesEmpty = state.pendingSTBatches.commitment.equals(Field(0));
     const verifyStProof = deferSTProof.not().and(batchesEmpty.not());
     log.provable.debug("Verify STProof", verifyStProof);
-    stateTransitionProof.verifyIf(verifyStProof);
+
+    // Brought in as a constant
+    const stProofVk = this.childVerificationKeyService.getAsConstant(
+      "StateTransitionProver"
+    );
+    stateTransitionProof.verifyIf(stProofVk, verifyStProof);
 
     // Apply STProof if not deferred
     const stateProofResult = this.includeSTProof(
@@ -250,7 +249,7 @@ export class BlockProverProgrammable extends ZkProgrammable<
 
   private verifyTransactionProof(
     state: BlockProverState,
-    transactionProof: TransactionProof,
+    transactionProof: DynamicTransactionProof,
     deferTransactionProof: Bool
   ) {
     // Verify Transaction proof if it has at least 1 tx and it isn't deferred
@@ -259,7 +258,11 @@ export class BlockProverProgrammable extends ZkProgrammable<
       state.bundleList.isEmpty().not()
     );
 
-    transactionProof.verifyIf(verifyTransactionProof);
+    // Brought in as a constant
+    const transactionProofVk = this.childVerificationKeyService.getAsConstant(
+      "StateTransitionProver"
+    );
+    transactionProof.verifyIf(transactionProofVk, verifyTransactionProof);
 
     // Fast-forward transaction trackers by the results of the aggregated transaction proof
     // Implicitly, the 'from' values here are asserted against the publicInput, since the hashlists
@@ -402,8 +405,8 @@ export class BlockProverProgrammable extends ZkProgrammable<
     batch: BlockArgumentsBatch,
     deferSTProof: Bool,
     deferTransactionProof: Bool,
-    stateTransitionProof: StateTransitionProof,
-    transactionProof: TransactionProof
+    stateTransitionProof: DynamicSTProof,
+    transactionProof: DynamicTransactionProof
   ) {
     const finalize = deferTransactionProof.or(deferSTProof).not();
 
@@ -432,8 +435,8 @@ export class BlockProverProgrammable extends ZkProgrammable<
     deferSTProof: Bool,
     deferTransactionProof: Bool,
     finalize: Bool,
-    stateTransitionProof?: StateTransitionProof,
-    transactionProof?: TransactionProof
+    stateTransitionProof?: DynamicSTProof,
+    transactionProof?: DynamicTransactionProof
   ): Promise<BlockProverPublicOutput> {
     let state = this.parseState(
       publicInput,
@@ -621,9 +624,7 @@ export class BlockProverProgrammable extends ZkProgrammable<
     BlockProverPublicInput,
     BlockProverPublicOutput
   >[] {
-    const { prover, stateTransitionProver, transactionProver } = this;
-    const StateTransitionProofClass = stateTransitionProver.zkProgram[0].Proof;
-    const TransactionProofClass = transactionProver.zkProgram[0].Proof;
+    const { prover } = this;
     const proveBlockBatchWithProofs =
       prover.proveBlockBatchWithProofs.bind(prover);
     const proveBlockBatchNoProofs = prover.proveBlockBatchNoProofs.bind(prover);
@@ -643,8 +644,8 @@ export class BlockProverProgrammable extends ZkProgrammable<
             BlockArgumentsBatch,
             Bool,
             Bool,
-            StateTransitionProofClass,
-            TransactionProofClass,
+            DynamicSTProof,
+            DynamicTransactionProof,
           ],
           async method(
             publicInput: BlockProverPublicInput,
@@ -654,8 +655,8 @@ export class BlockProverProgrammable extends ZkProgrammable<
             batch: BlockArgumentsBatch,
             deferSTProof: Bool,
             deferTransactionProof: Bool,
-            stateTransitionProof: StateTransitionProof,
-            transactionProof: TransactionProof
+            stateTransitionProof: DynamicSTProof,
+            transactionProof: DynamicTransactionProof
           ) {
             return {
               publicOutput: await proveBlockBatchWithProofs(
@@ -768,24 +769,26 @@ export class BlockProver
     @injectAll("ProvableBlockHook")
     blockHooks: ProvableBlockHook<unknown>[],
     @inject("StateServiceProvider")
-    stateServiceProvider: StateServiceProvider
+    stateServiceProvider: StateServiceProvider,
+    childVerificationKeyService: ChildVerificationKeyService
   ) {
     super();
     this.zkProgrammable = new BlockProverProgrammable(
       this,
-      stateTransitionProver.zkProgrammable,
-      transactionProver.zkProgrammable,
       blockHooks,
-      stateServiceProvider
+      stateServiceProvider,
+      childVerificationKeyService
     );
   }
 
   public async compile(
     registry: CompileRegistry
   ): Promise<Record<string, CompileArtifact> | undefined> {
-    return await registry.proverNeeded(async () => {
+    await registry.sideloaded(async () => {
       await this.stateTransitionProver.compile(registry);
       await this.transactionProver.compile(registry);
+    });
+    return await registry.proverNeeded(async () => {
       return await this.zkProgrammable.compile(registry);
     });
   }
@@ -816,8 +819,8 @@ export class BlockProver
     batch: BlockArgumentsBatch,
     deferSTProof: Bool,
     deferTransactionProof: Bool,
-    stateTransitionProof: StateTransitionProof,
-    transactionProof: TransactionProof
+    stateTransitionProof: DynamicSTProof,
+    transactionProof: DynamicTransactionProof
   ): Promise<BlockProverPublicOutput> {
     return this.zkProgrammable.proveBlockBatchWithProofs(
       publicInput,

packages/protocol/src/settlement/contracts/settlement/SettlementBase.ts

@@ -150,8 +150,8 @@ export abstract class SettlementBase
       throw new Error("Sanity check - vk hash has to be constant");
     }
     // Verify the blockproof
-
     blockProof.verify(blockProofVk);
+
     // Get and assert on-chain values
     const stateRoot = this.stateRoot.getAndRequireEquals();
     const networkStateHash = this.networkStateHash.getAndRequireEquals();

packages/sdk/src/query/StateServiceQueryModule.ts

@@ -31,7 +31,7 @@ export class StateServiceQueryModule
   }
 
   public get treeStore(): AsyncLinkedLeafStore {
-    return this.sequencer.dependencyContainer.resolve("AsyncLinkedMerkleStore");
+    return this.sequencer.dependencyContainer.resolve("AsyncLinkedLeafStore");
   }
 
   public get(key: Field) {

packages/sequencer/src/protocol/production/tasks/NewBlockTask.ts

@@ -15,6 +15,8 @@ import {
   BlockArgumentsBatch,
   BlockProverStateInput,
   ProtocolConstants,
+  DynamicSTProof,
+  DynamicTransactionProof,
 } from "@proto-kit/protocol";
 import { Bool } from "o1js";
 import {
@@ -143,6 +145,8 @@ export class NewBlockTask
             // deferSTProof.or(deferTransactionProof)
           );
         } else {
+          const stProof = DynamicSTProof.fromProof(input1);
+          const txProof = DynamicTransactionProof.fromProof(input2);
           await this.blockProver.proveBlockBatchWithProofs(
             publicInput,
             stateWitness,
@@ -151,8 +155,8 @@ export class NewBlockTask
             blockArgumentBatch,
             deferSTProof,
             deferTransactionProof,
-            input1,
-            input2
+            stProof,
+            txProof
           );
         }
       }

packages/sequencer/src/protocol/production/tasks/compile/CircuitCompileTask.ts

@@ -5,6 +5,7 @@ import {
   CompileRegistry,
   CompilableModule,
   safeParseJson,
+  NoConfig,
 } from "@proto-kit/common";
 import {
   Protocol,
@@ -29,10 +30,9 @@ export type CompilerTaskParams = {
   isSignedSettlement?: boolean;
 };
 
-export abstract class CircuitCompileTask extends UnpreparingTask<
-  CompilerTaskParams,
-  ArtifactRecord
-> {
+export abstract class CircuitCompileTask<
+  Config = NoConfig,
+> extends UnpreparingTask<CompilerTaskParams, ArtifactRecord, Config> {
   protected constructor(
     protected readonly protocol: Protocol<MandatoryProtocolModulesRecord>,
     protected readonly compileRegistry: CompileRegistry,