@0xobelisk/sui-client 1.0.7 → 1.0.9

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

@@ -1,4 +1,4 @@
-import { WebSocket } from 'ws';
+import { WebSocketInstance } from './ws-adapter';
 export type FetchOptions = RequestInit & {
     next?: {
         revalidate?: boolean | number;
@@ -17,5 +17,5 @@ export declare class Http {
         query: string;
         variables?: any;
     }): Promise<T>;
-    subscribe(names: string[], handleData: (data: any) => void): Promise<WebSocket>;
+    subscribe(names: string[], handleData: (data: any) => void): Promise<WebSocketInstance>;
 }

package/dist/libs/http/ws-adapter.d.ts

@@ -0,0 +1,6 @@
+export type WebSocketInstance = WebSocket;
+export interface WebSocketConstructor {
+    new (url: string): WebSocket;
+}
+export declare function createWebSocketClient(url: string): WebSocketInstance;
+export declare function isWebSocketSupported(): boolean;

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

@@ -1,25 +1,19 @@
 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 {
+export interface IndexerTransaction {
     id: number;
     checkpoint: number;
     digest: string;
+    created_at: string;
 }
-export interface Schema {
+export interface IndexerSchema {
     id: number;
     name: string;
     key1?: string;
@@ -28,13 +22,16 @@ export interface Schema {
     last_update_checkpoint: string;
     last_update_digest: string;
     is_removed: boolean;
+    created_at: string;
+    updated_at: string;
 }
-export interface Event {
+export interface IndexerEvent {
     id: number;
     checkpoint: string;
     digest: string;
     name: string;
     value: string;
+    created_at: string;
 }
 export interface ConnectionResponse<T> {
     edges: Array<{
@@ -42,6 +39,17 @@ export interface ConnectionResponse<T> {
         node: T;
     }>;
     pageInfo: PageInfo;
+    totalCount: number;
+}
+export interface StorageResponse<T> {
+    data: T[];
+    value: any[];
+    pageInfo: PageInfo;
+    totalCount: number;
+}
+export interface StorageItemResponse<T> {
+    data: T;
+    value: any;
 }
 export declare class SuiIndexerClient {
     private http;
@@ -50,43 +58,36 @@ export declare class SuiIndexerClient {
     getTransactions(params?: {
         first?: number;
         after?: string;
-        last?: number;
-        before?: string;
         checkpoint?: number;
-        orderBy?: OrderBy;
-        distinct?: boolean;
-    }): Promise<ConnectionResponse<Transaction>>;
+        orderBy?: string[];
+    }): Promise<ConnectionResponse<IndexerTransaction>>;
     getSchemas(params?: {
         first?: number;
         after?: string;
-        last?: number;
-        before?: string;
         name?: string;
         key1?: string;
         key2?: string;
-        orderBy?: OrderBy;
-        distinct?: boolean;
-    }): Promise<ConnectionResponse<Schema>>;
+        orderBy?: string[];
+    }): Promise<ConnectionResponse<IndexerSchema>>;
     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;
+        orderBy?: string[];
+    }): Promise<ConnectionResponse<IndexerEvent>>;
+    getStorage({ name, key1, key2, first, after, orderBy, }: {
+        name?: string;
         key1?: string;
         key2?: string;
         first?: number;
         after?: string;
-        last?: number;
-        before?: string;
-        orderBy?: OrderBy;
-        distinct?: boolean;
-    }): Promise<ConnectionResponse<Schema>>;
+        orderBy?: string[];
+    }): Promise<StorageResponse<IndexerSchema>>;
+    getStorageItem({ name, key1, key2, }: {
+        name: string;
+        key1?: string;
+        key2?: string;
+    }): Promise<StorageItemResponse<IndexerSchema> | undefined>;
     subscribe(names: string[], handleData: (data: any) => void): Promise<WebSocket>;
 }

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

