@0xobelisk/sui-client 1.0.0 → 1.0.1

package/dist/index.mjs

@@ -11,6 +11,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
 export * from "@mysten/sui/client";
@@ -973,7 +977,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:
@@ -995,6 +999,7 @@ var Dubhe = class {
     packageId,
     metadata
   } = {}) {
+    __privateAdd(this, _processKeyParameter);
     __privateAdd(this, _query, {});
     __privateAdd(this, _tx, {});
     __privateAdd(this, _object, {
@@ -1361,6 +1366,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 = bcs2.struct("StorageValue", {
+              contents: bcs2.vector(
+                bcs2.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 = bcs2.struct("StorageMap", {
+              contents: bcs2.vector(
+                bcs2.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 = bcs2.struct("StorageDoubleMap", {
+              contents: bcs2.vector(
+                bcs2.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;
@@ -1407,6 +1468,54 @@ var Dubhe = class {
       throw new ContractDataParsingError(dryResult);
     }
   }
+  async state({
+    schema,
+    struct,
+    objectId,
+    storageType,
+    params
+  }) {
+    const tx = new Transaction2();
+    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:
@@ -1674,6 +1783,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(value, "u8");
+    case "u16":
+      return tx.pure(value, "u16");
+    case "u32":
+      return tx.pure(value, "u32");
+    case "u64":
+      return tx.pure(value, "u64");
+    case "u128":
+      return tx.pure(value, "u128");
+    case "u256":
+      return tx.pure(value, "u256");
+    case "bool":
+      return tx.pure(value, "bool");
+    case "address":
+      return tx.pure(value, "address");
+    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
 import { MultiSigPublicKey } from "@mysten/sui/multisig";