Refactoring

Author: rpanic

packages/common/src/compiling/CompileRegistry.ts

@@ -41,8 +41,6 @@ export class CompileRegistry {
 
   private artifacts: ArtifactRecord = {};
 
-  // private cachedModuleOutputs: Record<string, ArtifactRecord | void> = {};
-
   // TODO Add possibility to force recompilation for non-sideloaded dependencies
 
   public async compile(target: CompileTarget) {
@@ -54,47 +52,6 @@ export class CompileRegistry {
     return this.artifacts[target.name];
   }
 
-  // public async compileModule<
-  //   ReturnType extends ArtifactRecord,
-  //   Dependencies extends Record<string, CompilableModule>,
-  // >(
-  //   compile: (
-  //     compiler: AtomicCompileHelper,
-  //     args: InferDependencyArtifacts<Dependencies>
-  //   ) => Promise<ReturnType>,
-  //   dependencies?: Dependencies
-  // ): Promise<ReturnType | undefined> {
-  //   const collectedArtifacts = await mapSequential(
-  //     Object.entries(dependencies ?? {}),
-  //     async ([depName, dep]) => {
-  //       if (this.cachedModuleOutputs[depName] !== undefined) {
-  //         return [depName, this.cachedModuleOutputs[depName]];
-  //       }
-  //       const artifact = await dep.compile(this);
-  //       if (artifact !== undefined) {
-  //         this.artifacts = {
-  //           ...this.artifacts,
-  //           ...artifact,
-  //         };
-  //       }
-  //       this.cachedModuleOutputs[depName] = artifact;
-  //       return [depName, artifact];
-  //     }
-  //   );
-  //
-  //   const artifacts = await compile(
-  //     this.compile,
-  //     Object.fromEntries(collectedArtifacts)
-  //   );
-  //
-  //   this.artifacts = {
-  //     ...this.artifacts,
-  //     ...artifacts,
-  //   };
-  //
-  //   return artifacts;
-  // }
-
   public getArtifact(name: string) {
     if (this.artifacts[name] === undefined) {
       throw new Error(

packages/common/src/utils.ts

@@ -182,3 +182,9 @@ export function isSubtypeOfName(
   // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
   return isSubtypeOfName(Object.getPrototypeOf(clas), name);
 }
+
+// TODO Eventually, replace this by a schema validation library
+export function safeParseJson<T>(json: string) {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  return JSON.parse(json) as T;
+}

packages/protocol/src/settlement/modularity/ProvableSettlementHook.ts

@@ -1,10 +1,13 @@
 import { Field, PublicKey, UInt32 } from "o1js";
+import { InferProofBase } from "@proto-kit/common";
 
 import { ProtocolModule } from "../../protocol/ProtocolModule";
 import { NetworkState } from "../../model/network/NetworkState";
 import type { BlockProof } from "../../prover/block/BlockProver";
 import type { SettlementSmartContractBase } from "../contracts/SettlementSmartContract";
 
+export type InputBlockProof = InferProofBase<BlockProof>;
+
 export type SettlementStateRecord = {
   sequencerKey: PublicKey;
   lastSettlementL1BlockHeight: UInt32;
@@ -15,7 +18,7 @@ export type SettlementStateRecord = {
 };
 
 export type SettlementHookInputs = {
-  blockProof: BlockProof;
+  blockProof: InputBlockProof;
   fromNetworkState: NetworkState;
   toNetworkState: NetworkState;
   newPromisedMessagesHash: Field;

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

@@ -7,6 +7,7 @@ import {
   ArtifactRecord,
   CompileRegistry,
   CompilableModule,
+  safeParseJson,
 } from "@proto-kit/common";
 import {
   MandatorySettlementModulesRecord,
@@ -25,21 +26,11 @@ export type CompilerTaskParams = {
   runtimeVKRoot?: string;
 };
 
-type SerializedArtifactRecord = Record<
+export type SerializedArtifactRecord = Record<
   string,
   { verificationKey: { hash: string; data: string } }
 >;
 
-export class SimpleJSONSerializer<Type> implements TaskSerializer<Type> {
-  public toJSON(parameters: Type): string {
-    return JSON.stringify(parameters);
-  }
-
-  public fromJSON(json: string): Type {
-    return JSON.parse(json) as Type;
-  }
-}
-
 export class ArtifactRecordSerializer {
   public toJSON(input: ArtifactRecord): SerializedArtifactRecord {
     const temp: SerializedArtifactRecord = Object.keys(
@@ -69,7 +60,7 @@ export class ArtifactRecordSerializer {
           ),
         },
       };
-    }, {} as ArtifactRecord);
+    }, {});
   }
 }
 
@@ -90,19 +81,25 @@ export class CircuitCompilerTask extends UnpreparingTask<
   }
 
   public inputSerializer(): TaskSerializer<CompilerTaskParams> {
+    type CompilerTaskParamsJSON = {
+      targets: string[];
+      runtimeVKRoot?: string;
+      existingArtifacts: SerializedArtifactRecord;
+    };
+
     const serializer = new ArtifactRecordSerializer();
     return {
       toJSON: (input) =>
         JSON.stringify({
           targets: input.targets,
-          root: input.runtimeVKRoot,
+          runtimeVKRoot: input.runtimeVKRoot,
           existingArtifacts: serializer.toJSON(input.existingArtifacts),
-        }),
+        } satisfies CompilerTaskParamsJSON),
       fromJSON: (input) => {
-        const json = JSON.parse(input);
+        const json = safeParseJson<CompilerTaskParamsJSON>(input);
         return {
           targets: json.targets,
-          root: json.runtimeVKRoot,
+          runtimeVKRoot: json.runtimeVKRoot,
           existingArtifacts: serializer.fromJSON(json.existingArtifacts),
         };
       },
@@ -113,7 +110,8 @@ export class CircuitCompilerTask extends UnpreparingTask<
     const serializer = new ArtifactRecordSerializer();
     return {
       toJSON: (input) => JSON.stringify(serializer.toJSON(input)),
-      fromJSON: (input) => serializer.fromJSON(JSON.parse(input)),
+      fromJSON: (input) =>
+        serializer.fromJSON(safeParseJson<SerializedArtifactRecord>(input)),
     };
   }
 

packages/sequencer/src/sequencer/SequencerStartupModule.ts

@@ -91,8 +91,8 @@ export class SequencerStartupModule extends SequencerModule {
           targets: ["protocol"],
           runtimeVKRoot: undefined,
         },
-        async (result) => {
-          results.protocol = result;
+        async (protocolResult) => {
+          results.protocol = protocolResult;
           resolveIfPossible();
         }
       );
@@ -104,8 +104,8 @@ export class SequencerStartupModule extends SequencerModule {
           targets: ["Settlement.BridgeContract"],
           runtimeVKRoot: undefined,
         },
-        async (result) => {
-          results.bridge = result;
+        async (bridgeResult) => {
+          results.bridge = bridgeResult;
           resolveIfPossible();
         }
       );
@@ -143,6 +143,9 @@ export class SequencerStartupModule extends SequencerModule {
 
     this.compileRegistry.addArtifactsRaw(record);
 
+    // TODO Compile all contracts and retrieve artifacts to enable crafting of
+    //  the deployments - edit: can also be done on-demand with the CompileTask
+
     await this.registrationFlow.start({
       runtimeVerificationKeyRoot: root,
       bridgeContractVerificationKey: bridgeVk?.verificationKey,

packages/sequencer/src/settlement/tasks/SettlementProvingTask.ts

@@ -393,16 +393,11 @@ export class SettlementProvingTask
       contractClasses[key] = module.contractFactory();
     }
 
-    try {
-      for (const [key, module] of modules) {
-        log.debug(`Compiling Settlement Module ${key}`);
+    for (const [key, module] of modules) {
+      log.debug(`Compiling Settlement Module ${key}`);
 
-        // eslint-disable-next-line no-await-in-loop
-        await module.compile(this.compileRegistry);
-      }
-    } catch (e) {
-      console.error(e);
-      throw e;
+      // eslint-disable-next-line no-await-in-loop
+      await module.compile(this.compileRegistry);
     }
 
     this.contractRegistry = new ContractRegistry(contractClasses);

packages/sequencer/src/worker/worker/startup/WorkerRegistrationTask.ts

@@ -4,6 +4,7 @@ import {
   ArtifactRecord,
   ChildVerificationKeyService,
   CompileRegistry,
+  safeParseJson,
 } from "@proto-kit/common";
 import { inject, injectable } from "tsyringe";
 import {
@@ -15,8 +16,14 @@ import { VerificationKey } from "o1js";
 
 import { Task } from "../../flow/Task";
 import { AbstractStartupTask } from "../../flow/AbstractStartupTask";
-import { VerificationKeySerializer } from "../../../protocol/production/helpers/VerificationKeySerializer";
-import { ArtifactRecordSerializer } from "../../../protocol/production/tasks/CircuitCompilerTask";
+import {
+  VerificationKeyJSON,
+  VerificationKeySerializer,
+} from "../../../protocol/production/helpers/VerificationKeySerializer";
+import {
+  ArtifactRecordSerializer,
+  SerializedArtifactRecord,
+} from "../../../protocol/production/tasks/CircuitCompilerTask";
 
 import { CloseWorkerError } from "./CloseWorkerError";
 
@@ -76,6 +83,12 @@ export class WorkerRegistrationTask
   }
 
   public inputSerializer() {
+    type WorkerStartupPayloadJSON = {
+      runtimeVerificationKeyRoot: string;
+      bridgeContractVerificationKey: VerificationKeyJSON | undefined;
+      compiledArtifacts: SerializedArtifactRecord;
+    };
+
     const artifactSerializer = new ArtifactRecordSerializer();
     return {
       toJSON: (payload: WorkerStartupPayload) => {
@@ -91,27 +104,22 @@ export class WorkerRegistrationTask
           compiledArtifacts: artifactSerializer.toJSON(
             payload.compiledArtifacts
           ),
-        });
+        } satisfies WorkerStartupPayloadJSON);
       },
       fromJSON: (payload: string) => {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        const jsonObject = JSON.parse(payload);
+        const jsonObject = safeParseJson<WorkerStartupPayloadJSON>(payload);
 
         return {
           runtimeVerificationKeyRoot: BigInt(
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             jsonObject.runtimeVerificationKeyRoot
           ),
           bridgeContractVerificationKey:
             jsonObject.bridgeContractVerificationKey !== undefined
               ? VerificationKeySerializer.fromJSON(
-                  // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                   jsonObject.bridgeContractVerificationKey
                 )
               : undefined,
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
           compiledArtifacts: artifactSerializer.fromJSON(
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             jsonObject.compiledArtifacts
           ),
         };

packages/sequencer/test/integration/Proven.test.ts

@@ -18,15 +18,9 @@ import {
 import { VanillaProtocolModules } from "@proto-kit/library";
 import { AppChain, InMemoryAreProofsEnabled } from "@proto-kit/sdk";
 import { container } from "tsyringe";
-import { PrivateKey, UInt64, VerificationKey } from "o1js";
+import { PrivateKey, UInt64 } from "o1js";
 
 import { testingSequencerFromModules } from "../TestingSequencer";
-
-import { ProtocolStateTestHook } from "./mocks/ProtocolStateTestHook";
-import { BlockTestService } from "./services/BlockTestService";
-import { ProvenBalance } from "./mocks/ProvenBalance";
-import { FungibleTokenContractModule } from "../../src/settlement/utils/FungibleTokenContractModule";
-import { FungibleTokenAdminContractModule } from "../../src/settlement/utils/FungibleTokenAdminContractModule";
 import {
   MinaBaseLayer,
   ProvenSettlementPermissions,
@@ -35,6 +29,10 @@ import {
   WithdrawalQueue,
 } from "../../src";
 
+import { ProtocolStateTestHook } from "./mocks/ProtocolStateTestHook";
+import { BlockTestService } from "./services/BlockTestService";
+import { ProvenBalance } from "./mocks/ProvenBalance";
+
 const timeout = 300000;
 
 describe("Proven", () => {