@0xobelisk/sui-client 1.1.10 → 1.1.11

package/dist/dubhe.d.ts

@@ -7,7 +7,7 @@ import { MapObjectStruct } from './types';
 import { SuiContractFactory } from './libs/suiContractFactory';
 import { SuiMoveMoudleFuncType } from './libs/suiContractFactory/types';
 import { NetworkConfig } from './libs/suiInteractor';
-import { DerivePathParams, FaucetNetworkType, MapMoudleFuncQuery, MapMoudleFuncTx, DubheParams, SuiTxArg, SuiObjectArg, SuiVecTxArg, SubscribableType } from './types';
+import { DerivePathParams, FaucetNetworkType, MapMoudleFuncQuery, MapMoudleFuncTx, DubheParams, SuiTxArg, SuiObjectArg, SuiVecTxArg, SubscribableType, IndexerTransactionResult } from './types';
 import { ConnectionResponse, IndexerTransaction, IndexerEvent, IndexerSchema, SuiIndexerClient, StorageResponse, StorageItemResponse } from './libs/suiIndexerClient';
 import { Http } from './libs/http';
 export declare function isUndefined(value?: unknown): value is undefined;
@@ -67,11 +67,18 @@ export declare class Dubhe {
         orderBy?: string[];
     }): Promise<ConnectionResponse<IndexerTransaction>>;
     getTransaction(digest: string): Promise<IndexerTransaction | undefined>;
+    /**
+     * Wait for the transaction to be processed by the indexer and return all transaction-related data
+     * @param digest transaction digest
+     * @param options option parameters
+     * @returns result object containing transaction, events and schema data
+     */
     waitForIndexerTransaction(digest: string, options?: {
         checkInterval?: number;
         timeout?: number;
         maxRetries?: number;
-    }): Promise<IndexerTransaction | undefined>;
+        pageSize?: number;
+    }): Promise<IndexerTransactionResult>;
     getEvents({ first, after, name, sender, digest, checkpoint, orderBy, }: {
         first?: number;
         after?: string;

package/dist/index.d.ts

@@ -14,3 +14,4 @@ export { SuiContractFactory } from './libs/suiContractFactory';
 export { SubscriptionKind } from './libs/suiIndexerClient';
 export { loadMetadata } from './metadata';
 export type * from './types';
+export type { IndexerEvent, IndexerSchema, IndexerTransaction, ConnectionResponse, StorageResponse, StorageItemResponse, PageInfo, } from './libs/suiIndexerClient';

package/dist/index.js

@@ -2319,25 +2319,60 @@ var Dubhe = class {
   async getTransaction(digest) {
     return await this.suiIndexerClient.getTransaction(digest);
   }
+  /**
+   * Wait for the transaction to be processed by the indexer and return all transaction-related data
+   * @param digest transaction digest
+   * @param options option parameters
+   * @returns result object containing transaction, events and schema data
+   */
   async waitForIndexerTransaction(digest, options) {
     const {
       checkInterval = 100,
       timeout = 3e4,
-      // 30 seconds default timeout
-      maxRetries = 300
-      // 300 times default max retries
+      maxRetries = 300,
+      pageSize = 100
     } = options ?? {};
     const startTime = Date.now();
     let retryCount = 0;
     while (retryCount < maxRetries) {
       try {
         if (Date.now() - startTime > timeout) {
-          throw new Error(`Timeout waiting for transaction ${digest}`);
+          throw new Error(`Waiting for transaction ${digest} timed out`);
         }
         await new Promise((resolve) => setTimeout(resolve, checkInterval));
-        const transaction = await this.getTransaction(digest);
-        if (transaction) {
-          return transaction;
+        const tx = await this.getTransaction(digest);
+        if (tx) {
+          const events = [];
+          const schemaChanges = [];
+          let hasNextEventsPage = true;
+          let eventsCursor;
+          while (hasNextEventsPage) {
+            const eventsResponse = await this.getEvents({
+              digest,
+              first: pageSize,
+              after: eventsCursor
+            });
+            events.push(...eventsResponse.edges.map((edge) => edge.node));
+            hasNextEventsPage = eventsResponse.pageInfo.hasNextPage;
+            eventsCursor = eventsResponse.pageInfo.endCursor;
+          }
+          let hasNextSchemasPage = true;
+          let schemasCursor;
+          while (hasNextSchemasPage) {
+            const schemasResponse = await this.getStorage({
+              last_update_digest: digest,
+              first: pageSize,
+              after: schemasCursor
+            });
+            schemaChanges.push(...schemasResponse.data);
+            hasNextSchemasPage = schemasResponse.pageInfo.hasNextPage;
+            schemasCursor = schemasResponse.pageInfo.endCursor;
+          }
+          return {
+            tx,
+            events,
+            schemaChanges
+          };
         }
         retryCount++;
       } catch (error) {
@@ -2347,7 +2382,7 @@ var Dubhe = class {
       }
     }
     throw new Error(
-      `Max retries (${maxRetries}) reached while waiting for transaction ${digest}`
+      `Reached maximum retries (${maxRetries}), failed to wait for transaction ${digest}`
     );
   }
   async getEvents({