@0xobelisk/client 0.2.8 → 0.2.9

package/dist/obelisk.d.ts

@@ -2687,5 +2687,73 @@ export declare class Obelisk {
             parent_object_id?: string | undefined;
         } | null | undefined;
     }>;
+    getComponentTable(worldId: string, componentName: string): Promise<string>;
+    getEntities(worldId: string, componentName: string, cursor?: string, limit?: number): Promise<{
+        data: import("src/types").EntityData[];
+        nextCursor: string | null;
+        hasNextPage: boolean;
+    }>;
+    getEntity(worldId: string, componentName: string, entityId: string): Promise<{
+        data?: {
+            objectId: string;
+            version: string;
+            digest: string;
+            type?: string | null | undefined;
+            bcs?: {
+                type: string;
+                version: string;
+                hasPublicTransfer: boolean;
+                dataType: "moveObject";
+                bcsBytes: string;
+            } | {
+                id: string;
+                dataType: "package";
+                moduleMap: Record<string, string>;
+            } | null | undefined;
+            owner?: {
+                AddressOwner: string;
+            } | {
+                ObjectOwner: string;
+            } | {
+                Shared: {
+                    initial_shared_version: string | null;
+                };
+            } | "Immutable" | null | undefined;
+            storageRebate?: string | null | undefined;
+            previousTransaction?: string | null | undefined;
+            content?: {
+                type: string;
+                fields: Record<string, any>;
+                hasPublicTransfer: boolean;
+                dataType: "moveObject";
+            } | {
+                disassembled: Record<string, unknown>;
+                dataType: "package";
+            } | null | undefined;
+            display?: Record<string, string> | {
+                data?: Record<string, string> | null | undefined;
+                error?: {
+                    code: string;
+                    version?: string | undefined;
+                    digest?: string | undefined;
+                    error?: string | undefined;
+                    object_id?: string | undefined;
+                    parent_object_id?: string | undefined;
+                } | null | undefined;
+            } | null | undefined;
+        } | null | undefined;
+        error?: {
+            code: string;
+            version?: string | undefined;
+            digest?: string | undefined;
+            error?: string | undefined;
+            object_id?: string | undefined;
+            parent_object_id?: string | undefined;
+        } | null | undefined;
+    } | undefined>;
     getOwnedObjects(owner: SuiAddress, cursor?: string, limit?: number): Promise<ObeliskObjectData[]>;
+    entity_key_from_object(objectId: string): Promise<string | undefined>;
+    entity_key_from_bytes(bytes: Uint8Array | Buffer | string): Promise<string>;
+    entity_key_from_u256(x: number): Promise<string>;
+    formatData(type: string, value: Buffer | number[] | Uint8Array): Promise<any>;
 }

package/dist/types/index.d.ts

@@ -39,17 +39,17 @@ export type ComponentValueType = {
     };
 };
 export type SuiTxArgument = {
-    kind: "Input";
+    kind: 'Input';
     index: number;
-    type?: "object" | "pure" | undefined;
+    type?: 'object' | 'pure' | undefined;
     value?: any;
 } | {
-    kind: "GasCoin";
+    kind: 'GasCoin';
 } | {
-    kind: "Result";
+    kind: 'Result';
     index: number;
 } | {
-    kind: "NestedResult";
+    kind: 'NestedResult';
     index: number;
     resultIndex: number;
 };
