@0xobelisk/client 0.0.1 → 0.0.2

package/README.md

@@ -1 +1,3 @@
 #
+
+Test QA

package/dist/framework/bcs.d.ts

@@ -0,0 +1,3 @@
+import { BCS } from '@mysten/bcs';
+export declare const bcsSource: BCS;
+export declare const bcsOnchain: BCS;

package/dist/framework/loader.d.ts

@@ -0,0 +1,11 @@
+import { FieldsWithTypes, Type } from './util';
+export type PrimitiveValue = string | number | boolean | bigint;
+export declare class StructClassLoader {
+    #private;
+    private map;
+    register(...classes: any): void;
+    fromFields(type: Type, value: Record<string, any> | PrimitiveValue): any;
+    fromFieldsWithTypes(type: Type, value: FieldsWithTypes | PrimitiveValue): any;
+}
+export declare const structClassLoaderSource: StructClassLoader;
+export declare const structClassLoaderOnchain: StructClassLoader;

package/dist/framework/util.d.ts

@@ -0,0 +1,90 @@
+import { ObjectCallArg, ObjectId, TransactionArgument, TransactionBlock } from '@mysten/sui.js';
+/** A Move type, e.g., `address`, `bool`, `u64`, `vector<u64>`, `0x2::sui::SUI`... */
+export type Type = string;
+export interface FieldsWithTypes {
+    fields: Record<string, any>;
+    type: string;
+}
+export type ObjectArg = ObjectId | ObjectCallArg | TransactionArgument;
+export type PureArg = bigint | string | number | boolean | null | TransactionArgument | Array<PureArg>;
+export type GenericArg = ObjectArg | PureArg | Array<ObjectArg> | Array<PureArg> | Array<GenericArg>;
+export declare function parseTypeName(name: Type): {
+    typeName: string;
+    typeArgs: Type[];
+};
+export declare function obj(txb: TransactionBlock, arg: ObjectArg): {
+    kind: "Input";
+    index: number;
+    type?: "object" | "pure" | undefined;
+    value?: any;
+} | {
+    kind: "GasCoin";
+} | {
+    kind: "Result";
+    index: number;
+} | {
+    kind: "NestedResult";
+    index: number;
+    resultIndex: number;
+};
+export declare function pure(txb: TransactionBlock, arg: PureArg, type: Type): {
+    kind: "Input";
+    index: number;
+    type?: "object" | "pure" | undefined;
+    value?: any;
+} | {
+    kind: "GasCoin";
+} | {
+    kind: "Result";
+    index: number;
+} | {
+    kind: "NestedResult";
+    index: number;
+    resultIndex: number;
+};
+export declare function option(txb: TransactionBlock, type: Type, arg: GenericArg | null): {
+    kind: "Input";
+    index: number;
+    type?: "object" | "pure" | undefined;
+    value?: any;
+} | {
+    kind: "GasCoin";
+} | {
+    kind: "Result";
+    index: number;
+} | {
+    kind: "NestedResult";
+    index: number;
+    resultIndex: number;
+};
+export declare function generic(txb: TransactionBlock, type: Type, arg: GenericArg): {
+    kind: "Input";
+    index: number;
+    type?: "object" | "pure" | undefined;
+    value?: any;
+} | {
+    kind: "GasCoin";
+} | {
+    kind: "Result";
+    index: number;
+} | {
+    kind: "NestedResult";
+    index: number;
+    resultIndex: number;
+};
+export declare function vector(txb: TransactionBlock, itemType: Type, items: Array<GenericArg> | TransactionArgument): {
+    kind: "Input";
+    index: number;
+    type?: "object" | "pure" | undefined;
+    value?: any;
+} | {
+    kind: "GasCoin";
+} | {
+    kind: "Result";
+    index: number;
+} | {
+    kind: "NestedResult";
+    index: number;
+    resultIndex: number;
+};
+export declare function typeArgIsPure(type: Type): boolean;

package/dist/index.d.ts

