Fixed graphql test

rpanic · rpanic · commit 1cede08e8869 · 2025-02-17T13:11:29.000+01:00
diff --git a/packages/sequencer/test/TestingSequencer.ts b/packages/sequencer/test/TestingSequencer.ts
@@ -30,37 +30,36 @@ export interface DefaultTestingSequencerModules extends SequencerModulesRecord {
   SequencerStartupModule: typeof SequencerStartupModule;
 }
 
-export function testingSequencerFromModules<
+export function testingSequencerModules<
   AdditionalModules extends SequencerModulesRecord,
   AdditionalTaskWorkerModules extends TaskWorkerModulesRecord,
 >(
   modules: AdditionalModules,
   additionalTaskWorkerModules?: AdditionalTaskWorkerModules
-): TypedClass<Sequencer<DefaultTestingSequencerModules & AdditionalModules>> {
+) {
   const taskWorkerModule = LocalTaskWorkerModule.from({
     ...VanillaTaskWorkerModules.withoutSettlement(),
     ...additionalTaskWorkerModules,
   });
 
-  const defaultModules: DefaultTestingSequencerModules = {
+  const defaultModules = {
     Database: InMemoryDatabase,
     Mempool: PrivateMempool,
     BaseLayer: NoopBaseLayer,
-    // LocalTaskWorkerModule: taskWorkerModule,
+    LocalTaskWorkerModule: taskWorkerModule,
     BatchProducerModule,
     BlockProducerModule,
     BlockTrigger: ManualBlockTrigger,
     TaskQueue: LocalTaskQueue,
     FeeStrategy: ConstantFeeStrategy,
-  } as DefaultTestingSequencerModules;
+    SequencerStartupModule,
+  } satisfies DefaultTestingSequencerModules;
 
-  return Sequencer.from({
-    modules: {
-      ...defaultModules,
-      ...modules,
-      // We need to make sure that the taskworkermodule is initialized last
-      LocalTaskWorkerModule: taskWorkerModule,
-      SequencerStartupModule,
-    },
-  });
+  return {
+    ...defaultModules,
+    ...modules,
+    // We need to make sure that the taskworkermodule is initialized last
+    LocalTaskWorkerModule: defaultModules.LocalTaskWorkerModule,
+    SequencerStartupModule: defaultModules.SequencerStartupModule,
+  };
 }
diff --git a/packages/sequencer/test/integration/BlockProduction.test.ts b/packages/sequencer/test/integration/BlockProduction.test.ts
@@ -33,7 +33,7 @@ import {
 } from "../../src";
 import {
   DefaultTestingSequencerModules,
-  testingSequencerFromModules,
+  testingSequencerModules,
 } from "../TestingSequencer";
 
 import { Balance } from "./mocks/Balance";
@@ -111,7 +111,10 @@ describe("block production", () => {
       },
     });
 
