@0xobelisk/sui-cli 1.2.0-pre.113 → 1.2.0-pre.115

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xobelisk/sui-cli",
-  "version": "1.2.0-pre.113",
+  "version": "1.2.0-pre.115",
   "description": "Tookit for interacting with move eps framework",
   "keywords": [
     "sui",
@@ -47,8 +47,8 @@
     "yargs": "^17.7.1",
     "zod": "^3.22.3",
     "zod-validation-error": "^1.3.0",
-    "@0xobelisk/sui-client": "1.2.0-pre.113",
-    "@0xobelisk/sui-common": "1.2.0-pre.113"
+    "@0xobelisk/sui-client": "1.2.0-pre.115",
+    "@0xobelisk/sui-common": "1.2.0-pre.115"
   },
   "devDependencies": {
     "@types/cli-progress": "^3.11.5",

package/src/commands/faucet.ts

@@ -28,6 +28,7 @@ const commandModule: CommandModule<Options, Options> = {
       },
       recipient: {
         type: 'string',
+        alias: 'r',
         desc: 'Sui address to fund'
       }
     });

package/src/commands/shell.ts

@@ -132,11 +132,12 @@ const ShellCommand: CommandModule<Options, Options> = {
             } else {
               yargsInstance.options(builder);
             }
+            const userArgs = parts.slice(1);
+            const hasNetworkFlag = userArgs.includes('--network') || userArgs.includes('-n');
             const argv = yargsInstance.parseSync([
               commandName,
-              '--network',
-              network,
-              ...parts.slice(1)
+              ...(hasNetworkFlag ? [] : ['--network', network]),
+              ...userArgs
             ]);
             if (handler) {
               await handler(argv);

package/src/utils/constants.ts

@@ -1,5 +1,9 @@
-export const TESTNET_DUBHE_HUB_OBJECT_ID =
-  '0xfef203de9d3a2980429e91df535a0503ccf8d3c05aa3815936984243dc96f19f';
+export {
+  TESTNET_DUBHE_HUB_OBJECT_ID,
+  TESTNET_DUBHE_FRAMEWORK_PACKAGE_ID,
+  MAINNET_DUBHE_HUB_OBJECT_ID,
+  MAINNET_DUBHE_FRAMEWORK_PACKAGE_ID
+} from '@0xobelisk/sui-client';
 
-export const TESTNET_ORIGINAL_DUBHE_PACKAGE_ID =
-  '0x8817b4976b6c607da01cea49d728f71d09274c82e9b163fa20c2382586f8aefc';
+// Keep legacy alias for backwards compatibility within this package
+export { TESTNET_DUBHE_FRAMEWORK_PACKAGE_ID as TESTNET_ORIGINAL_DUBHE_PACKAGE_ID } from '@0xobelisk/sui-client';

package/src/utils/publishHandler.ts

@@ -265,6 +265,13 @@ async function publishContract(
   const pubfilePath =
     network === 'localnet' ? getEphemeralPubFilePath(process.cwd(), network) : undefined;
 
+  // Move.toml paths — declared early so both the Published.toml handling block and
+  // the localnet env-patching block can reference them.
+  const contractMoveTomlPath = `${projectPath}/Move.toml`;
+  const dubheMoveTomlPath = path.join(path.dirname(projectPath), 'dubhe', 'Move.toml');
+  let savedContractMoveToml: string | null = null;
+  let savedDubheMoveToml: string | null = null;
+
   // So the build uses package address 0x0: for localnet always remove the contract's
   // Published.toml; for testnet/mainnet/devnet only when --force (clear current network entry).
   // Otherwise Sui CLI bakes the existing [published.<network>] address into the bytecode and
@@ -278,11 +285,20 @@ async function publishContract(
   if (network === 'localnet' && fs.existsSync(contractPublishedTomlPath)) {
     savedContractPublishedToml = fs.readFileSync(contractPublishedTomlPath, 'utf-8');
     fs.unlinkSync(contractPublishedTomlPath);
-  } else if (force && (network === 'testnet' || network === 'mainnet' || network === 'devnet')) {
+  } else if (network === 'testnet' || network === 'mainnet' || network === 'devnet') {
     const entry = getPublishedTomlEntry(projectPath, network);
-    if (entry) {
+    if (entry && force) {
+      // Existing entry + --force: clear it so the build uses 0x0 instead of the old address.
       savedContractPublishedEntry = { network, entry };
       clearPublishedTomlEntry(projectPath, network);
+    } else if (!entry) {
+      // No Published.toml entry for this network (first-time deploy to this network).
+      // The Sui CLI has no per-network override and falls back to Move.toml's [addresses]
+      // value, which may be non-zero from a previous deployment on a different network,
+      // causing PublishErrorNonZeroAddress.
+      // Temporarily zero out Move.toml before building so the self-address is 0x0.
+      savedContractMoveToml = fs.readFileSync(contractMoveTomlPath, 'utf-8');
+      updateMoveTomlAddress(projectPath, '0x0');
     }
   }
 
@@ -300,10 +316,6 @@ async function publishContract(
   // Sui CLI 1.40+ checks that the active environment is declared in Move.toml
   // even when --build-env is specified. Temporarily inject localnet into [environments]
   // for both the contract and its dubhe dependency.
-  const contractMoveTomlPath = `${projectPath}/Move.toml`;
-  const dubheMoveTomlPath = path.join(path.dirname(projectPath), 'dubhe', 'Move.toml');
-  let savedContractMoveToml: string | null = null;
-  let savedDubheMoveToml: string | null = null;
   if (network === 'localnet') {
     savedContractMoveToml = patchMoveTomlWithLocalnetEnv(contractMoveTomlPath, chainId);
     savedDubheMoveToml = patchMoveTomlWithLocalnetEnv(dubheMoveTomlPath, chainId);
@@ -450,7 +462,11 @@ async function publishContract(
       upgradeCapId,
       version,
       resources,
-      enums
+      enums,
+      // localnet: persist the locally deployed framework ID so the SDK can be
+      // initialised without hardcoding it.  testnet/mainnet use a well-known
+      // constant already embedded in the SDK defaults, so we store undefined.
+      network === 'localnet' ? await getOriginalDubhePackageId(network) : undefined
     );
 
     await saveMetadata(dubheConfig.name, network, packageId);
@@ -459,7 +475,11 @@ async function publishContract(
     let config = JSON.parse(fs.readFileSync(`${process.cwd()}/dubhe.config.json`, 'utf-8'));
     config.original_package_id = packageId;
     config.dubhe_object_id = dubheDappHub;
-    config.original_dubhe_package_id = await getOriginalDubhePackageId(network);
+    // When deploying the dubhe framework itself, the "original dubhe package ID" is
+    // the package we just published. For user packages, look up the well-known
+    // framework address for the target network from the client config.
+    config.original_dubhe_package_id =
+      dubheConfig.name === 'dubhe' ? packageId : await getOriginalDubhePackageId(network);
     config.start_checkpoint = startCheckpoint;
 
     fs.writeFileSync(`${process.cwd()}/dubhe.config.json`, JSON.stringify(config, null, 2));
@@ -625,7 +645,10 @@ export async function publishDubheFramework(
     upgradeCapId,
     version,
     {},
-    {}
+    {},
+    // Store the localnet framework package ID so other packages can read it
+    // from deployment JSON and pass it to the Dubhe client constructor.
+    network === 'localnet' ? packageId : undefined
   );
 
   updateEnvFile(`${projectPath}/Move.lock`, network, 'publish', chainId, packageId);

package/src/utils/storeConfig.ts

@@ -1,16 +1,31 @@
 import { mkdirSync, writeFileSync } from 'fs';
 import { dirname } from 'path';
 import { DubheConfig } from '@0xobelisk/sui-common';
-import { getDeploymentJson, getDubheDappHub } from './utils';
+import { getDeploymentJson, getDubheDappHub, getOriginalDubhePackageId } from './utils';
 
 async function storeConfig(network: string, packageId: string, outputPath: string) {
   const dubheDappHub = await getDubheDappHub(network);
-  let code = `type NetworkType = 'testnet' | 'mainnet' | 'devnet' | 'localnet';
+
+  // Mirror getDubheDappHub: for localnet the framework is deployed ephemerally so we
+  // read its package ID from src/dubhe/.history/sui_localnet/latest.json (same source
+  // as DUBHE_SCHEMA_ID above).  For testnet/mainnet the SDK resolves the framework
+  // address automatically via getDefaultConfig(), so we emit undefined.
+  let frameworkPackageId: string | undefined;
+  if (network === 'localnet') {
+    frameworkPackageId = await getOriginalDubhePackageId(network);
+  }
+
+  const frameworkIdLine =
+    frameworkPackageId !== undefined
+      ? `\n// Published package ID of the dubhe framework — required for proxy operations.\nexport const FRAMEWORK_PACKAGE_ID: string | undefined = '${frameworkPackageId}';\n`
+      : `\n// Published package ID of the dubhe framework — required for proxy operations.\n// For testnet/mainnet the SDK resolves this automatically via getDefaultConfig().\nexport const FRAMEWORK_PACKAGE_ID: string | undefined = undefined;\n`;
+
+  const code = `type NetworkType = 'testnet' | 'mainnet' | 'devnet' | 'localnet';
 
 export const NETWORK: NetworkType = '${network}';
 export const PACKAGE_ID = '${packageId}';
 export const DUBHE_SCHEMA_ID = '${dubheDappHub}';
-`;
+${frameworkIdLine}`;
 
   writeOutput(code, outputPath, 'storeConfig');
 }

package/src/utils/upgradeHandler.ts

@@ -11,14 +11,15 @@ import {
   initializeDubhe,
   getOnchainResources,
   getStartCheckpoint,
-  updateGenesisUpgradeFunction,
+  appendMigrateFunction,
   getDubheDappHub,
   updatePublishedToml,
   clearPublishedTomlEntry,
   restorePublishedTomlEntry,
   readPublishedToml,
   updateEphemeralPubFile,
-  getEphemeralPubFilePath
+  getEphemeralPubFilePath,
+  updateMoveTomlAddress
 } from './utils';
 import * as fs from 'fs';
 import * as path from 'path';
@@ -96,12 +97,14 @@ export async function upgradeHandler(
   });
 
   const tables = pendingMigration.map((migration) => migration.name);
-  // Only update genesis.move when there are new tables to register.
-  // When tables is empty, there are no schema changes so no migration needed.
-  // Note: updating genesis.move also requires separator comments inserted by
-  // `dubhe schemagen`; if they are missing, the update will throw.
+  // When new resources are detected, generate the migrate_to_vN entry function in
+  // migrate.move so the on-chain migration transaction can register the new package
+  // ID and version via dapp_system::upgrade_dapp.
+  // Note: the current framework stores data as dynamic fields and does NOT use
+  // register_table; genesis::migrate() is intentionally left empty and is called
+  // from migrate_to_vN solely to keep the extension point for future use.
   if (tables.length > 0) {
-    updateGenesisUpgradeFunction(projectPath, tables);
+    appendMigrateFunction(projectPath, config.name, oldVersion + 1);
   }
 
   const original_published_id = replaceEnvField(
@@ -120,8 +123,11 @@ export async function upgradeHandler(
 
   // For localnet upgrades: refresh Pub.localnet.toml with dubhe's current address
   // so that the build can resolve the dubhe dependency.
+  // Skip this step when upgrading dubhe itself — dubhe has no local dubhe dependency,
+  // and adding its own address to the pubfile causes PublishErrorNonZeroAddress because
+  // the Sui CLI treats the root package's pubfile entry as a non-zero self-address.
   const cwd = process.cwd();
-  if (network === 'localnet') {
+  if (network === 'localnet' && name !== 'dubhe') {
     const dubheProjectPath = `${cwd}/src/dubhe`;
     const dubheEntries = readPublishedToml(dubheProjectPath);
     const dubheEntry = dubheEntries['localnet'];
@@ -139,15 +145,32 @@ export async function upgradeHandler(
 
   try {
     let modules: any, dependencies: any, digest: any;
+    // When upgrading dubhe itself on localnet, Move.toml has a non-zero 'dubhe' address
+    // (the mainnet/testnet deploy address). This gets baked into the upgrade bytecode as the
+    // self-address, causing PublishErrorNonZeroAddress. Zero it out before the build and
+    // restore it afterwards — mirroring what publishDubheFramework does.
+    let savedDubheMoveTomlContent: string | null = null;
+    if (network === 'localnet' && name === 'dubhe') {
+      const moveTomlPath = `${projectPath}/Move.toml`;
+      savedDubheMoveTomlContent = fs.readFileSync(moveTomlPath, 'utf-8');
+      updateMoveTomlAddress(projectPath, '0x0');
+    }
     try {
       // For localnet: use --build-env testnet --pubfile-path Pub.localnet.toml
       // so the package compiles with address 0x0 (not in pubfile) and links
       // against the already-published dubhe dependency (from pubfile).
+      // Exception: when upgrading dubhe itself, skip the pubfile — dubhe has no
+      // local dubhe dependency and including itself in the pubfile causes
+      // PublishErrorNonZeroAddress.
       // For testnet/mainnet: use -e <network> as usual.
       let buildCmd: string;
       if (network === 'localnet') {
-        const pubfilePath = getEphemeralPubFilePath(cwd, network);
-        buildCmd = `sui move build --dump-bytecode-as-base64 --no-tree-shaking --build-env testnet --pubfile-path ${pubfilePath} --path ${path}/src/${name}`;
+        if (name !== 'dubhe') {
+          const pubfilePath = getEphemeralPubFilePath(cwd, network);
+          buildCmd = `sui move build --dump-bytecode-as-base64 --no-tree-shaking --build-env testnet --pubfile-path ${pubfilePath} --path ${path}/src/${name}`;
+        } else {
+          buildCmd = `sui move build --dump-bytecode-as-base64 --no-tree-shaking --build-env testnet --path ${path}/src/${name}`;
+        }
       } else {
         buildCmd = `sui move build --dump-bytecode-as-base64 --no-tree-shaking -e ${network} --path ${path}/src/${name}`;
       }
@@ -167,6 +190,11 @@ export async function upgradeHandler(
         restorePublishedTomlEntry(projectPath, network, savedPublishedEntry);
       }
       throw new UpgradeError(error.stdout || error.stderr || error.message);
+    } finally {
+      // Always restore dubhe Move.toml after build (success or error)
+      if (savedDubheMoveTomlContent !== null) {
+        fs.writeFileSync(`${projectPath}/Move.toml`, savedDubheMoveTomlContent, 'utf-8');
+      }
     }
 
     console.log('\n🚀 Starting Upgrade Process...');

package/src/utils/utils.ts

@@ -6,10 +6,15 @@ import { FsIibError } from './errors';
 import * as fs from 'fs';
 import chalk from 'chalk';
 import { spawn } from 'child_process';
-import { Dubhe, NetworkType, SuiMoveNormalizedModules, loadMetadata } from '@0xobelisk/sui-client';
+import {
+  Dubhe,
+  NetworkType,
+  SuiMoveNormalizedModules,
+  loadMetadata,
+  getDefaultConfig
+} from '@0xobelisk/sui-client';
 import { DubheCliError } from './errors';
 import { Component, MoveType, DubheConfig } from '@0xobelisk/sui-common';
-import { TESTNET_DUBHE_HUB_OBJECT_ID, TESTNET_ORIGINAL_DUBHE_PACKAGE_ID } from './constants';
 
 export type DeploymentJsonType = {
   projectName: string;
@@ -21,6 +26,12 @@ export type DeploymentJsonType = {
   version: number;
   resources: Record<string, Component | MoveType>;
   enums?: Record<string, string[]>;
+  /**
+   * Published package ID of the Dubhe framework used by this deployment.
+   * Populated for localnet (ephemeral deploy); undefined for testnet/mainnet
+   * where the SDK already knows the well-known constant.
+   */
+  frameworkPackageId?: string;
 };
 
 export function validatePrivateKey(privateKey: string): false | string {
@@ -96,36 +107,36 @@ export async function getDubheDappHub(network: string) {
   const path = process.cwd();
   const contractPath = `${path}/src/dubhe`;
 
-  switch (network) {
-    case 'mainnet':
-      return TESTNET_DUBHE_HUB_OBJECT_ID;
-    case 'testnet':
-      return TESTNET_DUBHE_HUB_OBJECT_ID;
-    case 'devnet':
-      return TESTNET_DUBHE_HUB_OBJECT_ID;
-    case 'localnet':
-      return await getDeploymentDappHub(contractPath, 'localnet');
-    default:
-      throw new Error(`Invalid network: ${network}`);
+  if (network === 'localnet') {
+    return await getDeploymentDappHub(contractPath, 'localnet');
+  }
+
+  const config = getDefaultConfig(network as NetworkType);
+  if (!config.dappHubId) {
+    throw new Error(
+      `DappHub object ID is not configured for network "${network}". ` +
+        `Update MAINNET_DUBHE_HUB_OBJECT_ID / TESTNET_DUBHE_HUB_OBJECT_ID in @0xobelisk/sui-client.`
+    );
   }
+  return config.dappHubId;
 }
 
 export async function getOriginalDubhePackageId(network: string) {
   const path = process.cwd();
   const contractPath = `${path}/src/dubhe`;
 
-  switch (network) {
-    case 'mainnet':
-      return TESTNET_ORIGINAL_DUBHE_PACKAGE_ID;
-    case 'testnet':
-      return TESTNET_ORIGINAL_DUBHE_PACKAGE_ID;
-    case 'devnet':
-      return TESTNET_ORIGINAL_DUBHE_PACKAGE_ID;
-    case 'localnet':
-      return await getOldPackageId(contractPath, network);
-    default:
-      throw new Error(`Invalid network: ${network}`);
+  if (network === 'localnet') {
+    return await getOldPackageId(contractPath, network);
+  }
+
+  const config = getDefaultConfig(network as NetworkType);
+  if (!config.frameworkPackageId) {
+    throw new Error(
+      `Framework package ID is not configured for network "${network}". ` +
+        `Update MAINNET_DUBHE_FRAMEWORK_PACKAGE_ID / TESTNET_DUBHE_FRAMEWORK_PACKAGE_ID in @0xobelisk/sui-client.`
+    );
   }
+  return config.frameworkPackageId;
 }
 export async function getOnchainResources(
   projectPath: string,
@@ -158,6 +169,14 @@ export async function getDappHub(projectPath: string, network: string): Promise<
   return deployment.dappHub;
 }
 
+export async function getFrameworkPackageIdFromDeployment(
+  projectPath: string,
+  network: string
+): Promise<string | undefined> {
+  const deployment = await getDeploymentJson(projectPath, network);
+  return deployment.frameworkPackageId;
+}
+
 export async function getUpgradeCap(projectPath: string, network: string): Promise<string> {
   const deployment = await getDeploymentJson(projectPath, network);
   return deployment.upgradeCap;
@@ -177,7 +196,8 @@ export async function saveContractData(
   upgradeCap: string,
   version: number,
   resources: Record<string, Component | MoveType>,
-  enums?: Record<string, string[]>
+  enums?: Record<string, string[]>,
+  frameworkPackageId?: string
 ) {
   const DeploymentData: DeploymentJsonType = {
     projectName,
@@ -188,7 +208,8 @@ export async function saveContractData(
     upgradeCap,
     version,
     resources,
-    enums
+    enums,
+    frameworkPackageId
   };
 
   const path = process.cwd();
@@ -929,3 +950,53 @@ export function updateGenesisUpgradeFunction(path: string, tables: string[]) {
 
   fs.writeFileSync(genesisPath, updatedContent, 'utf-8');
 }
+
+/**
+ * Appends a `migrate_to_vN` entry function to the package's migrate.move.
+ *
+ * This function is called by upgradeHandler when new resources are detected
+ * (pendingMigration.length > 0). The generated function delegates to
+ * `genesis::migrate`, which provides an extension point (separator comments)
+ * for any future resource-registration steps. The `new_package_id` and
+ * `new_version` arguments are kept in the signature to match the on-chain
+ * call emitted by upgradeHandler even though dapp_system::upgrade_dapp is
+ * public(package) in dubhe and cannot be called from external packages.
+ */
+export function appendMigrateFunction(
+  projectPath: string,
+  packageName: string,
+  newVersion: number
+): void {
+  const migratePath = `${projectPath}/sources/scripts/migrate.move`;
+  if (!fs.existsSync(migratePath)) {
+    throw new Error(`migrate.move not found at ${migratePath}`);
+  }
+
+  const content = fs.readFileSync(migratePath, 'utf-8');
+
+  // Idempotency: skip if the function already exists
+  if (content.includes(`migrate_to_v${newVersion}`)) {
+    return;
+  }
+
+  const migrateFunction = `
+    public entry fun migrate_to_v${newVersion}(
+        dapp_hub: &mut dubhe::dapp_service::DappHub,
+        _new_package_id: address,
+        _new_version: u32,
+        ctx: &mut TxContext
+    ) {
+        ${packageName}::genesis::migrate(dapp_hub, ctx);
+    }
+`;
+
+  // Insert the new function before the closing brace of the module
+  const closingBraceIdx = content.lastIndexOf('}');
+  if (closingBraceIdx === -1) {
+    throw new Error(`Could not find closing brace in ${migratePath}`);
+  }
+
+  const updated =
+    content.slice(0, closingBraceIdx) + migrateFunction + content.slice(closingBraceIdx);
+  fs.writeFileSync(migratePath, updated, 'utf-8');
+}