@@ -3,4 +3,5 @@ export { Obelisk } from './obelisk';
 export { SuiAccountManager } from './libs/suiAccountManager';
 export { SuiTxBlock } from './libs/suiTxBuilder';
 export { SuiRpcProvider } from './libs/suiRpcProvider';
+export { SuiContractFactory } from './libs/suiContractFactory';
 export type * from './types';

package/dist/index.js

@@ -16,23 +16,37 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj2, member, msg) => {
+  if (!member.has(obj2))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj2, member, getter) => {
+  __accessCheck(obj2, member, "read from private field");
+  return getter ? getter.call(obj2) : member.get(obj2);
+};
+var __privateAdd = (obj2, member, value) => {
+  if (member.has(obj2))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj2) : member.set(obj2, value);
+};
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
   Obelisk: () => Obelisk,
-  SUI_CLOCK_OBJECT_ID: () => import_sui10.SUI_CLOCK_OBJECT_ID,
-  SUI_SYSTEM_STATE_OBJECT_ID: () => import_sui10.SUI_SYSTEM_STATE_OBJECT_ID,
+  SUI_CLOCK_OBJECT_ID: () => import_sui11.SUI_CLOCK_OBJECT_ID,
+  SUI_SYSTEM_STATE_OBJECT_ID: () => import_sui11.SUI_SYSTEM_STATE_OBJECT_ID,
   SuiAccountManager: () => SuiAccountManager,
+  SuiContractFactory: () => SuiContractFactory,
   SuiRpcProvider: () => SuiRpcProvider,
   SuiTxBlock: () => SuiTxBlock,
-  TransactionBlock: () => import_sui10.TransactionBlock
+  TransactionBlock: () => import_sui11.TransactionBlock
 });
 module.exports = __toCommonJS(src_exports);
-var import_sui10 = require("@mysten/sui.js");
+var import_sui11 = require("@mysten/sui.js");
 
 // src/obelisk.ts
-var import_sui9 = require("@mysten/sui.js");
+var import_sui10 = require("@mysten/sui.js");
 
 // src/libs/suiAccountManager/index.ts
 var import_sui3 = require("@mysten/sui.js");
@@ -244,6 +258,28 @@ var SuiRpcProvider = class {
   async getBalance(addr, coinType) {
     return this.provider.getBalance({ owner: addr, coinType });
   }
+  async getDynamicFieldObject(parentId, name) {
+    return this.provider.getDynamicFieldObject({ parentId, name });
+  }
+  async getDynamicFields(parentId, cursor, limit) {
+    return this.provider.getDynamicFields({ parentId, cursor, limit });
+  }
+  async getObject(id) {
+    const options = { showContent: true, showDisplay: true, showType: true };
+    const object = await this.provider.getObject({ id, options });
+    const objectId = (0, import_sui6.getObjectId)(object);
+    const objectType = (0, import_sui6.getObjectType)(object);
+    const objectVersion = (0, import_sui6.getObjectVersion)(object);
+    const objectFields = (0, import_sui6.getObjectFields)(object);
+    const objectDisplay = (0, import_sui6.getObjectDisplay)(object);
+    return {
+      objectId,
+      objectType,
+      objectVersion,
+      objectFields,
+      objectDisplay
+    };
+  }
   async getObjects(ids) {
     const options = { showContent: true, showDisplay: true, showType: true };
     const objects = await this.provider.multiGetObjects({ ids, options });
@@ -263,6 +299,9 @@ var SuiRpcProvider = class {
     });
     return parsedObjects;
   }