@@ -0,0 +1 @@
+export declare const parseValue: (value: unknown) => unknown;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xobelisk/sui-client",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "Tookit for interacting with move eps framework",
   "keywords": [
     "sui",
@@ -57,7 +57,8 @@
     "tmp": "^0.2.1",
     "ts-retry-promise": "^0.7.1",
     "tweetnacl": "^1.0.3",
-    "valibot": "0.36.0"
+    "valibot": "0.36.0",
+    "ws": "^8.18.0"
   },
   "devDependencies": {
     "@commitlint/cli": "^18.0.0",
@@ -66,7 +67,6 @@
     "@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",
@@ -82,7 +82,7 @@
     "tsup": "^7.1.0",
     "typedoc": "^0.25.2",
     "typescript": "^5.2.2",
-    "ws": "^8.18.0"
+    "@types/ws": "^8.5.14"
   },
   "lint-staged": {
     "**/*.ts": [

package/src/dubhe.ts

@@ -50,12 +50,14 @@ import { bcs, fromHEX, toHEX } from '@mysten/bcs';
 import { ContractDataParsingError } from './errors';
 import {
   ConnectionResponse,
-  OrderBy,
-  Schema,
+  IndexerTransaction,
+  IndexerEvent,
+  IndexerSchema,
   SuiIndexerClient,
+  StorageResponse,
+  StorageItemResponse,
 } from './libs/suiIndexerClient';
 import { Http } from './libs/http';
-import { WebSocket } from 'ws';
 
 export function isUndefined(value?: unknown): value is undefined {
   return value === undefined;
@@ -1110,40 +1112,101 @@ export class Dubhe {
     });
   }
 
+  async getTransactions({
+    first,
+    after,
+    orderBy,
+  }: {
+    first?: number;
+    after?: string;
+    orderBy?: string[];
+  }): Promise<ConnectionResponse<IndexerTransaction>> {
+    return await this.suiIndexerClient.getTransactions({
+      first,
+      after,
+      orderBy,
+    });
+  }
+
+  async getEvents({
+    first,
+    after,
+    orderBy,
+  }: {
+    first?: number;
+    after?: string;
+    orderBy?: string[];
+  }): Promise<ConnectionResponse<IndexerEvent>> {
+    return await this.suiIndexerClient.getEvents({ first, after, orderBy });
+  }
+
+  async getSchemas({
+    name,
+    key1,
+    key2,
+    first,
+    after,
+    orderBy,
+  }: {
+    name?: string;
+    key1?: string;
+    key2?: string;
+    first?: number;
+    after?: string;
+    orderBy?: string[];
+  }): Promise<ConnectionResponse<IndexerSchema>> {
+    return await this.suiIndexerClient.getSchemas({
+      name,
+      key1,
+      key2,
+      first,
+      after,
+      orderBy,
+    });
+  }
+
   async getStorage({
     name,
     key1,
     key2,
     first,
     after,
-    last,
-    before,
     orderBy,
-    distinct,
   }: {
-    name: string;
+    name?: string;
     key1?: string;
     key2?: string;
     first?: number;
     after?: string;
-    last?: number;
-    before?: string;
-    orderBy?: OrderBy;
-    distinct?: boolean;
-  }): Promise<ConnectionResponse<Schema>> {
+    orderBy?: string[];
+  }): Promise<StorageResponse<IndexerSchema>> {
     return await this.suiIndexerClient.getStorage({
       name,
       key1,
       key2,
       first,
       after,
-      last,
-      before,
       orderBy,
-      distinct,
     });
   }
 
