@0xobelisk/sui-cli 0.4.9

package/src/commands/test.ts

@@ -0,0 +1,38 @@
+import type { CommandModule } from "yargs";
+import { execSync } from "child_process";
+import chalk from "chalk";
+
+type Options = {
+  packagePath: string;
+};
+
+const commandModule: CommandModule<Options, Options> = {
+  command: "test",
+
+  describe: "Run tests in Obelisk contracts",
+
+  builder(yargs) {
+    return yargs.options({
+      packagePath: {
+        type: "string",
+        default: ".",
+        description: "Options to pass to forge test",
+      },
+    });
+  },
+
+  async handler({ packagePath }) {
+    // Start an internal anvil process if no world address is provided
+    try {
+      execSync(`sui move test --path ${packagePath}`, {
+        encoding: "utf-8",
+      });
+    } catch (error: any) {
+      console.error(chalk.red("Error executing sui move test:"));
+      console.log(error.stdout);
+      process.exit(0);
+    }
+  },
+};
+
+export default commandModule;

package/src/commands/upgrade.ts

@@ -0,0 +1,53 @@
+import type { CommandModule } from "yargs";
+import { logError } from "../utils/errors";
+import { upgradeHandler } from "../utils";
+import { ObeliskConfig, loadConfig, ValueType } from "@0xobelisk/sui-common";
+
+type Options = {
+  network: any;
+  configPath: string;
+};
+
+const commandModule: CommandModule<Options, Options> = {
+  command: "upgrade",
+
+  describe: "Upgrade your move contracts",
+
+  builder(yargs) {
+    return yargs.options({
+      network: {
+        type: "string",
+        choices: ["mainnet", "testnet", "devnet", "localnet"],
+        desc: "Network of the node (mainnet/testnet/devnet/localnet)",
+      },
+      configPath: {
+        type: "string",
+        default: "obelisk.config.ts",
+        decs: "Path to the config file",
+      },
+    });
+  },
+
+  async handler({ network, configPath }) {
+    try {
+      const obeliskConfig = (await loadConfig(configPath)) as ObeliskConfig;
+
+      let schemaNames = Object.keys(obeliskConfig.schemas).filter(
+        (key) =>
+          !(
+            typeof obeliskConfig.schemas === "object" &&
+            "ephemeral" in obeliskConfig.schemas &&
+            (obeliskConfig.schemas[key] as ValueType).ephemeral
+          )
+      );
+
+      await upgradeHandler(obeliskConfig.name, network, schemaNames);
+    } catch (error: any) {
+      logError(error);
+      process.exit(1);
+    }
+    process.exit(0);
+  },
+};
+
+export default commandModule;

package/src/modules.d.ts

@@ -0,0 +1,11 @@
+// adding .js to minimal would break clients down the line because it probably won't get a synthetic default import
+/* eslint-disable @typescript-eslint/no-explicit-any */
+declare module "protobufjs/minimal" {
+  export const configure: any;
+  export const util: any;
+  export const Reader: any;
+  export type Reader = any;
+  export const Writer: any;
+  export type Writer = any;
+}
+declare module "rollup-plugin-preserve-shebang";

package/src/obelisk.ts

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { commands } from "./commands";
+import { logError } from "./utils/errors";
+
+// Load .env file into process.env
+import * as dotenv from "dotenv";
+import chalk from "chalk";
+dotenv.config();
+
+yargs(hideBin(process.argv))
+  // Explicit name to display in help (by default it's the entry file, which may not be "obelisk" for e.g. ts-node)
+  .scriptName("obelisk")
+  // Use the commands directory to scaffold
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- command array overload isn't typed, see https://github.com/yargs/yargs/blob/main/docs/advanced.md#esm-hierarchy
+  .command(commands as any)
+  // Enable strict mode.
+  .strict()
+  // Custom error handler
+  .fail((msg, err) => {
+    console.error(chalk.red(msg));
+    if (msg.includes("Missing required argument")) {
+      console.log(
+        chalk.yellow(`Run 'pnpm obelisk ${process.argv[2]} --help' for a list of available and required arguments.`)
+      );
+    }
+    console.log("");
+    logError(err);
+    console.log("");
+
+    process.exit(1);
+  })
+  // Useful aliases.
+  .alias({ h: "help" }).argv;