+  async getNormalizedMoveModulesByPackage(packageId) {
+    return this.provider.getNormalizedMoveModulesByPackage({ package: packageId });
+  }
   /**
    * @description Select coins that add up to the given amount.
    * @param addr the address of the owner
@@ -536,7 +575,191 @@ var SuiTxBlock = class {
   }
 };
 
+// src/libs/suiContractFactory/index.ts
+var SuiContractFactory = class {
+  // readonly #query: MapMessageQuery<ApiTypes> = {};
+  // readonly #tx: MapMessageTx<ApiTypes> = {};
+  /**
+   * Support the following ways to init the SuiToolkit:
+   * 1. mnemonics
+   * 2. secretKey (base64 or hex)
+   * If none of them is provided, will generate a random mnemonics with 24 words.
+   *
+   * @param mnemonics, 12 or 24 mnemonics words, separated by space
+   * @param secretKey, base64 or hex string, when mnemonics is provided, secretKey will be ignored
+   */
+  constructor({ packageId, metadata } = {}) {
+    this.packageId = packageId || "";
+    this.metadata = metadata || void 0;
+  }
+  getFuncByModuleName(moduleName) {
+    Object.values(this.metadata).forEach(
+      (value) => {
+        const data = value;
+        console.log(`moudle name: ${data.name}`);
+        Object.entries(data.exposedFunctions).forEach(([key, value2]) => {
+          console.log(`	func name: ${key}`);
+          Object.values(value2.parameters).forEach((values) => {
+          });
+        });
+      }
+    );
+  }
+  getAllFunc() {
+    Object.values(this.metadata).forEach(
+      (value) => {
+        const data = value;
+        console.log(`moudle name: ${data.name}`);
+        Object.entries(data.exposedFunctions).forEach(([key, value2]) => {
+          console.log(`	func name: ${key}`);
+          console.log(`		${value2.parameters.length}`);
+          Object.values(value2.parameters).forEach((values) => {
+            console.log(`		args: ${values}`);
+          });
+        });
+      }
+    );
+  }
+  getAllModule() {
+    Object.values(this.metadata).forEach(
+      (value, index) => {
+        const data = value;
+        console.log(`${index}. ${data.name}`);
+      }
+    );
+  }
+  async worldCall() {
+  }
+  //   async call(arguments: ({
+  //     kind: "Input";
+  //     index: number;
+  //     type?: "object" | "pure" | undefined;
+  //     value?: any;
+  // } | {
+  //     kind: "GasCoin";
+  // } | {
+  //     kind: "Result";
+  //     index: number;
+  // } | {
+  //     kind: "NestedResult";
+  //     index: number;
+  //     resultIndex: number;
+  // })[], derivePathParams?: DerivePathParams) {
+  //     const tx = new TransactionBlock();
+  //     tx.moveCall({
+  //       target: `${this.packageId}::${}::${}`,
+  //       arguments,
+  //     })
+  //     return ;
+  //   }
+};
+
+// src/framework/util.ts
+var import_sui9 = require("@mysten/sui.js");
+var import_bcs = require("@mysten/bcs");
+function parseTypeName(name) {
+  const parsed = import_sui9.bcs.parseTypeName(name);
+  return { typeName: parsed.name, typeArgs: parsed.params };
+}
+function obj(txb, arg) {
+  return (0, import_sui9.is)(arg, import_sui9.TransactionArgument) ? arg : txb.object(arg);
+}
+function pure(txb, arg, type) {
+  if ((0, import_sui9.is)(arg, import_sui9.TransactionArgument)) {
+    return obj(txb, arg);
+  }
+  function convertType(type2) {
+    const { typeName: typeName2, typeArgs: typeArgs2 } = parseTypeName(type2);
+    switch (typeName2) {
+      case "0x1::string::String":
+      case "0x1::ascii::String":
+        return import_bcs.BCS.STRING;
+      case "0x2::object::ID":
+        return import_bcs.BCS.ADDRESS;
+      case "0x1::option::Option":
+        return `vector<${convertType(typeArgs2[0])}>`;
+      case "vector":
+        return `vector<${convertType(typeArgs2[0])}>`;
+      default:
+        return type2;
+    }
+  }
+  function isOrHasNestedTransactionArgument(arg2) {
+    if (Array.isArray(arg2)) {
+      return arg2.some((item) => isOrHasNestedTransactionArgument(item));
+    }
+    return (0, import_sui9.is)(arg2, import_sui9.TransactionArgument);
+  }
+  function convertArg(arg2, type2) {
+    const { typeName: typeName2, typeArgs: typeArgs2 } = parseTypeName(type2);
+    if (typeName2 === "0x1::option::Option") {
+      if (arg2 === null) {
+        return [];
+      } else {
+        return [convertArg(arg2, typeArgs2[0])];
+      }
+    } else if (typeName2 === "vector" && Array.isArray(arg2)) {
+      return arg2.map((item) => convertArg(item, typeArgs2[0]));
+    } else if (typeName2 === "0x2::object::ID" || typeName2 === "address") {
+      return (0, import_sui9.normalizeSuiAddress)(arg2);
+    } else {
+      return arg2;
+    }
+  }
+  const { typeName, typeArgs } = parseTypeName(type);
+  switch (typeName) {
+    case "0x1::option::Option":
+      if (arg === null) {
+        return txb.pure([], `vector<${convertType(typeArgs[0])}>`);
+      }
+      if (isOrHasNestedTransactionArgument(arg)) {
+        throw new Error("nesting TransactionArgument is not currently supported");
+      }
+      break;
+    case "vector":
+      if (!Array.isArray(arg)) {
+        throw new Error("expected an array for vector type");
+      }
+      if (arg.length === 0) {
+        return txb.pure([], `vector<${convertType(typeArgs[0])}>`);
+      }
+      if (arg.some((arg2) => Array.isArray(arg2) && isOrHasNestedTransactionArgument(arg2))) {
+        throw new Error("nesting TransactionArgument is not currently supported");
+      }
+      if ((0, import_sui9.is)(arg[0], import_sui9.TransactionArgument) && arg.filter((arg2) => !(0, import_sui9.is)(arg2, import_sui9.TransactionArgument)).length > 0) {
+        throw new Error("mixing TransactionArgument with other types is not currently supported");
+      }
+      if ((0, import_sui9.is)(arg[0], import_sui9.TransactionArgument)) {
+        return txb.makeMoveVec({
+          objects: arg,
+          type: typeArgs[0]
+        });
+      }
+  }
+  return txb.pure(convertArg(arg, type), convertType(type));
+}
+
 // src/obelisk.ts
