@0xobelisk/sui-client 0.5.25 → 0.5.27

package/src/dubhe.ts

@@ -39,7 +39,6 @@ import {
 } from './types';
 import { normalizeHexAddress, numberToAddressHex } from './utils';
 import { bcs, fromHEX, toHEX } from '@mysten/bcs';
-import { TypeTagSerializer } from '@mysten/sui/bcs';
 
 export function isUndefined(value?: unknown): value is undefined {
   return value === undefined;
@@ -94,7 +93,6 @@ function createTx(
       typeArguments?: string[],
       isRaw?: boolean
     ): Promise<SuiTransactionBlockResponse | TransactionResult> => {
-      // const result = await fn(tx, params, typeArguments, isRaw);
       return await fn(tx, params, typeArguments, isRaw);
     }
   );
@@ -142,6 +140,22 @@ export class Dubhe {
     '0x1::option::Option<u128>': bcs.option(bcs.u128()),
     '0x1::option::Option<u256>': bcs.option(bcs.u256()),
     '0x1::option::Option<bool>': bcs.option(bcs.bool()),
+    '0x1::option::Option<vector<address>>': bcs.option(
+      bcs.vector(
+        bcs.bytes(32).transform({
+          // To change the input type, you need to provide a type definition for the input
+          input: (val: string) => fromHEX(val),
+          output: (val) => toHEX(val),
+        })
+      )
+    ),
+    '0x1::option::Option<vector<u8>>': bcs.option(bcs.vector(bcs.u8())),
+    '0x1::option::Option<vector<u16>>': bcs.option(bcs.vector(bcs.u16())),
+    '0x1::option::Option<vector<u32>>': bcs.option(bcs.vector(bcs.u32())),
+    '0x1::option::Option<vector<u64>>': bcs.option(bcs.vector(bcs.u64())),
+    '0x1::option::Option<vector<u128>>': bcs.option(bcs.vector(bcs.u128())),
+    '0x1::option::Option<vector<u256>>': bcs.option(bcs.vector(bcs.u256())),
+    '0x1::option::Option<vector<bool>>': bcs.option(bcs.vector(bcs.bool())),
     'vector<address>': bcs.vector(
       bcs.bytes(32).transform({
         // To change the input type, you need to provide a type definition for the input
@@ -156,6 +170,22 @@ export class Dubhe {
     'vector<u128>': bcs.vector(bcs.u128()),
     'vector<u256>': bcs.vector(bcs.u256()),
     'vector<bool>': bcs.vector(bcs.bool()),
+    'vector<vector<address>>': bcs.vector(
+      bcs.vector(
+        bcs.bytes(32).transform({
+          // To change the input type, you need to provide a type definition for the input
+          input: (val: string) => fromHEX(val),
+          output: (val) => toHEX(val),
+        })
+      )
+    ),
+    'vector<vector<u8>>': bcs.vector(bcs.vector(bcs.u8())),
+    'vector<vector<u16>>': bcs.vector(bcs.vector(bcs.u16())),
+    'vector<vector<u32>>': bcs.vector(bcs.vector(bcs.u32())),
+    'vector<vector<u64>>': bcs.vector(bcs.vector(bcs.u64())),
+    'vector<vector<u128>>': bcs.vector(bcs.vector(bcs.u128())),
+    'vector<vector<u256>>': bcs.vector(bcs.vector(bcs.u256())),
+    'vector<vector<bool>>': bcs.vector(bcs.vector(bcs.bool())),
   };
 
   /**
@@ -200,18 +230,24 @@ export class Dubhe {
             const objMoudleId = `${packageId}::${moduleName}`;
 
             Object.entries(data.structs).forEach(([objectName, objectType]) => {
-              const objId = `${objMoudleId}::${objectName}`;
+              const objectId = `${objMoudleId}::${objectName}`;
               const bcsmeta: MoveStructType = {
+                objectId,
                 objectName,
                 objectType,
               };
-              // if (isUndefined(this.#object[objId])) {
+              // if (isUndefined(this.#object[objectId])) {
               let bcsObj = this.#bcs(bcsmeta);
               if (bcsObj.loopFlag === true) {
                 loopFlag = bcsObj.loopFlag;
               }
-              this.#object[objId] = bcsObj.bcs;
-              // }
+
+              this.#object[objectId] = bcsObj.bcs;
+
+              this.#object[`vector<${objectId}>`] = bcs.vector(bcsObj.bcs);
+              this.#object[`0x1::option::Option<${objectId}>`] = bcs.option(
+                bcsObj.bcs
+              );
             });
 
             Object.entries(data.exposedFunctions).forEach(
@@ -458,7 +494,6 @@ export class Dubhe {
                   default:
                   // throw new Error('Unsupported type');
                 }
-
               case 'TypeParameter':
                 bcsJson[objName] = bcs.u128();
                 return;
@@ -518,7 +553,6 @@ export class Dubhe {
   view(dryResult: DevInspectResults) {
     let returnValues = [];
 
-    // "success" | "failure";
     if (dryResult.effects.status.status === 'success') {
       const resultList = dryResult.results![0].returnValues!;
 
@@ -527,7 +561,31 @@ export class Dubhe {
         let baseType = res[1];
 
         const value = Uint8Array.from(baseValue);
-        returnValues.push(this.object[baseType].parse(value));
+
+        if (!this.#object[baseType]) {
+          console.log(
+            '\n\x1b[41m\x1b[37m ERROR \x1b[0m \x1b[31mUnsupported Type\x1b[0m'
+          );
+          console.log('\x1b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m');
+          console.log(`\x1b[95m•\x1b[0m Type: \x1b[33m"${baseType}"\x1b[0m`);
+          console.log('\x1b[95m\n✨ Available Types:\x1b[0m');
+          Object.keys(this.#object).forEach((type) => {
+            console.log(`  \x1b[36m◆\x1b[0m ${type}`);
+          });
+          console.log('\n\x1b[34m💡 How to Add Custom Type:\x1b[0m');
+          console.log(
+            `  You can add custom type by extending the #object map in your code:`
+          );
+          console.log(
+            `  \x1b[32mdubhe.object["${baseType}"] = bcs.struct("YourTypeName", {\n    field1: bcs.string(),\n    field2: bcs.u64(),\n    // ... other fields\n  });\x1b[0m`
+          );
+          console.log(
+            '\x1b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m\n'
+          );
+          throw new Error(`Unsupported type: ${baseType}`);
+        }
+
+        returnValues.push(this.#object[baseType].parse(value));
       }
       return returnValues;
     } else {
@@ -816,64 +874,6 @@ export class Dubhe {
     });
   }
 
-  async getWorld(worldObjectId: string) {
-    return this.suiInteractor.getObject(worldObjectId);
-  }
-
-  async listSchemaNames(worldId: string) {
-    const worldObject = await this.getObject(worldId);
-    const newObjectContent = worldObject.content;
-    if (newObjectContent != null) {
-      const objectContent = newObjectContent as DubheObjectContent;
-      const objectFields = objectContent.fields as Record<string, any>;
-      return objectFields['schema_names'];
-    } else {
-      return [];
-    }
-  }
-
-  async getEntity(
-    worldId: string,
-    schemaName: string,
-    entityId?: string
-  ): Promise<any[] | undefined> {
-    const schemaModuleName = `${schemaName}_schema`;
-    const tx = new Transaction();
-    const params = [tx.object(worldId)] as TransactionArgument[];
-
-    if (entityId !== undefined) {
-      params.push(tx.object(entityId));
-    }
-
-    const dryResult = (await this.query[schemaModuleName].get(
-      tx,
-      params
-    )) as DevInspectResults;
-    // "success" | "failure";
-    return this.view(dryResult);
-  }
-
-  async containEntity(
-    worldId: string,
-    schemaName: string,
-    entityId?: string
-  ): Promise<boolean | undefined> {
-    const schemaModuleName = `${schemaName}_schema`;
-    const tx = new Transaction();
-    const params = [tx.object(worldId)] as TransactionArgument[];
-
-    if (entityId !== undefined) {
-      params.push(tx.object(entityId));
-    }
-
-    const dryResult = (await this.query[schemaModuleName].contains(
-      tx,
-      params
-    )) as DevInspectResults;
-
-    return this.view(dryResult) as boolean | undefined;
-  }
-
   async getOwnedObjects(owner: string, cursor?: string, limit?: number) {
     const ownedObjects = await this.suiInteractor.getOwnedObjects(
       owner,

package/src/types/index.ts

@@ -124,6 +124,7 @@ export type MoveStructValueType = {
   }[];
 };
 export type MoveStructType = {
+  objectId: string;
   objectType: MoveStructValueType;
   objectName: string;
 };