@0xobelisk/sui-client 1.0.3 → 1.0.5

package/dist/index.mjs

@@ -608,6 +608,27 @@ var SuiInteractor = class {
     }
     throw new Error("Failed to send transaction with all fullnodes");
   }
+  async waitForTransaction({
+    digest,
+    timeout = 60 * 1e3,
+    pollInterval = 2 * 1e3
+  }) {
+    for (const clientIdx in this.clients) {
+      try {
+        return await this.clients[clientIdx].waitForTransaction({
+          digest,
+          timeout,
+          pollInterval
+        });
+      } catch (err) {
+        console.warn(
+          `Failed to wait for transaction with fullnode ${this.fullNodes[clientIdx]}: ${err}`
+        );
+        await delay(2e3);
+      }
+    }
+    throw new Error("Failed to wait for transaction with all fullnodes");
+  }
   async getObjects(ids, options) {
     const opts = options ?? {
       showContent: true,
@@ -820,6 +841,56 @@ var SuiInteractor = class {
   }
 };
 
+// src/libs/suiInteractor/defaultConfig.ts
+var getDefaultURL = (networkType = "testnet") => {
+  switch (networkType) {
+    case "localnet":
+      return {
+        fullNode: "http://127.0.0.1:9000",
+        graphql: "http://127.0.0.1:9125",
+        network: "localnet",
+        txExplorer: "https://explorer.polymedia.app/txblock/:txHash?network=local",
+        accountExplorer: "https://explorer.polymedia.app/address/:address?network=local",
+        explorer: "https://explorer.polymedia.app?network=local"
+      };
+    case "devnet":
+      return {
+        fullNode: "https://fullnode.devnet.sui.io:443",
+        network: "devnet",
+        txExplorer: "https://suiscan.xyz/devnet/tx/:txHash",
+        accountExplorer: "https://suiscan.xyz/devnet/address/:address",
+        explorer: "https://suiscan.xyz/devnet"
+      };
+    case "testnet":
+      return {
+        fullNode: "https://fullnode.testnet.sui.io:443",
+        graphql: "https://sui-testnet.mystenlabs.com/graphql",
+        network: "testnet",
+        txExplorer: "https://suiscan.xyz/testnet/tx/:txHash",
+        accountExplorer: "https://suiscan.xyz/testnet/address/:address",
+        explorer: "https://suiscan.xyz/testnet"
+      };
+    case "mainnet":
+      return {
+        fullNode: "https://fullnode.mainnet.sui.io:443",
+        graphql: "https://sui-mainnet.mystenlabs.com/graphql",
+        network: "mainnet",
+        txExplorer: "https://suiscan.xyz/mainnet/tx/:txHash",
+        accountExplorer: "https://suiscan.xyz/mainnet/address/:address",
+        explorer: "https://suiscan.xyz/mainnet"
+      };
+    default:
+      return {
+        fullNode: "https://fullnode.testnet.sui.io:443",
+        graphql: "https://sui-testnet.mystenlabs.com/graphql",
+        network: "testnet",
+        txExplorer: "https://suiscan.xyz/testnet/tx/:txHash",
+        accountExplorer: "https://suiscan.xyz/testnet/address/:address",
+        explorer: "https://suiscan.xyz/testnet"
+      };
+  }
+};
+
 // src/libs/suiContractFactory/index.ts
 var SuiContractFactory = class {
   // readonly #query: MapMessageQuery<ApiTypes> = {};
@@ -915,6 +986,12 @@ function numberToAddressHex(num) {
   const paddedHex = "0x" + hex.padStart(64, "0");
   return paddedHex;
 }
+function normalizePackageId(input) {
+  const withPrefix = input.startsWith("0x") ? input : "0x" + input;
+  const withoutPrefix = withPrefix.slice(2);
+  const normalized = withoutPrefix.replace(/^0+/, "");
+  return "0x" + normalized;
+}
 
 // src/dubhe.ts
 import { bcs as bcs2, fromHEX as fromHEX2, toHEX } from "@mysten/bcs";
@@ -977,7 +1054,7 @@ function createTx(meta, fn) {
     }
   );
 }
