@easysui/sdk 0.1.1 → 0.2.1

package/dist/index.js

@@ -8,6 +8,7 @@ var cryptography = require('@mysten/sui/cryptography');
 var ed25519 = require('@mysten/sui/keypairs/ed25519');
 var secp256k1 = require('@mysten/sui/keypairs/secp256k1');
 var secp256r1 = require('@mysten/sui/keypairs/secp256r1');
+var utils = require('@mysten/sui/utils');
 var transactions = require('@mysten/sui/transactions');
 var bcs = require('@mysten/sui/bcs');
 var child_process = require('child_process');
@@ -57,20 +58,26 @@ function getKeypair(privkey) {
 
 // src/config/static.ts
 var STATIC_CONFIGS = {
+  localnet: {
+    CHAIN_ID: "d07607dc"
+  },
+  devnet: {
+    CHAIN_ID: "4c78adac"
+  },
   testnet: {
+    CHAIN_ID: "4c78adac",
     USDC_PACKAGE_ID: "0xa1ec7fc00a6f40db9693ad1415d0c193ad3906494428cf252621037bd7117e29"
   },
   mainnet: {
+    CHAIN_ID: "35834a8a",
     USDC_PACKAGE_ID: "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7"
   }
 };
-
-// src/config/config.ts
-dotenv__default.default.config({ path: path__default.default.resolve(process.cwd(), ".env") });
+dotenv__default.default.config({ path: path__default.default.resolve(process.cwd(), ".env"), quiet: true });
 var DENY_LIST_ID = "0x403";
-var CLOCK_ID = "0x6";
+var CLOCK_ID = utils.SUI_CLOCK_OBJECT_ID;
 var COIN_REGISTRY = "0x000000000000000000000000000000000000000000000000000000000000000c";
-var ADMIN_KEYPAIR = getKeypair(process.env.ADMIN_PRIVATE_KEY);
+var ADMIN_KEYPAIR = process.env.ADMIN_PRIVATE_KEY ? getKeypair(process.env.ADMIN_PRIVATE_KEY) : void 0;
 var Config = class _Config {
   static instance = null;
   static getInstance() {
@@ -80,7 +87,7 @@ var Config = class _Config {
     return this.instance;
   }
   get env() {
-    let env = process.env.NODE_ENV;
+    let env = process.env.NETWORK;
     if (!["mainnet", "testnet", "devnet", "localnet"].includes(env || "")) {
       env = "localnet";
     }
@@ -96,7 +103,7 @@ var Config = class _Config {
   static get vars() {
     const instance = this.getInstance();
     const NETWORK = instance.env;
-    dotenv__default.default.config({ path: path__default.default.resolve(process.cwd(), `.env.${NETWORK}`), override: true });
+    dotenv__default.default.config({ path: path__default.default.resolve(process.cwd(), `.env.${NETWORK}`), override: true, quiet: true });
     const envVars = {
       NETWORK,
       RPC: client.getFullnodeUrl(NETWORK),
@@ -160,6 +167,22 @@ function analyze_cost(ptb, resp) {
   columns.push(gasSpent);
   fs3__namespace.appendFileSync(COST_ANALYSIS_FILE, columns.join(",") + "\n");
 }
+function toFormatType(type, bytes) {
+  switch (type) {
+    case 2 /* base64 */:
+      return utils.toBase64(bytes);
+    case 1 /* hex */:
+      return utils.toHex(bytes);
+    default:
+      throw "The FORMAT_TYPES must be one of hex or base64";
+  }
+}
+function isHex(str) {
+  return /^[0-9a-fA-F]+$/.test(str) && str.length % 2 === 0;
+}
+function hexToBase64(hex) {
+  return utils.toBase64(utils.fromHex(hex));
+}
 
 // src/utils/sui_client.ts
 var MoveType = /* @__PURE__ */ ((MoveType2) => {
@@ -171,12 +194,19 @@ var MoveType = /* @__PURE__ */ ((MoveType2) => {
   MoveType2[MoveType2["u256"] = 6] = "u256";
   MoveType2[MoveType2["bool"] = 7] = "bool";
   MoveType2[MoveType2["string"] = 8] = "string";
-  MoveType2[MoveType2["object"] = 9] = "object";
-  MoveType2[MoveType2["address"] = 10] = "address";
-  MoveType2[MoveType2["address_opt"] = 11] = "address_opt";
-  MoveType2[MoveType2["vec_address"] = 12] = "vec_address";
+  MoveType2[MoveType2["string_opt"] = 9] = "string_opt";
+  MoveType2[MoveType2["object"] = 10] = "object";
+  MoveType2[MoveType2["address"] = 11] = "address";
+  MoveType2[MoveType2["address_opt"] = 12] = "address_opt";
+  MoveType2[MoveType2["vec_address"] = 13] = "vec_address";
+  MoveType2[MoveType2["vec_u64"] = 14] = "vec_u64";
   return MoveType2;
 })(MoveType || {});
+var txOptions = {
+  showEffects: true,
+  showObjectChanges: true,
+  showBalanceChanges: true
+};
 var SuiClient = class _SuiClient {
   static instance = null;
   client;
@@ -192,26 +222,21 @@ var SuiClient = class _SuiClient {
   static get client() {
     return this.getInstance().client;
   }
-  static async signAndExecute(ptb, signer, errorHandler = (e) => e) {
-    try {
-      const resp = await _SuiClient.client.signAndExecuteTransaction({
-        transaction: ptb,
-        signer,
-        options: {
-          showEffects: true,
-          showObjectChanges: true,
-          showBalanceChanges: true
-        }
-      });
-      await _SuiClient.client.waitForTransaction({ digest: resp.digest });
-      if (resp.effects?.status.status !== "success") {
-        throw new Error(JSON.stringify(resp));
-      }
-      analyze_cost(ptb, resp);
-      return resp;
-    } catch (e) {
-      throw new Error(errorHandler(e));
+  static async waitForTransaction(ptb, resp) {
+    await _SuiClient.client.waitForTransaction({ digest: resp.digest });
+    if (resp.effects?.status.status !== "success") {
+      throw new Error(JSON.stringify(resp));
     }
+    analyze_cost(ptb, resp);
+    return resp;
+  }
+  static async signAndExecute(ptb, signer) {
+    const resp = await _SuiClient.client.signAndExecuteTransaction({
+      transaction: ptb,
+      signer,
+      options: txOptions
+    });
+    return _SuiClient.waitForTransaction(ptb, resp);
   }
   static toMoveArg(ptb, value, type) {
     if (typeof value === "object" && !Array.isArray(value)) {
@@ -220,7 +245,7 @@ var SuiClient = class _SuiClient {
     if (!type) {
       if (typeof value === "string") {
         if (value.startsWith("0x")) {
-          type = 9 /* object */;
+          type = 10 /* object */;
         } else {
           type = 8 /* string */;
         }
@@ -239,10 +264,12 @@ var SuiClient = class _SuiClient {
       [6 /* u256 */]: (v) => ptb.pure.u256(v),
       [7 /* bool */]: (v) => ptb.pure.bool(v),
       [8 /* string */]: (v) => ptb.pure.string(v),
-      [9 /* object */]: (v) => ptb.object(v),
-      [10 /* address */]: (v) => ptb.pure.address(v),
-      [11 /* address_opt */]: (v) => ptb.pure.option("address", v),
-      [12 /* vec_address */]: (v) => ptb.pure.vector("address", v)
+      [9 /* string_opt */]: (v) => ptb.pure.option("string", v),
+      [10 /* object */]: (v) => ptb.object(v),
+      [11 /* address */]: (v) => ptb.pure.address(v),
+      [12 /* address_opt */]: (v) => ptb.pure.option("address", v),
+      [13 /* vec_address */]: (v) => ptb.pure.vector("address", v),
+      [14 /* vec_u64 */]: (v) => ptb.pure.vector("u64", v)
     };
     return factory[type](value);
   }
@@ -252,20 +279,73 @@ var SuiClient = class _SuiClient {
     typeArgs = [],
     args = [],
     argTypes = [],
-    errorHandler = (e) => e,
     ptb,
     withTransfer = false
   }) {
+    ptb = this.getPTB(target, typeArgs, args, argTypes, signer.toSuiAddress(), withTransfer, ptb);
+    return _SuiClient.signAndExecute(ptb, signer);
+  }
+  static async getMoveCallBytes({
+    signer,
+    target,
+    typeArgs = [],
+    args = [],
+    argTypes = [],
+    ptb,
+    withTransfer = false,
+    gasOwner,
+    format = 1 /* hex */
+  }) {
+    ptb = this.getPTB(target, typeArgs, args, argTypes, signer, withTransfer, ptb);
+    return await this.getMoveCallBytesFromPTB(ptb, signer, gasOwner, format);
+  }
+  static async getMoveCallBytesFromPTB(ptb, signer, gasOwner, format = 1 /* hex */) {
+    ptb.setSender(signer);
+    gasOwner ??= signer;
+    ptb.setGasOwner(gasOwner || signer);
+    const bytes = await ptb.build({ client: _SuiClient.client, onlyTransactionKind: false });
+    return toFormatType(format, bytes);
+  }
+  static toBytes(bytes) {
+    if (typeof bytes === "string") {
+      return isHex(bytes) ? utils.fromHex(bytes) : utils.fromBase64(bytes);
+    }
+    return bytes;
+  }
+  static async getSignature(signatureOrKeypair, bytes) {
+    if (typeof signatureOrKeypair !== "string") {
+      const signature = await signatureOrKeypair.signTransaction(bytes);
+      return signature.signature;
+    }
+    return isHex(signatureOrKeypair) ? hexToBase64(signatureOrKeypair) : signatureOrKeypair;
+  }
+  static async executeMoveCallBytes(bytes, senderSignature, gasOwnerSignature) {
+    const transactionBlock = this.toBytes(bytes);
+    senderSignature = await this.getSignature(senderSignature, transactionBlock);
+    const signature = [senderSignature];
+    if (gasOwnerSignature) {
+      gasOwnerSignature = await this.getSignature(gasOwnerSignature, transactionBlock);
+      signature.push(gasOwnerSignature);
+    }
+    const resp = await _SuiClient.client.executeTransactionBlock({
+      transactionBlock: utils.toBase64(transactionBlock),
+      signature,
+      options: txOptions
+    });
+    const ptb = transactions.Transaction.from(utils.toBase64(transactionBlock));
+    return _SuiClient.waitForTransaction(ptb, resp);
+  }
+  static getPTB(target, typeArgs = [], args = [], argTypes = [], signer, withTransfer = false, ptb) {
     ptb = ptb || new transactions.Transaction();
     const obj = ptb.moveCall({
       target,
       typeArguments: typeArgs,
       arguments: args.map((arg, i) => _SuiClient.toMoveArg(ptb, arg, argTypes[i]))
     });
-    if (withTransfer) {
-      ptb.transferObjects([obj], signer.toSuiAddress());
+    if (withTransfer && signer) {
+      ptb.transferObjects([obj], signer);
     }
-    return _SuiClient.signAndExecute(ptb, signer, errorHandler);
+    return ptb;
   }
   static async public_transfer(objects, from, to) {
     const tx = new transactions.Transaction();
@@ -298,10 +378,22 @@ var SuiClient = class _SuiClient {
     const bytes = Uint8Array.from(value);
     return "0x" + Buffer.from(bytes).toString("hex");
   }
+  static async devInspectString(ptb, sender) {
+    const value = await this.devInspectRaw(ptb, sender);
+    if (!value) {
+      return "";
+    }
+    return bcs.bcs.string().parse(new Uint8Array(value));
+  }
   static async getObject(id) {
     return _SuiClient.client.getObject({
       id,
-      options: { showContent: true }
+      options: {
+        showContent: true,
+        showType: true,
+        showDisplay: true,
+        showBcs: true
+      }
     });
   }
   static async getObjectsByType(owner, type) {
@@ -346,7 +438,7 @@ var Coin = class {
       target: `0x2::coin::mint`,
       typeArgs: [this.coinType],
       args: [treasuryId, amount],
-      argTypes: [9 /* object */, 4 /* u64 */],
+      argTypes: [10 /* object */, 4 /* u64 */],
       withTransfer: true
     });
   }
@@ -361,7 +453,7 @@ var Coin = class {
       target: `0x2::coin_registry::finalize_registration`,
       typeArgs: [this.coinType],
       args: [COIN_REGISTRY, currencyId],
-      argTypes: [9 /* object */, 9 /* object */]
+      argTypes: [10 /* object */, 10 /* object */]
     });
   }
   static async send(amount, from, to) {
@@ -395,7 +487,7 @@ var USDC = class extends Coin {
         target: `${Config.vars.USDC_PACKAGE_ID}::treasury::configure_new_controller`,
         typeArgs: [this.coinType],
         args: [Config.vars.USDC_TREASURY_CAP, admin.toSuiAddress(), admin.toSuiAddress()],
-        argTypes: [9 /* object */, 10 /* address */, 10 /* address */]
+        argTypes: [10 /* object */, 11 /* address */, 11 /* address */]
       });
       mintCapId = await getMintCapFromChain();
     }
@@ -408,7 +500,7 @@ var USDC = class extends Coin {
       target: `${Config.vars.USDC_PACKAGE_ID}::treasury::configure_minter`,
       typeArgs: [this.coinType],
       args: [Config.vars.USDC_TREASURY_CAP, DENY_LIST_ID, amount],
-      argTypes: [9 /* object */, 9 /* object */, 4 /* u64 */]
+      argTypes: [10 /* object */, 10 /* object */, 4 /* u64 */]
     });
     await SuiClient.moveCall({
       signer: admin,
@@ -416,11 +508,11 @@ var USDC = class extends Coin {
       typeArgs: [this.coinType],
       args: [Config.vars.USDC_TREASURY_CAP, mintCapId, DENY_LIST_ID, amount, receiver],
       argTypes: [
-        9 /* object */,
-        9 /* object */,
-        9 /* object */,
+        10 /* object */,
+        10 /* object */,
+        10 /* object */,
         4 /* u64 */,
-        10 /* address */
+        11 /* address */
       ]
     });
   }
@@ -483,53 +575,41 @@ var PublishSingleton = class _PublishSingleton {
       false
     );
   }
-  static getPublishTx(packagePath, sender) {
-    const transaction = new transactions.Transaction();
+  static getPublishCmd(packagePath, sender, inBytes = false) {
+    const network = Config.vars.NETWORK;
     if (!fs3__namespace.default.existsSync(packagePath)) {
       throw new Error(`Package doesn't exist under: ${packagePath}`);
     }
     if (fs3__namespace.default.existsSync(`${packagePath}/Move.lock`)) {
       fs3__namespace.default.unlinkSync(`${packagePath}/Move.lock`);
     }
+    if (fs3__namespace.default.existsSync(`Pub.${network}.toml`)) {
+      fs3__namespace.default.unlinkSync(`Pub.${network}.toml`);
+    }
     fs3__namespace.default.rmSync(`${packagePath}/build`, { recursive: true, force: true });
-    let buildCommand = `sui move build --dump-bytecode-as-base64 --path ${packagePath}`;
-    const network = Config.vars.NETWORK;
+    const isEphemeralChain = network !== "mainnet" && network !== "testnet";
+    const publishCmd = isEphemeralChain ? `test-publish --build-env testnet` : "publish";
+    let buildCommand = `sui client ${publishCmd} ${packagePath}`;
     if (network === "localnet" || network === "devnet") {
       buildCommand += " --with-unpublished-dependencies";
     }
-    const { modules, dependencies } = JSON.parse(child_process.execSync(buildCommand, { encoding: "utf-8" }));
-    const upgradeCap = transaction.publish({
-      modules,
-      dependencies
-    });
-    transaction.transferObjects([upgradeCap], sender);
-    return transaction;
+    buildCommand += inBytes ? " --serialize-unsigned-transaction" : " --json";
+    return buildCommand;
   }
   static async getPublishBytes(signer, packagePath) {
     signer ??= ADMIN_KEYPAIR.toSuiAddress();
     const _packagePath = this.getPackagePath(packagePath);
-    const transaction = this.getPublishTx(_packagePath, signer);
-    const client$1 = new client.SuiClient({ url: Config.vars.RPC });
-    const txBytes = await transaction.build({ client: client$1, onlyTransactionKind: true });
-    return Buffer.from(txBytes).toString("base64");
+    const cmd = this.getPublishCmd(_packagePath, signer, true);
+    return child_process.execSync(cmd, { encoding: "utf-8" }).trim();
   }
   static async publishPackage(signer, packagePath) {
-    const transaction = this.getPublishTx(packagePath, signer.toSuiAddress());
-    const client$1 = new client.SuiClient({ url: Config.vars.RPC });
-    const resp = await client$1.signAndExecuteTransaction({
-      transaction,
-      signer,
-      options: {
-        showObjectChanges: true,
-        showEffects: true
-      }
-    });
-    if (resp.effects?.status.status !== "success") {
-      throw new Error(`Failure during publish transaction:
-${JSON.stringify(resp, null, 2)}`);
+    const cmd = this.getPublishCmd(packagePath, signer.toSuiAddress());
+    const res = child_process.execSync(cmd, { encoding: "utf-8" });
+    const match = res.match(/\{[\s\S]*\}/);
+    if (!match) {
+      throw new Error(`No JSON found in the publish command output: ${res}`);
     }
-    await client$1.waitForTransaction({ digest: resp.digest });
-    return resp;
+    return JSON.parse(match[0]);
   }
   static findPublishedPackage(resp) {
     return resp.objectChanges?.find(
@@ -544,9 +624,9 @@ ${JSON.stringify(resp, null, 2)}`);
 };
 
 // src/utils/deploy.ts
-async function deploy(ConfigClass = Config) {
+async function deploy(ConfigClass = Config, packagePath) {
   const vars = ConfigClass.vars;
-  await PublishSingleton.publish();
+  await PublishSingleton.publish(ADMIN_KEYPAIR, packagePath);
   const newConfig = {
     ...vars,
     PACKAGE_ID: PublishSingleton.packageId,
@@ -604,6 +684,15 @@ async function waitForNextEpoch(timeoutMs = 5 * 60 * 1e3, pollIntervalMs = 2e3)
     await sleep(pollIntervalMs);
   }
 }
+function deriveObjectId(parentId, module, key, packageId, type, serializedBcs) {
+  serializedBcs ??= bcs.bcs.struct(key, { dummy_value: bcs.bcs.bool() }).serialize({ dummy_value: false });
+  const keyU8 = serializedBcs.toBytes();
+  let typeTag = `${packageId}::${module}::${key}`;
+  if (type) {
+    typeTag += `<${type}>`;
+  }
+  return utils.deriveObjectID(parentId, typeTag, keyU8);
+}
 
 exports.ADMIN_KEYPAIR = ADMIN_KEYPAIR;
 exports.CLOCK_ID = CLOCK_ID;
@@ -619,6 +708,7 @@ exports.analyze_cost = analyze_cost;
 exports.createFundedWallet = createFundedWallet;
 exports.createWallet = createWallet;
 exports.deploy = deploy;
+exports.deriveObjectId = deriveObjectId;
 exports.getDeployBytes = getDeployBytes;
 exports.getKeypair = getKeypair;
 exports.sleep = sleep;