Feat/query module

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

@@ -10,6 +10,7 @@ import {
 import { inject } from "tsyringe";
 import { IsNumberString } from "class-validator";
 import {
+  InclusionStatus,
   Mempool,
   PendingTransaction,
   TransactionStorage,
@@ -106,13 +107,6 @@ export class TransactionObject {
   }
 }
 
-export enum InclusionStatus {
-  UNKNOWN = "unknown",
-  PENDING = "pending",
-  INCLUDED = "included",
-  SETTLED = "settled",
-}
-
 registerEnumType(InclusionStatus, {
   name: "InclusionStatus",
 });

packages/sdk/package.json

@@ -29,7 +29,7 @@
     "@proto-kit/module": "*",
     "@proto-kit/protocol": "*",
     "@proto-kit/sequencer": "*",
-    "o1js": "^1.6.0",
+    "o1js": "^2.10.0",
     "tsyringe": "^4.10.0"
   },
   "devDependencies": {

packages/sdk/src/client/ClientAppChain.ts

@@ -29,6 +29,8 @@ import {
   AppChain,
   AppChainModule,
   MinimalAppChainDefinition,
+  BlockExplorerQuery,
+  BlockExplorerTransportModule,
 } from "@proto-kit/sequencer";
 import { container } from "tsyringe";
 import { Field, PublicKey, UInt64 } from "o1js";
@@ -40,6 +42,7 @@ import { GraphqlTransactionSender } from "../graphql/GraphqlTransactionSender";
 import { Signer } from "../transaction/InMemorySigner";
 import { AppChainTransaction } from "../transaction/AppChainTransaction";
 import { TransactionSender } from "../transaction/InMemoryTransactionSender";
+import { GraphqlBlockExplorerTransportModule } from "../graphql/GraphqlBlockExplorerTransportModule";
 
 export type InferModules<Container extends TypedClass<ModuleContainer<any>>> =
   Container extends TypedClass<infer Type>
@@ -77,6 +80,7 @@ export class ClientAppChain<
       TransactionSender: GraphqlTransactionSender,
       QueryTransportModule: GraphqlQueryTransportModule,
       NetworkStateTransportModule: GraphqlNetworkStateTransportModule,
+      BlockExplorerTransportModule: GraphqlBlockExplorerTransportModule,
     });
 
     appChain.configurePartial({
@@ -86,6 +90,7 @@ export class ClientAppChain<
       TransactionSender: {},
       QueryTransportModule: {},
       NetworkStateTransportModule: {},
+      BlockExplorerTransportModule: {},
     });
 
     /**
@@ -200,6 +205,7 @@ export class ClientAppChain<
       InferModules<AppChainModules["Protocol"]>
     >;
     network: NetworkStateQuery;
+    explorer: BlockExplorerQuery;
   } {
     const queryTransportModule = this.container.resolve<QueryTransportModule>(
       "QueryTransportModule"
@@ -210,7 +216,13 @@ export class ClientAppChain<
         "NetworkStateTransportModule"
       );
 
+    const blockExplorerTransportModule =
+      this.container.resolve<BlockExplorerTransportModule>(
+        "BlockExplorerTransportModule"
+      );
+
     const network = new NetworkStateQuery(networkStateTransportModule);
+    const explorer = new BlockExplorerQuery(blockExplorerTransportModule);
 
     return {
       runtime: QueryBuilderFactory.fromRuntime(
@@ -224,6 +236,8 @@ export class ClientAppChain<
       ),
 
       network,
+
+      explorer,
     };
   }
 }

packages/sdk/src/graphql/GraphqlBlockExplorerTransportModule.ts

@@ -0,0 +1,120 @@
+import { inject, injectable } from "tsyringe";
+import { gql } from "@urql/core";
+import {
+  AppChainModule,
+  BlockExplorerTransportModule,
+  ClientBlock,
+  ClientTransaction,
+  InclusionStatus,
+} from "@proto-kit/sequencer";
+import { Field } from "o1js";
+
+import { GraphqlClient } from "./GraphqlClient";
+
+interface BlockQueryResponse {
+  block: {
+    hash: string;
+    previousBlockHash: string;
+    height: number;
+    transactionsHash: string;
+    txs: ClientTransaction[];
+  };
+}
+
+@injectable()
+export class GraphqlBlockExplorerTransportModule
+  extends AppChainModule
+  implements BlockExplorerTransportModule
+{
+  public constructor(
+    @inject("GraphqlClient") private readonly graphqlClient: GraphqlClient
+  ) {
+    super();
+  }
+
+  public async fetchTxInclusion(txHash: string): Promise<InclusionStatus> {
+    const query = gql`
+      query transactionState($hash: String!) {
+        transactionState(hash: $hash)
+      }
+    `;
+
+    const queryResult = await this.graphqlClient.client
+      .query(query, { hash: txHash })
+      .toPromise();
+
+    if (queryResult.error) {
+      throw new Error(`Error in fetchTxInclusion query: ${queryResult.error}`);
+    }
+
+    return queryResult.data?.transactionState;
+  }
+
+  async getBlock(
+    param: { hash: string } | { height: number }
+  ): Promise<ClientBlock | undefined> {
+    let hash: string | undefined;
+    let height: number | undefined;
+
+    if ("hash" in param) {
+      hash = param.hash;
+    } else {
+      height = param.height;
+    }
+
+    const query = gql`
+      query block($hash: String, $height: Float) {
+        block(hash: $hash, height: $height) {
+          hash
+          previousBlockHash
+          height
+          txs {
+            tx {
+              hash
+              methodId
+              nonce
+              sender
+              argsFields
+              auxiliaryData
+              signature {
+                r
+                s
+              }
+              isMessage
+            }
+            status
+            statusMessage
+          }
+          transactionsHash
+        }
+      }
+    `;
+
+    const queryResult = await this.graphqlClient.client
+      .query<BlockQueryResponse>(query, { hash, height })
+      .toPromise();
+
+    if (queryResult.error) {
+      throw new Error(`Error fetching block: ${queryResult.error}`);
+    }
+
+    if (queryResult.data == null || queryResult.data.block == null) {
+      return undefined;
+    }
+
+    const blockData = queryResult.data.block;
+
+    const previousBlockHash =
+      blockData.previousBlockHash != null && blockData.previousBlockHash !== ""
+        ? Field(blockData.previousBlockHash)
+        : undefined;
+
+    return {
+      hash: Field(blockData.hash),
+      height: Field(blockData.height),
+      previousBlockHash,
+      transactionsHash: Field(blockData.transactionsHash),
+      transactions: blockData.txs,
+    };
+  }
+}

packages/sdk/src/index.ts

@@ -1,5 +1,6 @@
 export * from "./query/StateServiceQueryModule";
 export * from "./query/BlockStorageNetworkStateModule";
+export * from "./query/InMemoryBlockExplorer";
 export * from "./transaction/AppChainTransaction";
 export * from "./transaction/InMemorySigner";
 export * from "./transaction/InMemoryTransactionSender";
@@ -8,5 +9,6 @@ export * from "./graphql/GraphqlClient";
 export * from "./graphql/GraphqlQueryTransportModule";
 export * from "./graphql/GraphqlTransactionSender";
 export * from "./graphql/GraphqlNetworkStateTransportModule";
+export * from "./graphql/GraphqlBlockExplorerTransportModule";
 export * from "./client/ClientAppChain";
 export * from "./testing/TestingAppChain";

packages/sdk/src/query/InMemoryBlockExplorer.ts

@@ -0,0 +1,93 @@
+import { inject, injectable } from "tsyringe";
+import {
+  AppChainModule,
+  Block,
+  BlockExplorerTransportModule,
+  BlockStorage,
+  ClientBlock,
+  ClientTransaction,
+  TransactionStorage,
+  InclusionStatus,
+} from "@proto-kit/sequencer";
+import { ModuleContainerLike } from "@proto-kit/common";
+
+@injectable()
+export class InMemoryBlockExplorer
+  extends AppChainModule
+  implements BlockExplorerTransportModule
+{
+  private readonly blockStorage: BlockStorage;
+
+  private readonly transactionStorage: TransactionStorage;
+
+  public constructor(
+    @inject("Sequencer") public sequencer: ModuleContainerLike
+  ) {
+    super();
+    this.blockStorage =
+      sequencer.dependencyContainer.resolve<BlockStorage>("BlockStorage");
+    this.transactionStorage =
+      sequencer.dependencyContainer.resolve<TransactionStorage>(
+        "TransactionStorage"
+      );
+  }
+
+  public async fetchTxInclusion(txHash: string): Promise<InclusionStatus> {
+    const dbTx = await this.transactionStorage.findTransaction(txHash);
+    if (dbTx?.block !== undefined) {
+      return InclusionStatus.INCLUDED;
+    }
+    return InclusionStatus.UNKNOWN;
+  }
+
+  async getBlock(
+    param: { hash: string } | { height: number }
+  ): Promise<ClientBlock | undefined> {
+    let block: Block | undefined;
+
+    if ("hash" in param) {
+      block = await this.blockStorage.getBlock(param.hash);
+    } else if ("height" in param) {
+      block = await this.blockStorage.getBlockAt(param.height);
+    } else {
+      const currentHeight = await this.blockStorage.getCurrentBlockHeight();
+      if (currentHeight > 0) {
+        block = await this.blockStorage.getBlockAt(currentHeight - 1);
+      }
+    }
+
+    if (block === undefined) {
+      return undefined;
+    }
+
+    // Convert block.transactions to ClientTransaction format
+    const clientTransactions: ClientTransaction[] = block.transactions.map(
+      (txResult) => ({
+        tx: {
+          hash: txResult.tx.hash().toString(),
+          methodId: txResult.tx.methodId.toString(),
+          nonce: txResult.tx.nonce.toString(),
+          sender: txResult.tx.sender.toBase58(),
+          argsFields: txResult.tx.argsFields.map((f) => f.toString()),
+          auxiliaryData: txResult.tx.auxiliaryData,
+          signature: {
+            r: txResult.tx.signature.r.toString(),
+            // eslint-disable-next-line @typescript-eslint/no-base-to-string
+            s: txResult.tx.signature.s.toString(),
+          },
+          isMessage: txResult.tx.isMessage,
+        },
+        status: txResult.status.toBoolean(),
+        statusMessage: txResult.statusMessage,
+      })
+    );
+
+    return {
+      hash: block.hash,
+      previousBlockHash: block.previousBlockHash,
+      height: block.height,
+      transactions: clientTransactions,
+      transactionsHash: block.transactionsHash,
+    };
+  }
+}