feat: add isIndexedOnNode API (#8789)

# Description of change

Feature branch that fixes #8591

Author: kodemartin

.changeset/proud-pillows-pull.md

@@ -0,0 +1,6 @@
+---
+'@iota/graphql-transport': minor
+'@iota/iota-sdk': minor
+---
+
+Support the new node method `isTransactionIndexedOnNode`

crates/iota-graphql-rpc/schema.graphql

@@ -3576,6 +3576,10 @@ type Query {
 	"""
 	dryRunTransactionBlock(txBytes: String!, txMeta: TransactionMetadata, skipChecks: Boolean): DryRunResult!
 	"""
+	Check if a transaction is indexed on the fullnode.
+	"""
+	isTransactionIndexedOnNode(digest: String!): Boolean!
+	"""
 	Look up an Owner by its IotaAddress.
 	
 	`rootVersion` represents the version of the root object in some nested
@@ -4371,6 +4375,21 @@ type TransactionBlock {
 	and Base64 encoded.
 	"""
 	bcs: Base64
+	"""
+	Returns whether the transaction has been indexed on the fullnode.
+	
+	This makes a request to the fullnode if the transaction is not part of
+	a checkpoint to resolve the index status on the node.
+	
+	However, as this relies on the transaction data being already
+	constructed or fetched from the backing database, it only makes
+	sense to be used with `Mutation.executeTransactionBlock` on the
+	resulting effects.
+	
+	Otherwise, it is recommended that you use
+	`Query.isTransactionIndexedOnNode` for optimal performance.
+	"""
+	indexedOnNode: Boolean
 }
 
 type TransactionBlockConnection {

crates/iota-graphql-rpc/src/server/builder.rs

@@ -10,7 +10,7 @@ use std::{
 };
 
 use async_graphql::{
-    EmptySubscription, Schema, SchemaBuilder,
+    Context, EmptySubscription, ResultExt, Schema, SchemaBuilder,
     extensions::{ApolloTracing, ExtensionFactory, Tracing},
 };
 use async_graphql_axum::{GraphQLRequest, GraphQLResponse};
@@ -34,7 +34,7 @@ use iota_indexer::{
 use iota_metrics::spawn_monitored_task;
 use iota_network_stack::callback::{CallbackLayer, MakeCallbackHandler, ResponseHandler};
 use iota_package_resolver::{PackageStoreWithLruCache, Resolver};
-use iota_sdk::IotaClientBuilder;
+use iota_sdk::{IotaClient, IotaClientBuilder};
 use tokio::{join, net::TcpListener, sync::OnceCell};
 use tokio_util::sync::CancellationToken;
 use tower::{Layer, Service};
@@ -550,6 +550,19 @@ fn schema_builder() -> SchemaBuilder<Query, Mutation, EmptySubscription> {
         .register_output_type::<IMoveDatatype>()
 }
 
+pub(crate) fn get_fullnode_client<'ctx>(
+    ctx: &'ctx Context<'_>,
+) -> async_graphql::Result<&'ctx IotaClient> {
+    let iota_sdk_client: &Option<IotaClient> = ctx
+        .data()
+        .map_err(|_| Error::Internal("Unable to fetch IOTA SDK client".to_string()))
+        .extend()?;
+    iota_sdk_client
+        .as_ref()
+        .ok_or_else(|| Error::Internal("IOTA SDK client not initialized".to_string()))
+        .extend()
+}
+
 /// Return the string representation of the schema used by this server.
 pub fn export_schema() -> String {
     schema_builder().finish().sdl()

crates/iota-graphql-rpc/src/test_infra/cluster.rs

@@ -13,7 +13,10 @@ use iota_indexer::{
     test_utils::{IndexerTypeConfig, force_delete_database, start_test_indexer_impl},
 };
 use iota_swarm_config::genesis_config::{AccountConfig, DEFAULT_GAS_AMOUNT};
-use iota_types::storage::RestStateReader;
+use iota_types::{
+    storage::RestStateReader,
+    transaction::{Transaction, TransactionData},
+};
 use test_cluster::{TestCluster, TestClusterBuilder};
 use tokio::{join, task::JoinHandle};
 use tokio_util::sync::CancellationToken;
@@ -360,6 +363,25 @@ impl Cluster {
         self.cancellation_token.cancel();
         let _ = join!(self.graphql_server_join_handle, self.indexer_join_handle);
     }
+
+    /// Builds a transaction that transfers IOTA for testing.
+    pub async fn build_transfer_iota_for_test(&self) -> TransactionData {
+        let addresses = self.validator_fullnode_handle.wallet.get_addresses();
+
+        let recipient = addresses[1];
+        self.validator_fullnode_handle
+            .test_transaction_builder()
+            .await
+            .transfer_iota(Some(1_000), recipient)
+            .build()
+    }
+
+    /// Signs a transaction.
+    pub fn sign_transaction(&self, transaction: &TransactionData) -> Transaction {
+        self.validator_fullnode_handle
+            .wallet
+            .sign_transaction(transaction)
+    }
 }
 
 impl ExecutorCluster {

crates/iota-graphql-rpc/src/types/digest.rs

@@ -75,6 +75,12 @@ impl From<TransactionDigest> for Digest {
     }
 }
 
+impl From<Digest> for TransactionDigest {
+    fn from(digest: Digest) -> Self {
+        Self::new(digest.0)
+    }
+}
+
 impl fmt::Display for Digest {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}", Base58::encode(self.0))

crates/iota-graphql-rpc/src/types/query.rs

@@ -6,8 +6,8 @@ use std::str::FromStr;
 
 use async_graphql::{connection::Connection, *};
 use fastcrypto::encoding::{Base64, Encoding};
+use iota_json_rpc_api::ReadApiClient;
 use iota_json_rpc_types::DevInspectArgs;
-use iota_sdk::IotaClient;
 use iota_types::{
     TypeTag,
     gas_coin::GAS,
@@ -21,7 +21,7 @@ use crate::{
     connection::ScanConnection,
     error::Error,
     mutation::Mutation,
-    server::watermark_task::Watermark,
+    server::{builder::get_fullnode_client, watermark_task::Watermark},
     types::{
         address::Address,
         available_range::AvailableRange,
@@ -114,14 +114,7 @@ impl Query {
     ) -> Result<DryRunResult> {
         let skip_checks = skip_checks.unwrap_or(false);
 
-        let iota_sdk_client: &Option<IotaClient> = ctx
-            .data()
-            .map_err(|_| Error::Internal("Unable to fetch IOTA SDK client".to_string()))
-            .extend()?;
-        let iota_sdk_client = iota_sdk_client
-            .as_ref()
-            .ok_or_else(|| Error::Internal("IOTA SDK client not initialized".to_string()))
-            .extend()?;
+        let iota_sdk_client = get_fullnode_client(ctx)?;
 
         let (sender_address, tx_kind, gas_price, gas_sponsor, gas_budget, gas_objects) =
             if let Some(TransactionMetadata {
@@ -190,6 +183,19 @@ impl Query {
         DryRunResult::try_from(res).extend()
     }
 
+    /// Check if a transaction is indexed on the fullnode.
+    async fn is_transaction_indexed_on_node(
+        &self,
+        ctx: &Context<'_>,
+        digest: Digest,
+    ) -> Result<bool> {
+        let fullnode_client = get_fullnode_client(ctx)?;
+        Ok(fullnode_client
+            .http()
+            .is_transaction_indexed_on_node(digest.into())
+            .await?)
+    }
+
     /// Look up an Owner by its IotaAddress.
     ///
     /// `rootVersion` represents the version of the root object in some nested

crates/iota-graphql-rpc/src/types/transaction_block/mod.rs

@@ -13,6 +13,7 @@ use iota_indexer::{
     models::transactions::{OptimisticTransaction, StoredTransaction},
     schema::{transactions, tx_digests},
 };
+use iota_json_rpc_api::ReadApiClient;
 use iota_types::{
     base_types::IotaAddress as NativeIotaAddress,
     effects::TransactionEffects as NativeTransactionEffects,
@@ -30,7 +31,7 @@ use crate::{
     connection::ScanConnection,
     data::{self, DataLoader, Db, DbConnection, QueryExecutor},
     error::Error,
-    server::watermark_task::Watermark,
+    server::{builder::get_fullnode_client, watermark_task::Watermark},
     types::{
         address::Address,
         base64::Base64,
@@ -88,6 +89,16 @@ pub(crate) enum TransactionBlockInner {
     },
 }
 
+impl TransactionBlockInner {
+    /// Returns if the transaction is included in a checkpoint.
+    fn is_checkpointed(&self) -> bool {
+        let TransactionBlockInner::Stored { stored_tx, .. } = &self else {
+            return false;
+        };
+        stored_tx.checkpoint_sequence_number >= 0
+    }
+}
+
 /// An input filter selecting for either system or programmable transactions.
 #[derive(Enum, Copy, Clone, Eq, PartialEq, Debug)]
 pub(crate) enum TransactionBlockKindInput {
@@ -234,6 +245,35 @@ impl TransactionBlock {
             TransactionBlockInner::DryRun { .. } => None,
         }
     }
+
+    /// Returns whether the transaction has been indexed on the fullnode.
+    ///
+    /// This makes a request to the fullnode if the transaction is not part of
+    /// a checkpoint to resolve the index status on the node.
+    ///
+    /// However, as this relies on the transaction data being already
+    /// constructed or fetched from the backing database, it only makes
+    /// sense to be used with `Mutation.executeTransactionBlock` on the
+    /// resulting effects.
+    ///
+    /// Otherwise, it is recommended that you use
+    /// `Query.isTransactionIndexedOnNode` for optimal performance.
+    async fn indexed_on_node(&self, ctx: &Context<'_>) -> Result<Option<bool>> {
+        if self.inner.is_checkpointed() {
+            return Ok(Some(true));
+        }
+        let Some(digest) = self.native_signed_data().map(|d| d.digest()) else {
+            // dry-run transactions are never indexed
+            return Ok(Some(false));
+        };
+        let fullnode_client = get_fullnode_client(ctx)?;
+        Ok(Some(
+            fullnode_client
+                .http()
+                .is_transaction_indexed_on_node(digest)
+                .await?,
+        ))
+    }
 }
 
 impl TransactionBlock {