+function isUndefined(value) {
+  return value === void 0;
+}
+function withMeta(meta, creator) {
+  creator.meta = meta;
+  return creator;
+}
+function createQuery(meta, fn) {
+  return withMeta(meta, async (tx, params) => {
+    const result = await fn(tx, params);
+    return result;
+  });
+}
+function createTx(meta, fn) {
+  return withMeta(meta, async (tx, params, isRaw) => {
+    const result = await fn(tx, params, isRaw);
+    return result;
+  });
+}
+var _query, _tx, _exec, _read;
 var Obelisk = class {
   /**
    * Support the following ways to init the SuiToolkit:
@@ -549,20 +772,86 @@ var Obelisk = class {
    * @param networkType, 'testnet' | 'mainnet' | 'devnet' | 'localnet', default is 'devnet'
    * @param fullnodeUrl, the fullnode url, default is the preconfig fullnode url for the given network type
    * @param faucetUrl, the faucet url, default is the preconfig faucet url for the given network type
+   * @param packageId
    */
   constructor({
     mnemonics,
     secretKey,
     networkType,
     fullnodeUrl,
-    faucetUrl
+    faucetUrl,
+    packageId,
+    metadata
   } = {}) {
+    __privateAdd(this, _query, {});
+    __privateAdd(this, _tx, {});
+    __privateAdd(this, _exec, async (meta, tx, params, isRaw) => {
+      tx.moveCall({
+        target: `${this.contractFactory.packageId}::${meta.moudleName}::${meta.funcName}`,
+        arguments: params
+      });
+      if (isRaw === true) {
+        return tx;
+      }
+      return await this.signAndSendTxn(tx);
+    });
+    __privateAdd(this, _read, async (meta, tx, params) => {
+      tx.moveCall({
+        target: `${this.contractFactory.packageId}::${meta.moudleName}::${meta.funcName}`,
+        arguments: params
+      });
+      return await this.inspectTxn(tx);
+    });
     this.accountManager = new SuiAccountManager({ mnemonics, secretKey });
     this.rpcProvider = new SuiRpcProvider({
       fullnodeUrl,
       faucetUrl,
       networkType
     });
+    this.epsId = "0xf2196f638c3174e18c0e31aa630a02fd516c2c5deec1ded72c0fea864c9f091a";
+    this.componentsId = "0x3bc407eb543149e42846ade59ac2a3c901584af4339dc1ecd0affd090529545f";
+    this.packageId = packageId;
+    this.metadata = metadata;
+    Object.values(metadata).forEach((value) => {
+      let data = value;
+      let moduleName = data.name;
+      Object.entries(data.exposedFunctions).forEach(([funcName, value2]) => {
+        let meta = value2;
+        meta.moudleName = moduleName;
+        meta.funcName = funcName;
+        if (isUndefined(__privateGet(this, _query)[moduleName])) {
+          __privateGet(this, _query)[moduleName] = {};
+        }
+        if (isUndefined(__privateGet(this, _query)[moduleName][funcName])) {
+          __privateGet(this, _query)[moduleName][funcName] = createQuery(meta, (tx, p) => __privateGet(this, _read).call(this, meta, tx, p));
+        }
+        if (isUndefined(__privateGet(this, _tx)[moduleName])) {
+          __privateGet(this, _tx)[moduleName] = {};
+        }
+        if (isUndefined(__privateGet(this, _tx)[moduleName][funcName])) {
+          __privateGet(this, _tx)[moduleName][funcName] = createTx(meta, (tx, p, isRaw) => __privateGet(this, _exec).call(this, meta, tx, p, isRaw));
+        }
+      });
+    });
+    this.contractFactory = new SuiContractFactory({
+      packageId,
+      metadata
+    });
+  }
+  // async initialize() {
+  //   const metadata = await this.loadData();
+  //   this.metadata = metadata as SuiMoveNormalizedModules;
+  //   this.contractFactory = new SuiContractFactory({ 
+  //     packageId: this.packageId, 
+  //     metadata: this.metadata
+  //   })
+  //   return metadata
+  // }
+  get query() {
+    return __privateGet(this, _query);
+  }
+  get tx() {
+    return __privateGet(this, _tx);
   }
   /**
    * if derivePathParams is not provided or mnemonics is empty, it will return the currentSigner.
@@ -572,7 +861,7 @@ var Obelisk = class {
    */
   getSigner(derivePathParams) {
     const keyPair = this.accountManager.getKeyPair(derivePathParams);
-    return new import_sui9.RawSigner(keyPair, this.rpcProvider.provider);
+    return new import_sui10.RawSigner(keyPair, this.rpcProvider.provider);
   }
   /**
    * @description Switch the current account with the given derivePathParams
@@ -594,6 +883,12 @@ var Obelisk = class {
   provider() {
     return this.rpcProvider.provider;
   }
+  getPackageId() {
+    return this.contractFactory.packageId;
+  }
+  getMetadata() {
+    return this.contractFactory.metadata;
+  }
   /**
    * Request some SUI from faucet
    * @Returns {Promise<boolean>}, true if the request is successful, false otherwise.
@@ -606,6 +901,9 @@ var Obelisk = class {
     const owner = this.accountManager.getAddress(derivePathParams);
     return this.rpcProvider.getBalance(owner, coinType);
   }
+  async getObject(objectId) {
+    return this.rpcProvider.getObject(objectId);
+  }
   async getObjects(objectIds) {
     return this.rpcProvider.getObjects(objectIds);
   }
@@ -727,29 +1025,90 @@ var Obelisk = class {
    */
   async inspectTxn(tx, derivePathParams) {
     tx = tx instanceof SuiTxBlock ? tx.txBlock : tx;
+    console.log(this.getAddress(derivePathParams));
     return this.rpcProvider.provider.devInspectTransactionBlock({
       transactionBlock: tx,
       sender: this.getAddress(derivePathParams)
     });
   }
-  async call(world_id, system_name, counter, derivePathParams) {
-    const tx = new import_sui9.TransactionBlock();
+  async getBirthTime(objectId, derivePathParams) {
+    const tx = new import_sui10.TransactionBlock();
     tx.moveCall({
-      target: `${world_id}::system::${system_name}`,
+      // target: `0x12b216923e5454e1f076ccb5fc638b59f8aba2175c34df9899de71124d66badd::status_system::get_pet_state`,
+      target: `0x6afbf113a5872b781a2a0068b95c0d9d0ee89428518fdd65f862c841eab45b82::pet_system::get_pet_basic_info`,
       arguments: [
-        // txb.pure(manager),
-        tx.pure(counter)
+        // tx.pure("0x6fa43c68221960f942572905f3c198a5bccaa0700506b3b6bd83dd9b007e6324"),
+        // tx.pure("0xbf64721f0961a0426ccde6b8d9343e2cb2c26a105a5c33e57074580fd98b2cb1"),
+        // tx.pure("0x6"),
+        obj(tx, "0x26804211486be597a89c46c16b929d7031fb7c701ecf89d4c750e49459b4bea2"),
+        pure(tx, "0x35ba3bfb8590dbd060f41cd58c7b140d67efd2126648409cd231c74cff2828b8", `0x2::object::ID`),
+        obj(tx, "0x6")
       ]
     });
-    return this.signAndSendTxn(tx, derivePathParams);
-  }
+    return await this.inspectTxn(tx, derivePathParams);
+  }
+  async getWorld(worldObjectId) {
+    return this.rpcProvider.getObject(worldObjectId);
+  }
+  async getAllEntities(worldId, cursor, limit) {
+    const parentId = (await this.rpcProvider.getObject(worldId)).objectFields.entities.fields.id.id;
+    return await this.rpcProvider.getDynamicFields(parentId, cursor, limit);
+  }
+  async getEntity(worldId, entityId) {
+    const parentId = (await this.rpcProvider.getObject(worldId)).objectFields.entities.fields.id.id;
+    const name = {
+      type: "0x2::object::ID",
+      value: entityId
+    };
+    return await this.rpcProvider.getDynamicFieldObject(parentId, name);
+  }
+  async getEntityComponents(worldId, entityId, cursor, limit) {
+    const parentContent = (await this.getEntity(worldId, entityId)).data.content;
+    const parentId = parentContent.fields.value.fields.components.fields.id.id;
+    return await this.rpcProvider.getDynamicFields(parentId, cursor, limit);
+  }
+  async getEntityComponent(entityId, componentId) {
+    const parentId = (await this.rpcProvider.getObject(entityId)).objectFields.id.id;
+    const name = {
+      type: "0x2::object::ID",
+      value: componentId
+    };
+    return await this.rpcProvider.getDynamicFieldObject(parentId, name);
+  }
+  // async loadData() {
+  //   const jsonFileName = `metadata/${this.packageId}.json`;
+  //   try {
+  //     const data = await fs.promises.readFile(jsonFileName, 'utf-8');
+  //     const jsonData = JSON.parse(data);
+  //     return jsonData as SuiMoveNormalizedModules;
+  //   } catch (error) {
+  //     if (this.packageId !== undefined) {
+  //       const jsonData = await this.rpcProvider.getNormalizedMoveModulesByPackage(this.packageId);
+  //       fs.writeFile(jsonFileName, JSON.stringify(jsonData, null, 2), (err) => {
+  //         if (err) {
+  //           console.error('写入文件时出错:', err);
+  //         } else {
+  //           console.log('JSON 数据已保存到文件:', jsonFileName);
+  //         }
+  //       });
+  //       return jsonData as SuiMoveNormalizedModules;
+  //     } else {
+  //       console.error('please set your package id.');
+  //     }
+  //   }
+  // }
 };
+_query = new WeakMap();
+_tx = new WeakMap();
+_exec = new WeakMap();
+_read = new WeakMap();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Obelisk,
   SUI_CLOCK_OBJECT_ID,
   SUI_SYSTEM_STATE_OBJECT_ID,
   SuiAccountManager,
+  SuiContractFactory,
   SuiRpcProvider,
   SuiTxBlock,
   TransactionBlock