package/src/utils/errors.ts

@@ -0,0 +1,46 @@
+import chalk from "chalk";
+import { ZodError } from "zod";
+import { fromZodError, ValidationError } from "zod-validation-error";
+
+export class NotInsideProjectError extends Error {
+  name = "NotInsideProjectError";
+  message = "You are not inside a Obelisk project";
+}
+
+export class ObeliskCliError extends Error {
+  name = "ObeliskCliError";
+}
+
+export class UpgradeError extends Error {
+  name = "UpgradeError";
+}
+
+export class FsIibError extends Error {
+  name = "FsIibError";
+}
+
+export function logError(error: unknown) {
+  if (error instanceof ValidationError) {
+    console.log(chalk.redBright(error.message));
+  } else if (error instanceof ZodError) {
+    // TODO currently this error shouldn't happen, use `fromZodErrorCustom`
+    const validationError = fromZodError(error, {
+      prefixSeparator: "\n- ",
+      issueSeparator: "\n- ",
+    });
+    console.log(chalk.redBright(validationError.message));
+  } else if (error instanceof NotInsideProjectError) {
+    console.log(chalk.red(error.message));
+    console.log("");
+    // TODO add docs to the website and update the link to the specific page
+    console.log(
+      chalk.blue(
+        `To learn more about Obelisk's configuration, please go to https://github.com/0xobelisk`
+      )
+    );
+  } else if (error instanceof ObeliskCliError) {
+    console.log(chalk.red(error));
+  } else {
+    console.log(error);
+  }
+}

package/src/utils/index.ts

@@ -0,0 +1,5 @@
+export * from "./publishHandler";
+export * from "./upgradeHandler";
+export * from "./errors";
+export * from "./printObelisk";
+export * from "./utils";

package/src/utils/printObelisk.ts

@@ -0,0 +1,20 @@
+import chalk from "chalk";
+
+export function printObelisk() {
+  console.log(
+    chalk.yellow(`
+Welcome to obelisk world
+\t\t\t --from team@obelisk
+ ________  ________  _______   ___       ___  ________  ___  __       
+|\\   __  \\|\\   __  \\|\\  ___ \\ |\\  \\     |\\  \\|\\   ____\\|\\  \\|\\  \\     
+\\ \\  \\|\\  \\ \\  \\|\\ /\\ \\   __/|\\ \\  \\    \\ \\  \\ \\  \\___|\\ \\  \\/  /|_   
+ \\ \\  \\\\\\  \\ \\   __  \\ \\  \\_|/_\\ \\  \\    \\ \\  \\ \\_____  \\ \\   ___  \\  
+  \\ \\  \\\\\\  \\ \\  \\|\\  \\ \\  \\_|\\ \\ \\  \\____\\ \\  \\|____|\\  \\ \\  \\\\ \\  \\ 
+   \\ \\_______\\ \\_______\\ \\_______\\ \\_______\\ \\__\\____\\_\\  \\ \\__\\\\ \\__\\
+    \\|_______|\\|_______|\\|_______|\\|_______|\\|__|\\_________\\|__| \\|__|
+                                                \\|_________|          
+                                                                      
+                                                                      
+`)
+  );
+}

package/src/utils/publishHandler.ts

