@0xobelisk/sui-client 1.0.6 → 1.0.7

package/dist/libs/http/errors.d.ts

@@ -0,0 +1,28 @@
+export declare class BaseError extends Error {
+    code: number;
+    type: string;
+    constructor(message: string, code: number, type: string);
+}
+export declare class HttpError extends BaseError {
+    constructor(message: string, code: number);
+}
+export declare class GraphQLError extends BaseError {
+    constructor(message: string);
+}
+export declare class ValidationError extends BaseError {
+    constructor(message: string);
+}
+export declare class NotFoundError extends BaseError {
+    constructor(message: string);
+}
+export declare class ParseError extends BaseError {
+    constructor(message: string);
+}
+export type ErrorType = BaseError | Error | HttpError | NotFoundError | ValidationError | ParseError | GraphQLError;
+export declare function handleError(error: ErrorType): {
+    code: number;
+    error: {
+        message: string;
+        type: string;
+    };
+};

package/dist/libs/http/http.d.ts

@@ -0,0 +1,21 @@
+import { WebSocket } from 'ws';
+export type FetchOptions = RequestInit & {
+    next?: {
+        revalidate?: boolean | number;
+    };
+};
+export declare class Http {
+    private customFetch?;
+    private apiEndpoint;
+    private graphqlEndpoint;
+    private wsEndpoint;
+    private defaultOptions?;
+    constructor(apiEndpoint: string, wsEndpoint: string, customFetch?: typeof fetch | undefined, defaultOptions?: FetchOptions);
+    private getFetch;
+    fetch(url: string): Promise<Response>;
+    fetchGraphql<T>({ query, variables, }: {
+        query: string;
+        variables?: any;
+    }): Promise<T>;
+    subscribe(names: string[], handleData: (data: any) => void): Promise<WebSocket>;
+}

package/dist/libs/http/index.d.ts

@@ -0,0 +1,4 @@
+export { Http } from './http';
+export type { FetchOptions } from './http';
+export * from './errors';
+export * from './types';

package/dist/libs/http/types.d.ts

@@ -0,0 +1 @@
+export declare const ERROR: {};

package/dist/libs/suiIndexerClient/index.d.ts

@@ -0,0 +1,92 @@
+import { Http } from '../http';
+import { WebSocket } from 'ws';
+export interface OrderDirection {
+    ASC: 'ASC';
+    DESC: 'DESC';
+}
+export interface OrderBy {
+    field: string;
+    direction: OrderDirection['ASC'] | OrderDirection['DESC'];
+}
+export interface PageInfo {
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    startCursor?: string;
+    endCursor?: string;
+}
+export interface Transaction {
+    id: number;
+    checkpoint: number;
+    digest: string;
+}
+export interface Schema {
+    id: number;
+    name: string;
+    key1?: string;
+    key2?: string;
+    value: string;
+    last_update_checkpoint: string;
+    last_update_digest: string;
+    is_removed: boolean;
+}
+export interface Event {
+    id: number;
+    checkpoint: string;
+    digest: string;
+    name: string;
+    value: string;
+}
+export interface ConnectionResponse<T> {
+    edges: Array<{
+        cursor: string;
+        node: T;
+    }>;
+    pageInfo: PageInfo;
+}
+export declare class SuiIndexerClient {
+    private http;
+    constructor(http: Http);
+    private fetchGraphql;
+    getTransactions(params?: {
+        first?: number;
+        after?: string;
+        last?: number;
+        before?: string;
+        checkpoint?: number;
+        orderBy?: OrderBy;
+        distinct?: boolean;
+    }): Promise<ConnectionResponse<Transaction>>;
+    getSchemas(params?: {
+        first?: number;
+        after?: string;
+        last?: number;
+        before?: string;
+        name?: string;
+        key1?: string;
+        key2?: string;
+        orderBy?: OrderBy;
+        distinct?: boolean;
+    }): Promise<ConnectionResponse<Schema>>;
+    getEvents(params?: {
+        first?: number;
+        after?: string;
+        last?: number;
+        before?: string;
+        name?: string;
+        checkpoint?: string;
+        orderBy?: OrderBy;
+        distinct?: boolean;
+    }): Promise<ConnectionResponse<Event>>;
+    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>;
+}

package/dist/libs/suiInteractor/defaultConfig.d.ts

