Merge branch 'develop' into fix/tests-node-upgrade

rpanic · rpanic · commit 31c2013c4b4a · 2025-01-31T12:26:58.000+01:00
diff --git a/packages/common/src/config/ModuleContainer.ts b/packages/common/src/config/ModuleContainer.ts
@@ -4,7 +4,7 @@ import {
   DependencyContainer,
   Frequency,
   InjectionToken,
-  instancePerContainerCachingFactory,
+  instanceCachingFactory,
   isClassProvider,
   isFactoryProvider,
   isTokenProvider,
@@ -417,9 +417,7 @@ export class ModuleContainer<
           // this enables us to have a singletoned factory
           // that returns the same instance for each resolve
           this.container.register(key, {
-            useFactory: instancePerContainerCachingFactory(
-              declaration.useFactory
-            ),
+            useFactory: instanceCachingFactory(declaration.useFactory),
           });
         } else if (isClassProvider(declaration)) {
           this.container.register(key, declaration, {
diff --git a/packages/module/src/method/MethodParameterEncoder.ts b/packages/module/src/method/MethodParameterEncoder.ts
@@ -62,7 +62,7 @@ function getAllPropertyNamesOfPrototypeChain(type: unknown): string[] {
   );
 }
 
-function isFlexibleProvablePure(
+export function isFlexibleProvablePure(
   type: unknown
 ): type is FlexibleProvablePure<unknown> {
   // The required properties are defined on the prototype for Structs and CircuitValues
@@ -73,35 +73,43 @@ function isFlexibleProvablePure(
   return mandatory.every((prop) => props.includes(prop));
 }
 
-export class MethodParameterEncoder {
-  public static fromMethod(target: RuntimeModule<unknown>, methodName: string) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    const paramtypes: ArgTypeArray = Reflect.getMetadata(
-      "design:paramtypes",
-      target,
-      methodName
+export function checkArgsProvable(
+  target: RuntimeModule<unknown>,
+  methodName: string
+) {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+  const paramtypes: ArgTypeArray = Reflect.getMetadata(
+    "design:paramtypes",
+    target,
+    methodName
+  );
+
+  if (paramtypes === undefined) {
+    throw new Error(
+      `Method with name ${methodName} doesn't exist on this module`
     );
+  }
 
-    if (paramtypes === undefined) {
-      throw new Error(
-        `Method with name ${methodName} doesn't exist on this module`
-      );
-    }
+  const indizes = paramtypes
+    .map((type, index) => {
+      if (isProofBaseType(type) || isFlexibleProvablePure(type)) {
+        return undefined;
+      }
+      return `${index}`;
+    })
+    .filter(filterNonUndefined);
+  if (indizes.length > 0) {
+    const indexString = indizes.reduce((a, b) => `${a}, ${b}`);
+    throw new Error(
+      `Not all arguments of method '${target.name}.${methodName}' are provable types or proofs (indizes: [${indexString}])`
+    );
+  }
+  return paramtypes;
+}
 
-    const indizes = paramtypes
-      .map((type, index) => {
-        if (isProofBaseType(type) || isFlexibleProvablePure(type)) {
-          return undefined;
-        }
-        return `${index}`;
-      })
-      .filter(filterNonUndefined);
-    if (indizes.length > 0) {
-      const indexString = indizes.reduce((a, b) => `${a}, ${b}`);
-      throw new Error(
-        `Not all arguments of method '${target.name}.${methodName}' are provable types or proofs (indizes: [${indexString}])`
-      );
-    }
+export class MethodParameterEncoder {
+  public static fromMethod(target: RuntimeModule<unknown>, methodName: string) {
+    const paramtypes = checkArgsProvable(target, methodName);
 
     return new MethodParameterEncoder(paramtypes);
   }
diff --git a/packages/module/src/method/runtimeMethod.ts b/packages/module/src/method/runtimeMethod.ts
@@ -17,7 +17,10 @@ import {
 
 import type { RuntimeModule } from "../runtime/RuntimeModule.js";
 
-import { MethodParameterEncoder } from "./MethodParameterEncoder";
+import {
+  MethodParameterEncoder,
+  checkArgsProvable,
+} from "./MethodParameterEncoder";
 
 const errors = {
   runtimeNotProvided: (name: string) =>
@@ -196,11 +199,9 @@ function runtimeMethodInternal(options: {
   return (
     target: RuntimeModule<unknown>,
     methodName: string,
-    descriptor: TypedPropertyDescriptor<
-      // TODO Limit possible parameter types
-      (...args: any[]) => Promise<any>
-    >
+    descriptor: TypedPropertyDescriptor<(...args: any[]) => Promise<any>>
   ) => {
+    checkArgsProvable(target, methodName);
     const executionContext = container.resolve<RuntimeMethodExecutionContext>(
       RuntimeMethodExecutionContext
     );
diff --git a/packages/module/test/method/MethodParameterEncoder.test.ts b/packages/module/test/method/MethodParameterEncoder.test.ts
@@ -7,14 +7,9 @@ import {
   ZkProgram,
   Proof,
 } from "o1js";
-import { NonMethods, noop } from "@proto-kit/common";
+import { NonMethods } from "@proto-kit/common";
 
-import {
-  MethodParameterEncoder,
-  RuntimeModule,
-  runtimeModule,
-  runtimeMethod,
-} from "../../src";
+import { MethodParameterEncoder } from "../../src";
 
 class TestStruct extends Struct({
   a: Field,
@@ -124,29 +119,3 @@ describe("MethodParameterEncoder", () => {
     );
   }, 30000);
 });
-
-class TieredStruct extends TestStruct {}
-
-@runtimeModule()
-class TestModule extends RuntimeModule {
-  @runtimeMethod()
-  public async foo(
-    a: TieredStruct,
-    b: PublicKey,
-    c: Field,
-    d: TestProof,
-    e: string
-  ) {
-    noop();
-  }
-}
-
-describe("MethodParameterEncoder construction", () => {
-  it("should throw on non-provable method signature", () => {
-    const module = new TestModule();
-    module.name = "testModule";
-    expect(() => MethodParameterEncoder.fromMethod(module, "foo")).toThrowError(
-      "'testModule.foo' are provable types or proofs (indizes: [4])"
-    );
-  });
-});
diff --git a/packages/module/test/method/runtimeMethod-fail.test.ts b/packages/module/test/method/runtimeMethod-fail.test.ts
@@ -0,0 +1,50 @@
+import { Bool, Field, PublicKey, Struct, ZkProgram } from "o1js";
+import { noop } from "@proto-kit/common";
+
+import { runtimeMethod, RuntimeModule, runtimeModule } from "../../src";
+
+class TestStruct extends Struct({
+  a: Field,
+  b: Bool,
+}) {}
+class TieredStruct extends TestStruct {}
+const TestProgram = ZkProgram({
+  name: "TestProgram",
+  publicInput: PublicKey,
+  publicOutput: TestStruct,
+  methods: {
+    foo: {
+      privateInputs: [],
+      method: async (input: PublicKey) => {
+        return {
+          a: Field(input.x),
+          b: Bool(input.isOdd),
+        };
+      },
+    },
+  },
+});
+class TestProof extends ZkProgram.Proof(TestProgram) {}
+
+describe("Creating module with non-provable method argument", () => {
+  it("should throw on non-provable method signature", () => {
+    expect(() => {
+      @runtimeModule()
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      class TestModule extends RuntimeModule {
+        @runtimeMethod()
+        public async foo(
+          a: TieredStruct,
+          b: PublicKey,
+          c: Field,
+          d: TestProof,
+          e: string
+        ) {
+          noop();
+        }
+      }
+    }).toThrow(
+      "Not all arguments of method 'undefined.foo' are provable types or proofs (indizes: [4])"
+    );
+  });
+});
diff --git a/packages/protocol/src/protocol/Protocol.ts b/packages/protocol/src/protocol/Protocol.ts
@@ -28,10 +28,16 @@ import { ProtocolEnvironment } from "./ProtocolEnvironment";
 import { ProvableBlockHook } from "./ProvableBlockHook";
 import { TransitioningProtocolModule } from "./TransitioningProtocolModule";
 
+/**
+ * This is a mapping of abstract classes to their respective injection tokens.
+ * Keys are the abstract classes names, which need to be set dynamically
+ * and can't be hardcoded since producing optimized builds may mangle the
+ * class names, making them different from the ones in the source code.
+ */
 const PROTOCOL_INJECTION_TOKENS: Record<string, string> = {
-  ProvableTransactionHook: "ProvableTransactionHook",
-  ProvableBlockHook: "ProvableBlockHook",
-  ProvableSettlementHook: "ProvableSettlementHook",
+  [ProvableTransactionHook.name]: "ProvableTransactionHook",
+  [ProvableBlockHook.name]: "ProvableBlockHook",
+  [ProvableSettlementHook.name]: "ProvableSettlementHook",
 };
 
 export type ProtocolModulesRecord = ModulesRecord<
@@ -162,7 +168,7 @@ export class Protocol<
 
       implementingModules.forEach(([key]) => {
         this.container.register(
-          abstractType.name,
+          newInjectionToken,
           { useToken: key },
           { lifecycle: Lifecycle.ContainerScoped }
         );
@@ -175,7 +181,7 @@ export class Protocol<
 
         // Register default (noop) version
         this.container.register(
-          abstractType.name,
+          newInjectionToken,
           { useClass: defaultType },
           { lifecycle: Lifecycle.ContainerScoped }
         );
diff --git a/packages/sequencer/test/integration/BlockProduction.test.ts b/packages/sequencer/test/integration/BlockProduction.test.ts
@@ -312,6 +312,107 @@ describe("block production", () => {
     expect(newState).toBeUndefined();
   }, 30_000);
 
+  it("should produce txs in non-consecutive blocks", async () => {
+    log.setLevel("TRACE");
+
+    const privateKey = PrivateKey.random();
+    const publicKey = privateKey.toPublicKey();
+
+    const privateKey2 = PrivateKey.random();
+    const publicKey2 = privateKey2.toPublicKey();
+
+    await mempool.add(
+      createTransaction({
+        runtime,
+        method: ["Balance", "setBalanceIf"],
+        privateKey,
+        args: [publicKey, UInt64.from(100), Bool(true)],
+        nonce: 0,
+      })
+    );
+
+    // let [block, batch] = await blockTrigger.produceBlockAndBatch();
+    const block = await blockTrigger.produceBlock();
+
+    expect(block).toBeDefined();
+
+    expect(block!.transactions).toHaveLength(1);
+    expect(block!.transactions[0].status.toBoolean()).toBe(true);
+    expect(block!.transactions[0].statusMessage).toBeUndefined();
+
+    expect(block!.transactions[0].stateTransitions).toHaveLength(1);
+    expect(block!.transactions[0].protocolTransitions).toHaveLength(2);
+
+    await blockTrigger.produceBlock();
+
+    await mempool.add(
+      createTransaction({
+        runtime,
+        method: ["Balance", "setBalanceIf"],
+        privateKey: privateKey2,
+        args: [publicKey2, UInt64.from(100), Bool(true)],
+        nonce: 0,
+      })
+    );
+    await blockTrigger.produceBlock();
+
+    await mempool.add(
+      createTransaction({
+        runtime,
+        method: ["Balance", "setBalanceIf"],
+        privateKey: privateKey2,
+        args: [publicKey2, UInt64.from(100), Bool(true)],
+        nonce: 1,
+      })
+    );
+    await blockTrigger.produceBlock();
+
+    await mempool.add(
+      createTransaction({
+        runtime,
+        method: ["Balance", "setBalanceIf"],
+        privateKey: privateKey2,
+        args: [publicKey2, UInt64.from(100), Bool(true)],
+        nonce: 2,
+      })
+    );
+    await blockTrigger.produceBlock();
+
+    await mempool.add(
+      createTransaction({
+        runtime,
+        method: ["Balance", "setBalanceIf"],
+        privateKey: privateKey2,
+        args: [publicKey2, UInt64.from(100), Bool(true)],
+        nonce: 3,
+      })
+    );
+    await blockTrigger.produceBlock();
+
+    // Second tx
+    await mempool.add(
+      createTransaction({
+        runtime,
+        method: ["Balance", "setBalanceIf"],
+        privateKey,
+        args: [publicKey, UInt64.from(100), Bool(true)],
+        nonce: 1,
+      })
+    );
+
+    log.info("Starting second block");
+
+    const block2 = await blockTrigger.produceBlock();
+
+    expect(block2).toBeDefined();
+
+    expect(block2!.transactions).toHaveLength(1);
+    console.log(block2!.transactions[0]);
+    console.log(block2!.transactions[0].statusMessage);
+    expect(block2!.transactions[0].status.toBoolean()).toBe(true);
+    expect(block2!.transactions[0].statusMessage).toBeUndefined();
+  }, 60_000);
+
   const numberTxs = 3;
 
   it("should produce block with multiple transaction", async () => {
