@proto-kit/protocol 0.1.1-develop.267 → 0.1.1-develop.298

package/src/model/StateTransitionProvableBatch.ts

@@ -1,4 +1,4 @@
-import { Bool, Provable, Struct } from "snarkyjs";
+import { Bool, Provable, Struct } from "o1js";
 import { range } from "@proto-kit/common";
 
 import { constants } from "../Constants";

package/src/model/Transaction.ts

@@ -6,7 +6,7 @@ import {
   Signature,
   Struct,
   UInt64,
-} from "snarkyjs";
+} from "o1js";
 
 function argsToHash(...args: FlexibleProvable<any>[]): Field {
   const fields = args.flatMap((argument) => argument.toFields(argument));

package/src/model/network/NetworkState.ts

@@ -1,4 +1,4 @@
-import { Field, Poseidon, Struct, UInt64 } from "snarkyjs";
+import { Field, Poseidon, Struct, UInt64 } from "o1js";
 
 export class CurrentBlock extends Struct({
   height: UInt64,

package/src/model/transaction/ProtocolTransaction.ts

@@ -1,4 +1,4 @@
-import { Bool, Field, PublicKey, Signature, Struct, UInt64 } from "snarkyjs";
+import { Bool, Field, PublicKey, Signature, Struct, UInt64 } from "o1js";
 
 export class ProtocolTransaction extends Struct({
   methodId: Field,

package/src/model/transaction/RuntimeTransaction.ts

@@ -1,4 +1,4 @@
-import { Field, Poseidon, PublicKey, Struct, UInt64 } from "snarkyjs";
+import { Field, Poseidon, PublicKey, Struct, UInt64 } from "o1js";
 
 import { ProtocolTransaction } from "./ProtocolTransaction";
 

package/src/protocol/Protocol.ts

@@ -1,4 +1,6 @@
 import {
+  AreProofsEnabled,
+  ChildContainerProvider,
   log,
   ModuleContainer,
   ModulesConfig,
@@ -18,15 +20,16 @@ import { StateService } from "../state/StateService";
 import { ProtocolModule } from "./ProtocolModule";
 import { ProvableTransactionHook } from "./ProvableTransactionHook";
 import { NoopTransactionHook } from "../blockmodules/NoopTransactionHook";
+import { ProtocolEnvironment } from "./ProtocolEnvironment";
 
 export type GenericProtocolModuleRecord = ModulesRecord<
-  TypedClass<ProtocolModule>
+  TypedClass<ProtocolModule<unknown>>
 >;
 
-interface BlockProverType extends ProtocolModule, BlockProvable {}
+interface BlockProverType extends ProtocolModule<object>, BlockProvable {}
 
 interface StateTransitionProverType
-  extends ProtocolModule,
+  extends ProtocolModule<object>,
     StateTransitionProvable {}
 
 export interface ProtocolCustomModulesRecord {
@@ -45,34 +48,22 @@ export interface ProtocolDefinition<Modules extends ProtocolModulesRecord> {
    * @deprecated
    */
   state?: StateService;
-  // config: ModulesConfig<Modules>
+  config?: ModulesConfig<Modules>;
 }
 
-export class Protocol<
-  Modules extends ProtocolModulesRecord
-> extends ModuleContainer<Modules> {
+export class Protocol<Modules extends ProtocolModulesRecord>
+  extends ModuleContainer<Modules>
+  implements ProtocolEnvironment
+{
   // .from() to create Protocol
   public static from<Modules extends ProtocolModulesRecord>(
     modules: ProtocolDefinition<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<any>(
-      (agg, item: string) => {
-        // 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 as ModulesConfig<Modules>);
-
-    return protocol;
+  ): TypedClass<Protocol<Modules>> {
+    return class ScopedProtocol extends Protocol<Modules> {
+      public constructor() {
+        super(modules);
+      }
+    };
   }
 
   public definition: ProtocolDefinition<Modules>;
@@ -85,32 +76,6 @@ export class Protocol<
   public constructor(definition: ProtocolDefinition<Modules>) {
     super(definition);
     this.definition = definition;
-
-    // Register the BlockModules seperately since we need to
-    // inject them differently later
-    let atLeastOneTransactionHookRegistered = false;
-    Object.entries(definition.modules).forEach(([key, value]) => {
-      if (Object.prototype.isPrototypeOf.call(ProvableTransactionHook, value)) {
-        this.container.register(
-          "ProvableTransactionHook",
-          { useToken: key },
-          { lifecycle: Lifecycle.ContainerScoped }
-        );
-        atLeastOneTransactionHookRegistered = true;
-      }
-    });
-
-    // We need this so that tsyringe doesn't throw when no hooks are registered
-    if (!atLeastOneTransactionHookRegistered) {
-      this.container.register(
-        "ProvableTransactionHook",
-        { useClass: NoopTransactionHook },
-        { lifecycle: Lifecycle.ContainerScoped }
-      );
-    }
-    // this.container.afterResolution<ProvableTransactionHook>("ProvableTransactionHook", (token, result) => {
-    //   if ()
-    // })
   }
 
   public get stateService(): StateService {
@@ -128,10 +93,6 @@ export class Protocol<
     log.debug(`Decorated ${moduleName}`);
     containedModule.protocol = this;
 
-    log.debug(
-      "Is instanceof:",
-      containedModule instanceof ProvableTransactionHook
-    );
     if (containedModule instanceof ProvableTransactionHook) {
       containedModule.name = moduleName;
     }
@@ -162,21 +123,67 @@ export class Protocol<
       InstanceType<Modules["StateTransitionProver"]>
     >("StateTransitionProver");
   }
+
+  public getAreProofsEnabled(): AreProofsEnabled {
+    return this.container.resolve<AreProofsEnabled>("AreProofsEnabled");
+  }
+
+  public create(childContainerProvider: ChildContainerProvider) {
+    super.create(childContainerProvider);
+
+    // Register the BlockModules seperately since we need to
+    // inject them differently later
+    let atLeastOneTransactionHookRegistered = false;
+    Object.entries(this.definition.modules).forEach(([key, value]) => {
+      if (Object.prototype.isPrototypeOf.call(ProvableTransactionHook, value)) {
+        this.container.register(
+          "ProvableTransactionHook",
+          { useToken: key },
+          { lifecycle: Lifecycle.ContainerScoped }
+        );
+        atLeastOneTransactionHookRegistered = true;
+      }
+    });
+
+    // We need this so that tsyringe doesn't throw when no hooks are registered
+    if (!atLeastOneTransactionHookRegistered) {
+      this.container.register(
+        "ProvableTransactionHook",
+        { useClass: NoopTransactionHook },
+        { lifecycle: Lifecycle.ContainerScoped }
+      );
+    }
+  }
 }
 
 export const VanillaProtocol = {
   create(stateService?: StateService) {
-    return VanillaProtocol.from({}, stateService);
+    return VanillaProtocol.from(
+      {},
+      {
+        BlockProver: {},
+        StateTransitionProver: {},
+      },
+      stateService
+    );
   },
 
   from<AdditonalModules extends GenericProtocolModuleRecord>(
     additionalModules: AdditonalModules,
+    config: ModulesConfig<
+      AdditonalModules & {
+        StateTransitionProver: typeof StateTransitionProver;
+        BlockProver: typeof BlockProver;
+      }
+    >,
     stateService?: StateService
-  ): Protocol<
-    AdditonalModules & {
-      StateTransitionProver: typeof StateTransitionProver;
-      BlockProver: typeof BlockProver;
-    }
+  ): TypedClass<
+    Protocol<
+      AdditonalModules & {
+        StateTransitionProver: typeof StateTransitionProver;
+        BlockProver: typeof BlockProver;
+      }
+    >
   > {
     return Protocol.from({
       modules: {
@@ -184,7 +191,9 @@ export const VanillaProtocol = {
         BlockProver,
         ...additionalModules,
       },
+
+      config,
       state: stateService,
     });
   },
-};
+};

package/src/protocol/ProtocolEnvironment.ts

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

package/src/protocol/ProtocolModule.ts

@@ -1,20 +1,23 @@
 import {
   AreProofsEnabled,
-  Configurable,
+  ChildContainerProvider,
+  ConfigurableModule,
+  noop,
 } from "@proto-kit/common";
 
-import type { Protocol, ProtocolModulesRecord } from "./Protocol";
+import { ProtocolEnvironment } from "./ProtocolEnvironment";
 
-export abstract class ProtocolModule
-  implements Configurable<unknown>
-{
-  public config = {};
-
-  public protocol?: Protocol<ProtocolModulesRecord>;
+export abstract class ProtocolModule<
+  Config
+> extends ConfigurableModule<Config> {
+  public protocol?: ProtocolEnvironment;
 
   public get appChain(): AreProofsEnabled | undefined {
-    return this.protocol?.dependencyContainer.resolve<AreProofsEnabled>(
-      "AppChain"
-    );
+    return this.protocol?.getAreProofsEnabled();
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public create(childContainerProvider: ChildContainerProvider): void {
+    noop();
   }
 }

package/src/protocol/ProvableTransactionHook.ts

@@ -2,6 +2,6 @@ import { BlockProverExecutionData } from "../prover/block/BlockProvable";
 
 import { TransitioningProtocolModule } from "./TransitioningProtocolModule";
 
-export abstract class ProvableTransactionHook extends TransitioningProtocolModule {
+export abstract class ProvableTransactionHook<Config> extends TransitioningProtocolModule<Config> {
   public abstract onTransaction(executionData: BlockProverExecutionData): void;
 }

package/src/protocol/TransitioningProtocolModule.ts

@@ -1,5 +1,7 @@
 import { ProtocolModule } from "./ProtocolModule";
 
-export abstract class TransitioningProtocolModule extends ProtocolModule {
+export abstract class TransitioningProtocolModule<
+  Config
+> extends ProtocolModule<Config> {
   public name?: string;
 }

package/src/prover/block/BlockProvable.ts

@@ -1,4 +1,4 @@
-import { Field, Proof, Struct } from "snarkyjs";
+import { Field, Proof, Struct } from "o1js";
 import { WithZkProgrammable } from "@proto-kit/common";
 
 import { StateTransitionProof } from "../statetransition/StateTransitionProvable";

package/src/prover/block/BlockProver.ts

@@ -1,5 +1,5 @@
 /* eslint-disable max-lines */
-import { Experimental, Field, type Proof, Provable, SelfProof } from "snarkyjs";
+import { Experimental, Field, type Proof, Provable, SelfProof } from "o1js";
 import { container, inject, injectable, injectAll } from "tsyringe";
 import {
   AreProofsEnabled,
@@ -75,7 +75,7 @@ export class BlockProverProgrammable extends ZkProgrammable<
       StateTransitionProverPublicOutput
     >,
     public readonly runtime: ZkProgrammable<undefined, MethodPublicOutput>,
-    private readonly blockModules: ProvableTransactionHook[]
+    private readonly blockModules: ProvableTransactionHook<unknown>[]
   ) {
     super();
   }
@@ -377,7 +377,7 @@ export class BlockProverProgrammable extends ZkProgrammable<
  * then be merged to be committed to the base-layer contract
  */
 @injectable()
-export class BlockProver extends ProtocolModule implements BlockProvable {
+export class BlockProver extends ProtocolModule<object> implements BlockProvable {
   public zkProgrammable: BlockProverProgrammable;
 
   public constructor(
@@ -389,7 +389,7 @@ export class BlockProver extends ProtocolModule implements BlockProvable {
     @inject("Runtime")
     public readonly runtime: WithZkProgrammable<undefined, MethodPublicOutput>,
     @injectAll("ProvableTransactionHook")
-    transactionHooks: ProvableTransactionHook[]
+    transactionHooks: ProvableTransactionHook<unknown>[]
   ) {
     super();
     this.zkProgrammable = new BlockProverProgrammable(

package/src/prover/statetransition/StateTransitionProvable.ts

@@ -1,4 +1,4 @@
-import { Field, Proof, Struct } from "snarkyjs";
+import { Field, Proof, Struct } from "o1js";
 import { WithZkProgrammable, ZkProgrammable } from "@proto-kit/common";
 
 import { StateTransitionProvableBatch } from "../../model/StateTransitionProvableBatch";

package/src/prover/statetransition/StateTransitionProver.ts

@@ -1,5 +1,5 @@
 /* eslint-disable max-lines */
-import { Bool, Experimental, Field, Provable, SelfProof } from "snarkyjs";
+import { Bool, Experimental, Field, Provable, SelfProof } from "o1js";
 import { injectable } from "tsyringe";
 import {
   AreProofsEnabled,
@@ -203,12 +203,6 @@ export class StateTransitionProverProgrammable extends ZkProgrammable<
       transition.from.value
     );
 
-    // if (!membershipValid.toBoolean()) {
-    //   console.log(
-    //     `Merklewitness error ${root1.toString()} ${root2.toString()}`
-    //   );
-    // }
-
     membershipValid
       .or(transition.from.isSome.not())
       .assertTrue(
@@ -351,7 +345,7 @@ export class StateTransitionProverProgrammable extends ZkProgrammable<
 
 @injectable()
 export class StateTransitionProver
-  extends ProtocolModule
+  extends ProtocolModule<object>
   implements StateTransitionProvable
 {
   public readonly zkProgrammable: StateTransitionProverProgrammable;

package/src/prover/statetransition/StateTransitionWitnessProvider.ts

@@ -1,4 +1,4 @@
-import type { Field } from "snarkyjs";
+import type { Field } from "o1js";
 import { injectable } from "tsyringe";
 
 import { RollupMerkleWitness } from "../../utils/merkletree/RollupMerkleTree.js";

package/src/state/State.ts

@@ -1,5 +1,5 @@
 import { Mixin } from "ts-mixer";
-import { Bool, Field, Provable, type FlexibleProvablePure } from "snarkyjs";
+import { Bool, Field, Provable, type FlexibleProvablePure } from "o1js";
 import { container } from "tsyringe";
 import { dummyValue } from "@proto-kit/common";
 

package/src/state/StateMap.ts

@@ -1,4 +1,4 @@
-import type { Field, FlexibleProvablePure } from "snarkyjs";
+import type { Field, FlexibleProvablePure } from "o1js";
 import { Mixin } from "ts-mixer";
 
 import { Path } from "../model/Path";

package/src/state/StateService.ts

@@ -1,6 +1,6 @@
-import { Field } from "snarkyjs";
+import { Field } from "o1js";
 
 export interface StateService {
   get: (key: Field) => Field[] | undefined;
   set: (key: Field, value: Field[] | undefined) => void;
-}
+}

package/src/state/assert/assert.test.ts

@@ -1,6 +1,6 @@
 import "reflect-metadata";
 
-import { Bool } from "snarkyjs";
+import { Bool } from "o1js";
 import { container } from "tsyringe";
 
 import { assert } from "./assert";

package/src/state/assert/assert.ts

@@ -1,4 +1,4 @@
-import { Bool } from "snarkyjs";
+import { Bool } from "o1js";
 import { container } from "tsyringe";
 import { log } from "@proto-kit/common";
 

package/src/state/context/RuntimeMethodExecutionContext.ts

@@ -1,6 +1,9 @@
-import { Bool } from "snarkyjs";
+import { Bool } from "o1js";
 import { singleton } from "tsyringe";
-import { ProvableMethodExecutionContext, ProvableMethodExecutionResult } from "@proto-kit/common";
+import {
+  ProvableMethodExecutionContext,
+  ProvableMethodExecutionResult,
+} from "@proto-kit/common";
 import { StateTransition } from "../../model/StateTransition";
 import { RuntimeTransaction } from "../../model/transaction/RuntimeTransaction";
 import { NetworkState } from "../../model/network/NetworkState";

package/src/state/protocol/ProtocolState.ts

@@ -21,7 +21,9 @@ const errors = {
  * underlying values to improve developer experience.
  */
 export function protocolState() {
-  return <TargetTransitioningModule extends TransitioningProtocolModule>(
+  return <
+    TargetTransitioningModule extends TransitioningProtocolModule<unknown>
+  >(
     target: TargetTransitioningModule,
     propertyKey: string
   ) => {

package/src/utils/PrefixedProvableHashList.ts

@@ -1,4 +1,4 @@
-import { Field, FlexibleProvablePure, Poseidon } from "snarkyjs";
+import { Field, FlexibleProvablePure, Poseidon } from "o1js";
 
 import { ProvableHashList } from "./ProvableHashList.js";
 import { stringToField } from "./utils";

package/src/utils/ProvableHashList.ts

@@ -1,4 +1,4 @@
-import { Field, Poseidon, FlexibleProvablePure, Bool, Provable } from "snarkyjs";
+import { Field, Poseidon, FlexibleProvablePure, Bool, Provable } from "o1js";
 
 /**
  * Utilities for creating a hash list from a given value type.

package/src/utils/merkletree/RollupMerkleTree.ts

@@ -2,7 +2,7 @@
 /* eslint-disable line-comment-position */
 /* eslint-disable no-inline-comments */
 /* eslint-disable @typescript-eslint/no-magic-numbers */
-import { Bool, Field, Poseidon, Provable, Struct } from "snarkyjs";
+import { Bool, Field, Poseidon, Provable, Struct } from "o1js";
 import { range } from "@proto-kit/common";
 
 import { notInCircuit } from "../utils";

package/src/utils/utils.ts

@@ -1,7 +1,7 @@
 // eslint-disable-next-line max-len
-/* eslint-disable @typescript-eslint/no-explicit-any,@typescript-eslint/ban-types, @typescript-eslint/no-unsafe-return,@typescript-eslint/no-empty-function */
+/* eslint-disable @typescript-eslint/no-explicit-any,@typescript-eslint/ban-types, @typescript-eslint/no-unsafe-return */
 
-import { Field, Poseidon, Provable } from "snarkyjs";
+import { Field, Poseidon, Provable } from "o1js";
 import floor from "lodash/floor";
 
 export type ReturnType<FunctionType extends Function> = FunctionType extends (
@@ -82,5 +82,3 @@ export function singleFieldToString(value: Field | bigint): string {
   }
   return value.toString();
 }
-
-export function noop(): void {}

package/test/BlockProver.test.ts

@@ -1,12 +1,5 @@
 import "reflect-metadata";
-import {
-  Bool,
-  Experimental,
-  Field,
-  PrivateKey,
-  Proof,
-  UInt64,
-} from "snarkyjs";
+import { Bool, Experimental, Field, PrivateKey, Proof, UInt64 } from "o1js";
 
 import {
   BlockProver,
@@ -29,12 +22,16 @@ import { UnsignedTransaction } from "@proto-kit/sequencer";
 import { AccountStateModule } from "../src/blockmodules/AccountStateModule";
 import { container } from "tsyringe";
 import {
-  BlockModule, DefaultProvableHashList,
+  BlockModule,
+  DefaultProvableHashList,
   MethodPublicOutput,
   NetworkState,
-  Protocol, ProtocolMethodExecutionContext,
-  ProtocolTransaction, ProvableStateTransition, RuntimeTransaction,
-  StateTransitionProver
+  Protocol,
+  ProtocolMethodExecutionContext,
+  ProtocolTransaction,
+  ProvableStateTransition,
+  RuntimeTransaction,
+  StateTransitionProver,
 } from "../src";
 
 type BlockProverProofPair = [

package/test/State.test.ts

@@ -1,5 +1,5 @@
 import "reflect-metadata";
-import { Bool, Field, Provable, UInt64 } from "snarkyjs";
+import { Bool, Field, Provable, UInt64 } from "o1js";
 import { container } from "tsyringe";
 
 import {

package/test/StateTransition.test.ts

@@ -1,12 +1,14 @@
 import "reflect-metadata";
-import { Bool, Field } from "snarkyjs";
+import { Bool, Field } from "o1js";
 import { container } from "tsyringe";
 
 import {
   Option,
   ProvableStateTransition,
   DefaultProvableHashList,
-  StateTransitionProvableBatch, CachedMerkleTreeStore, InMemoryMerkleTreeStorage
+  StateTransitionProvableBatch,
+  CachedMerkleTreeStore,
+  InMemoryMerkleTreeStorage,
 } from "../src/index";
 import {
   RollupMerkleTree,

package/test/utils/MerkleTree.test.ts

@@ -1,5 +1,5 @@
 import { MockAsyncMerkleTreeStore } from "@proto-kit/module/test/state/MockAsyncMerkleStore";
-import { Field, Provable } from "snarkyjs";
+import { Field, Provable } from "o1js";
 
 import { CachedMerkleTreeStore, RollupMerkleTree } from "../../src";
 import { log } from "@proto-kit/common";

package/test/utils.test.ts

@@ -1,5 +1,5 @@
 import "reflect-metadata";
-import { Field } from "snarkyjs";
+import { Field } from "o1js";
 
 import { stringToField } from "../src";