Refactor/refactor provable types

packages/api/src/graphql/modules/BlockResolver.ts

@@ -1,5 +1,5 @@
 import { inject } from "tsyringe";
-import { Block, BlockStorage } from "@proto-kit/sequencer";
+import { Block, BlockStorage, PendingTransaction } from "@proto-kit/sequencer";
 import { Arg, Field, ObjectType, Query } from "type-graphql";
 
 import { GraphqlModule, graphqlModule } from "../GraphqlModule";
@@ -10,17 +10,17 @@ import { BatchTransactionModel } from "./model/BatchTransactionModel";
 export class BlockModel {
   public static fromServiceLayerModel(block: Block) {
     return new BlockModel(
-      Number(block.networkState.during.block.height.toBigInt()),
+      Number(block.networkState.during.block.height),
       block.transactions.map((tx) =>
         BatchTransactionModel.fromServiceLayerModel({
-          tx: tx.tx,
-          status: tx.status.toBoolean(),
+          tx: PendingTransaction.fromJSON(tx.tx),
+          status: tx.status,
           statusMessage: tx.statusMessage,
         })
       ),
-      block.transactionsHash.toString(),
-      block.hash.toString(),
-      block.previousBlockHash?.toString()
+      block.transactionsHash,
+      block.hash,
+      block.previousBlockHash
     );
   }
 

packages/api/src/graphql/modules/MempoolResolver.ts

@@ -125,10 +125,10 @@ export class MempoolResolver extends GraphqlModule {
     description: "Adds a transaction to the mempool and validates it",
   })
   public async submitTx(@Arg("tx") tx: TransactionObject): Promise<string> {
-    const decoded = PendingTransaction.fromJSON(tx);
+    const decoded = PendingTransaction.fromJSON(tx).toJSON();
     await this.mempool.add(decoded);
 
-    return decoded.hash().toString();
+    return decoded.hash;
   }
 
   // TODO Add retrieval of pending messages somewhere as well
@@ -162,6 +162,6 @@ export class MempoolResolver extends GraphqlModule {
   })
   public async transactions() {
     const txs = await this.transactionStorage.getPendingUserTransactions();
-    return txs.map((x) => x.hash().toString());
+    return txs.map((x) => x.hash);
   }
 }

packages/api/src/metrics/SequencerInstrumentation.ts

@@ -15,7 +15,7 @@ export class SequencerInstrumentation extends InstrumentationBase<{}> {
     super("protokit", "canary", {});
     if (trigger !== undefined) {
       trigger.events.on("block-produced", (block) => {
-        this.blockProduced(parseInt(block.height.toString(), 10));
+        this.blockProduced(parseInt(block.height, 10));
       });
     }
   }

packages/indexer/src/IndexerNotifier.ts

