@0xobelisk/sui-client 1.0.3 → 1.0.4

package/dist/dubhe.d.ts

@@ -6,6 +6,7 @@ import { SuiInteractor } from './libs/suiInteractor';
 import { MapObjectStruct } from './types';
 import { SuiContractFactory } from './libs/suiContractFactory';
 import { SuiMoveMoudleFuncType } from './libs/suiContractFactory/types';
+import { NetworkConfig } from './libs/suiInteractor';
 import { DerivePathParams, FaucetNetworkType, MapMoudleFuncQuery, MapMoudleFuncTx, DubheParams, SuiTxArg, SuiObjectArg, SuiVecTxArg } from './types';
 export declare function isUndefined(value?: unknown): value is undefined;
 export declare function withMeta<T extends {
@@ -39,20 +40,23 @@ export declare class Dubhe {
     get tx(): MapMoudleFuncTx;
     get object(): MapObjectStruct;
     view(dryResult: DevInspectResults): any[];
-    state({ schema, field, objectId, storageType, params, }: {
+    state({ tx, schema, params, }: {
+        tx: Transaction;
+        schema: string;
+        params: any[];
+    }): Promise<any[] | undefined>;
+    parseState({ schema, objectId, storageType, params, }: {
         schema: string;
-        field: string;
         objectId: string;
         storageType: string;
         params: any[];
-    }): Promise<any[]>;
+    }): Promise<any[] | undefined>;
     /**
-     * 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?: DerivePathParams): import("@mysten/sui/dist/cjs/keypairs/ed25519").Ed25519Keypair;
+    getSigner(derivePathParams?: DerivePathParams): import("@mysten/sui/dist/cjs/keypairs/ed25519").Ed25519Keypair;
     /**
      * @description Switch the current account with the given derivePathParams
      * @param derivePathParams, such as { accountIndex: 2, isExternal: false, addressIndex: 10 }, comply with the BIP44 standard
@@ -67,6 +71,10 @@ export declare class Dubhe {
     getPackageId(): string;
     getMetadata(): SuiMoveNormalizedModules | undefined;
     getNetwork(): import("./types").NetworkType | undefined;
+    getNetworkConfig(): NetworkConfig;
+    getTxExplorerUrl(txHash: string): string;
+    getAccountExplorerUrl(address: string): string;
+    getExplorerUrl(): string;
     /**
      * Request some SUI from faucet
      * @Returns {Promise<boolean>}, true if the request is successful, false otherwise.
@@ -79,7 +87,8 @@ export declare class Dubhe {
     getObjects(objectIds: string[]): Promise<SuiObjectData[]>;
     signTxn(tx: Uint8Array | Transaction | SuiTx, derivePathParams?: DerivePathParams): Promise<import("@mysten/sui/dist/cjs/cryptography").SignatureWithBytes>;
     signAndSendTxn(tx: Uint8Array | Transaction | SuiTx, derivePathParams?: DerivePathParams): Promise<SuiTransactionBlockResponse>;
-    sendTxn(transactionBlock: Uint8Array | string, signature: string | string[]): Promise<SuiTransactionBlockResponse>;
+    sendTx(transaction: Uint8Array | string, signature: string | string[]): Promise<SuiTransactionBlockResponse>;
+    waitForTransaction(digest: string): Promise<SuiTransactionBlockResponse>;
     /**
      * Transfer the given amount of SUI to the recipient
      * @param recipient

package/dist/index.js

@@ -641,6 +641,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,
@@ -853,6 +874,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> = {};
@@ -1010,7 +1081,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:
@@ -1153,6 +1224,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 = {};
@@ -1230,39 +1307,64 @@ var Dubhe = class {
                   }
                   return;
                 case "Vector":
-                  switch (value) {
-                    case "U8":
-                      bcsJson[objName] = import_bcs3.bcs.vector(import_bcs3.bcs.u8());
-                      return;
-                    case "U16":
-                      bcsJson[objName] = import_bcs3.bcs.vector(import_bcs3.bcs.u16());
-                      return;
-                    case "U32":
-                      bcsJson[objName] = import_bcs3.bcs.vector(import_bcs3.bcs.u32());
-                      return;
-                    case "U64":
-                      bcsJson[objName] = import_bcs3.bcs.vector(import_bcs3.bcs.u64());
-                      return;
-                    case "U128":
-                      bcsJson[objName] = import_bcs3.bcs.vector(import_bcs3.bcs.u128());
-                      return;
-                    case "U256":
-                      bcsJson[objName] = import_bcs3.bcs.vector(import_bcs3.bcs.u256());
-                      return;
-                    case "Bool":
-                      bcsJson[objName] = import_bcs3.bcs.vector(import_bcs3.bcs.bool());
-                      return;
-                    case "Address":
-                      bcsJson[objName] = import_bcs3.bcs.vector(
-                        import_bcs3.bcs.bytes(32).transform({
-                          // To change the input type, you need to provide a type definition for the input
-                          input: (val) => (0, import_bcs3.fromHEX)(val),
-                          output: (val) => (0, import_bcs3.toHEX)(val)
-                        })
-                      );
+                  if (typeof value === "string") {
+                    switch (value) {
+                      case "U8":
+                        bcsJson[objName] = import_bcs3.bcs.vector(import_bcs3.bcs.u8());
+                        return;
+                      case "U16":
+                        bcsJson[objName] = import_bcs3.bcs.vector(import_bcs3.bcs.u16());
+                        return;
+                      case "U32":
+                        bcsJson[objName] = import_bcs3.bcs.vector(import_bcs3.bcs.u32());
+                        return;
+                      case "U64":
+                        bcsJson[objName] = import_bcs3.bcs.vector(import_bcs3.bcs.u64());
+                        return;
+                      case "U128":
+                        bcsJson[objName] = import_bcs3.bcs.vector(import_bcs3.bcs.u128());
+                        return;
+                      case "U256":
+                        bcsJson[objName] = import_bcs3.bcs.vector(import_bcs3.bcs.u256());
+                        return;
+                      case "Bool":
+                        bcsJson[objName] = import_bcs3.bcs.vector(import_bcs3.bcs.bool());
+                        return;
+                      case "Address":
+                        bcsJson[objName] = import_bcs3.bcs.vector(
+                          import_bcs3.bcs.bytes(32).transform({
+                            // To change the input type, you need to provide a type definition for the input
+                            input: (val) => (0, import_bcs3.fromHEX)(val),
+                            output: (val) => (0, import_bcs3.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 = import_bcs3.bcs.vector(baseType);
+                      }
+                      bcsJson[objName] = baseType;
                       return;
-                    default:
+                    }
                   }
+                  return;
                 case "TypeParameter":
                   bcsJson[objName] = import_bcs3.bcs.u128();
                   return;
@@ -1313,6 +1415,174 @@ 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] = import_bcs3.bcs.string();
+                        return;
+                      } else if (structType.address === "0x2" && structType.module === "object" && structType.name === "UID") {
+                        variantJson[objName] = import_bcs3.bcs.fixedArray(32, import_bcs3.bcs.u8()).transform({
+                          input: (id) => (0, import_bcs3.fromHEX)(id),
+                          output: (id) => (0, import_bcs3.toHEX)(Uint8Array.from(id))
+                        });
+                        return;
+                      } else if (structType.address === "0x2" && structType.module === "object" && structType.name === "ID") {
+                        variantJson[objName] = import_bcs3.bcs.fixedArray(32, import_bcs3.bcs.u8()).transform({
+                          input: (id) => (0, import_bcs3.fromHEX)(id),
+                          output: (id) => (0, import_bcs3.toHEX)(Uint8Array.from(id))
+                        });
+                        return;
+                      } else if (structType.address === "0x2" && structType.module === "bag" && structType.name === "Bag") {
+                        variantJson[objName] = import_bcs3.bcs.fixedArray(32, import_bcs3.bcs.u8()).transform({
+                          input: (id) => (0, import_bcs3.fromHEX)(id),
+                          output: (id) => (0, import_bcs3.toHEX)(Uint8Array.from(id))
+                        });
+                        return;
+                      } else if (structType.address === "0x1" && structType.module === "option" && structType.name === "Option") {
+                        switch (structType.typeArguments[0]) {
+                          case "U8":
+                            variantJson[objName] = import_bcs3.bcs.option(import_bcs3.bcs.u8());
+                            return;
+                          case "U16":
+                            variantJson[objName] = import_bcs3.bcs.option(import_bcs3.bcs.u16());
+                            return;
+                          case "U32":
+                            variantJson[objName] = import_bcs3.bcs.option(import_bcs3.bcs.u32());
+                            return;
+                          case "U64":
+                            variantJson[objName] = import_bcs3.bcs.option(import_bcs3.bcs.u64());
+                            return;
+                          case "U128":
+                            variantJson[objName] = import_bcs3.bcs.option(import_bcs3.bcs.u128());
+                            return;
+                          case "U256":
+                            variantJson[objName] = import_bcs3.bcs.option(import_bcs3.bcs.u256());
+                            return;
+                          case "Bool":
+                            variantJson[objName] = import_bcs3.bcs.option(import_bcs3.bcs.bool());
+                            return;
+                          case "Address":
+                            variantJson[objName] = import_bcs3.bcs.option(
+                              import_bcs3.bcs.bytes(32).transform({
+                                // To change the input type, you need to provide a type definition for the input
+                                input: (val) => (0, import_bcs3.fromHEX)(val),
+                                output: (val) => (0, import_bcs3.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] = import_bcs3.bcs.vector(import_bcs3.bcs.u8());
+                            return;
+                          case "U16":
+                            variantJson[objName] = import_bcs3.bcs.vector(import_bcs3.bcs.u16());
+                            return;
+                          case "U32":
+                            variantJson[objName] = import_bcs3.bcs.vector(import_bcs3.bcs.u32());
+                            return;
+                          case "U64":
+                            variantJson[objName] = import_bcs3.bcs.vector(import_bcs3.bcs.u64());
+                            return;
+                          case "U128":
+                            variantJson[objName] = import_bcs3.bcs.vector(import_bcs3.bcs.u128());
+                            return;
+                          case "U256":
+                            variantJson[objName] = import_bcs3.bcs.vector(import_bcs3.bcs.u256());
+                            return;
+                          case "Bool":
+                            variantJson[objName] = import_bcs3.bcs.vector(import_bcs3.bcs.bool());
+                            return;
+                          case "Address":
+                            variantJson[objName] = import_bcs3.bcs.vector(
+                              import_bcs3.bcs.bytes(32).transform({
+                                // To change the input type, you need to provide a type definition for the input
+                                input: (val) => (0, import_bcs3.fromHEX)(val),
+                                output: (val) => (0, import_bcs3.toHEX)(val)
+                              })
+                            );
+                            return;
+                          default:
+                        }
+                      }
+                    case "TypeParameter":
+                      variantJson[objName] = import_bcs3.bcs.u128();
+                      return;
+                    default:
+                      throw new Error("Unsupported type");
+                  }
+                }
+                return;
+              case "string":
+                switch (objType) {
+                  case "U8":
+                    variantJson[objName] = import_bcs3.bcs.u8();
+                    return;
+                  case "U16":
+                    variantJson[objName] = import_bcs3.bcs.u16();
+                    return;
+                  case "U32":
+                    variantJson[objName] = import_bcs3.bcs.u32();
+                    return;
+                  case "U64":
+                    variantJson[objName] = import_bcs3.bcs.u64();
+                    return;
+                  case "U128":
+                    variantJson[objName] = import_bcs3.bcs.u128();
+                    return;
+                  case "U256":
+                    variantJson[objName] = import_bcs3.bcs.u256();
+                    return;
+                  case "Bool":
+                    variantJson[objName] = import_bcs3.bcs.bool();
+                    return;
+                  case "Address":
+                    variantJson[objName] = import_bcs3.bcs.bytes(32).transform({
+                      // To change the input type, you need to provide a type definition for the input
+                      input: (val) => (0, import_bcs3.fromHEX)(val),
+                      output: (val) => (0, import_bcs3.toHEX)(val)
+                    });
+                    return;
+                  default:
+                    return;
+                }
+              default:
+                throw new Error("Unsupported type");
+            }
+          });
+        } else {
+          variantJson[name] = null;
+        }
+      });
+      return {
+        bcs: import_bcs3.bcs.enum(bcsmeta.objectName, variantJson),
+        loopFlag
+      };
+    });
     this.accountManager = new SuiAccountManager({ mnemonics, secretKey });
     fullnodeUrls = fullnodeUrls || [(0, import_client2.getFullnodeUrl)(networkType ?? "mainnet")];
     this.suiInteractor = new SuiInteractor(fullnodeUrls, networkType);
@@ -1329,6 +1599,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}>`] = import_bcs3.bcs.vector(bcsObj.bcs);
+                  __privateGet(this, _object)[`vector<vector<${objectId}>>`] = import_bcs3.bcs.vector(
+                    import_bcs3.bcs.vector(bcsObj.bcs)
+                  );
+                  __privateGet(this, _object)[`0x1::option::Option<${objectId}>`] = import_bcs3.bcs.option(
+                    bcsObj.bcs
+                  );
+                }
+              });
+            }
             Object.entries(data.structs).forEach(([objectName, objectType]) => {
               const objectId = `${objMoudleId}::${objectName}`;
               const bcsmeta = {
@@ -1502,15 +1796,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 import_transactions3.Transaction();
-    const moduleName = `${schema}_schema`;
-    const functionName = `get_${field}`;
     const schemaObject = tx.object(objectId);
     const storageValueMatch = storageType.match(/^StorageValue<(.+)>$/);
     const storageMapMatch = storageType.match(/^StorageMap<(.+),\s*(.+)>$/);
@@ -1545,19 +1857,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);
   }
   /**
@@ -1586,6 +1897,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.
@@ -1625,15 +1948,18 @@ var Dubhe = class {
     }
     const txBlock = tx instanceof SuiTx ? tx.tx : tx;
     const txBytes = txBlock instanceof import_transactions3.Transaction ? 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
@@ -1817,7 +2143,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()) {