-var _query, _tx, _object, _exec, _read, _bcs, _processKeyParameter, processKeyParameter_fn;
+var _query, _tx, _object, _exec, _read, _getVectorDepth, _bcs, _bcsenum, _processKeyParameter, processKeyParameter_fn;
 var Dubhe = class {
   /**
    * Support the following ways to init the DubheClient:
@@ -1120,6 +1197,12 @@ var Dubhe = class {
       });
       return await this.inspectTxn(tx);
     });
+    __privateAdd(this, _getVectorDepth, (field) => {
+      if (typeof field === "object" && "Vector" in field) {
+        return 1 + __privateGet(this, _getVectorDepth).call(this, field.Vector);
+      }
+      return 0;
+    });
     __privateAdd(this, _bcs, (bcsmeta) => {
       let loopFlag = false;
       const bcsJson = {};
@@ -1197,39 +1280,64 @@ var Dubhe = class {
                   }
                   return;
                 case "Vector":
-                  switch (value) {
-                    case "U8":
-                      bcsJson[objName] = bcs2.vector(bcs2.u8());
-                      return;
-                    case "U16":
-                      bcsJson[objName] = bcs2.vector(bcs2.u16());
-                      return;
-                    case "U32":
-                      bcsJson[objName] = bcs2.vector(bcs2.u32());
-                      return;
-                    case "U64":
-                      bcsJson[objName] = bcs2.vector(bcs2.u64());
-                      return;
-                    case "U128":
-                      bcsJson[objName] = bcs2.vector(bcs2.u128());
-                      return;
-                    case "U256":
-                      bcsJson[objName] = bcs2.vector(bcs2.u256());
-                      return;
-                    case "Bool":
-                      bcsJson[objName] = bcs2.vector(bcs2.bool());
-                      return;
-                    case "Address":
-                      bcsJson[objName] = bcs2.vector(
-                        bcs2.bytes(32).transform({
-                          // To change the input type, you need to provide a type definition for the input
-                          input: (val) => fromHEX2(val),
-                          output: (val) => toHEX(val)
-                        })
-                      );
+                  if (typeof value === "string") {
+                    switch (value) {
+                      case "U8":
+                        bcsJson[objName] = bcs2.vector(bcs2.u8());
+                        return;
+                      case "U16":
+                        bcsJson[objName] = bcs2.vector(bcs2.u16());
+                        return;
+                      case "U32":
+                        bcsJson[objName] = bcs2.vector(bcs2.u32());
+                        return;
+                      case "U64":
+                        bcsJson[objName] = bcs2.vector(bcs2.u64());
+                        return;
+                      case "U128":
+                        bcsJson[objName] = bcs2.vector(bcs2.u128());
+                        return;
+                      case "U256":
+                        bcsJson[objName] = bcs2.vector(bcs2.u256());
+                        return;
+                      case "Bool":
+                        bcsJson[objName] = bcs2.vector(bcs2.bool());
+                        return;
+                      case "Address":
+                        bcsJson[objName] = bcs2.vector(
+                          bcs2.bytes(32).transform({
+                            // To change the input type, you need to provide a type definition for the input
+                            input: (val) => fromHEX2(val),
+                            output: (val) => toHEX(val)
+                          })
+                        );
+                        return;
+                      default:
+                    }
+                  }
+                  if (typeof value === "object") {
+                    const vectorDepth = __privateGet(this, _getVectorDepth).call(this, value);
+                    let innerType = value;
+                    for (let i = 0; i < vectorDepth; i++) {
+                      innerType = innerType.Vector;
+                    }
+                    if ("Struct" in innerType) {
+                      const structType2 = innerType.Struct;
+                      const structId = `${structType2.address}::${structType2.module}::${structType2.name}`;
+                      let bcsType = __privateGet(this, _object)[structId];
+                      if (!bcsType) {
+                        loopFlag = true;
+                        return;
+                      }
+                      let baseType = bcsType;
+                      for (let i = 0; i <= vectorDepth; i++) {
+                        baseType = bcs2.vector(baseType);
+                      }
+                      bcsJson[objName] = baseType;
                       return;
-                    default:
+                    }
                   }
+                  return;
                 case "TypeParameter":
                   bcsJson[objName] = bcs2.u128();
                   return;
@@ -1280,10 +1388,178 @@ var Dubhe = class {
         loopFlag
       };
     });
+    __privateAdd(this, _bcsenum, (bcsmeta) => {
+      let loopFlag = false;
+      const variantJson = {};
+      Object.entries(bcsmeta.objectType.variants).forEach(([name, type]) => {
+        if (type.length > 0) {
+          Object.entries(type).forEach(([index, value]) => {
+            const objType = value.type;
+            const objName = value.name;
+            switch (typeof objType) {
+              case "object":
+                for (const [key, value2] of Object.entries(objType)) {
+                  switch (key) {
+                    case "Struct":
+                      const structType = value2;
+                      if (structType.address === "0x1" && structType.module === "ascii" && structType.name === "String") {
+                        variantJson[objName] = bcs2.string();
+                        return;
+                      } else if (structType.address === "0x2" && structType.module === "object" && structType.name === "UID") {
+                        variantJson[objName] = bcs2.fixedArray(32, bcs2.u8()).transform({
+                          input: (id) => fromHEX2(id),
+                          output: (id) => toHEX(Uint8Array.from(id))
+                        });
+                        return;
+                      } else if (structType.address === "0x2" && structType.module === "object" && structType.name === "ID") {
+                        variantJson[objName] = bcs2.fixedArray(32, bcs2.u8()).transform({
+                          input: (id) => fromHEX2(id),
+                          output: (id) => toHEX(Uint8Array.from(id))
+                        });
+                        return;
+                      } else if (structType.address === "0x2" && structType.module === "bag" && structType.name === "Bag") {
+                        variantJson[objName] = bcs2.fixedArray(32, bcs2.u8()).transform({
+                          input: (id) => fromHEX2(id),
+                          output: (id) => toHEX(Uint8Array.from(id))
+                        });
+                        return;
+                      } else if (structType.address === "0x1" && structType.module === "option" && structType.name === "Option") {
+                        switch (structType.typeArguments[0]) {
+                          case "U8":
+                            variantJson[objName] = bcs2.option(bcs2.u8());
+                            return;
+                          case "U16":
+                            variantJson[objName] = bcs2.option(bcs2.u16());
+                            return;
+                          case "U32":
+                            variantJson[objName] = bcs2.option(bcs2.u32());
+                            return;
+                          case "U64":
+                            variantJson[objName] = bcs2.option(bcs2.u64());
+                            return;
+                          case "U128":
+                            variantJson[objName] = bcs2.option(bcs2.u128());
+                            return;
+                          case "U256":
+                            variantJson[objName] = bcs2.option(bcs2.u256());
+                            return;
+                          case "Bool":
+                            variantJson[objName] = bcs2.option(bcs2.bool());
+                            return;
+                          case "Address":
+                            variantJson[objName] = bcs2.option(
+                              bcs2.bytes(32).transform({
+                                // To change the input type, you need to provide a type definition for the input
+                                input: (val) => fromHEX2(val),
+                                output: (val) => toHEX(val)
+                              })
+                            );
+                            return;
+                          default:
+                        }
+                      } else {
+                        if (this.object[`${structType.address}::${structType.module}::${structType.name}`] === void 0) {
+                          loopFlag = true;
+                        } else {
+                          variantJson[objName] = this.object[`${structType.address}::${structType.module}::${structType.name}`];
+                          return;
+                        }
+                      }
+                      return;
+                    case "Vector":
+                      if (typeof value2 === "string") {
+                        switch (value2) {
+                          case "U8":
+                            variantJson[objName] = bcs2.vector(bcs2.u8());
+                            return;
+                          case "U16":
+                            variantJson[objName] = bcs2.vector(bcs2.u16());
+                            return;
+                          case "U32":
+                            variantJson[objName] = bcs2.vector(bcs2.u32());
+                            return;
+                          case "U64":
+                            variantJson[objName] = bcs2.vector(bcs2.u64());
+                            return;
+                          case "U128":
+                            variantJson[objName] = bcs2.vector(bcs2.u128());
+                            return;
+                          case "U256":
+                            variantJson[objName] = bcs2.vector(bcs2.u256());
+                            return;
+                          case "Bool":
+                            variantJson[objName] = bcs2.vector(bcs2.bool());
+                            return;
+                          case "Address":
+                            variantJson[objName] = bcs2.vector(
+                              bcs2.bytes(32).transform({
+                                // To change the input type, you need to provide a type definition for the input
+                                input: (val) => fromHEX2(val),
+                                output: (val) => toHEX(val)
+                              })
+                            );
+                            return;
+                          default:
+                        }
+                      }
+                    case "TypeParameter":
+                      variantJson[objName] = bcs2.u128();
+                      return;
+                    default:
+                      throw new Error("Unsupported type");
+                  }
+                }
+                return;
+              case "string":
+                switch (objType) {
+                  case "U8":
+                    variantJson[objName] = bcs2.u8();
+                    return;
+                  case "U16":
+                    variantJson[objName] = bcs2.u16();
+                    return;
+                  case "U32":
+                    variantJson[objName] = bcs2.u32();
+                    return;
+                  case "U64":
+                    variantJson[objName] = bcs2.u64();
+                    return;
+                  case "U128":
+                    variantJson[objName] = bcs2.u128();
+                    return;
+                  case "U256":
+                    variantJson[objName] = bcs2.u256();
+                    return;
+                  case "Bool":
+                    variantJson[objName] = bcs2.bool();
+                    return;
+                  case "Address":
+                    variantJson[objName] = bcs2.bytes(32).transform({
+                      // To change the input type, you need to provide a type definition for the input
+                      input: (val) => fromHEX2(val),
+                      output: (val) => toHEX(val)
+                    });
+                    return;
+                  default:
+                    return;
+                }
+              default:
+                throw new Error("Unsupported type");
+            }
+          });
+        } else {
+          variantJson[name] = null;
+        }
+      });
+      return {
+        bcs: bcs2.enum(bcsmeta.objectName, variantJson),
+        loopFlag
+      };
+    });
     this.accountManager = new SuiAccountManager({ mnemonics, secretKey });
     fullnodeUrls = fullnodeUrls || [getFullnodeUrl(networkType ?? "mainnet")];
     this.suiInteractor = new SuiInteractor(fullnodeUrls, networkType);
-    this.packageId = packageId;
+    this.packageId = packageId ? normalizePackageId(packageId) : void 0;
     if (metadata !== void 0) {
       this.metadata = metadata;
       const maxLoopNum = 5;
@@ -1296,6 +1572,30 @@ var Dubhe = class {
             const data = moudlevalue;
             const moduleName = data.name;
             const objMoudleId = `${packageId}::${moduleName}`;
+            if (data.enums) {
+              Object.entries(data.enums).forEach(([enumName, enumType]) => {
+                const objectId = `${objMoudleId}::${enumName}`;
+                const bcsmeta = {
+                  objectId,
+                  objectName: enumName,
+                  objectType: enumType
+                };
+                let bcsObj = __privateGet(this, _bcsenum).call(this, bcsmeta);
+                if (bcsObj.loopFlag === true) {
+                  loopFlag = bcsObj.loopFlag;
+                }
+                if (__privateGet(this, _object)[objectId] === void 0) {
+                  __privateGet(this, _object)[objectId] = bcsObj.bcs;
+                  __privateGet(this, _object)[`vector<${objectId}>`] = bcs2.vector(bcsObj.bcs);
+                  __privateGet(this, _object)[`vector<vector<${objectId}>>`] = bcs2.vector(
+                    bcs2.vector(bcsObj.bcs)
+                  );
+                  __privateGet(this, _object)[`0x1::option::Option<${objectId}>`] = bcs2.option(
+                    bcsObj.bcs
+                  );
+                }
+              });
+            }
             Object.entries(data.structs).forEach(([objectName, objectType]) => {
               const objectId = `${objMoudleId}::${objectName}`;
               const bcsmeta = {
@@ -1469,15 +1769,33 @@ var Dubhe = class {
     }
   }
   async state({
+    tx,
+    schema,
+    params
+  }) {
+    const moduleName = `schema`;
+    const functionName = `get_${schema}`;
+    let queryResponse = void 0;
+    try {
+      queryResponse = await this.query[moduleName][functionName]({
+        tx,
+        params
+      });
+      if (queryResponse.effects.status.status !== "success") {
+        return void 0;
+      }
+    } catch {
+      return void 0;
+    }
+    return this.view(queryResponse);
+  }
+  async parseState({
     schema,
-    field,
     objectId,
     storageType,
     params
   }) {
     const tx = new Transaction2();
-    const moduleName = `${schema}_schema`;
-    const functionName = `get_${field}`;
     const schemaObject = tx.object(objectId);
     const storageValueMatch = storageType.match(/^StorageValue<(.+)>$/);
     const storageMapMatch = storageType.match(/^StorageMap<(.+),\s*(.+)>$/);
@@ -1512,19 +1830,18 @@ var Dubhe = class {
         `Invalid storage type: ${storageType}. Must be StorageValue<V>, StorageMap<K,V>, or StorageDoubleMap<K1,K2,V>`
       );
     }
-    const queryResponse = await this.query[moduleName][functionName]({
+    return this.state({
       tx,
+      schema,
       params: processedParams
     });
-    return this.view(queryResponse);
   }
   /**
-   * if derivePathParams is not provided or mnemonics is empty, it will return the keypair.
    * else:
    * it will generate signer from the mnemonic with the given derivePathParams.
    * @param derivePathParams, such as { accountIndex: 2, isExternal: false, addressIndex: 10 }, comply with the BIP44 standard
    */
-  getKeypair(derivePathParams) {
+  getSigner(derivePathParams) {
     return this.accountManager.getKeyPair(derivePathParams);
   }
   /**
@@ -1553,6 +1870,18 @@ var Dubhe = class {
   getNetwork() {
     return this.suiInteractor.network;
   }
+  getNetworkConfig() {
+    return getDefaultURL(this.getNetwork());
+  }
+  getTxExplorerUrl(txHash) {
+    return this.getNetworkConfig().txExplorer.replace(":txHash", txHash);
+  }
+  getAccountExplorerUrl(address) {
+    return this.getNetworkConfig().accountExplorer.replace(":address", address);
+  }
+  getExplorerUrl() {
+    return this.getNetworkConfig().explorer;
+  }
   /**
    * Request some SUI from faucet
    * @Returns {Promise<boolean>}, true if the request is successful, false otherwise.
@@ -1592,15 +1921,18 @@ var Dubhe = class {
     }
     const txBlock = tx instanceof SuiTx ? tx.tx : tx;
     const txBytes = txBlock instanceof Transaction2 ? await txBlock.build({ client: this.client() }) : txBlock;
-    const keyPair = this.getKeypair(derivePathParams);
+    const keyPair = this.getSigner(derivePathParams);
     return await keyPair.signTransaction(txBytes);
   }
   async signAndSendTxn(tx, derivePathParams) {
     const { bytes, signature } = await this.signTxn(tx, derivePathParams);
-    return this.suiInteractor.sendTx(bytes, signature);
+    return this.sendTx(bytes, signature);
+  }
+  async sendTx(transaction, signature) {
+    return this.suiInteractor.sendTx(transaction, signature);
   }
-  async sendTxn(transactionBlock, signature) {
-    return this.suiInteractor.sendTx(transactionBlock, signature);
+  async waitForTransaction(digest) {
+    return this.suiInteractor.waitForTransaction({ digest });
   }
   /**
    * Transfer the given amount of SUI to the recipient
@@ -1784,7 +2116,9 @@ _tx = new WeakMap();
 _object = new WeakMap();
 _exec = new WeakMap();
 _read = new WeakMap();
+_getVectorDepth = new WeakMap();
 _bcs = new WeakMap();
+_bcsenum = new WeakMap();
 _processKeyParameter = new WeakSet();
 processKeyParameter_fn = function(tx, keyType, value) {
   switch (keyType.toLowerCase()) {