@0xobelisk/sui-client 1.0.6 → 1.0.8

package/dist/dubhe.d.ts

@@ -8,6 +8,8 @@ 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 } from './types';
+import { ConnectionResponse, OrderBy, Schema, SuiIndexerClient } from './libs/suiIndexerClient';
+import { Http } from './libs/http';
 export declare function isUndefined(value?: unknown): value is undefined;
 export declare function withMeta<T extends {
     meta: SuiMoveMoudleFuncType;
@@ -18,8 +20,10 @@ export declare function withMeta<T extends {
  */
 export declare class Dubhe {
     #private;
+    http: Http;
     accountManager: SuiAccountManager;
     suiInteractor: SuiInteractor;
+    suiIndexerClient: SuiIndexerClient;
     contractFactory: SuiContractFactory;
     packageId: string | undefined;
     metadata: SuiMoveNormalizedModules | undefined;
@@ -35,7 +39,7 @@ export declare class Dubhe {
      * @param fullnodeUrl, the fullnode url, default is the preconfig fullnode url for the given network type
      * @param packageId
      */
-    constructor({ mnemonics, secretKey, networkType, fullnodeUrls, packageId, metadata, }?: DubheParams);
+    constructor({ mnemonics, secretKey, networkType, fullnodeUrls, packageId, metadata, customFetch, defaultOptions, indexerUrl, indexerWsUrl, }?: DubheParams);
     get query(): MapMoudleFuncQuery;
     get tx(): MapMoudleFuncTx;
     get object(): MapObjectStruct;
@@ -51,6 +55,18 @@ export declare class Dubhe {
         storageType: string;
         params: any[];
     }): Promise<any[] | undefined>;
+    getStorage({ name, key1, key2, first, after, last, before, orderBy, distinct, }: {
+        name: string;
+        key1?: string;
+        key2?: string;
+        first?: number;
+        after?: string;
+        last?: number;
+        before?: string;
+        orderBy?: OrderBy;
+        distinct?: boolean;
+    }): Promise<ConnectionResponse<Schema>>;
+    subscribe(names: string[], handleData: (data: any) => void): Promise<WebSocket>;
     /**
      * else:
      * it will generate signer from the mnemonic with the given derivePathParams.
@@ -83,6 +99,7 @@ export declare class Dubhe {
     getBalance(coinType?: string, derivePathParams?: DerivePathParams): Promise<import("@mysten/sui/client").CoinBalance>;
     balanceOf(accountAddress?: string, coinType?: string, derivePathParams?: DerivePathParams): Promise<import("@mysten/sui/client").CoinBalance>;
     client(): import("@mysten/sui/client").SuiClient;
+    indexerClient(): SuiIndexerClient;
     getObject(objectId: string): Promise<SuiObjectData>;
     getObjects(objectIds: string[]): Promise<SuiObjectData[]>;
     signTxn(tx: Uint8Array | Transaction | SuiTx, derivePathParams?: DerivePathParams): Promise<import("@mysten/sui/dist/cjs/cryptography").SignatureWithBytes>;

package/dist/index.js

@@ -69,7 +69,6 @@ var import_bcs4 = require("@mysten/bcs");
 
 // src/dubhe.ts
 var import_keccak256 = __toESM(require("keccak256"));
-var import_client2 = require("@mysten/sui/client");
 var import_transactions3 = require("@mysten/sui/transactions");
 var import_bcs2 = require("@mysten/bcs");
 
@@ -891,7 +890,8 @@ var getDefaultURL = (networkType = "testnet") => {
         network: "localnet",
         txExplorer: "https://explorer.polymedia.app/txblock/:txHash?network=local",
         accountExplorer: "https://explorer.polymedia.app/address/:address?network=local",
-        explorer: "https://explorer.polymedia.app?network=local"
+        explorer: "https://explorer.polymedia.app?network=local",
+        indexerUrl: "http://127.0.0.1:3001"
       };
     case "devnet":
       return {
@@ -899,7 +899,8 @@ var getDefaultURL = (networkType = "testnet") => {
         network: "devnet",
         txExplorer: "https://suiscan.xyz/devnet/tx/:txHash",
         accountExplorer: "https://suiscan.xyz/devnet/address/:address",
-        explorer: "https://suiscan.xyz/devnet"
+        explorer: "https://suiscan.xyz/devnet",
+        indexerUrl: "http://127.0.0.1:3001"
       };
     case "testnet":
       return {
@@ -908,7 +909,8 @@ var getDefaultURL = (networkType = "testnet") => {
         network: "testnet",
         txExplorer: "https://suiscan.xyz/testnet/tx/:txHash",
         accountExplorer: "https://suiscan.xyz/testnet/address/:address",
-        explorer: "https://suiscan.xyz/testnet"
+        explorer: "https://suiscan.xyz/testnet",
+        indexerUrl: "http://127.0.0.1:3001"
       };
     case "mainnet":
       return {
@@ -917,7 +919,8 @@ var getDefaultURL = (networkType = "testnet") => {
         network: "mainnet",
         txExplorer: "https://suiscan.xyz/mainnet/tx/:txHash",
         accountExplorer: "https://suiscan.xyz/mainnet/address/:address",
-        explorer: "https://suiscan.xyz/mainnet"
+        explorer: "https://suiscan.xyz/mainnet",
+        indexerUrl: "http://127.0.0.1:3001"
       };
     default:
       return {
@@ -926,7 +929,8 @@ var getDefaultURL = (networkType = "testnet") => {
         network: "testnet",
         txExplorer: "https://suiscan.xyz/testnet/tx/:txHash",
         accountExplorer: "https://suiscan.xyz/testnet/address/:address",
-        explorer: "https://suiscan.xyz/testnet"
+        explorer: "https://suiscan.xyz/testnet",
+        indexerUrl: "http://127.0.0.1:3001"
       };
   }
 };
@@ -1032,6 +1036,14 @@ function normalizePackageId(input) {
   const normalized = withoutPrefix.replace(/^0+/, "");
   return "0x" + normalized;
 }
+function convertHttpToWebSocket(url) {
+  if (url.startsWith("https://")) {
+    return url.replace("https://", "wss://");
+  } else if (url.startsWith("http://")) {
+    return url.replace("http://", "ws://");
+  }
+  return url;
+}
 
 // src/dubhe.ts
 var import_bcs3 = require("@mysten/bcs");
@@ -1059,6 +1071,283 @@ var ContractDataParsingError = class extends Error {
   }
 };
 
+// src/libs/suiIndexerClient/index.ts
+var SuiIndexerClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async fetchGraphql(query, variables) {
+    return this.http.fetchGraphql({ query, variables });
+  }
+  async getTransactions(params) {
+    const query = `
+      query GetTransactions($first: Int, $after: String, $last: Int, $before: String, $checkpoint: Int, $orderBy: TransactionOrderBy, $distinct: Boolean) {
+        transactions(first: $first, after: $after, last: $last, before: $before, checkpoint: $checkpoint, orderBy: $orderBy, distinct: $distinct) {
+          edges {
+            cursor
+            node {
+              id
+              checkpoint
+              digest
+              created_at
+            }
+          }
+          pageInfo {
+            hasNextPage
+            hasPreviousPage
+            startCursor
+            endCursor
+          }
+        }
+      }
+    `;
+    const response = await this.fetchGraphql(query, params);
+    return response.transactions;
+  }
+  async getSchemas(params) {
+    const query = `
+      query GetSchemas($first: Int, $after: String, $last: Int, $before: String, $name: String, $key1: String, $key2: String, $orderBy: SchemaOrderBy, $distinct: Boolean) {
+        schemas(first: $first, after: $after, last: $last, before: $before, name: $name, key1: $key1, key2: $key2, orderBy: $orderBy, distinct: $distinct) {
+          edges {
+            cursor
+            node {
+              id
+              name
+              key1
+              key2
+              value
+              last_update_checkpoint
+              last_update_digest
+              is_removed
+              created_at
+              updated_at
+            }
+          }
+          pageInfo {
+            hasNextPage
+            hasPreviousPage
+            startCursor
+            endCursor
+          }
+        }
+      }
+    `;
+    const response = await this.fetchGraphql(query, params);
+    return response.schemas;
+  }
+  async getEvents(params) {
+    const query = `
+      query GetEvents($first: Int, $after: String, $last: Int, $before: String, $name: String, $checkpoint: String, $orderBy: EventOrderBy, $distinct: Boolean) {
+        events(first: $first, after: $after, last: $last, before: $before, name: $name, checkpoint: $checkpoint, orderBy: $orderBy, distinct: $distinct) {
+          edges {
+            cursor
+            node {
+              id
+              checkpoint
+              digest
+              name
+              value
+              created_at
+            }
+          }
+          pageInfo {
+            hasNextPage
+            hasPreviousPage
+            startCursor
+            endCursor
+          }
+        }
+      }
+    `;
+    const response = await this.fetchGraphql(query, params);
+    return response.events;
+  }
+  async getStorage({
+    name,
+    key1,
+    key2,
+    first,
+    after,
+    last,
+    before,
+    orderBy,
+    distinct
+  }) {
+    const schemas = await this.getSchemas({
+      name,
+      key1,
+      key2,
+      first,
+      after,
+      last,
+      before,
+      orderBy,
+      distinct
+    });
+    return schemas;
+  }
+  async subscribe(names, handleData) {
+    return this.http.subscribe(names, handleData);
+  }
+};
+
+// src/libs/http/errors.ts
+var BaseError = class extends Error {
+  constructor(message, code, type) {
+    super(message);
+    this.code = code;
+    this.type = type;
+    this.name = this.constructor.name;
+  }
+};
+var HttpError = class extends BaseError {
+  constructor(message, code) {
+    super(message, code, "ERROR_HTTP");
+  }
+};
+var GraphQLError = class extends BaseError {
+  constructor(message) {
+    super(message, 400, "ERROR_GRAPHQL");
+  }
+};
+var ParseError = class extends BaseError {
+  constructor(message) {
+    super(message, 500, "ERROR_PARSE");
+  }
+};
+
+// src/libs/http/ws-adapter.ts
+function createWebSocketClient(url) {
+  if (typeof window !== "undefined") {
+    return new WebSocket(url);
+  } else {
+    try {
+      require.resolve("ws");
+      const WebSocket2 = require("ws");
+      return new WebSocket2(url);
+    } catch (e) {
+      console.error("Failed to load WebSocket implementation:", e);
+      throw new Error(
+        'WebSocket implementation not available. Please install the "ws" package.'
+      );
+    }
+  }
+}
+
+// src/libs/http/http.ts
+var Http = class {
+  constructor(apiEndpoint, wsEndpoint, customFetch, defaultOptions) {
+    this.customFetch = customFetch;
+    this.apiEndpoint = apiEndpoint;
+    this.graphqlEndpoint = apiEndpoint + "/graphql";
+    this.wsEndpoint = wsEndpoint;
+    this.defaultOptions = defaultOptions;
+  }
+  getFetch() {
+    return this.customFetch || fetch;
+  }
+  async fetch(url) {
+    try {
+      const fetchFn = this.getFetch();
+      const response = await fetchFn(url, {
+        ...this.defaultOptions
+      });
+      if (!response.ok) {
+        throw new HttpError(
+          `HTTP error! status: ${response.status}`,
+          response.status
+        );
+      }
+      return response;
+    } catch (error) {
+      if (error instanceof HttpError) {
+        throw error;
+      }
+      throw new HttpError(`Failed to fetch: ${error.message}`, 500);
+    }
+  }
+  async fetchGraphql({
+    query,
+    variables
+  }) {
+    try {
+      const isFirstPage = variables?.after === "first";
+      const fetchFn = this.getFetch();
+      const response = await fetchFn(this.graphqlEndpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        body: JSON.stringify({
+          query,
+          variables: {
+            ...variables,
+            after: isFirstPage ? void 0 : variables?.after
+          }
+        }),
+        ...this.defaultOptions
+      });
+      if (!response.ok) {
+        const errorData = await response.json();
+        if (errorData.errors?.[0]?.message?.includes("Syntax Error")) {
+          throw new GraphQLError(
+            `GraphQL syntax error: ${errorData.errors[0].message}`
+          );
+        }
+        if (errorData.errors?.length > 0) {
+          throw new GraphQLError(
+            errorData.errors[0].message || "Unknown GraphQL error"
+          );
+        }
+        throw new HttpError(
+          `HTTP error: ${JSON.stringify(errorData)}`,
+          response.status
+        );
+      }
+      const data = await response.json();
+      if (data.errors) {
+        throw new GraphQLError(
+          data.errors[0]?.message || "GraphQL query failed"
+        );
+      }
+      return data.data;
+    } catch (error) {
+      if (error instanceof BaseError) {
+        throw error;
+      }
+      if (error instanceof SyntaxError) {
+        throw new ParseError("Failed to parse JSON response");
+      }
+      throw new HttpError(
+        `Failed to fetch GraphQL: ${error.message}`,
+        500
+      );
+    }
+  }
+  async subscribe(names, handleData) {
+    const ws = createWebSocketClient(this.wsEndpoint);
+    ws.onopen = () => {
+      console.log("Connected to the WebSocket server");
+      const subscribeMessage = JSON.stringify({
+        type: "subscribe",
+        names
+      });
+      ws.send(subscribeMessage);
+    };
+    ws.onmessage = (event) => {
+      handleData(JSON.parse(event.data.toString()));
+    };
+    ws.onclose = () => {
+      console.log("Disconnected from the WebSocket server");
+    };
+    ws.onerror = (error) => {
+      console.error(`WebSocket error:`, error);
+    };
+    return ws;
+  }
+};
+
 // src/dubhe.ts
 function isUndefined(value) {
   return value === void 0;
@@ -1114,7 +1403,11 @@ var Dubhe = class {
     networkType,
     fullnodeUrls,
     packageId,
-    metadata
+    metadata,
+    customFetch,
+    defaultOptions,
+    indexerUrl,
+    indexerWsUrl
   } = {}) {
     __privateAdd(this, _processKeyParameter);
     __privateAdd(this, _query, {});
@@ -1596,9 +1889,15 @@ var Dubhe = class {
         loopFlag
       };
     });
+    networkType = networkType ?? "mainnet";
+    const defaultParams = getDefaultURL(networkType);
     this.accountManager = new SuiAccountManager({ mnemonics, secretKey });
-    fullnodeUrls = fullnodeUrls || [(0, import_client2.getFullnodeUrl)(networkType ?? "mainnet")];
+    fullnodeUrls = fullnodeUrls || [defaultParams.fullNode];
     this.suiInteractor = new SuiInteractor(fullnodeUrls, networkType);
+    indexerUrl = indexerUrl || defaultParams.indexerUrl;
+    indexerWsUrl = indexerWsUrl || convertHttpToWebSocket(indexerUrl);
+    this.http = new Http(indexerUrl, indexerWsUrl, customFetch, defaultOptions);
+    this.suiIndexerClient = new SuiIndexerClient(this.http);
     this.packageId = packageId ? normalizePackageId(packageId) : void 0;
     if (metadata !== void 0) {
       this.metadata = metadata;
@@ -1876,6 +2175,32 @@ var Dubhe = class {
       params: processedParams
     });
   }
+  async getStorage({
+    name,
+    key1,
+    key2,
+    first,
+    after,
+    last,
+    before,
+    orderBy,
+    distinct
+  }) {
+    return await this.suiIndexerClient.getStorage({
+      name,
+      key1,
+      key2,
+      first,
+      after,
+      last,
+      before,
+      orderBy,
+      distinct
+    });
+  }
+  async subscribe(names, handleData) {
+    return this.suiIndexerClient.subscribe(names, handleData);
+  }
   /**
    * else:
    * it will generate signer from the mnemonic with the given derivePathParams.
@@ -1949,6 +2274,9 @@ var Dubhe = class {
   client() {
     return this.suiInteractor.currentClient;
   }
+  indexerClient() {
+    return this.suiIndexerClient;
+  }
   async getObject(objectId) {
     return this.suiInteractor.getObject(objectId);
   }
@@ -2241,9 +2569,9 @@ var MultiSigClient = class _MultiSigClient {
 };
 
 // src/metadata/index.ts
-var import_client4 = require("@mysten/sui/client");
+var import_client3 = require("@mysten/sui/client");
 async function loadMetadata(networkType, packageId, fullnodeUrls) {
-  fullnodeUrls = fullnodeUrls || [(0, import_client4.getFullnodeUrl)(networkType)];
+  fullnodeUrls = fullnodeUrls || [(0, import_client3.getFullnodeUrl)(networkType)];
   const suiInteractor = new SuiInteractor(fullnodeUrls);
   if (packageId !== void 0) {
     const jsonData = await suiInteractor.getNormalizedMoveModulesByPackage(