@0xobelisk/sui-client 1.1.9 → 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;
@@ -27,6 +27,7 @@ export declare class Dubhe {
     contractFactory: SuiContractFactory;
     packageId: string | undefined;
     metadata: SuiMoveNormalizedModules | undefined;
+    projectName: string | undefined;
     /**
      * Support the following ways to init the DubheClient:
      * 1. mnemonics
@@ -44,16 +45,18 @@ export declare class Dubhe {
     get tx(): MapMoudleFuncTx;
     get object(): MapObjectStruct;
     view(dryResult: DevInspectResults): any[];
-    state({ tx, schema, params, }: {
+    state({ tx, schema, params, customModuleName, }: {
         tx: Transaction;
         schema: string;
         params: any[];
+        customModuleName?: string;
     }): Promise<any[] | undefined>;
-    parseState({ schema, objectId, storageType, params, }: {
+    parseState({ schema, objectId, storageType, params, customModuleName, }: {
         schema: string;
         objectId: string;
         storageType: string;
         params: any[];
+        customModuleName?: string;
     }): Promise<any[] | undefined>;
     getTransactions({ first, after, sender, digest, checkpoint, orderBy, }: {
         first?: number;
@@ -64,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

@@ -2024,6 +2024,10 @@ var Dubhe = class {
           (moudlevalue) => {
             const data = moudlevalue;
             const moduleName = data.name;
+            const itemModuleName = moduleName;
+            if (itemModuleName.endsWith("_genesis")) {
+              this.projectName = itemModuleName.replace("_genesis", "");
+            }
             const objMoudleId = `${this.packageId}::${moduleName}`;
             if (data.enums) {
               Object.entries(data.enums).forEach(([enumName, enumType]) => {
@@ -2224,9 +2228,13 @@ var Dubhe = class {
   async state({
     tx,
     schema,
-    params
+    params,
+    customModuleName
   }) {
-    const moduleName = `schema`;
+    if (!this.metadata) {
+      throw new Error("Metadata is not loaded");
+    }
+    const moduleName = `${customModuleName ?? this.projectName}_schema`;
     const functionName = `get_${schema}`;
     let queryResponse = void 0;
     try {
@@ -2246,7 +2254,8 @@ var Dubhe = class {
     schema,
     objectId,
     storageType,
-    params
+    params,
+    customModuleName
   }) {
     const tx = new import_transactions3.Transaction();
     const schemaObject = tx.object(objectId);
@@ -2286,7 +2295,8 @@ var Dubhe = class {
     return this.state({
       tx,
       schema,
-      params: processedParams
+      params: processedParams,
+      customModuleName
     });
   }
   async getTransactions({
@@ -2309,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) {
@@ -2337,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({