@0xobelisk/sui-client 1.0.6 → 1.0.8

package/dist/index.mjs

@@ -1,3 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 var __accessCheck = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
@@ -28,7 +35,6 @@ import { bcs as bcs3, BcsType as BcsType2 } from "@mysten/bcs";
 
 // src/dubhe.ts
 import keccak256 from "keccak256";
-import { getFullnodeUrl } from "@mysten/sui/client";
 import { Transaction as Transaction2 } from "@mysten/sui/transactions";
 import { fromHex, toHex } from "@mysten/bcs";
 
@@ -858,7 +864,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 {
@@ -866,7 +873,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 {
@@ -875,7 +883,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 {
@@ -884,7 +893,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 {
@@ -893,7 +903,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"
       };
   }
 };
@@ -999,6 +1010,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
 import { bcs as bcs2, fromHEX as fromHEX2, toHEX } from "@mysten/bcs";
@@ -1026,6 +1045,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;
@@ -1081,7 +1377,11 @@ var Dubhe = class {
     networkType,
     fullnodeUrls,
     packageId,
-    metadata
+    metadata,
+    customFetch,
+    defaultOptions,
+    indexerUrl,
+    indexerWsUrl
   } = {}) {
     __privateAdd(this, _processKeyParameter);
     __privateAdd(this, _query, {});
@@ -1563,9 +1863,15 @@ var Dubhe = class {
         loopFlag
       };
     });
+    networkType = networkType ?? "mainnet";
+    const defaultParams = getDefaultURL(networkType);
     this.accountManager = new SuiAccountManager({ mnemonics, secretKey });
-    fullnodeUrls = fullnodeUrls || [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;
@@ -1843,6 +2149,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.
@@ -1916,6 +2248,9 @@ var Dubhe = class {
   client() {
     return this.suiInteractor.currentClient;
   }
+  indexerClient() {
+    return this.suiIndexerClient;
+  }
   async getObject(objectId) {
     return this.suiInteractor.getObject(objectId);
   }
@@ -2208,9 +2543,9 @@ var MultiSigClient = class _MultiSigClient {
 };
 
 // src/metadata/index.ts
-import { getFullnodeUrl as getFullnodeUrl2 } from "@mysten/sui/client";
+import { getFullnodeUrl } from "@mysten/sui/client";
 async function loadMetadata(networkType, packageId, fullnodeUrls) {
-  fullnodeUrls = fullnodeUrls || [getFullnodeUrl2(networkType)];
+  fullnodeUrls = fullnodeUrls || [getFullnodeUrl(networkType)];
   const suiInteractor = new SuiInteractor(fullnodeUrls);
   if (packageId !== void 0) {
     const jsonData = await suiInteractor.getNormalizedMoveModulesByPackage(