@0xobelisk/sui-client 1.0.0 → 1.0.2

package/dist/dubhe.d.ts

@@ -39,6 +39,13 @@ export declare class Dubhe {
     get tx(): MapMoudleFuncTx;
     get object(): MapObjectStruct;
     view(dryResult: DevInspectResults): any[];
+    state({ schema, struct, objectId, storageType, params, }: {
+        schema: string;
+        struct: string;
+        objectId: string;
+        storageType: string;
+        params: any[];
+    }): Promise<any[]>;
     /**
      * if derivePathParams is not provided or mnemonics is empty, it will return the keypair.
      * else:

package/dist/index.js

@@ -40,6 +40,10 @@ var __privateAdd = (obj, member, value) => {
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 };
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
 
 // src/index.ts
 var src_exports = {};
@@ -1006,7 +1010,7 @@ function createTx(meta, fn) {
     }
   );
 }
-var _query, _tx, _object, _exec, _read, _bcs;
+var _query, _tx, _object, _exec, _read, _bcs, _processKeyParameter, processKeyParameter_fn;
 var Dubhe = class {
   /**
    * Support the following ways to init the DubheClient:
@@ -1028,6 +1032,7 @@ var Dubhe = class {
     packageId,
     metadata
   } = {}) {
+    __privateAdd(this, _processKeyParameter);
     __privateAdd(this, _query, {});
     __privateAdd(this, _tx, {});
     __privateAdd(this, _object, {
@@ -1394,6 +1399,62 @@ var Dubhe = class {
         let baseValue = res[0];
         let baseType = res[1];
         const value = Uint8Array.from(baseValue);
+        const storageValueMatch = baseType.match(
+          /^.*::storage_value::StorageValue<(.+)>$/
+        );
+        if (storageValueMatch) {
+          const innerType = storageValueMatch[1];
+          if (__privateGet(this, _object)[innerType]) {
+            const storageValueBcs = import_bcs3.bcs.struct("StorageValue", {
+              contents: import_bcs3.bcs.vector(
+                import_bcs3.bcs.struct("Entry", {
+                  value: __privateGet(this, _object)[innerType]
+                })
+              )
+            });
+            returnValues.push(storageValueBcs.parse(value));
+            continue;
+          }
+        }
+        const storageMapMatch = baseType.match(
+          /^.*::storage_map::StorageMap<(.+)>$/
+        );
+        if (storageMapMatch) {
+          const innerType = storageMapMatch[1];
+          const [keyType, valueType] = innerType.split(",").map((type) => type.trim());
+          if (__privateGet(this, _object)[keyType] && __privateGet(this, _object)[valueType]) {
+            const storageMapBcs = import_bcs3.bcs.struct("StorageMap", {
+              contents: import_bcs3.bcs.vector(
+                import_bcs3.bcs.struct("Entry", {
+                  key: __privateGet(this, _object)[keyType],
+                  value: __privateGet(this, _object)[valueType]
+                })
+              )
+            });
+            returnValues.push(storageMapBcs.parse(value));
+            continue;
+          }
+        }
+        const storageDoubleMapMatch = baseType.match(
+          /^.*::storage_double_map::StorageDoubleMap<(.+)>$/
+        );
+        if (storageDoubleMapMatch) {
+          const innerType = storageDoubleMapMatch[1];
+          const [key1, key2, valueType] = innerType.split(",").map((type) => type.trim());
+          if (__privateGet(this, _object)[key1] && __privateGet(this, _object)[key2] && __privateGet(this, _object)[valueType]) {
+            const storageDoubleMapBcs = import_bcs3.bcs.struct("StorageDoubleMap", {
+              contents: import_bcs3.bcs.vector(
+                import_bcs3.bcs.struct("Entry", {
+                  key1: __privateGet(this, _object)[key1],
+                  key2: __privateGet(this, _object)[key2],
+                  value: __privateGet(this, _object)[valueType]
+                })
+              )
+            });
+            returnValues.push(storageDoubleMapBcs.parse(value));
+            continue;
+          }
+        }
         if (__privateGet(this, _object)[baseType]) {
           returnValues.push(__privateGet(this, _object)[baseType].parse(value));
           continue;
@@ -1440,6 +1501,56 @@ var Dubhe = class {
       throw new ContractDataParsingError(dryResult);
     }
   }
+  async state({
+    schema,
+    struct,
+    objectId,
+    storageType,
+    params
+  }) {
+    const tx = new import_transactions3.Transaction();
+    const moduleName = `${schema}_schema`;
+    const functionName = `get_${struct}`;
+    const schemaObject = tx.object(objectId);
+    const storageValueMatch = storageType.match(/^StorageValue<(.+)>$/);
+    const storageMapMatch = storageType.match(/^StorageMap<(.+),\s*(.+)>$/);
+    const storageDoubleMapMatch = storageType.match(
+      /^StorageDoubleMap<(.+),\s*(.+),\s*(.+)>$/
+    );
+    let processedParams = [
+      schemaObject
+    ];
+    if (storageValueMatch) {
+      if (params.length > 0) {
+        console.warn(
+          "StorageValue does not require additional parameters. Extra parameters will be ignored."
+        );
+      }
+    } else if (storageMapMatch) {
+      if (params.length !== 1) {
+        throw new Error("StorageMap requires exactly one key parameter");
+      }
+      const keyType = storageMapMatch[1].trim();
+      processedParams.push(__privateMethod(this, _processKeyParameter, processKeyParameter_fn).call(this, tx, keyType, params[0]));
+    } else if (storageDoubleMapMatch) {
+      if (params.length !== 2) {
+        throw new Error("StorageDoubleMap requires exactly two key parameters");
+      }
+      const key1Type = storageDoubleMapMatch[1].trim();
+      const key2Type = storageDoubleMapMatch[2].trim();
+      processedParams.push(__privateMethod(this, _processKeyParameter, processKeyParameter_fn).call(this, tx, key1Type, params[0]));
+      processedParams.push(__privateMethod(this, _processKeyParameter, processKeyParameter_fn).call(this, tx, key2Type, params[1]));
+    } else {
+      throw new Error(
+        `Invalid storage type: ${storageType}. Must be StorageValue<V>, StorageMap<K,V>, or StorageDoubleMap<K1,K2,V>`
+      );
+    }
+    const queryResponse = await this.query[moduleName][functionName]({
+      tx,
+      params: processedParams
+    });
+    return this.view(queryResponse);
+  }
   /**
    * if derivePathParams is not provided or mnemonics is empty, it will return the keypair.
    * else:
@@ -1707,6 +1818,45 @@ _object = new WeakMap();
 _exec = new WeakMap();
 _read = new WeakMap();
 _bcs = new WeakMap();
+_processKeyParameter = new WeakSet();
+processKeyParameter_fn = function(tx, keyType, value) {
+  switch (keyType.toLowerCase()) {
+    case "u8":
+      return tx.pure.u8(value);
+    case "u16":
+      return tx.pure.u16(value);
+    case "u32":
+      return tx.pure.u32(value);
+    case "u64":
+      return tx.pure.u64(value);
+    case "u128":
+      return tx.pure.u128(value);
+    case "u256":
+      return tx.pure.u256(value);
+    case "bool":
+      return tx.pure.bool(value);
+    case "address":
+      return tx.pure.address(value);
+    default:
+      if (keyType.includes("::")) {
+        return tx.object(value);
+      }
+      console.log(
+        "\n\x1B[41m\x1B[37m ERROR \x1B[0m \x1B[31mUnsupported Key Type\x1B[0m"
+      );
+      console.log("\x1B[90m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\x1B[0m");
+      console.log(`\x1B[95m\u2022\x1B[0m Type: \x1B[33m"${keyType}"\x1B[0m`);
+      console.log("\x1B[95m\u2022\x1B[0m Supported Types:\x1B[0m");
+      console.log("  \x1B[36m\u25C6\x1B[0m u8, u16, u32, u64, u128, u256");
+      console.log("  \x1B[36m\u25C6\x1B[0m bool");
+      console.log("  \x1B[36m\u25C6\x1B[0m address");
+      console.log(
+        "  \x1B[36m\u25C6\x1B[0m object (format: package::module::type)"
+      );
+      console.log("\x1B[90m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\x1B[0m\n");
+      throw new Error(`Unsupported key type: ${keyType}`);
+  }
+};
 
 // src/libs/multiSig/client.ts
 var import_multisig = require("@mysten/sui/multisig");