Granularized compile tasks

packages/sequencer/src/index.ts

@@ -23,6 +23,8 @@ export * from "./worker/worker/FlowTaskWorker";
 export * from "./worker/worker/LocalTaskWorkerModule";
 export * from "./worker/worker/TaskWorkerModule";
 export * from "./worker/worker/WorkerReadyModule";
+export * from "./worker/startup/WorkerRegistrationTask";
+export * from "./worker/startup/CloseWorkerError";
 export * from "./protocol/baselayer/BaseLayer";
 export * from "./protocol/baselayer/MinaBaseLayer";
 export * from "./protocol/baselayer/NoopBaseLayer";
@@ -47,6 +49,10 @@ export * from "./protocol/production/tasks/serializers/RuntimeVerificationKeyAtt
 export * from "./protocol/production/tasks/serializers/StateTransitionParametersSerializer";
 export * from "./protocol/production/tasks/serializers/TransactionProvingTaskParameterSerializer";
 export * from "./protocol/production/tasks/serializers/VerificationKeySerializer";
+export * from "./protocol/production/tasks/compile/CircuitCompileTask";
+export * from "./protocol/production/tasks/compile/ProtocolCompileTask";
+export * from "./protocol/production/tasks/compile/RuntimeCompileTask";
+export * from "./protocol/production/tasks/compile/SettlementCompileTask";
 export * from "./protocol/production/trigger/BlockTrigger";
 export * from "./protocol/production/trigger/ManualBlockTrigger";
 export * from "./protocol/production/trigger/TimedBlockTrigger";

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

@@ -0,0 +1,122 @@
+import {
+  log,
+  mapSequential,
+  ArtifactRecord,
+  CompileRegistry,
+  CompilableModule,
+  safeParseJson,
+} from "@proto-kit/common";
+import {
+  Protocol,
+  RuntimeVerificationKeyRootService,
+  MandatoryProtocolModulesRecord,
+  BridgingSettlementContractArgs,
+  ContractArgsRegistry,
+} from "@proto-kit/protocol";
+
+import { TaskSerializer } from "../../../../worker/flow/Task";
+import { UnpreparingTask } from "../../../../worker/flow/UnpreparingTask";
+import { SignedSettlementPermissions } from "../../../../settlement/permissions/SignedSettlementPermissions";
+import { ProvenSettlementPermissions } from "../../../../settlement/permissions/ProvenSettlementPermissions";
+import {
+  ArtifactRecordSerializer,
+  SerializedArtifactRecord,
+} from "../serializers/ArtifactionRecordSerializer";
+
+export type CompilerTaskParams = {
+  existingArtifacts: ArtifactRecord;
+  runtimeVKRoot?: string;
+  isSignedSettlement?: boolean;
+};
+
+export abstract class CircuitCompileTask extends UnpreparingTask<
+  CompilerTaskParams,
+  ArtifactRecord
+> {
+  protected constructor(
+    protected readonly protocol: Protocol<MandatoryProtocolModulesRecord>,
+    protected readonly compileRegistry: CompileRegistry,
+    protected readonly contractArgsRegistry: ContractArgsRegistry
+  ) {
+    super();
+  }
+
+  public inputSerializer(): TaskSerializer<CompilerTaskParams> {
+    type CompilerTaskParamsJSON = {
+      runtimeVKRoot?: string;
+      existingArtifacts: SerializedArtifactRecord;
+      isSignedSettlement?: boolean;
+    };
+
+    const serializer = new ArtifactRecordSerializer();
+    return {
+      toJSON: (input) =>
+        JSON.stringify({
+          runtimeVKRoot: input.runtimeVKRoot,
+          existingArtifacts: serializer.toJSON(input.existingArtifacts),
+          isSignedSettlement: input.isSignedSettlement,
+        } satisfies CompilerTaskParamsJSON),
+      fromJSON: (input) => {
+        const json = safeParseJson<CompilerTaskParamsJSON>(input);
+        return {
+          runtimeVKRoot: json.runtimeVKRoot,
+          existingArtifacts: serializer.fromJSON(json.existingArtifacts),
+          isSignedSettlement: json.isSignedSettlement,
+        };
+      },
+    };
+  }
+
+  public resultSerializer(): TaskSerializer<ArtifactRecord> {
+    const serializer = new ArtifactRecordSerializer();
+    return {
+      toJSON: (input) => JSON.stringify(serializer.toJSON(input)),
+      fromJSON: (input) =>
+        serializer.fromJSON(safeParseJson<SerializedArtifactRecord>(input)),
+    };
+  }
+
+  public abstract getTargets(): Promise<CompilableModule[]>;
+
+  public async compute(input: CompilerTaskParams): Promise<ArtifactRecord> {
+    log.info("Computing VKs");
+
+    this.compileRegistry.addArtifactsRaw(input.existingArtifacts);
+
+    // We need to initialize the VK tree root if we have it, so that
+    // the BlockProver can bake in that root
+    if (input.runtimeVKRoot !== undefined) {
+      this.protocol.dependencyContainer
+        .resolve(RuntimeVerificationKeyRootService)
+        .setRoot(BigInt(input.runtimeVKRoot));
+    }
+
+    if (input.isSignedSettlement !== undefined) {
+      this.contractArgsRegistry.addArgs<BridgingSettlementContractArgs>(
+        "SettlementContract",
+        {
+          signedSettlements: input.isSignedSettlement,
+          // TODO Add distinction between mina and custom tokens
+          BridgeContractPermissions: (input.isSignedSettlement
+            ? new SignedSettlementPermissions()
+            : new ProvenSettlementPermissions()
+          ).bridgeContractMina(),
+        }
+      );
+    }
+
+    const targets = await this.getTargets();
+
+    const msg = `Compiling targets ${this.name}`;
+    log.time(msg);
+    await mapSequential(targets, async (target) => {
+      await target.compile(this.compileRegistry);
+    });
+    log.timeEnd.info(msg);
+
+    const newEntries = Object.entries(
+      this.compileRegistry.getAllArtifacts()
+    ).filter(([key]) => !(key in input.existingArtifacts));
+    return Object.fromEntries(newEntries);
+  }
+}

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