@@ -57,7 +57,7 @@ export type ComponentContentType = {
     type: string;
     fields: ComponentValueType;
     hasPublicTransfer: boolean;
-    dataType: "moveObject";
+    dataType: 'moveObject';
 };
 export interface MessageMeta {
     readonly meta: SuiMoveMoudleFuncType;
@@ -101,6 +101,18 @@ export type ObjectData = {
     objectDisplay: DisplayFieldsResponse;
     objectFields: ObjectContentFields;
 };
+export type ObjectFieldType = {
+    id: {
+        id: string;
+    };
+    name: string;
+    value: string;
+};
+export type EntityData = {
+    objectId: string;
+    index: string;
+    key: string;
+};
 export type SuiTxArg = Infer<typeof TransactionArgument> | Infer<typeof ObjectCallArg> | string | number | bigint | boolean;
 export type SuiObjectArg = SharedObjectRef | Infer<typeof SuiObjectRef> | string | Infer<typeof ObjectCallArg> | Infer<typeof TransactionArgument>;
 export type SuiVecTxArg = {
@@ -112,3 +124,12 @@ export type SuiVecTxArg = {
  */
 export type SuiBasicTypes = 'address' | 'bool' | 'u8' | 'u16' | 'u32' | 'u64' | 'u128' | 'u256';
 export type SuiInputTypes = 'object' | SuiBasicTypes;
+export type SuiReturnValues = {
+    returnValues: [number[], string][];
+}[];
+export type DynamicFieldContentType = {
+    type: string;
+    fields: Record<string, any>;
+    hasPublicTransfer: boolean;
+    dataType: string;
+};

package/dist/utils/index.d.ts

@@ -1 +1,3 @@
 export declare function capitalizeFirstLetter(input: string): string;
+export declare function normalizeHexAddress(input: string): string | null;
+export declare function numberToAddressHex(num: number): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xobelisk/client",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "description": "Tookit for interacting with move eps framework",
   "keywords": [
     "sui",
@@ -46,8 +46,6 @@
     "watch": "pnpm run clean & pnpm run watch:types & pnpm run watch:tsup",
     "test": "pnpm test:typecheck && pnpm test:unit",
     "test:typecheck": "tsc -p ./test",
-    "test:unit": "vitest run --test-timeout=60000",
-    "test:watch": "vitest",
     "format:fix": "prettier --ignore-path 'dist/* docs/*' --write '**/*.{ts,json,md}'",
     "lint:fix": "eslint . --ignore-pattern dist --ext .ts --fix",
     "commit": "commit",
@@ -90,8 +88,7 @@
     "tsconfig-paths": "^4.2.0",
     "tsup": "^7.1.0",
     "typedoc": "^0.24.8",
-    "typescript": "^5.0.4",
-    "vitest": "^0.32.2"
+    "typescript": "^5.0.4"
   },
   "lint-staged": {
     "**/*.ts": [

package/src/libs/suiInteractor/suiInteractor.ts

@@ -10,11 +10,21 @@ import {
   getObjectVersion,
   getSharedObjectInitialVersion,
   DynamicFieldName,
-  SuiAddress
+  SuiAddress,
 } from '@mysten/sui.js';
 import { requestSuiFromFaucetV0, getFaucetHost } from '@mysten/sui.js/faucet';
-import { SuiClient, getFullnodeUrl, GetBalanceParams } from '@mysten/sui.js/client';
-import { FaucetNetworkType, NetworkType, ObjectData } from 'src/types';
+import {
+  SuiClient,
+  getFullnodeUrl,
+  GetBalanceParams,
+} from '@mysten/sui.js/client';
+import {
+  FaucetNetworkType,
+  NetworkType,
+  ObjectData,
+  ObjectFieldType,
+  EntityData,
+} from 'src/types';
 import { SuiOwnedObject, SuiSharedObject } from '../suiModel';
 import { delay } from './util';
 
@@ -78,6 +88,7 @@ export class SuiInteractor {
     }
     throw new Error('Failed to send transaction with all fullnodes');
   }
+
   async getObjects(ids: string[]) {
     const options = {
       showContent: true,
@@ -129,11 +140,50 @@ export class SuiInteractor {
     return objects[0];
   }
 
+  async getEntitiesObjects(ids: string[]) {
+    const options = {
+      showContent: true,
+      showType: true,
+    };
+
+    // const currentProviderIdx = this.providers.indexOf(this.currentProvider);
+    // const providers = [
+    //   ...this.providers.slice(currentProviderIdx, this.providers.length),
+    //   ...this.providers.slice(0, currentProviderIdx),
+    // ]
+
+    for (const provider of this.providers) {
+      try {
+        const objects = await provider.multiGetObjects({ ids, options });
+        const parsedObjects = objects.map((object) => {
+          const objectId = getObjectId(object);
+          const objectFields = getObjectFields(object) as ObjectFieldType;
+          const index = objectFields.name;
+          const key = objectFields.value;
+          return {
+            objectId,
+            index,
+            key,
+          };
+        });
+        return parsedObjects as EntityData[];
+      } catch (err) {
+        await delay(2000);
+        console.warn(
+          `Failed to get objects with fullnode ${provider.connection.fullnode}: ${err}`
+        );
+      }
+    }
+    throw new Error('Failed to get objects with all fullnodes');
+  }
 
-  async getDynamicFieldObject(parentId: string, name: string | DynamicFieldName) {
+  async getDynamicFieldObject(
+    parentId: string,
+    name: string | DynamicFieldName
+  ) {
     for (const provider of this.providers) {
       try {
-        return provider.getDynamicFieldObject({ parentId, name })
+        return provider.getDynamicFieldObject({ parentId, name });
       } catch (err) {
         await delay(2000);
         console.warn(
@@ -147,7 +197,7 @@ export class SuiInteractor {
   async getDynamicFields(parentId: string, cursor?: string, limit?: number) {
     for (const provider of this.providers) {
       try {
-        return provider.getDynamicFields({ parentId, cursor, limit })
+        return provider.getDynamicFields({ parentId, cursor, limit });
       } catch (err) {
         await delay(2000);
         console.warn(
@@ -172,12 +222,12 @@ export class SuiInteractor {
     throw new Error('Failed to get objects with all fullnodes');
   }
 
-
   async getNormalizedMoveModulesByPackage(packageId: string) {
     for (const provider of this.providers) {
       try {
-        return provider.getNormalizedMoveModulesByPackage({package: packageId});
-
+        return provider.getNormalizedMoveModulesByPackage({
+          package: packageId,
+        });
       } catch (err) {
         await delay(2000);
         console.warn(

package/src/obelisk.ts

@@ -30,9 +30,16 @@ import {
   MapMoudleFuncQuery,
   MapMoudleFuncTx,
   FaucetNetworkType,
+  SuiReturnValues,
+  DynamicFieldContentType,
 } from './types';
-import { capitalizeFirstLetter } from './utils';
+import {
+  capitalizeFirstLetter,
+  normalizeHexAddress,
+  numberToAddressHex,
+} from './utils';
 import keccak256 from 'keccak256';
+import { BCS, getSuiMoveConfig, fromHEX, fromB64, fromB58 } from '@mysten/bcs';
 
 export function isUndefined(value?: unknown): value is undefined {
   return value === undefined;
@@ -467,11 +474,137 @@ export class Obelisk {
     const name = {
       type: 'address',
       value: componentIdValue,
-      // value: [250,208,186,160,39,171,62,206,98,224,138,41,11,217,63,100,248,104,207,64,78,126,43,109,129,68,64,127,236,113,152,132]
     } as DynamicFieldName;
     return await this.suiInteractor.getDynamicFieldObject(parentId, name);
   }
 
+  async getComponentTable(worldId: string, componentName: string) {
+    let componentMoudleName = `${componentName}_comp`;
+    const tx = new TransactionBlock();
+    let params = [tx.pure(worldId)] as SuiTxArgument[];
+
+    const tableResult = (await this.query[componentMoudleName].data(
+      tx,
+      params
+    )) as DevInspectResults;
+    const tableId = tableResult.results as SuiReturnValues;
+    const bcs = new BCS(getSuiMoveConfig());
+
+    let value = Uint8Array.from(tableId[0].returnValues[0][0]);
+    let data = bcs.de('address', value);
+    return '0x' + data;
+  }
+
+  async getEntities(
+    worldId: string,
+    componentName: string,
+    cursor?: string,
+    limit?: number
+  ) {
+    let componentMoudleName = `${componentName}_comp`;
+
+    const tx = new TransactionBlock();
+    let params = [tx.pure(worldId)] as SuiTxArgument[];
+
+    const tableResult = (await this.query[componentMoudleName].entities(
+      tx,
+      params
+    )) as DevInspectResults;
+    const entities = tableResult.results as SuiReturnValues;
+    const bcs = new BCS(getSuiMoveConfig());
+
+    let value = Uint8Array.from(entities[0].returnValues[0][0]);
+    let tableId = '0x' + bcs.de('address', value);
+    let dynamicFields = await this.suiInteractor.getDynamicFields(
+      tableId,
+      cursor,
+      limit
+    );
+    let objectIds = dynamicFields.data.map((field) => field.objectId);
+    let objectDatas = await this.suiInteractor.getEntitiesObjects(objectIds);
+    return {
+      data: objectDatas,
+      nextCursor: dynamicFields.nextCursor,
+      hasNextPage: dynamicFields.hasNextPage,
+    };
+  }
+
+  async getEntity(worldId: string, componentName: string, entityId: string) {
+    let checkWorldId = normalizeHexAddress(worldId);
+    if (checkWorldId) {
+      worldId = checkWorldId;
+    } else {
+      return undefined;
+    }
+
+    let checkEntityId = normalizeHexAddress(entityId);
+    if (checkEntityId) {
+      entityId = checkEntityId;
+    } else {
+      return undefined;
+    }
+
+    const parentId = await this.getComponentTable(worldId, componentName);
+    const name = {
+      type: 'address',
+      value: entityId,
+    } as DynamicFieldName;
+
+    let dynamicFieldObject = await this.suiInteractor.getDynamicFieldObject(
+      parentId,
+      name
+    );
+    return dynamicFieldObject;
+  }
+
+  // async getEntityData(
+  //   worldId: string,
+  //   componentName: string,
+  //   entityId: string
+  // ) {
+  //   const parentId = await this.getComponentTable(worldId, componentName);
+  //   const name = {
+  //     type: 'address',
+  //     value: entityId,
+  //   } as DynamicFieldName;
+
+  //   let dynamicFieldObject = await this.suiInteractor.getDynamicFieldObject(
+  //     parentId,
+  //     name
+  //   );
+  //   let componentMoudleName = `${componentName}_comp`;
+
+  //   const tx = new TransactionBlock();
+  //   let params = [] as SuiTxArgument[];
+
+  //   const typeResult = (await this.query[componentMoudleName].types(
+  //     tx,
+  //     params
+  //   )) as DevInspectResults;
+  //   let typeReturn = typeResult.results as SuiReturnValues;
+  //   console.log(typeReturn[0].returnValues[0][0]);
+
+  //   const typeBCS = new BCS(getSuiMoveConfig());
+  //   let typeValue = Uint8Array.from(typeReturn[0].returnValues[0][0]);
+
+  //   let typeData = typeBCS.de('vector<vector<u8>>', typeValue);
+  //   console.log(typeData);
+  //   const entityType = String.fromCharCode(...typeData[0]);
+
+  //   let dynamicFieldContent = dynamicFieldObject.data!
+  //     .content as DynamicFieldContentType;
+
+  //   let entityValue = dynamicFieldContent.fields['value'];
+  //   const bcs = new BCS(getSuiMoveConfig());
+  //   let value = Uint8Array.from(entityValue);
+  //   console.log(entityType);
+  //   console.log(value);
+
+  //   let data = bcs.de(entityType, value);
+  //   console.log(data);
+  //   return data;
+  // }
+
   async getOwnedObjects(owner: SuiAddress, cursor?: string, limit?: number) {
     const ownedObjects = await this.suiInteractor.getOwnedObjects(
       owner,
@@ -493,4 +626,33 @@ export class Obelisk {
 
     return ownedObjectsRes;
   }
+
+  async entity_key_from_object(objectId: string) {
+    let checkObjectId = normalizeHexAddress(objectId);
+    if (checkObjectId !== null) {
+      objectId = checkObjectId;
+      return objectId;
+    } else {
+      return undefined;
+    }
+  }
+
+  async entity_key_from_bytes(bytes: Uint8Array | Buffer | string) {
+    let hashBytes = keccak256(bytes);
+    const hashU8Array: number[] = Array.from(hashBytes);
+    const bcs = new BCS(getSuiMoveConfig());
+    let value = Uint8Array.from(hashU8Array);
+    let data = bcs.de('address', value);
+    return '0x' + data;
+  }
+
+  async entity_key_from_u256(x: number) {
+    return numberToAddressHex(x);
+  }
+
+  async formatData(type: string, value: Buffer | number[] | Uint8Array) {
+    const bcs = new BCS(getSuiMoveConfig());
+    let u8Value = Uint8Array.from(value);
+    return bcs.de(type, u8Value);
+  }
 }

package/src/types/index.ts

@@ -9,12 +9,13 @@ import {
   TransactionBlock,
   SuiTransactionBlockResponse,
   DevInspectResults,
-  SuiMoveNormalizedModules
+  SuiMoveNormalizedModules,
 } from '@mysten/sui.js';
 
-
-import { SuiMoveMoudleValueType, SuiMoveMoudleFuncType } from '../libs/suiContractFactory/types';
-
+import {
+  SuiMoveMoudleValueType,
+  SuiMoveMoudleFuncType,
+} from '../libs/suiContractFactory/types';
 
 export type ObeliskObjectData = {
   objectId: string;
@@ -24,73 +25,79 @@ export type ObeliskObjectData = {
   objectFields: ObjectContentFields;
 };
 
-
 export type ObeliskParams = {
   mnemonics?: string;
   secretKey?: string;
   fullnodeUrls?: string[];
   faucetUrl?: string;
   networkType?: NetworkType;
-  packageId?: string,
-  metadata?: SuiMoveNormalizedModules,
+  packageId?: string;
+  metadata?: SuiMoveNormalizedModules;
 };
 
 export type ComponentFieldType = {
-    components: {
-        type: string;
-        fields: {
-            id: {
-                id: string;
-            },
-            size: string;
-        }
-    }
-}
+  components: {
+    type: string;
+    fields: {
+      id: {
+        id: string;
+      };
+      size: string;
+    };
+  };
+};
 
 export type ComponentValueType = {
-    id: {
-        id: string;
+  id: {
+    id: string;
+  };
+  name: string;
+  value: {
+    type: string;
+    fields: ComponentFieldType;
+  };
+};
+
+export type SuiTxArgument =
+  | {
+      kind: 'Input';
+      index: number;
+      type?: 'object' | 'pure' | undefined;
+      value?: any;
     }
-    name: string;
-    value: {
-        type: string;
-        fields: ComponentFieldType;
+  | {
+      kind: 'GasCoin';
     }
-
-}
-
-export type SuiTxArgument = {
-    kind: "Input";
-    index: number;
-    type?: "object" | "pure" | undefined;
-    value?: any;
-  } | {
-    kind: "GasCoin";
-  } | {
-    kind: "Result";
-    index: number;
-  } | {
-    kind: "NestedResult";
-    index: number;
-    resultIndex: number;
-  }
+  | {
+      kind: 'Result';
+      index: number;
+    }
+  | {
+      kind: 'NestedResult';
+      index: number;
+      resultIndex: number;
+    };
 export type ComponentContentType = {
-    type: string;
-    fields: ComponentValueType;
-    hasPublicTransfer: boolean;
-    dataType: "moveObject";
-}
+  type: string;
+  fields: ComponentValueType;
+  hasPublicTransfer: boolean;
+  dataType: 'moveObject';
+};
 
 export interface MessageMeta {
   readonly meta: SuiMoveMoudleFuncType;
 }
 
 export interface ContractQuery extends MessageMeta {
-  (tx: TransactionBlock, params: SuiTxArgument[], isRaw?: boolean): Promise<DevInspectResults | TransactionBlock>;
+  (tx: TransactionBlock, params: SuiTxArgument[], isRaw?: boolean): Promise<
+    DevInspectResults | TransactionBlock
+  >;
 }
 
 export interface ContractTx extends MessageMeta {
-  (tx: TransactionBlock, params: SuiTxArgument[], isRaw?: boolean): SuiTransactionBlockResponse | TransactionBlock;
+  (tx: TransactionBlock, params: SuiTxArgument[], isRaw?: boolean):
+    | SuiTransactionBlockResponse
+    | TransactionBlock;
 }
 
 export type MapMessageTx = Record<string, ContractTx>;
@@ -102,8 +109,6 @@ export type MapMoudleFuncQuery = Record<string, MapMessageQuery>;
 export type MapMoudleFuncTest = Record<string, Record<string, string>>;
 export type MapMoudleFuncQueryTest = Record<string, Record<string, string>>;
 
-
-
 export type AccountMangerParams = {
   mnemonics?: string;
   secretKey?: string;
@@ -116,7 +121,7 @@ export type DerivePathParams = {
 };
 
 export type NetworkType = 'testnet' | 'mainnet' | 'devnet' | 'localnet';
-export type FaucetNetworkType = 'testnet' | 'devnet' | 'localnet'
+export type FaucetNetworkType = 'testnet' | 'devnet' | 'localnet';
 
 export type SuiKitParams = {
   mnemonics?: string;
@@ -136,7 +141,19 @@ export type ObjectData = {
   objectFields: ObjectContentFields;
 };
 
+export type ObjectFieldType = {
+  id: {
+    id: string;
+  };
+  name: string;
+  value: string;
+};
 
+export type EntityData = {
+  objectId: string;
+  index: string;
+  key: string;
+};
 
 export type SuiTxArg =
   | Infer<typeof TransactionArgument>
@@ -171,3 +188,14 @@ export type SuiBasicTypes =
   | 'u256';
 
 export type SuiInputTypes = 'object' | SuiBasicTypes;
+
+export type SuiReturnValues = {
+  returnValues: [number[], string][];
+}[];
+
+export type DynamicFieldContentType = {
+  type: string;
+  fields: Record<string, any>;
+  hasPublicTransfer: boolean;
+  dataType: string;
+};

package/src/utils/index.ts

@@ -1,3 +1,23 @@
 export function capitalizeFirstLetter(input: string): string {
-    return input.charAt(0).toUpperCase() + input.slice(1);
+  return input.charAt(0).toUpperCase() + input.slice(1);
+}
+
+export function normalizeHexAddress(input: string): string | null {
+  const hexRegex = /^(0x)?[0-9a-fA-F]{64}$/;
+
+  if (hexRegex.test(input)) {
+    if (input.startsWith('0x')) {
+      return input;
+    } else {
+      return '0x' + input;
+    }
+  } else {
+    return null;
+  }
+}
+
+export function numberToAddressHex(num: number): string {
+  const hex = num.toString(16);
+  const paddedHex = '0x' + hex.padStart(64, '0');
+  return paddedHex;
 }

package/src/framework/bcs.ts

@@ -1,6 +0,0 @@
-
-import { BCS, getSuiMoveConfig } from '@mysten/bcs'
-
-export const bcsSource = new BCS(getSuiMoveConfig())
-export const bcsOnchain = new BCS(getSuiMoveConfig())
-