feat(ts-sdk): Add isTransactionIndexedOnNode method (#8716)

Closes #8606

`waitForTransaction` will be refactored in
#8720


[run-ci]

Author: marc2332

.changeset/proud-pillows-pull.md

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

sdk/graphql-transport/src/generated/queries.ts

@@ -4344,6 +4344,8 @@ export type Query = {
    * error.
    */
   events: EventConnection;
+  /** Check if a transaction is indexed on the fullnode. */
+  isTransactionIndexedOnNode: Scalars['Boolean']['output'];
   /**
    * The latest version of the package at `address`.
    *
@@ -4533,6 +4535,11 @@ export type QueryEventsArgs = {
 };
 
 
+export type QueryIsTransactionIndexedOnNodeArgs = {
+  digest: Scalars['String']['input'];
+};
+
+
 export type QueryLatestPackageArgs = {
   address: Scalars['IotaAddress']['input'];
 };
@@ -5223,6 +5230,21 @@ export type TransactionBlock = {
    * transaction block is a sponsored transaction block.
    */
   gasInput?: Maybe<GasInput>;
+  /**
+   * 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?: Maybe<Scalars['Boolean']['output']>;
   /**
    * The type of this transaction as well as the commands and/or parameters
    * comprising the transaction of this kind.
@@ -6011,6 +6033,13 @@ export type ResolveNameServiceNamesQueryVariables = Exact<{
 
 export type ResolveNameServiceNamesQuery = { __typename?: 'Query', address?: { __typename?: 'Address', iotaNamesRegistrations: { __typename?: 'NameRegistrationConnection', pageInfo: { __typename?: 'PageInfo', hasNextPage: boolean, endCursor?: string | null }, nodes: Array<{ __typename?: 'NameRegistration', name: string }> } } | null };
 
+export type IsTransactionIndexedOnNodeQueryVariables = Exact<{
+  digest: Scalars['String']['input'];
+}>;
+
+
+export type IsTransactionIndexedOnNodeQuery = { __typename?: 'Query', isTransactionIndexedOnNode: boolean };
+
 export type GetOwnedObjectsQueryVariables = Exact<{
   owner: Scalars['IotaAddress']['input'];
   limit?: InputMaybe<Scalars['Int']['input']>;
@@ -8222,6 +8251,11 @@ export const ResolveNameServiceNamesDocument = new TypedDocumentString(`
   }
 }
     `) as unknown as TypedDocumentString<ResolveNameServiceNamesQuery, ResolveNameServiceNamesQueryVariables>;
+export const IsTransactionIndexedOnNodeDocument = new TypedDocumentString(`
+    query IsTransactionIndexedOnNode($digest: String!) {
+  isTransactionIndexedOnNode(digest: $digest)
+}
+    `) as unknown as TypedDocumentString<IsTransactionIndexedOnNodeQuery, IsTransactionIndexedOnNodeQueryVariables>;
 export const GetOwnedObjectsDocument = new TypedDocumentString(`
     query getOwnedObjects($owner: IotaAddress!, $limit: Int, $cursor: String, $showBcs: Boolean = false, $showContent: Boolean = false, $showDisplay: Boolean = false, $showType: Boolean = false, $showOwner: Boolean = false, $showPreviousTransaction: Boolean = false, $showStorageRebate: Boolean = false, $filter: ObjectFilter) {
   address(address: $owner) {

sdk/graphql-transport/src/methods.ts

@@ -54,6 +54,7 @@ import {
     GetTransactionBlockDocument,
     GetTypeLayoutDocument,
     GetValidatorsApyDocument,
+    IsTransactionIndexedOnNodeDocument,
     MultiGetObjectsDocument,
     MultiGetTransactionBlocksDocument,
     PaginateCheckpointTransactionBlocksDocument,
@@ -1460,6 +1461,19 @@ export const RPC_METHODS: {
             featureFlags,
         };
     },
+
+    async isTransactionIndexedOnNode(transport, [digest]): Promise<boolean> {
+        const isTransactionIndexedOnNode = await transport.graphqlQuery(
+            {
+                query: IsTransactionIndexedOnNodeDocument,
+                variables: {
+                    digest,
+                },
+            },
+            (data) => data.isTransactionIndexedOnNode,
+        );
+        return isTransactionIndexedOnNode;
+    },
 };
 
 export class UnsupportedParamError extends Error {

sdk/graphql-transport/src/queries/isTransactionIndexed.graphql

@@ -0,0 +1,6 @@
+# Copyright (c) 2025 IOTA Stiftung
+# SPDX-License-Identifier: Apache-2.0
+
+query IsTransactionIndexedOnNode($digest: String!) {
+    isTransactionIndexedOnNode(digest: $digest)
+}

sdk/graphql-transport/test/compatibility.test.ts

@@ -813,4 +813,58 @@ describe('GraphQL IotaClient compatibility', () => {
 
         expect(graphql).toEqual(rpc);
     });
+
+    test('isTransactionIndexedOnNode', async () => {
+        const tx = new Transaction();
+        tx.setSender(toolbox.address());
+        const [coin] = tx.splitCoins(tx.gas, [1]);
+        tx.transferObjects([coin], toolbox.address());
+
+        const transaction = await graphQLClient!.signAndExecuteTransaction({
+            transaction: tx as Transaction,
+            signer: toolbox.keypair,
+            options: {
+                showBalanceChanges: true,
+                showEffects: true,
+                showEvents: true,
+                // TODO inputs missing valueType
+                showInput: false,
+                showObjectChanges: true,
+                showRawInput: true,
+            },
+        });
+
+        expect(
+            await toolbox.client.isTransactionIndexedOnNode({ digest: transaction.digest }),
+        ).toEqual(false);
+        expect(
+            await graphQLClient.isTransactionIndexedOnNode({ digest: transaction.digest }),
+        ).toEqual(false);
+
+        await toolbox.client.waitForTransaction({ digest: transaction.digest });
+
+        let result = null;
+        for (const _ of Array.from({ length: 5 })) {
+            try {
+                result = await toolbox.client.isTransactionIndexedOnNode({
+                    digest: transaction.digest,
+                });
+                if (result) {
+                    break;
+                } else {
+                    await new Promise((r) => {
+                        setTimeout(r, 2000);
+                    });
+                }
+
+                // eslint-disable-next-line no-empty
+            } catch (e) {}
+        }
+        expect(result).toEqual(true);
+
+        await graphQLClient.waitForTransaction({ digest: transaction.digest });
+        expect(
+            await graphQLClient.isTransactionIndexedOnNode({ digest: transaction.digest }),
+        ).toEqual(true);
+    });
 });

sdk/typescript/src/client/client.ts

@@ -98,6 +98,7 @@ import type {
     IotaNameRecord,
     IotaNamesReverseLookupParams,
     IotaNamesFindAllRegistrationNFTsParams,
+    IsTransactionIndexedOnNodeParams,
 } from './types/index.js';
 
 export interface PaginationArguments<Cursor> {
@@ -986,4 +987,14 @@ export class IotaClient {
             params: [input.address, input.cursor, input.limit, input.options],
         });
     }
+
+    /**
+     * Check if a Transaction has been indexed on the Node.
+     */
+    async isTransactionIndexedOnNode(input: IsTransactionIndexedOnNodeParams): Promise<boolean> {
+        return await this.transport.request({
+            method: 'iota_isTransactionIndexedOnNode',
+            params: [input.digest],
+        });
+    }
 }

sdk/typescript/src/client/types/params.ts

@@ -139,6 +139,11 @@ export interface GetTransactionBlockParams {
     /** options for specifying the content to be returned */
     options?: RpcTypes.IotaTransactionBlockResponseOptions | null | undefined;
 }
+/** Return if the transaction has been indexed on the fullnode. */
+export interface IsTransactionIndexedOnNodeParams {
+    /** the digest of the queried transaction */
+    digest: string;
+}
 /** Return the object data for a list of objects */
 export interface MultiGetObjectsParams {
     /** the IDs of the queried objects */