+  async getStorageItem({
+    name,
+    key1,
+    key2,
+  }: {
+    name: string;
+    key1?: string;
+    key2?: string;
+  }): Promise<StorageItemResponse<IndexerSchema> | undefined> {
+    const response = await this.suiIndexerClient.getStorageItem({
+      name,
+      key1,
+      key2,
+    });
+    return response;
+  }
+
   async subscribe(
     names: string[],
     handleData: (data: any) => void

package/src/libs/http/http.ts

@@ -1,5 +1,5 @@
-import { WebSocket } from 'ws';
 import { BaseError, HttpError, GraphQLError, ParseError } from './errors';
+import { createWebSocketClient, WebSocketInstance } from './ws-adapter';
 
 export type FetchOptions = RequestInit & {
   next?: {
@@ -62,7 +62,6 @@ export class Http {
     try {
       const isFirstPage = variables?.after === 'first';
       const fetchFn = this.getFetch();
-      console.log(query);
       const response = await fetchFn(this.graphqlEndpoint, {
         method: 'POST',
         headers: {
@@ -109,7 +108,6 @@ export class Http {
 
       return data.data;
     } catch (error) {
-      console.log(error);
       if (error instanceof BaseError) {
         throw error;
       }
@@ -123,30 +121,32 @@ export class Http {
     }
   }
 
-  async subscribe(names: string[], handleData: (data: any) => void): Promise<WebSocket> {
-    const ws = new WebSocket(this.wsEndpoint);
+  async subscribe(
+    names: string[],
+    handleData: (data: any) => void
+  ): Promise<WebSocketInstance> {
+    const ws = createWebSocketClient(this.wsEndpoint);
 
-    ws.on('open', () => {
+    ws.onopen = () => {
       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.onmessage = (event) => {
+      handleData(JSON.parse(event.data.toString()));
+    };
 
-    ws.on('close', () => {
+    ws.onclose = () => {
       console.log('Disconnected from the WebSocket server');
-    });
+    };
 
-    ws.on('error', (error) => {
-      console.error(`WebSocket error: ${error}`);
-    });
+    ws.onerror = (error) => {
+      console.error(`WebSocket error:`, error);
+    };
 
     return ws;
   }

package/src/libs/http/ws-adapter.ts

@@ -0,0 +1,36 @@
+export type WebSocketInstance = WebSocket;
+
+export interface WebSocketConstructor {
+  new (url: string): WebSocket;
+}
+
+export function createWebSocketClient(url: string): WebSocketInstance {
+  if (typeof window !== 'undefined') {
+    // Browser Environment
+    return new WebSocket(url);
+  } else {
+    // Node.js Environment
+    try {
+      require.resolve('ws');
+      const WebSocket = require('ws');
+      return new WebSocket(url);
+    } catch (e) {
+      console.error('Failed to load WebSocket implementation:', e);
+      throw new Error(
+        'WebSocket implementation not available. Please install the "ws" package.'
+      );
+    }
+  }
+}
+
+export function isWebSocketSupported(): boolean {
+  if (typeof window !== 'undefined') {
+    return typeof WebSocket !== 'undefined';
+  }
+  try {
+    require.resolve('ws');
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/libs/suiIndexerClient/index.ts

@@ -1,30 +1,29 @@
 import { Http } from '../http';
-import { WebSocket } from 'ws';
+import { parseValue } from './utils';
 
 export interface OrderDirection {
   ASC: 'ASC';
   DESC: 'DESC';
 }
 
-export interface OrderBy {
-  field: string;
-  direction: OrderDirection['ASC'] | OrderDirection['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 {
+export interface IndexerTransaction {
   id: number;
   checkpoint: number;
   digest: string;
+  created_at: string;
 }
 
-export interface Schema {
+export interface IndexerSchema {
   id: number;
   name: string;
   key1?: string;
@@ -33,14 +32,17 @@ export interface Schema {
   last_update_checkpoint: string;
   last_update_digest: string;
   is_removed: boolean;
+  created_at: string;
+  updated_at: string;
 }
 
-export interface Event {
+export interface IndexerEvent {
   id: number;
   checkpoint: string;
   digest: string;
   name: string;
   value: string;
+  created_at: string;
 }
 
 export interface ConnectionResponse<T> {
@@ -49,6 +51,19 @@ export interface ConnectionResponse<T> {
     node: T;
   }>;
   pageInfo: PageInfo;
+  totalCount: number;
+}
+
+export interface StorageResponse<T> {
+  data: T[];
+  value: any[];
+  pageInfo: PageInfo;
+  totalCount: number;
+}
+
+export interface StorageItemResponse<T> {
+  data: T;
+  value: any;
 }
 
 export class SuiIndexerClient {
@@ -65,35 +80,32 @@ export class SuiIndexerClient {
   async getTransactions(params?: {
     first?: number;
     after?: string;
-    last?: number;
-    before?: string;
     checkpoint?: number;
-    orderBy?: OrderBy;
-    distinct?: boolean;
+    orderBy?: string[];
   }) {
     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) {
+      query GetTransactions($first: Int, $after: String, $checkpoint: Int, $orderBy: [TransactionOrderField!]) {
+        transactions(first: $first, after: $after, checkpoint: $checkpoint, orderBy: $orderBy) {
           edges {
             cursor
             node {
               id
               checkpoint
               digest
+              created_at
             }
           }
           pageInfo {
             hasNextPage
-            hasPreviousPage
-            startCursor
             endCursor
           }
+          totalCount
         }
       }
     `;
 
     const response = await this.fetchGraphql<{
-      transactions: ConnectionResponse<Transaction>;
+      transactions: ConnectionResponse<IndexerTransaction>;
     }>(query, params);
     return response.transactions;
   }
@@ -101,17 +113,14 @@ export class SuiIndexerClient {
   async getSchemas(params?: {
     first?: number;
     after?: string;
-    last?: number;
-    before?: string;
     name?: string;
     key1?: string;
     key2?: string;
-    orderBy?: OrderBy;
-    distinct?: boolean;
-  }): Promise<ConnectionResponse<Schema>> {
+    orderBy?: string[];
+  }): Promise<ConnectionResponse<IndexerSchema>> {
     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) {
+      query GetSchemas($first: Int, $after: String, $name: String, $key1: String, $key2: String, $orderBy: [SchemaOrderField!]) {
+        schemas(first: $first, after: $after, name: $name, key1: $key1, key2: $key2, orderBy: $orderBy) {
           edges {
             cursor
             node {
@@ -123,20 +132,21 @@ export class SuiIndexerClient {
               last_update_checkpoint
               last_update_digest
               is_removed
+              created_at
+              updated_at
             }
           }
           pageInfo {
             hasNextPage
-            hasPreviousPage
-            startCursor
             endCursor
           }
+          totalCount
         }
       }
     `;
 
     const response = await this.fetchGraphql<{
-      schemas: ConnectionResponse<Schema>;
+      schemas: ConnectionResponse<IndexerSchema>;
     }>(query, params);
     return response.schemas;
   }
@@ -144,16 +154,13 @@ export class SuiIndexerClient {
   async getEvents(params?: {
     first?: number;
     after?: string;
-    last?: number;
-    before?: string;
     name?: string;
     checkpoint?: string;
-    orderBy?: OrderBy;
-    distinct?: boolean;
-  }) {
+    orderBy?: string[];
+  }): Promise<ConnectionResponse<IndexerEvent>> {
     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) {
+      query GetEvents($first: Int, $after: String, $name: String, $checkpoint: String, $orderBy: [EventOrderField!]) {
+        events(first: $first, after: $after, name: $name, checkpoint: $checkpoint, orderBy: $orderBy) {
           edges {
             cursor
             node {
@@ -162,20 +169,20 @@ export class SuiIndexerClient {
               digest
               name
               value
+              created_at
             }
           }
           pageInfo {
             hasNextPage
-            hasPreviousPage
-            startCursor
             endCursor
           }
+          totalCount
         }
       }
     `;
 
     const response = await this.fetchGraphql<{
-      events: ConnectionResponse<Event>;
+      events: ConnectionResponse<IndexerEvent>;
     }>(query, params);
     return response.events;
   }
@@ -186,34 +193,57 @@ export class SuiIndexerClient {
     key2,
     first,
     after,
-    last,
-    before,
     orderBy,
-    distinct,
   }: {
-    name: string;
+    name?: string;
     key1?: string;
     key2?: string;
     first?: number;
     after?: string;
-    last?: number;
-    before?: string;
-    orderBy?: OrderBy;
-    distinct?: boolean;
-  }): Promise<ConnectionResponse<Schema>> {
+    orderBy?: string[];
+  }): Promise<StorageResponse<IndexerSchema>> {
     const schemas = await this.getSchemas({
       name,
       key1,
       key2,
       first,
       after,
-      last,
-      before,
       orderBy,
-      distinct,
     });
+    const data = schemas.edges.map((edge) => edge.node);
+    const value = data.map((item) => parseValue(item.value));
+    return {
+      data,
+      value,
+      pageInfo: schemas.pageInfo,
+      totalCount: schemas.totalCount,
+    };
+  }
 
-    return schemas;
+  async getStorageItem({
+    name,
+    key1,
+    key2,
+  }: {
+    name: string;
+    key1?: string;
+    key2?: string;
+  }): Promise<StorageItemResponse<IndexerSchema> | undefined> {
+    const schemas = await this.getSchemas({
+      name,
+      key1,
+      key2,
+      first: 1,
+    });
+    const data = schemas.edges[0]?.node;
+    if (!data) {
+      return undefined;
+    }
+    const value = parseValue(data.value);
+    return {
+      data,
+      value,
+    };
   }
 
   async subscribe(