@@ -6,5 +6,6 @@ export interface NetworkConfig {
     txExplorer: string;
     accountExplorer: string;
     explorer: string;
+    indexerUrl: string;
 }
 export declare const getDefaultURL: (networkType?: NetworkType) => NetworkConfig;

package/dist/types/index.d.ts

@@ -5,6 +5,7 @@ import type { Transaction, TransactionObjectArgument, TransactionResult, Argumen
 import type { SuiMoveNormalizedModules, DevInspectResults, SuiTransactionBlockResponse, DisplayFieldsResponse, MoveStruct, SuiMoveNormalizedEnum, SuiMoveNormalizedStruct } from '@mysten/sui/client';
 import { SuiTx } from '../libs/suiTxBuilder';
 import { SuiMoveMoudleFuncType } from '../libs/suiContractFactory/types';
+import { FetchOptions } from '../libs/http';
 export declare const ObjectContentFields: import("superstruct").Struct<Record<string, any>, null>;
 export type ObjectContentFields = Infer<typeof ObjectContentFields>;
 export type DubheObjectData = {
@@ -28,6 +29,10 @@ export type DubheParams = {
     networkType?: NetworkType;
     packageId?: string;
     metadata?: SuiMoveNormalizedModules;
+    customFetch?: typeof fetch;
+    defaultOptions?: FetchOptions;
+    indexerUrl?: string;
+    indexerWsUrl?: string;
 };
 export type SchemaFieldType = {
     schemas: {

package/dist/utils/index.d.ts

@@ -2,3 +2,4 @@ export declare function capitalizeFirstLetter(input: string): string;
 export declare function normalizeHexAddress(input: string): string | null;
 export declare function numberToAddressHex(num: number): string;
 export declare function normalizePackageId(input: string): string;
+export declare function convertHttpToWebSocket(url: string): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xobelisk/sui-client",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "Tookit for interacting with move eps framework",
   "keywords": [
     "sui",
@@ -37,47 +37,52 @@
     "src"
   ],
   "dependencies": {
+    "@graphql-typed-document-node/core": "^3.2.0",
     "@mysten/bcs": "^1.2.1",
     "@mysten/sui": "^1.19.0",
+    "@mysten/zklogin": "^0.7.8",
     "@noble/curves": "^1.4.2",
     "@noble/hashes": "^1.4.0",
     "@scure/bip39": "^1.3.0",
-    "@mysten/zklogin": "^0.7.8",
-    "@graphql-typed-document-node/core": "^3.2.0",
     "@suchipi/femver": "^1.0.0",
     "assert": "^2.1.0",
     "bech32": "^2.0.0",
-    "superstruct": "^1.0.3",
-    "ts-retry-promise": "^0.7.1",
-    "tweetnacl": "^1.0.3",
     "colorts": "^0.1.63",
+    "gql.tada": "^1.7.0",
+    "graphql": "^16.8.1",
     "husky": "^8.0.3",
     "keccak256": "^1.0.6",
     "process": "^0.11.10",
-    "gql.tada": "^1.7.0",
-    "graphql": "^16.8.1",
+    "superstruct": "^1.0.3",
     "tmp": "^0.2.1",
+    "ts-retry-promise": "^0.7.1",
+    "tweetnacl": "^1.0.3",
     "valibot": "0.36.0"
   },
   "devDependencies": {
     "@commitlint/cli": "^18.0.0",
     "@commitlint/config-conventional": "^18.0.0",
     "@commitlint/prompt-cli": "^18.0.0",
+    "@types/jest": "^29.5.14",
     "@types/node": "^20.8.7",
     "@types/tmp": "^0.2.5",
+    "@types/ws": "^8.5.14",
     "@typescript-eslint/eslint-plugin": "^6.8.0",
     "@typescript-eslint/parser": "^6.8.0",
     "dotenv": "^16.3.1",
     "eslint": "^8.52.0",
     "eslint-config-prettier": "^8.8.0",
     "eslint-plugin-prettier": "^5.0.1",
+    "graphql-ws": "^6.0.2",
+    "jest": "^29.7.0",
     "lint-staged": "^15.0.2",
     "prettier": "^2.8.8",
     "ts-node": "^10.9.1",
     "tsconfig-paths": "^4.2.0",
     "tsup": "^7.1.0",
     "typedoc": "^0.25.2",
-    "typescript": "^5.2.2"
+    "typescript": "^5.2.2",
+    "ws": "^8.18.0"
   },
   "lint-staged": {
     "**/*.ts": [

package/src/dubhe.ts

@@ -41,12 +41,21 @@ import {
   SuiVecTxArg,
 } from './types';
 import {
+  convertHttpToWebSocket,
   normalizeHexAddress,
   normalizePackageId,
   numberToAddressHex,
 } from './utils';
 import { bcs, fromHEX, toHEX } from '@mysten/bcs';
 import { ContractDataParsingError } from './errors';
+import {
+  ConnectionResponse,
+  OrderBy,
+  Schema,
+  SuiIndexerClient,
+} from './libs/suiIndexerClient';
+import { Http } from './libs/http';
+import { WebSocket } from 'ws';
 
 export function isUndefined(value?: unknown): value is undefined {
   return value === undefined;
@@ -121,8 +130,10 @@ function createTx(
  * @description This class is used to aggregate the tools that used to interact with SUI network.
  */
 export class Dubhe {
+  public http: Http;
   public accountManager: SuiAccountManager;
   public suiInteractor: SuiInteractor;
+  public suiIndexerClient: SuiIndexerClient;
   public contractFactory: SuiContractFactory;
   public packageId: string | undefined;
   public metadata: SuiMoveNormalizedModules | undefined;
@@ -237,13 +248,27 @@ export class Dubhe {
     fullnodeUrls,
     packageId,
     metadata,
+    customFetch,
+    defaultOptions,
+    indexerUrl,
+    indexerWsUrl,
   }: DubheParams = {}) {
+    networkType = networkType ?? 'mainnet';
+
+    const defaultParams = getDefaultURL(networkType);
+
     // Init the account manager
     this.accountManager = new SuiAccountManager({ mnemonics, secretKey });
     // Init the rpc provider
-    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) : undefined;
     if (metadata !== undefined) {
       this.metadata = metadata as SuiMoveNormalizedModules;
@@ -1085,6 +1110,47 @@ export class Dubhe {
     });
   }
 
+  async 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>> {
+    return await this.suiIndexerClient.getStorage({
+      name,
+      key1,
+      key2,
+      first,
+      after,
+      last,
+      before,
+      orderBy,
+      distinct,
+    });
+  }
+
+  async subscribe(
+    names: string[],
+    handleData: (data: any) => void
+  ): Promise<WebSocket> {
+    return this.suiIndexerClient.subscribe(names, handleData);
+  }
+
   #processKeyParameter(tx: Transaction, keyType: string, value: any) {
     // Handle basic types
     switch (keyType.toLowerCase()) {
@@ -1228,6 +1294,10 @@ export class Dubhe {
     return this.suiInteractor.currentClient;
   }
 
+  indexerClient() {
+    return this.suiIndexerClient;
+  }
+
   async getObject(objectId: string) {
     return this.suiInteractor.getObject(objectId);
   }

package/src/libs/http/errors.ts

@@ -0,0 +1,122 @@
+export class BaseError extends Error {
+  constructor(message: string, public code: number, public type: string) {
+    super(message);
+    this.name = this.constructor.name;
+  }
+}
+
+export class HttpError extends BaseError {
+  constructor(message: string, code: number) {
+    super(message, code, 'ERROR_HTTP');
+  }
+}
+
+export class GraphQLError extends BaseError {
+  constructor(message: string) {
+    super(message, 400, 'ERROR_GRAPHQL');
+  }
+}
+
+export class ValidationError extends BaseError {
+  constructor(message: string) {
+    super(message, 400, 'ERROR_VALIDATION');
+  }
+}
+
+export class NotFoundError extends BaseError {
+  constructor(message: string) {
+    super(message, 404, 'ERROR_NOT_FOUND');
+  }
+}
+
+export class ParseError extends BaseError {
+  constructor(message: string) {
+    super(message, 500, 'ERROR_PARSE');
+  }
+}
+
+export type ErrorType =
+  | BaseError
+  | Error
+  | HttpError
+  | NotFoundError
+  | ValidationError
+  | ParseError
+  | GraphQLError;
+
+export function handleError(error: ErrorType) {
+  if (!(error instanceof Error)) {
+    return {
+      code: 500,
+      error: {
+        message: 'Unknown error occurred',
+        type: `ERROR_UNKNOWN`,
+      },
+    };
+  }
+
+  switch (true) {
+    case error instanceof HttpError:
+      return {
+        code: (error as HttpError).code,
+        error: {
+          message: error.message,
+          type: 'ERROR_HTTP',
+        },
+      };
+
+    case error instanceof GraphQLError:
+      return {
+        code: 400,
+        error: {
+          message: error.message,
+          type: 'ERROR_GRAPHQL',
+        },
+      };
+
+    case error instanceof ValidationError:
+      return {
+        code: 400,
+        error: {
+          message: error.message,
+          type: 'ERROR_VALIDATION',
+        },
+      };
+
+    case error instanceof NotFoundError:
+      return {
+        code: 404,
+        error: {
+          message: error.message,
+          type: 'ERROR_NOT_FOUND',
+        },
+      };
+
+    case error instanceof ParseError:
+      return {
+        code: 500,
+        error: {
+          message: error.message,
+          type: 'ERROR_PARSE',
+        },
+      };
+
+    case error instanceof BaseError:
+      return {
+        code: (error as BaseError).code,
+        error: {
+          message: error.message,
+          type: (error as BaseError).type,
+        },
+      };
+
+    default:
+      return {
+        code: 500,
+        error: {
+          message: error.message || 'Internal server error',
+          type: 'ERROR_UNKNOWN',
+        },
+      };
+  }
+}

package/src/libs/http/http.ts

@@ -0,0 +1,153 @@
+import { WebSocket } from 'ws';
+import { BaseError, HttpError, GraphQLError, ParseError } from './errors';
+
+export type FetchOptions = RequestInit & {
+  next?: {
+    revalidate?: boolean | number;
+  };
+};
+
+export class Http {
+  private apiEndpoint: string;
+  private graphqlEndpoint: string;
+  private wsEndpoint: string;
+  private defaultOptions?: FetchOptions;
+
+  constructor(
+    apiEndpoint: string,
+    wsEndpoint: string,
+    private customFetch?: typeof fetch,
+    defaultOptions?: FetchOptions
+  ) {
+    this.apiEndpoint = apiEndpoint;
+    this.graphqlEndpoint = apiEndpoint + '/graphql';
+    this.wsEndpoint = wsEndpoint;
+    this.defaultOptions = defaultOptions;
+  }
+
+  private getFetch() {
+    return this.customFetch || fetch;
+  }
+
+  async fetch(url: string): Promise<Response> {
+    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 as Error).message}`, 500);
+    }
+  }
+
+  async fetchGraphql<T>({
+    query,
+    variables,
+  }: {
+    query: string;
+    variables?: any;
+  }): Promise<T> {
+    try {
+      const isFirstPage = variables?.after === 'first';
+      const fetchFn = this.getFetch();
+      console.log(query);
+      const response = await fetchFn(this.graphqlEndpoint, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Accept: 'application/json',
+        },
+        body: JSON.stringify({
+          query,
+          variables: {
+            ...variables,
+            after: isFirstPage ? undefined : 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) {
+      console.log(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 as Error).message}`,
+        500
+      );
+    }
+  }
+
+  async subscribe(names: string[], handleData: (data: any) => void): Promise<WebSocket> {
+    const ws = new WebSocket(this.wsEndpoint);
+
+    ws.on('open', () => {
+      console.log('Connected to the WebSocket server');
+      // Subscribe to specific event names
+      const subscribeMessage = JSON.stringify({
+        type: 'subscribe',
+        names: names,
+      });
+      ws.send(subscribeMessage);
+    });
+
+    ws.on('message', (data) => {
+      handleData(JSON.parse(data.toString()));
+    });
+
+    ws.on('close', () => {
+      console.log('Disconnected from the WebSocket server');
+    });
+
+    ws.on('error', (error) => {
+      console.error(`WebSocket error: ${error}`);
+    });
+
+    return ws;
+  }
+}

package/src/libs/http/index.ts

@@ -0,0 +1,4 @@
+export { Http } from './http';
+export type { FetchOptions } from './http';
+export * from './errors';
+export * from './types';

package/src/libs/http/types.ts

@@ -0,0 +1 @@
+export const ERROR = {};