@easysui/sdk 0.0.1

package/dist/index.js

@@ -0,0 +1,598 @@
+'use strict';
+
+var path = require('path');
+var fs3 = require('fs');
+var dotenv = require('dotenv');
+var client = require('@mysten/sui/client');
+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 transactions = require('@mysten/sui/transactions');
+var bcs = require('@mysten/sui/bcs');
+var child_process = require('child_process');
+var faucet$1 = require('@mysten/sui/faucet');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var path__default = /*#__PURE__*/_interopDefault(path);
+var fs3__namespace = /*#__PURE__*/_interopNamespace(fs3);
+var dotenv__default = /*#__PURE__*/_interopDefault(dotenv);
+
+// src/config/config.ts
+function getKeypair(privkey) {
+  const parsed = cryptography.decodeSuiPrivateKey(privkey);
+  switch (parsed.scheme) {
+    case "ED25519": {
+      return ed25519.Ed25519Keypair.fromSecretKey(parsed.secretKey);
+    }
+    case "Secp256k1": {
+      return secp256k1.Secp256k1Keypair.fromSecretKey(parsed.secretKey);
+    }
+    case "Secp256r1": {
+      return secp256r1.Secp256r1Keypair.fromSecretKey(parsed.secretKey);
+    }
+    default:
+      throw new Error(`Key scheme ${parsed.schema} not supported`);
+  }
+}
+
+// src/config/static.ts
+var STATIC_CONFIGS = {
+  testnet: {
+    USDC_PACKAGE_ID: "0xa1ec7fc00a6f40db9693ad1415d0c193ad3906494428cf252621037bd7117e29"
+  },
+  mainnet: {
+    USDC_PACKAGE_ID: "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7"
+  }
+};
+
+// src/config/config.ts
+dotenv__default.default.config({ path: path__default.default.resolve(process.cwd(), ".env") });
+var DENY_LIST_ID = "0x403";
+var CLOCK_ID = "0x6";
+var ADMIN_KEYPAIR = getKeypair(process.env.ADMIN_PRIVATE_KEY);
+var Config = class _Config {
+  static instance = null;
+  static getInstance() {
+    if (!_Config.instance) {
+      this.instance = new _Config();
+    }
+    return this.instance;
+  }
+  get env() {
+    let env = process.env.NODE_ENV;
+    if (!["mainnet", "testnet", "devnet", "localnet"].includes(env || "")) {
+      env = "localnet";
+    }
+    return env;
+  }
+  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 });
+    const envVars = {
+      NETWORK,
+      RPC: client.getFullnodeUrl(NETWORK),
+      PACKAGE_PATH: process.env.PACKAGE_PATH || "",
+      PACKAGE_ID: process.env.PACKAGE_ID || "",
+      UPGRADE_CAP_ID: process.env.UPGRADE_CAP_ID || "",
+      USDC_TREASURY_CAP: process.env.USDC_TREASURY_CAP,
+      USDC_PACKAGE_ID: process.env.USDC_PACKAGE_ID
+    };
+    const staticVars = STATIC_CONFIGS[NETWORK] || {};
+    return {
+      ...staticVars,
+      ...envVars
+    };
+  }
+  static write(config) {
+    const instance = this.getInstance();
+    const env = instance.env;
+    const envFile = path__default.default.join(process.cwd(), `.env${env ? `.${env}` : ""}`);
+    const envVariables = Object.entries(config).filter(([_, value]) => value).map(([key, value]) => `${key}=${value}`).join("\n");
+    fs3__namespace.default.writeFileSync(envFile, envVariables, "utf8");
+    return envFile;
+  }
+};
+var COST_ANALYSIS_FILE = "./gas_cost_estimation.csv";
+var HEADERS = [
+  "environment",
+  "executedAt",
+  "digest",
+  "packageId",
+  "call",
+  "computationCost",
+  "storageCost",
+  "storageRebate",
+  "nonRefundableStorageFee",
+  "gasSpent"
+];
+function analyze_cost(ptb, resp) {
+  if (!process.env.COST_ANALYZER_ENABLED) {
+    return;
+  }
+  if (!fs3__namespace.existsSync(COST_ANALYSIS_FILE)) {
+    fs3__namespace.writeFileSync(COST_ANALYSIS_FILE, HEADERS.join(",") + "\n");
+  }
+  const columns = [Config.vars.NETWORK, Date.now(), resp.digest];
+  const moveCalls = ptb.blockData.transactions.filter((txItem) => txItem.kind === "MoveCall");
+  const moveCall = moveCalls.pop();
+  if (!moveCall?.target) {
+    return;
+  }
+  const splits = moveCall.target.split("::");
+  columns.push(splits[0]);
+  columns.push(`${splits[1]}::${splits[2]}`);
+  const gasUsed = resp.effects?.gasUsed;
+  columns.push(gasUsed?.computationCost || "N/A");
+  columns.push(gasUsed?.storageCost || "N/A");
+  columns.push(gasUsed?.storageRebate || "N/A");
+  columns.push(gasUsed?.nonRefundableStorageFee || "N/A");
+  const totalGasCost = BigInt(gasUsed?.computationCost || 0) + BigInt(gasUsed?.storageCost || 0);
+  const gasSpent = totalGasCost - BigInt(gasUsed?.storageRebate || 0);
+  columns.push(gasSpent);
+  fs3__namespace.appendFileSync(COST_ANALYSIS_FILE, columns.join(",") + "\n");
+}
+
+// src/utils/sui_client.ts
+var MoveType = /* @__PURE__ */ ((MoveType2) => {
+  MoveType2[MoveType2["u8"] = 0] = "u8";
+  MoveType2[MoveType2["u16"] = 1] = "u16";
+  MoveType2[MoveType2["u32"] = 2] = "u32";
+  MoveType2[MoveType2["u64"] = 3] = "u64";
+  MoveType2[MoveType2["u128"] = 4] = "u128";
+  MoveType2[MoveType2["u256"] = 5] = "u256";
+  MoveType2[MoveType2["bool"] = 6] = "bool";
+  MoveType2[MoveType2["string"] = 7] = "string";
+  MoveType2[MoveType2["object"] = 8] = "object";
+  MoveType2[MoveType2["address"] = 9] = "address";
+  MoveType2[MoveType2["address_opt"] = 10] = "address_opt";
+  MoveType2[MoveType2["vec_address"] = 11] = "vec_address";
+  return MoveType2;
+})(MoveType || {});
+var SuiClient = class _SuiClient {
+  static instance = null;
+  client;
+  constructor() {
+    this.client = new client.SuiClient({ url: Config.vars.RPC });
+  }
+  static getInstance() {
+    if (!_SuiClient.instance) {
+      this.instance = new _SuiClient();
+    }
+    return this.instance;
+  }
+  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 toMoveArg(ptb, value, type) {
+    if (typeof value === "object" && !Array.isArray(value)) {
+      return value;
+    }
+    if (!type) {
+      if (typeof value === "string") {
+        if (value.startsWith("0x")) {
+          type = 8 /* object */;
+        } else {
+          type = 7 /* string */;
+        }
+      } else if (typeof value === "boolean") {
+        type = 6 /* bool */;
+      } else if (typeof value === "number" || typeof value === "bigint") {
+        type = 3 /* u64 */;
+      }
+    }
+    const factory = {
+      [0 /* u8 */]: (v) => ptb.pure.u8(v),
+      [1 /* u16 */]: (v) => ptb.pure.u16(v),
+      [2 /* u32 */]: (v) => ptb.pure.u32(v),
+      [3 /* u64 */]: (v) => ptb.pure.u64(v),
+      [4 /* u128 */]: (v) => ptb.pure.u128(v),
+      [5 /* u256 */]: (v) => ptb.pure.u256(v),
+      [6 /* bool */]: (v) => ptb.pure.bool(v),
+      [7 /* string */]: (v) => ptb.pure.string(v),
+      [8 /* object */]: (v) => ptb.object(v),
+      [9 /* address */]: (v) => ptb.pure.address(v),
+      [10 /* address_opt */]: (v) => ptb.pure.option("address", v),
+      [11 /* vec_address */]: (v) => ptb.pure.vector("address", v)
+    };
+    return factory[type](value);
+  }
+  static async moveCall({
+    signer,
+    target,
+    typeArgs = [],
+    args = [],
+    argTypes = [],
+    errorHandler = (e) => e,
+    ptb,
+    withTransfer = false
+  }) {
+    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());
+    }
+    return _SuiClient.signAndExecute(ptb, signer, errorHandler);
+  }
+  static async public_transfer(objects, from, to) {
+    const tx = new transactions.Transaction();
+    tx.transferObjects(objects, to);
+    return await _SuiClient.signAndExecute(tx, from);
+  }
+  static async devInspect(ptb, sender) {
+    return await _SuiClient.client.devInspectTransactionBlock({
+      transactionBlock: ptb,
+      sender
+    });
+  }
+  static async devInspectRaw(ptb, sender) {
+    const result = await this.devInspect(ptb, sender);
+    return result.results?.[0].returnValues?.[0]?.[0];
+  }
+  static async devInspectBool(ptb, sender) {
+    const result = await this.devInspectRaw(ptb, sender);
+    return result && result[0] === 1;
+  }
+  static async devInspectU64(ptb, sender) {
+    const value = await this.devInspectRaw(ptb, sender);
+    return BigInt(bcs.bcs.u64().parse(new Uint8Array(value)));
+  }
+  static async devInspectAddress(ptb, sender) {
+    const value = await this.devInspectRaw(ptb, sender);
+    if (!value) {
+      return void 0;
+    }
+    const bytes = Uint8Array.from(value);
+    return "0x" + Buffer.from(bytes).toString("hex");
+  }
+  static async getObject(id) {
+    return _SuiClient.client.getObject({
+      id,
+      options: { showContent: true }
+    });
+  }
+  static async getObjectsByType(owner, type) {
+    const res = await _SuiClient.client.getOwnedObjects({
+      owner,
+      filter: {
+        StructType: type
+      }
+    });
+    return res.data.map((o) => o.data?.objectId).filter((o) => o);
+  }
+};
+var Coin = class {
+  static get coinType() {
+    throw new Error("`coinType` getter must be implemented !");
+  }
+  static async getBalance(owner) {
+    const result = await SuiClient.client.getBalance({
+      owner,
+      coinType: this.coinType
+    });
+    return BigInt(result.totalBalance);
+  }
+  static async getCoin(owner, amount) {
+    const balance = amount || await this.getBalance(owner.toSuiAddress());
+    const tx = new transactions.Transaction();
+    const coinSplit = transactions.coinWithBalance({
+      balance,
+      useGasCoin: false,
+      type: this.coinType
+    });
+    tx.transferObjects([coinSplit], owner.toSuiAddress());
+    const result = await SuiClient.signAndExecute(tx, owner);
+    const coin = result.objectChanges?.find(
+      (o) => o.type === "created" && o.objectType === `0x2::coin::Coin<${this.coinType}>`
+    );
+    return coin?.objectId;
+  }
+  static async _mint(treasuryId, amount, minter) {
+    await SuiClient.moveCall({
+      signer: minter,
+      target: `0x2::coin::mint`,
+      typeArgs: [this.coinType],
+      args: [treasuryId, amount],
+      argTypes: [8 /* object */, 3 /* u64 */],
+      withTransfer: true
+    });
+  }
+  static async send(amount, from, to) {
+    const coin = await this.getCoin(from, amount);
+    const ptb = new transactions.Transaction();
+    ptb.transferObjects([ptb.object(coin)], to);
+    await SuiClient.signAndExecute(ptb, from);
+  }
+  static async assertBalance(wallet, amount) {
+    await expect(this.getBalance(wallet.toSuiAddress())).resolves.toBe(amount);
+  }
+};
+
+// src/tokens/usdc.ts
+var USDC = class extends Coin {
+  static get coinType() {
+    return Config.vars.USDC_PACKAGE_ID + "::usdc::USDC";
+  }
+  static async getMintCapId(admin) {
+    async function getMintCapFromChain() {
+      const mintCapIds = await SuiClient.getObjectsByType(
+        admin.toSuiAddress(),
+        `${Config.vars.USDC_PACKAGE_ID}::treasury::MintCap`
+      );
+      return mintCapIds.pop();
+    }
+    let mintCapId = await getMintCapFromChain();
+    if (!mintCapId) {
+      await SuiClient.moveCall({
+        signer: admin,
+        target: `${Config.vars.USDC_PACKAGE_ID}::treasury::configure_new_controller`,
+        typeArgs: [this.coinType],
+        args: [Config.vars.USDC_TREASURY_CAP, admin.toSuiAddress(), admin.toSuiAddress()],
+        argTypes: [8 /* object */, 9 /* address */, 9 /* address */]
+      });
+      mintCapId = await getMintCapFromChain();
+    }
+    return mintCapId;
+  }
+  static async faucet(amount, receiver, admin) {
+    const mintCapId = await this.getMintCapId(admin);
+    await SuiClient.moveCall({
+      signer: admin,
+      target: `${Config.vars.USDC_PACKAGE_ID}::treasury::configure_minter`,
+      typeArgs: [this.coinType],
+      args: [Config.vars.USDC_TREASURY_CAP, DENY_LIST_ID, amount],
+      argTypes: [8 /* object */, 8 /* object */, 3 /* u64 */]
+    });
+    await SuiClient.moveCall({
+      signer: admin,
+      target: `${Config.vars.USDC_PACKAGE_ID}::treasury::mint`,
+      typeArgs: [this.coinType],
+      args: [Config.vars.USDC_TREASURY_CAP, mintCapId, DENY_LIST_ID, amount, receiver],
+      argTypes: [
+        8 /* object */,
+        8 /* object */,
+        8 /* object */,
+        3 /* u64 */,
+        9 /* address */
+      ]
+    });
+  }
+};
+var PublishSingleton = class _PublishSingleton {
+  constructor(publishResp) {
+    this.publishResp = publishResp;
+  }
+  static instance = null;
+  static getDeployVars(signer, packagePath) {
+    signer ??= ADMIN_KEYPAIR;
+    packagePath ??= Config.vars.PACKAGE_PATH;
+    if (!packagePath) {
+      throw new Error(
+        "You must set the `PACKAGE_PATH` environment variable to your Move.toml path."
+      );
+    }
+    return [signer, packagePath];
+  }
+  static async publish(signer, packagePath) {
+    const [_signer, _packagePath] = this.getDeployVars(signer, packagePath);
+    if (!_PublishSingleton.instance) {
+      const publishResp = await _PublishSingleton.publishPackage(_signer, _packagePath);
+      const packageId = this.findPublishedPackage(publishResp)?.packageId;
+      if (!packageId) {
+        throw new Error("Expected to find package published");
+      }
+      _PublishSingleton.instance = new _PublishSingleton(publishResp);
+    }
+  }
+  static getInstance() {
+    if (!_PublishSingleton.instance) {
+      throw new Error("Use `async PublishSingleton.publish()` first");
+    }
+    return _PublishSingleton.instance;
+  }
+  static publishResponse() {
+    return this.getInstance().publishResp;
+  }
+  static get packageId() {
+    const packageChng = this.findPublishedPackage(this.publishResponse());
+    if (!packageChng) {
+      throw new Error("Expected to find package published");
+    }
+    return packageChng.packageId;
+  }
+  static findObjectIdByType(type, fail = true) {
+    const obj = this.findObjectChangeCreatedByType(this.publishResponse(), type);
+    if (fail && !obj) {
+      throw new Error(`Expected to find ${type} shared object created.`);
+    }
+    return obj?.objectId || "";
+  }
+  static get upgradeCapId() {
+    return this.findObjectIdByType(`0x2::package::UpgradeCap`);
+  }
+  static get usdcTreasuryCap() {
+    return this.findObjectIdByType(
+      `${this.packageId}::treasury::Treasury<${this.packageId}::usdc::USDC>`,
+      false
+    );
+  }
+  static getPublishTx(packagePath, signer) {
+    const transaction = new transactions.Transaction();
+    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`);
+    }
+    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;
+    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], signer.toSuiAddress());
+    return transaction;
+  }
+  static async getPublishBytes(signer, packagePath) {
+    const [_signer, _packagePath] = this.getDeployVars(signer, packagePath);
+    const transaction = this.getPublishTx(_packagePath, _signer);
+    transaction.setSender(_signer.toSuiAddress());
+    const client$1 = new client.SuiClient({ url: Config.vars.RPC });
+    const txBytes = await transaction.build({ client: client$1 });
+    return Buffer.from(txBytes).toString("base64");
+  }
+  static async publishPackage(signer, packagePath) {
+    const transaction = this.getPublishTx(packagePath, signer);
+    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)}`);
+    }
+    await client$1.waitForTransaction({ digest: resp.digest });
+    return resp;
+  }
+  static findPublishedPackage(resp) {
+    return resp.objectChanges?.find(
+      (chng) => chng.type === "published"
+    );
+  }
+  static findObjectChangeCreatedByType(resp, type) {
+    return resp.objectChanges?.find(
+      (chng) => chng.type === "created" && chng.objectType === type
+    );
+  }
+};
+
+// src/utils/deploy.ts
+async function deploy(vars) {
+  vars ??= Config.vars;
+  await PublishSingleton.publish();
+  const newConfig = {
+    ...vars,
+    PACKAGE_ID: PublishSingleton.packageId,
+    UPGRADE_CAP_ID: PublishSingleton.upgradeCapId
+  };
+  if (PublishSingleton.usdcTreasuryCap) {
+    newConfig.USDC_PACKAGE_ID = PublishSingleton.packageId;
+    newConfig.USDC_TREASURY_CAP = PublishSingleton.usdcTreasuryCap;
+  }
+  Config.write(newConfig);
+  return `Move contracts deployed successfully on ${vars.NETWORK} contract details have been stored in .env.${vars.NETWORK}`;
+}
+async function getDeployBytes() {
+  return await PublishSingleton.getPublishBytes();
+}
+function createWallet() {
+  return new ed25519.Ed25519Keypair();
+}
+async function createFundedWallet(usdcAmount) {
+  const wallet = createWallet();
+  await faucet(wallet.toSuiAddress());
+  if (usdcAmount) {
+    await USDC.faucet(usdcAmount, wallet.toSuiAddress(), ADMIN_KEYPAIR);
+  }
+  return wallet;
+}
+async function faucet(address) {
+  await faucet$1.requestSuiFromFaucetV2({
+    host: faucet$1.getFaucetHost(Config.vars.NETWORK),
+    // or 'devnet', 'localnet'
+    recipient: address
+  });
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function waitForNextEpoch(timeoutMs = 5 * 60 * 1e3, pollIntervalMs = 2e3) {
+  const startEpoch = (await SuiClient.client.getLatestSuiSystemState()).epoch;
+  const startTime = Date.now();
+  while (true) {
+    const { epoch } = await SuiClient.client.getLatestSuiSystemState();
+    if (Number(epoch) > Number(startEpoch)) {
+      return epoch;
+    }
+    if (Date.now() - startTime > timeoutMs) {
+      throw new Error("Timeout waiting for next epoch.");
+    }
+    await sleep(pollIntervalMs);
+  }
+}
+
+exports.ADMIN_KEYPAIR = ADMIN_KEYPAIR;
+exports.CLOCK_ID = CLOCK_ID;
+exports.Coin = Coin;
+exports.Config = Config;
+exports.DENY_LIST_ID = DENY_LIST_ID;
+exports.MoveType = MoveType;
+exports.PublishSingleton = PublishSingleton;
+exports.STATIC_CONFIGS = STATIC_CONFIGS;
+exports.SuiClient = SuiClient;
+exports.USDC = USDC;
+exports.analyze_cost = analyze_cost;
+exports.createFundedWallet = createFundedWallet;
+exports.createWallet = createWallet;
+exports.deploy = deploy;
+exports.getDeployBytes = getDeployBytes;
+exports.getKeypair = getKeypair;
+exports.sleep = sleep;
+exports.waitForNextEpoch = waitForNextEpoch;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map