@0xobelisk/sui-client 1.2.0-pre.4 → 1.2.0-pre.40

package/dist/index.js

@@ -51,7 +51,6 @@ __export(src_exports, {
   BcsType: () => import_bcs4.BcsType,
   Dubhe: () => Dubhe,
   MultiSigClient: () => MultiSigClient,
-  SubscriptionKind: () => SubscriptionKind,
   SuiAccountManager: () => SuiAccountManager,
   SuiContractFactory: () => SuiContractFactory,
   SuiTx: () => SuiTx,
@@ -1037,14 +1036,6 @@ 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");
@@ -1072,398 +1063,6 @@ var ContractDataParsingError = class extends Error {
   }
 };
 
-// src/libs/suiIndexerClient/utils.ts
-var parseData = (data) => {
-  if (typeof data !== "object" || data === null) {
-    return data;
-  }
-  if (Array.isArray(data)) {
-    return data.map((item) => parseData(item));
-  }
-  const parsedData = {};
-  for (const key in data) {
-    if (Object.prototype.hasOwnProperty.call(data, key)) {
-      const value = data[key];
-      if (typeof value === "object" && value !== null) {
-        if ("variant" in value) {
-          parsedData[key] = value.variant;
-        } else if ("fields" in value) {
-          parsedData[key] = parseData(value.fields);
-        } else {
-          parsedData[key] = parseData(value);
-        }
-      } else {
-        parsedData[key] = value;
-      }
-    }
-  }
-  return parsedData;
-};
-var parseValue = (value) => {
-  if (typeof value !== "object" || value === null) {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => parseValue(item));
-  }
-  if ("variant" in value) {
-    return value.variant;
-  }
-  if ("fields" in value) {
-    return parseData(value.fields);
-  }
-  return parseData(value);
-};
-
-// src/libs/suiIndexerClient/index.ts
-var SubscriptionKind = /* @__PURE__ */ ((SubscriptionKind2) => {
-  SubscriptionKind2["Event"] = "event";
-  SubscriptionKind2["Schema"] = "schema";
-  return SubscriptionKind2;
-})(SubscriptionKind || {});
-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, $sender: String, $digest: String, $checkpoint: Int, $orderBy: [TransactionOrderField!]) {
-        transactions(first: $first, after: $after, sender: $sender, digest: $digest, checkpoint: $checkpoint, orderBy: $orderBy) {
-          edges {
-            cursor
-            node {
-              id
-              checkpoint
-              digest
-              sender
-              created_at
-            }
-          }
-          pageInfo {
-            hasNextPage
-            endCursor
-          }
-          totalCount
-        }
-      }
-    `;
-    const response = await this.fetchGraphql(query, params);
-    return response.transactions;
-  }
-  async getTransaction(digest) {
-    const response = await this.getTransactions({
-      first: 1,
-      digest
-    });
-    return response.edges[0]?.node;
-  }
-  async getSchemas(params) {
-    const query = `
-      query GetSchemas(
-        $first: Int, 
-        $after: String, 
-        $name: String, 
-        $key1: JSON, 
-        $key2: JSON,
-        $is_removed: Boolean,
-        $last_update_checkpoint: String,
-        $last_update_digest: String,
-        $value: JSON,
-        $orderBy: [SchemaOrderField!],
-        $jsonOrderBy: [JsonPathOrder!]
-      ) {
-        schemas(
-          first: $first,
-          after: $after,
-          name: $name,
-          key1: $key1,
-          key2: $key2,
-          is_removed: $is_removed,
-          last_update_checkpoint: $last_update_checkpoint,
-          last_update_digest: $last_update_digest,
-          value: $value,
-          orderBy: $orderBy,
-          jsonOrderBy: $jsonOrderBy
-        ) {
-          edges {
-            cursor
-            node {
-              id
-              name
-              key1
-              key2
-              value
-              last_update_checkpoint
-              last_update_digest
-              is_removed
-              created_at
-              updated_at
-            }
-          }
-          pageInfo {
-            hasNextPage
-            endCursor
-          }
-          totalCount
-        }
-      }
-    `;
-    const response = await this.fetchGraphql(query, params);
-    return response.schemas;
-  }
-  async getEvents(params) {
-    const query = `
-      query GetEvents($first: Int, $after: String, $name: String, $sender: String, $digest: String, $checkpoint: String, $orderBy: [EventOrderField!]) {
-        events(first: $first, after: $after, name: $name, sender: $sender, digest: $digest, checkpoint: $checkpoint, orderBy: $orderBy) {
-          edges {
-            cursor
-            node {
-              id
-              checkpoint
-              digest
-              name
-              sender
-              value
-              created_at
-            }
-          }
-          pageInfo {
-            hasNextPage
-            endCursor
-          }
-          totalCount
-        }
-      }
-    `;
-    const response = await this.fetchGraphql(query, params);
-    return response.events;
-  }
-  async getStorage({
-    name,
-    key1,
-    key2,
-    is_removed = false,
-    last_update_checkpoint,
-    last_update_digest,
-    value,
-    first,
-    after,
-    orderBy,
-    jsonOrderBy
-  }) {
-    const schemas = await this.getSchemas({
-      name,
-      key1,
-      key2,
-      is_removed,
-      last_update_checkpoint,
-      last_update_digest,
-      value,
-      first,
-      after,
-      orderBy,
-      jsonOrderBy
-    });
-    const data = schemas.edges.map((edge) => edge.node);
-    const result = data.map((item) => parseValue(item.value));
-    return {
-      data,
-      value: result,
-      pageInfo: schemas.pageInfo,
-      totalCount: schemas.totalCount
-    };
-  }
-  async getStorageItem({
-    name,
-    key1,
-    key2,
-    is_removed,
-    last_update_checkpoint,
-    last_update_digest,
-    value
-  }) {
-    const schemas = await this.getSchemas({
-      name,
-      key1,
-      key2,
-      is_removed,
-      last_update_checkpoint,
-      last_update_digest,
-      value,
-      first: 1
-    });
-    const data = schemas.edges[0]?.node;
-    if (!data) {
-      return void 0;
-    }
-    const result = parseValue(data.value);
-    return {
-      data,
-      value: result
-    };
-  }
-  async subscribe(types, handleData) {
-    return this.http.subscribe(types, 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(types, handleData) {
-    const ws = createWebSocketClient(this.wsEndpoint);
-    ws.onopen = () => {
-      console.log("Connected to the WebSocket server");
-      const subscribeMessage = JSON.stringify(types);
-      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;
@@ -1521,12 +1120,274 @@ var Dubhe = class {
     networkType,
     fullnodeUrls,
     packageId,
-    metadata,
-    customFetch,
-    defaultOptions,
-    indexerUrl,
-    indexerWsUrl
+    metadata
   } = {}) {
+    // async getTransactions({
+    //   first,
+    //   after,
+    //   sender,
+    //   digest,
+    //   checkpoint,
+    //   packageId,
+    //   module,
+    //   functionName,
+    //   orderBy,
+    //   showEvent,
+    // }: {
+    //   first?: number;
+    //   after?: string;
+    //   sender?: string;
+    //   digest?: string;
+    //   checkpoint?: number;
+    //   packageId?: string;
+    //   module?: string;
+    //   functionName?: string[];
+    //   orderBy?: string[];
+    //   showEvent?: boolean;
+    // }): Promise<ConnectionResponse<IndexerTransaction>> {
+    //   return await this.suiIndexerClient.getTransactions({
+    //     first,
+    //     after,
+    //     sender,
+    //     digest,
+    //     checkpoint,
+    //     packageId,
+    //     module,
+    //     functionName,
+    //     orderBy,
+    //     showEvent,
+    //   });
+    // }
+    // async getTransaction(
+    //   digest: string
+    // ): Promise<IndexerTransaction | undefined> {
+    //   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: string,
+    //   options?: {
+    //     checkInterval?: number;
+    //     timeout?: number;
+    //     maxRetries?: number;
+    //     pageSize?: number;
+    //   }
+    // ): Promise<IndexerTransactionResult> {
+    //   const {
+    //     checkInterval = 100,
+    //     timeout = 30000,
+    //     maxRetries = 300,
+    //     pageSize = 100,
+    //   } = options ?? {};
+    //   const startTime = Date.now();
+    //   let retryCount = 0;
+    //   while (retryCount < maxRetries) {
+    //     try {
+    //       if (Date.now() - startTime > timeout) {
+    //         throw new Error(`Waiting for transaction ${digest} timed out`);
+    //       }
+    //       await new Promise((resolve) => setTimeout(resolve, checkInterval));
+    //       const tx = await this.getTransaction(digest);
+    //       if (tx) {
+    //         const events: IndexerEvent[] = [];
+    //         const schemaChanges: IndexerSchema[] = [];
+    //         let hasNextEventsPage = true;
+    //         let eventsCursor: string | undefined;
+    //         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: string | undefined;
+    //         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) {
+    //       throw new Error(
+    //         `Error while waiting for transaction ${digest}: ${error}`
+    //       );
+    //     }
+    //   }
+    //   throw new Error(
+    //     `Reached maximum retries (${maxRetries}), failed to wait for transaction ${digest}`
+    //   );
+    // }
+    // async getEvents({
+    //   first,
+    //   after,
+    //   names,
+    //   sender,
+    //   digest,
+    //   checkpoint,
+    //   orderBy,
+    // }: {
+    //   first?: number;
+    //   after?: string;
+    //   names?: string[];
+    //   sender?: string;
+    //   digest?: string;
+    //   checkpoint?: string;
+    //   orderBy?: string[];
+    // }): Promise<ConnectionResponse<IndexerEvent>> {
+    //   return await this.suiIndexerClient.getEvents({
+    //     first,
+    //     after,
+    //     names,
+    //     sender,
+    //     digest,
+    //     checkpoint,
+    //     orderBy,
+    //   });
+    // }
+    // async getSchemas({
+    //   name,
+    //   key1,
+    //   key2,
+    //   is_removed,
+    //   last_update_checkpoint,
+    //   last_update_digest,
+    //   value,
+    //   first,
+    //   after,
+    //   orderBy,
+    //   jsonOrderBy,
+    // }: {
+    //   name?: string;
+    //   key1?: any;
+    //   key2?: any;
+    //   is_removed?: boolean;
+    //   last_update_checkpoint?: string;
+    //   last_update_digest?: string;
+    //   value?: any;
+    //   first?: number;
+    //   after?: string;
+    //   orderBy?: string[];
+    //   jsonOrderBy?: JsonPathOrder[];
+    // }): Promise<ConnectionResponse<IndexerSchema>> {
+    //   return await this.suiIndexerClient.getSchemas({
+    //     name,
+    //     key1,
+    //     key2,
+    //     is_removed,
+    //     last_update_checkpoint,
+    //     last_update_digest,
+    //     value,
+    //     first,
+    //     after,
+    //     orderBy,
+    //     jsonOrderBy,
+    //   });
+    // }
+    // async getStorage({
+    //   name,
+    //   key1,
+    //   key2,
+    //   is_removed,
+    //   last_update_checkpoint,
+    //   last_update_digest,
+    //   value,
+    //   first,
+    //   after,
+    //   orderBy,
+    //   jsonOrderBy,
+    // }: {
+    //   name?: string;
+    //   key1?: any;
+    //   key2?: any;
+    //   is_removed?: boolean;
+    //   last_update_checkpoint?: string;
+    //   last_update_digest?: string;
+    //   value?: any;
+    //   first?: number;
+    //   after?: string;
+    //   orderBy?: string[];
+    //   jsonOrderBy?: JsonPathOrder[];
+    // }): Promise<StorageResponse<IndexerSchema>> {
+    //   return await this.suiIndexerClient.getStorage({
+    //     name,
+    //     key1,
+    //     key2,
+    //     is_removed,
+    //     last_update_checkpoint,
+    //     last_update_digest,
+    //     value,
+    //     first,
+    //     after,
+    //     orderBy,
+    //     jsonOrderBy,
+    //   });
+    // }
+    // async getStorageItem({
+    //   name,
+    //   key1,
+    //   key2,
+    //   is_removed,
+    //   last_update_checkpoint,
+    //   last_update_digest,
+    //   value,
+    // }: {
+    //   name: string;
+    //   key1?: any;
+    //   key2?: any;
+    //   is_removed?: boolean;
+    //   last_update_checkpoint?: string;
+    //   last_update_digest?: string;
+    //   value?: any;
+    // }): Promise<StorageItemResponse<IndexerSchema> | undefined> {
+    //   const response = await this.suiIndexerClient.getStorageItem({
+    //     name,
+    //     key1,
+    //     key2,
+    //     is_removed,
+    //     last_update_checkpoint,
+    //     last_update_digest,
+    //     value,
+    //   });
+    //   return response;
+    // }
+    // async subscribe({
+    //   types,
+    //   handleData,
+    //   onOpen,
+    //   onClose,
+    // }: {
+    //   types: SubscribableType[];
+    //   handleData: (data: any) => void;
+    //   onOpen?: () => void;
+    //   onClose?: () => void;
+    // }): Promise<WebSocket> {
+    //   return this.suiIndexerClient.subscribe({
+    //     types,
+    //     handleData,
+    //     onOpen,
+    //     onClose,
+    //   });
+    // }
     __privateAdd(this, _processKeyParameter);
     __privateAdd(this, _query, {});
     __privateAdd(this, _tx, {});
@@ -2012,10 +1873,6 @@ var Dubhe = class {
     this.accountManager = new SuiAccountManager({ mnemonics, secretKey });
     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;
@@ -2303,188 +2160,6 @@ var Dubhe = class {
       customModuleName
     });
   }
-  async getTransactions({
-    first,
-    after,
-    sender,
-    digest,
-    checkpoint,
-    orderBy
-  }) {
-    return await this.suiIndexerClient.getTransactions({
-      first,
-      after,
-      sender,
-      digest,
-      checkpoint,
-      orderBy
-    });
-  }
-  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,
-      maxRetries = 300,
-      pageSize = 100
-    } = options ?? {};
-    const startTime = Date.now();
-    let retryCount = 0;
-    while (retryCount < maxRetries) {
-      try {
-        if (Date.now() - startTime > timeout) {
-          throw new Error(`Waiting for transaction ${digest} timed out`);
-        }
-        await new Promise((resolve) => setTimeout(resolve, checkInterval));
-        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) {
-        throw new Error(
-          `Error while waiting for transaction ${digest}: ${error}`
-        );
-      }
-    }
-    throw new Error(
-      `Reached maximum retries (${maxRetries}), failed to wait for transaction ${digest}`
-    );
-  }
-  async getEvents({
-    first,
-    after,
-    name,
-    sender,
-    digest,
-    checkpoint,
-    orderBy
-  }) {
-    return await this.suiIndexerClient.getEvents({
-      first,
-      after,
-      name,
-      sender,
-      digest,
-      checkpoint,
-      orderBy
-    });
-  }
-  async getSchemas({
-    name,
-    key1,
-    key2,
-    is_removed,
-    last_update_checkpoint,
-    last_update_digest,
-    value,
-    first,
-    after,
-    orderBy,
-    jsonOrderBy
-  }) {
-    return await this.suiIndexerClient.getSchemas({
-      name,
-      key1,
-      key2,
-      is_removed,
-      last_update_checkpoint,
-      last_update_digest,
-      value,
-      first,
-      after,
-      orderBy,
-      jsonOrderBy
-    });
-  }
-  async getStorage({
-    name,
-    key1,
-    key2,
-    is_removed,
-    last_update_checkpoint,
-    last_update_digest,
-    value,
-    first,
-    after,
-    orderBy,
-    jsonOrderBy
-  }) {
-    return await this.suiIndexerClient.getStorage({
-      name,
-      key1,
-      key2,
-      is_removed,
-      last_update_checkpoint,
-      last_update_digest,
-      value,
-      first,
-      after,
-      orderBy,
-      jsonOrderBy
-    });
-  }
-  async getStorageItem({
-    name,
-    key1,
-    key2,
-    is_removed,
-    last_update_checkpoint,
-    last_update_digest,
-    value
-  }) {
-    const response = await this.suiIndexerClient.getStorageItem({
-      name,
-      key1,
-      key2,
-      is_removed,
-      last_update_checkpoint,
-      last_update_digest,
-      value
-    });
-    return response;
-  }
-  async subscribe(types, handleData) {
-    return this.suiIndexerClient.subscribe(types, handleData);
-  }
   /**
    * else:
    * it will generate signer from the mnemonic with the given derivePathParams.
@@ -2558,9 +2233,6 @@ var Dubhe = class {
   client() {
     return this.suiInteractor.currentClient;
   }
-  indexerClient() {
-    return this.suiIndexerClient;
-  }
   async getObject(objectId) {
     return this.suiInteractor.getObject(objectId);
   }
@@ -2840,9 +2512,9 @@ var import_multisig = require("@mysten/sui/multisig");
 
 // src/libs/multiSig/publickey.ts
 var import_ed255193 = require("@mysten/sui/keypairs/ed25519");
-var import_utils6 = require("@mysten/sui/utils");
+var import_utils5 = require("@mysten/sui/utils");
 function ed25519PublicKeyFromBase64(rawPubkey) {
-  let bytes = (0, import_utils6.fromB64)(rawPubkey);
+  let bytes = (0, import_utils5.fromB64)(rawPubkey);
   if (bytes.length !== 32 && bytes.length !== 33)
     throw "invalid pubkey length";
   bytes = bytes.length === 33 ? bytes.slice(1) : bytes;
@@ -2893,7 +2565,6 @@ async function loadMetadata(networkType, packageId, fullnodeUrls) {
   BcsType,
   Dubhe,
   MultiSigClient,
-  SubscriptionKind,
   SuiAccountManager,
   SuiContractFactory,
   SuiTx,