@@ -48,10 +48,7 @@ export class IndexerNotifier extends SequencerModule<Record<never, never>> {
       this.indexSettlementTask.inputSerializer();
 
     this.sequencer.events.on("block-metadata-produced", async (block) => {
-      log.debug(
-        "Notifiying the indexer about block",
-        block.block.height.toBigInt()
-      );
+      log.debug("Notifiying the indexer about block", block.block.height);
       const payload = await inputSerializer.toJSON(block);
       const sequencerId = this.sequencerIdProvider.getSequencerId();
 
@@ -69,7 +66,8 @@ export class IndexerNotifier extends SequencerModule<Record<never, never>> {
         const txQueue = await this.taskQueue.getQueue(
           this.indexPendingTxTask.name
         );
-        const payload = await txInputSerializer.toJSON(tx);
+        // This part seems weird
+        const payload = await txInputSerializer.toJSON(tx.toJSON());
         const sequencerId = this.sequencerIdProvider.getSequencerId();
 
         const task: TaskPayload = {

packages/indexer/src/tasks/IndexBlockTask.ts

@@ -37,12 +37,11 @@ export class IndexBlockTask
       await this.blockStorage.pushBlock(input.block);
       await this.blockStorage.pushResult(input.result);
     } catch (error) {
-      log.error("Failed to index block", input.block.height.toBigInt(), error);
-      return undefined;
+      log.error("Failed to index block", input.block.height, error);
+      return;
     }
 
-    log.info(`Block ${input.block.height.toBigInt()} indexed sucessfully`);
-    return "";
+    log.info(`Block ${input.block.height} indexed sucessfully`);
   }
 
   public inputSerializer(): TaskSerializer<IndexBlockTaskParameters> {

packages/indexer/src/tasks/IndexPendingTxTask.ts

@@ -1,5 +1,5 @@
 import {
-  PendingTransaction,
+  PendingTransactionJSONType,
   Task,
   TaskSerializer,
   TaskWorkerModule,
@@ -13,7 +13,7 @@ import { IndexPendingTxTaskParametersSerializer } from "./IndexPendingTxTaskPara
 @injectable()
 export class IndexPendingTxTask
   extends TaskWorkerModule
-  implements Task<PendingTransaction, string | void>
+  implements Task<PendingTransactionJSONType, string | void>
 {
   public name = "index-pending-tx";
 
@@ -28,7 +28,9 @@ export class IndexPendingTxTask
   // eslint-disable-next-line @typescript-eslint/no-empty-function
   public async prepare(): Promise<void> {}
 
-  public async compute(input: PendingTransaction): Promise<string | void> {
+  public async compute(
+    input: PendingTransactionJSONType
+  ): Promise<string | void> {
     try {
       await this.transactionStorage.pushUserTransaction(input);
       return "";
@@ -38,7 +40,7 @@ export class IndexPendingTxTask
     }
   }
 
-  public inputSerializer(): TaskSerializer<PendingTransaction> {
+  public inputSerializer(): TaskSerializer<PendingTransactionJSONType> {
     return this.taskSerializer;
   }
 

packages/indexer/src/tasks/IndexPendingTxTaskParameters.ts

@@ -1,18 +1,18 @@
-import { PendingTransaction } from "@proto-kit/sequencer";
+import { PendingTransactionJSONType } from "@proto-kit/sequencer";
 import { TransactionMapper } from "@proto-kit/persistance";
 import { injectable } from "tsyringe";
 
 @injectable()
 export class IndexPendingTxTaskParametersSerializer {
   public constructor(public transactionMapper: TransactionMapper) {}
 
-  public toJSON(parameters: PendingTransaction): string {
+  public toJSON(parameters: PendingTransactionJSONType): string {
     return JSON.stringify({
       tx: this.transactionMapper.mapOut(parameters),
     });
   }
 
-  public fromJSON(json: string): PendingTransaction {
+  public fromJSON(json: string): PendingTransactionJSONType {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const parsed = JSON.parse(json) as {
       tx: ReturnType<TransactionMapper["mapOut"]>;

packages/indexer/test/GeneratedResolverFactoryGraphqlModule.test.ts

@@ -8,7 +8,7 @@ import { log } from "@proto-kit/common";
 import { jest } from "@jest/globals";
 
 import { Indexer } from "../src/Indexer";
-import { GeneratedResolverFactoryGraphqlModule } from "../src/api/GeneratedResolverFactoryGraphqlModule";
+import { GeneratedResolverFactoryGraphqlModule } from "../src";
 
 log.setLevel("info");
 

packages/indexer/test/IndexBlockTask.test.ts

@@ -54,8 +54,6 @@ describe("IndexBlockTask", () => {
     const storage = indexer.resolve("BlockStorage");
     const latestBlock = await storage.getLatestBlock();
 
-    expect(latestBlock?.block.hash.toBigInt()).toBe(
-      block.block.hash.toBigInt()
-    );
+    expect(latestBlock?.block.hash).toBe(block.block.hash);
   });
 });

packages/indexer/test/IndexerNotifier.test.ts

@@ -141,7 +141,7 @@ async function sendTransactions(
   const txs = await mempool.getTxs();
   console.log(
     "txs",
-    txs.map((tx) => tx.nonce.toBigInt())
+    txs.map((tx) => tx.nonce)
   );
 
   return await appChain.produceBlock();
@@ -183,7 +183,7 @@ describe.skip("IndexerNotifier", () => {
       .resolve(IndexBlockTaskParametersSerializer)
       .fromJSON(addTaskSpy.mock.lastCall?.[0].payload!);
 
-    expect(block.height.toBigInt()).toBe(0n);
+    expect(block.height).toBe("0");
     expect(block.transactions.length).toBe(2);
   });
 });

packages/library/src/hooks/RuntimeFeeAnalyzerService.ts

@@ -110,8 +110,8 @@ export class RuntimeFeeAnalyzerService extends ConfigurableModule<RuntimeFeeAnal
                 {
                   ...values,
 
-                  [methodId.toString()]: {
-                    methodId,
+                  [methodId]: {
+                    methodId: BigInt(methodId),
 
                     baseFee:
                       this.config.methods[combinedMethodName]?.baseFee ??
@@ -129,7 +129,7 @@ export class RuntimeFeeAnalyzerService extends ConfigurableModule<RuntimeFeeAnal
                 {
                   ...indexes,
                   // eslint-disable-next-line no-plusplus
-                  [methodId.toString()]: BigInt(methodCounter++),
+                  [methodId]: BigInt(methodCounter++),
                 },
               ];
             },

packages/module/src/runtime/MethodIdResolver.ts

@@ -29,7 +29,7 @@ export class MethodIdResolver {
       this.runtime.assertIsValidModuleName(moduleName);
 
       runtime.resolve(moduleName).runtimeMethodNames.forEach((methodName) => {
-        dict[this.getMethodId(moduleName, methodName).toString()] = {
+        dict[this.getMethodId(moduleName, methodName)] = {
           moduleName,
           methodName,
         };
@@ -83,8 +83,8 @@ export class MethodIdResolver {
       }, {});
   }
 
-  public getMethodNameFromId(methodId: bigint): [string, string] | undefined {
-    const methodPath = this.dictionary[methodId.toString()];
+  public getMethodNameFromId(methodId: string): [string, string] | undefined {
+    const methodPath = this.dictionary[methodId];
 
     if (methodPath === undefined) {
       return undefined;
@@ -97,12 +97,12 @@ export class MethodIdResolver {
     return [moduleName, methodName];
   }
 
-  public getMethodId(moduleName: string, methodName: string): bigint {
+  public getMethodId(moduleName: string, methodName: string): string {
     this.runtime.assertIsValidModuleName(moduleName);
 
     return Poseidon.hash([
       stringToField(moduleName),
       stringToField(methodName),
-    ]).toBigInt();
+    ]).toString();
   }
 }

packages/module/src/runtime/Runtime.ts

@@ -337,7 +337,7 @@ export class Runtime<Modules extends RuntimeModulesRecord>
    * Encoding: "stringToField(module.name) << 128 + stringToField(method-name)"
    */
   public getMethodById(
-    methodId: bigint
+    methodId: string
   ): ((...args: unknown[]) => Promise<unknown>) | undefined {
     const methodDescriptor =
       this.methodIdResolver.getMethodNameFromId(methodId);

packages/persistance/src/services/prisma/PrismaBlockStorage.ts

@@ -1,5 +1,5 @@
 import {
-  TransactionExecutionResult,
+  TransactionExecutionResultJson,
   Block,
   BlockResult,
   BlockQueue,
@@ -53,9 +53,10 @@ export class PrismaBlockStorage implements BlockQueue, BlockStorage {
     if (dbResult === null) {
       return undefined;
     }
-    const transactions = dbResult.transactions.map<TransactionExecutionResult>(
-      (txresult) => this.transactionResultMapper.mapIn([txresult, txresult.tx])
-    );
+    const transactions =
+      dbResult.transactions.map<TransactionExecutionResultJson>((txresult) =>
+        this.transactionResultMapper.mapIn([txresult, txresult.tx])
+      );
 
     return {
       block: {
@@ -80,15 +81,15 @@ export class PrismaBlockStorage implements BlockQueue, BlockStorage {
   public async pushBlock(block: Block): Promise<void> {
     log.trace(
       "Pushing block to DB. Txs:",
-      block.transactions.map((x) => x.tx.hash().toString())
+      block.transactions.map((x) => x.tx.hash)
     );
 
     const transactions = block.transactions.map<DBTransactionExecutionResult>(
       (tx) => {
         const encoded = this.transactionResultMapper.mapOut(tx);
         return {
           ...encoded[0],
-          blockHash: block.hash.toString(),
+          blockHash: block.hash,
         };
       }
     );
@@ -191,7 +192,7 @@ export class PrismaBlockStorage implements BlockQueue, BlockStorage {
     if (result !== undefined) {
       if (result.result === undefined) {
         throw new Error(
-          `Block result for block ${result.block.height.toString()} not found`
+          `Block result for block ${result.block.height} not found`
         );
       }
       return {
@@ -221,11 +222,10 @@ export class PrismaBlockStorage implements BlockQueue, BlockStorage {
     });
 
     return blocks.map((block, index) => {
-      const transactions = block.transactions.map<TransactionExecutionResult>(
-        (txresult) => {
+      const transactions =
+        block.transactions.map<TransactionExecutionResultJson>((txresult) => {
           return this.transactionResultMapper.mapIn([txresult, txresult.tx]);
-        }
-      );
+        });
       const decodedBlock = this.blockMapper.mapIn(block);
       decodedBlock.transactions = transactions;
 

packages/persistance/src/services/prisma/PrismaMessageStorage.ts

@@ -1,4 +1,7 @@
-import { MessageStorage, PendingTransaction } from "@proto-kit/sequencer";
+import {
+  MessageStorage,
+  PendingTransactionJSONType,
+} from "@proto-kit/sequencer";
 import { inject, injectable } from "tsyringe";
 
 import type { PrismaConnection } from "../../PrismaDatabaseConnection";
@@ -21,7 +24,7 @@ export class PrismaMessageStorage implements MessageStorage {
     const batches: {
       fromMessagesHash: string;
       toMessagesHash: string;
-      messages: PendingTransaction[];
+      messages: PendingTransactionJSONType[];
     }[] = [];
     let currentHash = fromMessagesHash;
 
@@ -43,7 +46,7 @@ export class PrismaMessageStorage implements MessageStorage {
     | {
         fromMessagesHash: string;
         toMessagesHash: string;
-        messages: PendingTransaction[];
+        messages: PendingTransactionJSONType[];
       }
     | undefined
   > {
@@ -84,7 +87,7 @@ export class PrismaMessageStorage implements MessageStorage {
   public async pushMessages(
     fromMessageHash: string,
     toMessageHash: string,
-    messages: PendingTransaction[]
+    messages: PendingTransactionJSONType[]
   ): Promise<void> {
     const transactions = messages.map((message) =>
       this.transactionMapper.mapOut(message)

packages/persistance/src/services/prisma/PrismaTransactionStorage.ts

@@ -1,6 +1,6 @@
 import { inject, injectable } from "tsyringe";
 import {
-  PendingTransaction,
+  PendingTransactionJSONType,
   trace,
   Tracer,
   TransactionStorage,
@@ -19,7 +19,9 @@ export class PrismaTransactionStorage implements TransactionStorage {
   ) {}
 
   @trace("db.txs.get")
-  public async getPendingUserTransactions(): Promise<PendingTransaction[]> {
+  public async getPendingUserTransactions(): Promise<
+    PendingTransactionJSONType[]
+  > {
     const { prismaClient } = this.connection;
 
     const txs = await prismaClient.transaction.findMany({
@@ -51,7 +53,9 @@ export class PrismaTransactionStorage implements TransactionStorage {
     }
   }
 
-  public async pushUserTransaction(tx: PendingTransaction): Promise<boolean> {
+  public async pushUserTransaction(
+    tx: PendingTransactionJSONType
+  ): Promise<boolean> {
     const { prismaClient } = this.connection;
 
     const result = await prismaClient.transaction.createMany({
@@ -64,7 +68,7 @@ export class PrismaTransactionStorage implements TransactionStorage {
 
   public async findTransaction(hash: string): Promise<
     | {
-        transaction: PendingTransaction;
+        transaction: PendingTransactionJSONType;
         block?: string;
         batch?: number;
       }