-    const sequencerClass = testingSequencerFromModules({});
+    const modules = testingSequencerModules({});
+    const sequencerClass = Sequencer.from({
+      modules,
+    });
 
     // TODO Analyze how we can get rid of the library import for mandatory modules
     const protocolClass = Protocol.from({
@@ -130,8 +133,8 @@ describe("block production", () => {
 
     app.configure({
       Sequencer: {
-        Database: {},
-        BlockTrigger: {},
+        // Database: {},
+        // BlockTrigger: {},
         Mempool: {},
         BatchProducerModule: {},
         BlockProducerModule: {},
@@ -140,7 +143,7 @@ describe("block production", () => {
         TaskQueue: {},
         FeeStrategy: {},
         SequencerStartupModule: {},
-      },
+      } as any,
       Runtime: {
         Balance: {},
         NoopRuntime: {},
diff --git a/packages/stack/test/graphql/graphql-server.ts b/packages/stack/test/graphql/graphql-server.ts
@@ -0,0 +1,272 @@
+import {
+  AppChain,
+  BlockStorageNetworkStateModule,
+  InMemorySigner,
+  InMemoryTransactionSender,
+  StateServiceQueryModule,
+} from "@proto-kit/sdk";
+import { PrivateKey, PublicKey } from "o1js";
+import { Runtime, runtimeMethod, runtimeModule } from "@proto-kit/module";
+import { Protocol, State, state } from "@proto-kit/protocol";
+import {
+  Balance,
+  Balances,
+  BalancesKey,
+  TokenId,
+  VanillaProtocolModules,
+  VanillaRuntimeModules,
+  UInt64,
+} from "@proto-kit/library";
+import { log } from "@proto-kit/common";
+import {
+  BatchProducerModule,
+  InMemoryDatabase,
+  LocalTaskQueue,
+  LocalTaskWorkerModule,
+  NoopBaseLayer,
+  PrivateMempool,
+  Sequencer,
+  BlockProducerModule,
+  VanillaTaskWorkerModules,
+  SequencerStartupModule,
+  ManualBlockTrigger,
+} from "@proto-kit/sequencer";
+import {
+  BatchStorageResolver,
+  GraphqlSequencerModule,
+  GraphqlServer,
+  MempoolResolver,
+  MerkleWitnessResolver,
+  NodeStatusResolver,
+  QueryGraphqlModule,
+  BlockResolver,
+} from "@proto-kit/api";
+import { container } from "tsyringe";
+
+@runtimeModule()
+export class TestBalances extends Balances {
+  /**
+   * We use `satisfies` here in order to be able to access
+   * presets by key in a type safe way.
+   */
+  // public static presets = {} satisfies Presets<object>;
+
+  @state() public totalSupply = State.from<UInt64>(UInt64);
+
+  @runtimeMethod()
+  public async getBalanceForUser(
+    tokenId: TokenId,
+    address: PublicKey
+  ): Promise<Balance> {
+    return await super.getBalance(tokenId, address);
+  }
+
+  @runtimeMethod()
+  public async addBalance(
+    tokenId: TokenId,
+    address: PublicKey,
+    balance: UInt64
+  ) {
+    const totalSupply = await this.totalSupply.get();
+    await this.totalSupply.set(totalSupply.orElse(UInt64.zero).add(balance));
+
+    const previous = await this.balances.get(
+      new BalancesKey({ tokenId, address })
+    );
+    await this.balances.set(
+      new BalancesKey({ tokenId, address }),
+      previous.orElse(UInt64.zero).add(balance)
+    );
+  }
+}
+
+export async function startGraphqlServer() {
+  log.setLevel("DEBUG");
+
+  const appChain = AppChain.from({
+    Runtime: Runtime.from({
+      modules: VanillaRuntimeModules.with({
+        Balances: TestBalances,
+      }),
+    }),
+
+    Protocol: Protocol.from({
+      modules: VanillaProtocolModules.with({}),
+    }),
+
+    Sequencer: Sequencer.from({
+      modules: {
+        Database: InMemoryDatabase,
+        // Database: PrismaRedisDatabase,
+
+        Mempool: PrivateMempool,
+        GraphqlServer,
+        LocalTaskWorkerModule: LocalTaskWorkerModule.from(
+          VanillaTaskWorkerModules.withoutSettlement()
+        ),
+
+        BaseLayer: NoopBaseLayer,
+        BatchProducerModule,
+        BlockProducerModule,
+        BlockTrigger: ManualBlockTrigger,
+        TaskQueue: LocalTaskQueue,
+        // SettlementModule: SettlementModule,
+
+        Graphql: GraphqlSequencerModule.from({
+          modules: {
+            MempoolResolver,
+            QueryGraphqlModule,
+            BatchStorageResolver,
+            BlockResolver,
+            NodeStatusResolver,
+            MerkleWitnessResolver,
+          },
+
+          config: {
+            MempoolResolver: {},
+            QueryGraphqlModule: {},
+            BatchStorageResolver: {},
+            NodeStatusResolver: {},
+            MerkleWitnessResolver: {},
+            BlockResolver: {},
+          },
+        }),
+
+        SequencerStartupModule,
+      },
+    }),
+
+    modules: {
+      Signer: InMemorySigner,
+      TransactionSender: InMemoryTransactionSender,
+      QueryTransportModule: StateServiceQueryModule,
+      NetworkStateTransportModule: BlockStorageNetworkStateModule,
+    },
+  });
+
+  appChain.configure({
+    Runtime: {
+      Balances: {},
+    },
+
+    Protocol: {
+      BlockProver: {},
+      StateTransitionProver: {},
+      AccountState: {},
+      BlockHeight: {},
+      TransactionFee: {
+        tokenId: 0n,
+        feeRecipient: PrivateKey.random().toPublicKey().toBase58(),
+        baseFee: 0n,
+        methods: {},
+        perWeightUnitFee: 0n,
+      },
+      LastStateRoot: {},
+    },
+
+    Sequencer: {
+      GraphqlServer: {
+        port: 8080,
+        host: "0.0.0.0",
+        graphiql: true,
+      },
+      SequencerStartupModule: {},
+
+      // SettlementModule: {
+      //   address: PrivateKey.random().toPublicKey(),
+      //   feepayer: PrivateKey.random(),
+      // },
+
+      Graphql: {
+        QueryGraphqlModule: {},
+        MempoolResolver: {},
+        BatchStorageResolver: {},
+        NodeStatusResolver: {},
+        BlockResolver: {},
+        MerkleWitnessResolver: {},
+      },
+
+      Database: {
+        // redis: {
+        //   host: "localhost",
+        //   port: 6379,
+        //   password: "password",
+        // },
+        // prisma: {
+        //   connection: {
+        //     host: "localhost",
+        //     password: "password",
+        //     username: "user",
+        //     port: 5432,
+        //     db: {
+        //       name: "protokit",
+        //     },
+        //   },
+        // },
+      },
+
+      Mempool: {},
+      BatchProducerModule: {},
+      LocalTaskWorkerModule: VanillaTaskWorkerModules.defaultConfig(),
+      BaseLayer: {},
+      TaskQueue: {},
+
+      BlockProducerModule: {
+        allowEmptyBlock: true,
+      },
+
+      BlockTrigger: {},
+    },
+
+    TransactionSender: {},
+    QueryTransportModule: {},
+    NetworkStateTransportModule: {},
+
+    Signer: {
+      signer: PrivateKey.random(),
+    },
+  });
+
+  await appChain.start(false, container.createChildContainer());
+  // const pk = PublicKey.fromBase58(
+  //   "B62qmETai5Y8vvrmWSU8F4NX7pTyPqYLMhc1pgX3wD8dGc2wbCWUcqP"
+  // );
+
+  const balances = appChain.runtime.resolve("Balances");
+
+  const priv = PrivateKey.fromBase58(
+    "EKFEMDTUV2VJwcGmCwNKde3iE1cbu7MHhzBqTmBtGAd6PdsLTifY"
+  );
+
+  const tokenId = TokenId.from(0);
+
+  const as = await appChain.query.protocol.AccountState.accountState.get(
+    priv.toPublicKey()
+  );
+  const nonce = Number(as?.nonce.toString() ?? "0");
+
+  const tx = await appChain.transaction(
+    priv.toPublicKey(),
+    async () => {
+      await balances.addBalance(tokenId, priv.toPublicKey(), UInt64.from(1000));
+    },
+    {
+      nonce,
+    }
+  );
+  appChain.resolve("Signer").config.signer = priv;
+  await tx.sign();
+  await tx.send();
+
+  const tx2 = await appChain.transaction(
+    priv.toPublicKey(),
+    async () => {
+      await balances.addBalance(tokenId, priv.toPublicKey(), UInt64.from(1000));
+    },
+    { nonce: nonce + 1 }
+  );
+  await tx2.sign();
+  await tx2.send();
+
+  return appChain;
+}
diff --git a/packages/stack/test/graphql/graphql.test.ts b/packages/stack/test/graphql/graphql.test.ts
@@ -22,7 +22,7 @@ import {
 import { beforeAll } from "@jest/globals";
 import { container } from "tsyringe";
 
-import { startServer, TestBalances } from "../../src/scripts/graphql/server";
+import { startGraphqlServer, TestBalances } from "./graphql-server";
 
 const pk = PrivateKey.random();
 
@@ -93,12 +93,12 @@ function prepareClient() {
 
 describe("graphql client test", () => {
   let appChain: ReturnType<typeof prepareClient>;
-  let server: Awaited<ReturnType<typeof startServer>>;
+  let server: Awaited<ReturnType<typeof startGraphqlServer>>;
   let trigger: ManualBlockTrigger;
   const tokenId = TokenId.from(0);
 
   beforeAll(async () => {
-    server = await startServer();
+    server = await startGraphqlServer();
 
     await sleep(2000);
 