@@ -0,0 +1,28 @@
+import { inject, injectable, Lifecycle, scoped } from "tsyringe";
+import { CompilableModule, CompileRegistry } from "@proto-kit/common";
+import {
+  ContractArgsRegistry,
+  MandatoryProtocolModulesRecord,
+  Protocol,
+} from "@proto-kit/protocol";
+
+import { CircuitCompileTask } from "./CircuitCompileTask";
+
+@injectable()
+@scoped(Lifecycle.ContainerScoped)
+export class ProtocolCompileTask extends CircuitCompileTask {
+  public name = "compile-protocol";
+
+  public constructor(
+    @inject("Protocol")
+    protocol: Protocol<MandatoryProtocolModulesRecord>,
+    compileRegistry: CompileRegistry,
+    contractArgsRegistry: ContractArgsRegistry
+  ) {
+    super(protocol, compileRegistry, contractArgsRegistry);
+  }
+
+  public async getTargets(): Promise<CompilableModule[]> {
+    return [this.protocol.blockProver];
+  }
+}

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

@@ -0,0 +1,30 @@
+import { inject, injectable, Lifecycle, scoped } from "tsyringe";
+import { CompilableModule, CompileRegistry } from "@proto-kit/common";
+import { Runtime } from "@proto-kit/module";
+import {
+  ContractArgsRegistry,
+  MandatoryProtocolModulesRecord,
+  Protocol,
+} from "@proto-kit/protocol";
+
+import { CircuitCompileTask } from "./CircuitCompileTask";
+
+@injectable()
+@scoped(Lifecycle.ContainerScoped)
+export class RuntimeCompileTask extends CircuitCompileTask {
+  public name = "compile-runtime";
+
+  public constructor(
+    @inject("Runtime") protected readonly runtime: Runtime<never>,
+    @inject("Protocol")
+    protocol: Protocol<MandatoryProtocolModulesRecord>,
+    compileRegistry: CompileRegistry,
+    contractArgsRegistry: ContractArgsRegistry
+  ) {
+    super(protocol, compileRegistry, contractArgsRegistry);
+  }
+
+  public async getTargets(): Promise<CompilableModule[]> {
+    return [this.runtime];
+  }
+}