@@ -0,0 +1,184 @@
+import { TransactionBlock } from "@mysten/sui.js/transactions";
+import { Ed25519Keypair } from "@mysten/sui.js/keypairs/ed25519";
+import {
+  getFullnodeUrl,
+  SuiClient,
+  SuiTransactionBlockResponse,
+} from "@mysten/sui.js/client";
+import { execSync } from "child_process";
+import chalk from "chalk";
+import { ObeliskCliError } from "./errors";
+import {
+  updateVersionInFile,
+  saveContractData,
+  validatePrivateKey,
+} from "./utils";
+
+export async function publishHandler(
+  name: string,
+  network: "mainnet" | "testnet" | "devnet" | "localnet"
+) {
+  const path = process.cwd();
+  const projectPath = `${path}/contracts/${name}`;
+
+  const privateKey = process.env.PRIVATE_KEY;
+  if (!privateKey)
+    throw new ObeliskCliError(
+      `Missing PRIVATE_KEY environment variable.
+Run 'echo "PRIVATE_KEY=YOUR_PRIVATE_KEY" > .env'
+in your contracts directory to use the default sui private key.`
+    );
+
+  const privateKeyFormat = validatePrivateKey(privateKey);
+  if (privateKeyFormat === false) {
+    throw new ObeliskCliError(`Please check your privateKey.`);
+  }
+  const privateKeyRaw = Buffer.from(privateKeyFormat as string, "hex");
+  const keypair = Ed25519Keypair.fromSecretKey(privateKeyRaw);
+  const client = new SuiClient({
+    url: getFullnodeUrl(network),
+  });
+
+  // Set version 1
+  await updateVersionInFile(projectPath, "1");
+  let modules: any, dependencies: any;
+  try {
+    const { modules: extractedModules, dependencies: extractedDependencies } =
+      JSON.parse(
+        execSync(
+          `sui move build --dump-bytecode-as-base64 --path ${projectPath}`,
+          {
+            encoding: "utf-8",
+          }
+        )
+      );
+    modules = extractedModules;
+    dependencies = extractedDependencies;
+  } catch (error: any) {
+    console.error(chalk.red("Error executing sui move build:"));
+    console.error(error.stdout);
+    process.exit(1); // You might want to exit with a non-zero status code to indicate an error
+  }
+
+  console.log(chalk.blue(`Account: ${keypair.toSuiAddress()}`));
+
+  const tx = new TransactionBlock();
+  const [upgradeCap] = tx.publish({
+    modules,
+    dependencies,
+  });
+  tx.transferObjects(
+    [upgradeCap],
+    tx.pure(keypair.getPublicKey().toSuiAddress())
+  );
+
+  let result: SuiTransactionBlockResponse;
+  try {
+    result = await client.signAndExecuteTransactionBlock({
+      signer: keypair,
+      transactionBlock: tx,
+      options: {
+        showObjectChanges: true,
+      },
+    });
+  } catch (error: any) {
+    console.error(chalk.red(`Failed to execute publish, please republish`));
+    console.error(error.message);
+    process.exit(1);
+  }
+
+  if (result.effects?.status.status === "failure") {
+    console.log(chalk.red(`Failed to execute publish, please republish`));
+    process.exit(1);
+  }
+
+  let version = 1;
+  let packageId = "";
+  let worldId = "";
+  let upgradeCapId = "";
+  let adminCapId = "";
+  result.objectChanges!.map((object) => {
+    if (object.type === "published") {
+      console.log(chalk.blue(`${name} PackageId: ${object.packageId}`));
+      packageId = object.packageId;
+    }
+    if (
+      object.type === "created" &&
+      object.objectType.endsWith("::world::World")
+    ) {
+      console.log(chalk.blue(`${name} WorldId: ${object.objectId}`));
+      worldId = object.objectId;
+    }
+    if (
+      object.type === "created" &&
+      object.objectType === "0x2::package::UpgradeCap"
+    ) {
+      console.log(chalk.blue(`${name} UpgradeCap: ${object.objectId}`));
+      upgradeCapId = object.objectId;
+    }
+    if (
+      object.type === "created" &&
+      object.objectType.endsWith("::world::AdminCap")
+    ) {
+      console.log(chalk.blue(`${name} AdminCapId: ${object.objectId}`));
+      adminCapId = object.objectId;
+    }
+  });
+
+  console.log(chalk.green(`Publish transaction digest: ${result.digest}`));
+
+  saveContractData(
+    name,
+    network,
+    packageId,
+    worldId,
+    upgradeCapId,
+    adminCapId,
+    version
+  );
+
+  console.log("Executing the deployHook: ");
+  const delay = (ms: number) =>
+    new Promise((resolve) => setTimeout(resolve, ms));
+  await delay(5000);
+
+  const deployHookTx = new TransactionBlock();
+
+  deployHookTx.moveCall({
+    target: `${packageId}::deploy_hook::run`,
+    arguments: [deployHookTx.object(worldId), deployHookTx.object(adminCapId)],
+  });
+
+  let deployHookResult: SuiTransactionBlockResponse;
+  try {
+    deployHookResult = await client.signAndExecuteTransactionBlock({
+      signer: keypair,
+      transactionBlock: deployHookTx,
+      options: {
+        showEffects: true,
+      },
+    });
+  } catch (error: any) {
+    console.error(
+      chalk.red(
+        `Failed to execute deployHook, please republish or manually call deploy_hook::run`
+      )
+    );
+    console.error(error.message);
+    process.exit(1);
+  }
+
+  if (deployHookResult.effects?.status.status === "success") {
+    console.log(
+      chalk.green(
+        `Successful auto-execution of deployHook, please check the transaction digest: ${deployHookResult.digest}`
+      )
+    );
+  } else {
+    console.log(
+      chalk.yellow(
+        `Failed to execute deployHook, please republish or manually call deploy_hook::run`
+      )
+    );
+  }
+}

