@0xobelisk/client 0.3.0 → 0.3.2

package/dist/types/index.d.ts

@@ -0,0 +1,141 @@
+import { Infer } from 'superstruct';
+import { DisplayFieldsResponse, ObjectCallArg, ObjectContentFields, SharedObjectRef, SuiObjectRef, TransactionArgument, TransactionBlock, SuiTransactionBlockResponse, DevInspectResults, SuiMoveNormalizedModules } from '@mysten/sui.js';
+import { SuiMoveMoudleFuncType } from '../libs/suiContractFactory/types';
+export type ObeliskObjectData = {
+    objectId: string;
+    objectType: string;
+    objectVersion: number;
+    objectDisplay: DisplayFieldsResponse;
+    objectFields: ObjectContentFields;
+};
+export type ObeliskParams = {
+    mnemonics?: string;
+    secretKey?: string;
+    fullnodeUrls?: string[];
+    faucetUrl?: string;
+    networkType?: NetworkType;
+    packageId?: string;
+    metadata?: SuiMoveNormalizedModules;
+};
+export type SchemaFieldType = {
+    schemas: {
+        type: string;
+        fields: {
+            id: {
+                id: string;
+            };
+            size: string;
+        };
+    };
+};
+export type SchemaValueType = {
+    id: {
+        id: string;
+    };
+    name: string;
+    value: {
+        type: string;
+        fields: SchemaFieldType;
+    };
+};
+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;
+};
+export type SchemaContentType = {
+    type: string;
+    fields: SchemaValueType;
+    hasPublicTransfer: boolean;
+    dataType: 'moveObject';
+};
+export interface MessageMeta {
+    readonly meta: SuiMoveMoudleFuncType;
+}
+export interface ContractQuery extends MessageMeta {
+    (tx: TransactionBlock, params: SuiTxArgument[], isRaw?: boolean): Promise<DevInspectResults | TransactionBlock>;
+}
+export interface ContractTx extends MessageMeta {
+    (tx: TransactionBlock, params: SuiTxArgument[], isRaw?: boolean): SuiTransactionBlockResponse | TransactionBlock;
+}
+export type MapMessageTx = Record<string, ContractTx>;
+export type MapMessageQuery = Record<string, ContractQuery>;
+export type MapMoudleFuncTx = Record<string, MapMessageTx>;
+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;
+};
+export type DerivePathParams = {
+    accountIndex?: number;
+    isExternal?: boolean;
+    addressIndex?: number;
+};
+export type NetworkType = 'testnet' | 'mainnet' | 'devnet' | 'localnet';
+export type FaucetNetworkType = 'testnet' | 'devnet' | 'localnet';
+export type SuiKitParams = {
+    mnemonics?: string;
+    secretKey?: string;
+    fullnodeUrls?: string[];
+    faucetUrl?: string;
+    networkType?: NetworkType;
+};
+export type ObjectData = {
+    objectId: string;
+    objectType: string;
+    objectVersion: number;
+    objectDigest: string;
+    initialSharedVersion?: number;
+    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 = {
+    value: SuiTxArg[];
+    vecType: SuiInputTypes;
+} | SuiTxArg[];
+/**
+ * These are the basics types that can be used in the SUI
+ */
+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;
+};
+export type ObjectContent = {
+    type: string;
+    fields: Record<string, any>;
+    hasPublicTransfer: boolean;
+    dataType: string;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xobelisk/client",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Tookit for interacting with move eps framework",
   "keywords": [
     "sui",

package/src/obelisk.ts

@@ -1,45 +1,36 @@
 import {
-  RawSigner,
-  TransactionBlock,
   DevInspectResults,
-  SuiTransactionBlockResponse,
-  SuiMoveNormalizedModules,
-  DynamicFieldName,
+  RawSigner,
   SuiAddress,
+  SuiMoveNormalizedModules,
+  SuiTransactionBlockResponse,
+  TransactionBlock,
 } from '@mysten/sui.js';
 import { SuiAccountManager } from './libs/suiAccountManager';
 import { SuiTxBlock } from './libs/suiTxBuilder';
-import { SuiInteractor, getDefaultConnection } from './libs/suiInteractor';
-import { SuiSharedObject, SuiOwnedObject } from './libs/suiModel';
+import { getDefaultConnection, SuiInteractor } from './libs/suiInteractor';
 
 import { ObeliskObjectData } from 'src/types';
 import { SuiContractFactory } from './libs/suiContractFactory';
 import {
-  SuiMoveMoudleValueType,
   SuiMoveMoudleFuncType,
+  SuiMoveMoudleValueType,
 } from './libs/suiContractFactory/types';
 import {
-  ObeliskParams,
-  DerivePathParams,
-  SuiTxArg,
-  SuiVecTxArg,
-  ComponentContentType,
-  SuiTxArgument,
   ContractQuery,
   ContractTx,
+  DerivePathParams,
+  FaucetNetworkType,
   MapMoudleFuncQuery,
   MapMoudleFuncTx,
-  FaucetNetworkType,
-  SuiReturnValues,
-  DynamicFieldContentType,
+  ObeliskParams,
+  SuiTxArg,
+  SuiTxArgument,
+  SuiVecTxArg,
 } from './types';
-import {
-  capitalizeFirstLetter,
-  normalizeHexAddress,
-  numberToAddressHex,
-} from './utils';
+import { normalizeHexAddress, numberToAddressHex } from './utils';
 import keccak256 from 'keccak256';
-import { BCS, getSuiMoveConfig, fromHEX, fromB64, fromB58 } from '@mysten/bcs';
+import { BCS, getSuiMoveConfig } from '@mysten/bcs';
 
 export function isUndefined(value?: unknown): value is undefined {
   return value === undefined;
@@ -139,10 +130,10 @@ export class Obelisk {
     if (metadata !== undefined) {
       this.metadata = metadata as SuiMoveNormalizedModules;
       Object.values(metadata as SuiMoveNormalizedModules).forEach((value) => {
-        let data = value as SuiMoveMoudleValueType;
-        let moduleName = data.name;
+        const data = value as SuiMoveMoudleValueType;
+        const moduleName = data.name;
         Object.entries(data.exposedFunctions).forEach(([funcName, value]) => {
-          let meta = value as SuiMoveMoudleFuncType;
+          const meta = value as SuiMoveMoudleFuncType;
           meta.moudleName = moduleName;
           meta.funcName = funcName;
 
@@ -454,155 +445,105 @@ export class Obelisk {
     return this.suiInteractor.getObject(worldObjectId);
   }
 
-  async getComponents(worldId: string, cursor?: string, limit?: number) {
-    const parentId = (await this.suiInteractor.getObject(worldId)).objectFields
-      .comps.fields.id.id;
-
-    return await this.suiInteractor.getDynamicFields(parentId, cursor, limit);
-  }
-
-  async getComponentByName(worldId: string, componentName: string) {
-    const componentNameId = `${componentName}`;
-    const componentId = keccak256(componentNameId);
-    return await this.getComponent(worldId, componentId);
+  async listSchemaNames(worldId: string) {
+    const worldObject = await this.getObject(worldId);
+    const newObjectContent = worldObject.objectFields;
+    return newObjectContent['schemaNames'];
   }
 
-  async getComponent(worldId: string, componentId: Buffer) {
-    const componentIdValue: number[] = Array.from(componentId);
-    const parentId = (await this.suiInteractor.getObject(worldId)).objectFields
-      .comps.fields.id.id;
-    const name = {
-      type: 'address',
-      value: componentIdValue,
-    } as DynamicFieldName;
-    return await this.suiInteractor.getDynamicFieldObject(parentId, name);
-  }
-
-  async getComponentTable(worldId: string, componentName: string) {
-    let componentMoudleName = `${componentName}_comp`;
+  async getEntity(
+    worldId: string,
+    schemaName: string,
+    entityId?: string
+  ): Promise<any[] | undefined> {
+    const schemaMoudleName = `${schemaName}_schema`;
     const tx = new TransactionBlock();
-    let params = [tx.pure(worldId)] as SuiTxArgument[];
+    const params = [tx.pure(worldId)] as SuiTxArgument[];
+    if (entityId !== undefined) {
+      params.push(tx.pure(entityId));
+    }
 
-    const tableResult = (await this.query[componentMoudleName].data(
+    const getResult = (await this.query[schemaMoudleName].get(
       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;
+    const returnValue = [];
+
+    // "success" | "failure";
+    if (getResult.effects.status.status === 'success') {
+      const resultList = getResult.results![0].returnValues!;
+      for (const res of resultList) {
+        const bcs = new BCS(getSuiMoveConfig());
+        const value = Uint8Array.from(res[0]);
+        const data = bcs.de(res[1], value);
+        returnValue.push(data);
+      }
+      return returnValue;
+    } else {
+      return undefined;
+    }
   }
 
-  async getEntities(
+  async containEntity(
     worldId: string,
-    componentName: string,
-    cursor?: string,
-    limit?: number
-  ) {
-    let componentMoudleName = `${componentName}_comp`;
-
+    schemaName: string,
+    entityId?: string
+  ): Promise<boolean | undefined> {
+    const schemaMoudleName = `${schemaName}_schema`;
     const tx = new TransactionBlock();
-    let params = [tx.pure(worldId)] as SuiTxArgument[];
+    const params = [tx.pure(worldId)] as SuiTxArgument[];
+    if (entityId !== undefined) {
+      params.push(tx.pure(entityId));
+    }
 
-    const tableResult = (await this.query[componentMoudleName].entities(
+    const getResult = (await this.query[schemaMoudleName].contains(
       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;
+    // "success" | "failure";
+    if (getResult.effects.status.status === 'success') {
+      const res = getResult.results![0].returnValues![0];
+      const bcs = new BCS(getSuiMoveConfig());
+      const value = Uint8Array.from(res[0]);
+      return bcs.de(res[1], value);
     } 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(
+  // async getEntities(
   //   worldId: string,
-  //   componentName: string,
-  //   entityId: string
+  //   schemaName: string,
+  //   cursor?: string,
+  //   limit?: number
   // ) {
-  //   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`;
+  //   let schemaMoudleName = `${schemaName}_schema`;
 
   //   const tx = new TransactionBlock();
-  //   let params = [] as SuiTxArgument[];
+  //   let params = [tx.pure(worldId)] as SuiTxArgument[];
 
-  //   const typeResult = (await this.query[componentMoudleName].types(
+  //   const tableResult = (await this.query[schemaonentMoudleName].entities(
   //     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 entities = tableResult.results as SuiReturnValues;
   //   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;
+  //   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 getOwnedObjects(owner: SuiAddress, cursor?: string, limit?: number) {
@@ -611,10 +552,10 @@ export class Obelisk {
       cursor,
       limit
     );
-    let ownedObjectsRes: ObeliskObjectData[] = [];
+    const ownedObjectsRes: ObeliskObjectData[] = [];
 
     for (const object of ownedObjects.data) {
-      let objectDetail = await this.getObject(object.data!.objectId);
+      const objectDetail = await this.getObject(object.data!.objectId);
 
       if (
         objectDetail.objectType.split('::')[0] ===
@@ -628,7 +569,7 @@ export class Obelisk {
   }
 
   async entity_key_from_object(objectId: string) {
-    let checkObjectId = normalizeHexAddress(objectId);
+    const checkObjectId = normalizeHexAddress(objectId);
     if (checkObjectId !== null) {
       objectId = checkObjectId;
       return objectId;
@@ -638,11 +579,11 @@ export class Obelisk {
   }
 
   async entity_key_from_bytes(bytes: Uint8Array | Buffer | string) {
-    let hashBytes = keccak256(bytes);
+    const 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);
+    const value = Uint8Array.from(hashU8Array);
+    const data = bcs.de('address', value);
     return '0x' + data;
   }
 
@@ -652,7 +593,7 @@ export class Obelisk {
 
   async formatData(type: string, value: Buffer | number[] | Uint8Array) {
     const bcs = new BCS(getSuiMoveConfig());
-    let u8Value = Uint8Array.from(value);
+    const u8Value = Uint8Array.from(value);
     return bcs.de(type, u8Value);
   }
 }

package/src/types/index.ts

@@ -35,8 +35,8 @@ export type ObeliskParams = {
   metadata?: SuiMoveNormalizedModules;
 };
 
-export type ComponentFieldType = {
-  components: {
+export type SchemaFieldType = {
+  schemas: {
     type: string;
     fields: {
       id: {
@@ -47,14 +47,14 @@ export type ComponentFieldType = {
   };
 };
 
-export type ComponentValueType = {
+export type SchemaValueType = {
   id: {
     id: string;
   };
   name: string;
   value: {
     type: string;
-    fields: ComponentFieldType;
+    fields: SchemaFieldType;
   };
 };
 
@@ -77,9 +77,9 @@ export type SuiTxArgument =
       index: number;
       resultIndex: number;
     };
-export type ComponentContentType = {
+export type SchemaContentType = {
   type: string;
-  fields: ComponentValueType;
+  fields: SchemaValueType;
   hasPublicTransfer: boolean;
   dataType: 'moveObject';
 };
@@ -199,3 +199,10 @@ export type DynamicFieldContentType = {
   hasPublicTransfer: boolean;
   dataType: string;
 };
+
+export type ObjectContent = {
+  type: string;
+  fields: Record<string, any>;
+  hasPublicTransfer: boolean;
+  dataType: string;
+};