package/src/utils/upgradeHandler.ts

@@ -0,0 +1,237 @@
+import { TransactionBlock, UpgradePolicy } from "@mysten/sui.js/transactions";
+import { Ed25519Keypair } from "@mysten/sui.js/keypairs/ed25519";
+import { getFullnodeUrl, SuiClient } from "@mysten/sui.js/client";
+import { execSync } from "child_process";
+import chalk from "chalk";
+import { ObeliskCliError, UpgradeError } from "./errors";
+import {
+  updateVersionInFile,
+  getOldPackageId,
+  getVersion,
+  getWorldId,
+  getUpgradeCap,
+  saveContractData,
+  validatePrivateKey,
+  getAdminCap,
+} from "./utils";
+
+type ObjectContent = {
+  type: string;
+  fields: Record<string, any>;
+  hasPublicTransfer: boolean;
+  dataType: string;
+};
+
+export async function upgradeHandler(
+  name: string,
+  network: "mainnet" | "testnet" | "devnet" | "localnet",
+  schemaNames: string[]
+) {
+  const path = process.cwd();
+  const projectPath = `${path}/contracts/${name}`;
+  const privateKey = process.env.PRIVATE_KEY;
+  if (!privateKey)
+    throw new ObeliskCliError(
+      `Missing PRIVATE_KEY environment variable.
+Run 'echo "PRIVATE_KEY=YOUR_PRIVATE_KEY" > .env'
+in your contracts directory to use the default sui private key.`
+    );
+
+  const privateKeyFormat = validatePrivateKey(privateKey);
+  if (privateKeyFormat === false) {
+    throw new ObeliskCliError(`Please check your privateKey.`);
+  }
+  const privateKeyRaw = Buffer.from(privateKeyFormat as string, "hex");
+  const keypair = Ed25519Keypair.fromSecretKey(privateKeyRaw);
+
+  const client = new SuiClient({
+    url: getFullnodeUrl(network),
+  });
+
+  let oldVersion = Number(await getVersion(projectPath, network));
+  let oldPackageId = await getOldPackageId(projectPath, network);
+  let worldId = await getWorldId(projectPath, network);
+  let upgradeCap = await getUpgradeCap(projectPath, network);
+  let adminCap = await getAdminCap(projectPath, network);
+
+  const newVersion = oldVersion + 1;
+  await updateVersionInFile(projectPath, newVersion.toString());
+
+  try {
+    let modules: any, dependencies: any, digest: any;
+    try {
+      const {
+        modules: extractedModules,
+        dependencies: extractedDependencies,
+        digest: extractedDigest,
+      } = JSON.parse(
+        execSync(
+          `sui move build --dump-bytecode-as-base64 --path ${path}/contracts/${name}`,
+          {
+            encoding: "utf-8",
+          }
+        )
+      );
+
+      modules = extractedModules;
+      dependencies = extractedDependencies;
+      digest = extractedDigest;
+    } catch (error: any) {
+      throw new UpgradeError(error.stdout);
+    }
+
+    const tx = new TransactionBlock();
+    const ticket = tx.moveCall({
+      target: "0x2::package::authorize_upgrade",
+      arguments: [
+        tx.object(upgradeCap),
+        tx.pure(UpgradePolicy.COMPATIBLE),
+        tx.pure(digest),
+      ],
+    });
+
+    const receipt = tx.upgrade({
+      modules,
+      dependencies,
+      packageId: oldPackageId,
+      ticket,
+    });
+
+    tx.moveCall({
+      target: "0x2::package::commit_upgrade",
+      arguments: [tx.object(upgradeCap), receipt],
+    });
+
+    tx.transferObjects(
+      [tx.object(upgradeCap)],
+      tx.pure(keypair.getPublicKey().toSuiAddress())
+    );
+
+    const result = await client.signAndExecuteTransactionBlock({
+      signer: keypair,
+      transactionBlock: tx,
+      options: {
+        showObjectChanges: true,
+      },
+    });
+
+    console.log("");
+    console.log(`${name} WorldId: ${worldId}`);
+
+    let newPackageId = "";
+    let newUpgradeCap = "";
+    result.objectChanges!.map((object) => {
+      if (object.type === "published") {
+        console.log(chalk.blue(`${name} PackageId: ${object.packageId}`));
+        newPackageId = object.packageId;
+      }
+      if (
+        object.type === "mutated" &&
+        object.objectType === "0x2::package::UpgradeCap"
+      ) {
+        console.log(chalk.blue(`${name} UpgradeCap: ${object.objectId}`));
+        newUpgradeCap = object.objectId;
+      }
+    });
+
+    console.log(chalk.green(`Upgrade Transaction Digest: ${result.digest}`));
+
+    saveContractData(
+      name,
+      network,
+      newPackageId,
+      worldId,
+      newUpgradeCap,
+      adminCap,
+      newVersion
+    );
+
+    oldPackageId = newPackageId;
+    upgradeCap = newUpgradeCap;
+    oldVersion = newVersion;
+
+    console.log("\nExecuting the migrate: ");
+    const delay = (ms: number) =>
+      new Promise((resolve) => setTimeout(resolve, ms));
+    await delay(5000);
+
+    const migrateTx = new TransactionBlock();
+    migrateTx.moveCall({
+      target: `${newPackageId}::world::migrate`,
+      arguments: [migrateTx.object(worldId), migrateTx.object(adminCap)],
+    });
+
+    let newWorldObject = await client.getObject({
+      id: worldId,
+      options: {
+        showContent: true,
+        showDisplay: true,
+        showType: true,
+        showOwner: true,
+      },
+    });
+    let newObjectContent = newWorldObject.data!.content as ObjectContent;
+
+    const uniqueSchema: string[] = schemaNames.filter(
+      (item) => !newObjectContent.fields["schema_names"].includes(item)
+    );
+
+    console.log("new schema:", uniqueSchema);
+    let needRegisterSchema = [];
+    for (const newSchema of uniqueSchema) {
+      migrateTx.moveCall({
+        target: `${newPackageId}::${newSchema}_schema::register`,
+        arguments: [migrateTx.object(worldId), migrateTx.object(adminCap)],
+      });
+      needRegisterSchema.push(`${newSchema}_schema`);
+    }
+    const migrateResult = await client.signAndExecuteTransactionBlock({
+      signer: keypair,
+      transactionBlock: migrateTx,
+      options: {
+        showEffects: true,
+      },
+    });
+
+    if (migrateResult.effects?.status.status === "success") {
+      console.log(
+        chalk.green(
+          `${name} migrate world success, new world version is: ${newObjectContent.fields["version"]}, package version is ${newVersion}`
+        )
+      );
+      if (needRegisterSchema.length !== 0) {
+        console.log(
+          chalk.green(
+            `new schema: ${needRegisterSchema.toString()} register success.`
+          )
+        );
+      }
+
+      console.log(
+        chalk.blue(
+          `\n${name} world schemas is ${newObjectContent.fields["schema_names"]}`
+        )
+      );
+    } else {
+      console.log(
+        chalk.red(
+          `${name} migrate world failed, world version is: ${newObjectContent.fields["version"]}, package version is ${newVersion}`
+        )
+      );
+    }
+  } catch (error: any) {
+    console.log(chalk.red("Upgrade failed!"));
+    console.error(error.message);
+
+    saveContractData(
+      name,
+      network,
+      oldPackageId,
+      worldId,
+      upgradeCap,
+      adminCap,
+      oldVersion
+    );
+    await updateVersionInFile(projectPath, oldVersion.toString());
+  }
+}