@0xobelisk/sui-cli 1.2.0-pre.98 → 2.0.0

package/src/utils/upgradeHandler.ts

@@ -10,19 +10,23 @@ import {
   switchEnv,
   initializeDubhe,
   getOnchainResources,
-  getOnchainComponents,
   getStartCheckpoint,
-  updateGenesisUpgradeFunction,
-  getDubheDappHub,
+  appendMigrateFunction,
+  getDubheDappHubId,
+  getDappStorageId,
+  getOriginalDubhePackageId,
   updatePublishedToml,
+  syncDubheFrameworkAddress,
   clearPublishedTomlEntry,
   restorePublishedTomlEntry,
   readPublishedToml,
   updateEphemeralPubFile,
-  getEphemeralPubFilePath
+  getEphemeralPubFilePath,
+  updateMoveTomlAddress,
+  appendPackageIdToConfig,
+  removeEnvFromMoveLock
 } from './utils';
 import * as fs from 'fs';
-import * as path from 'path';
 import { DubheConfig } from '@0xobelisk/sui-common';
 
 type Migration = {
@@ -30,93 +34,56 @@ type Migration = {
   fields: any;
 };
 
-function replaceEnvField(
-  filePath: string,
-  networkType: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
-  field: 'original-published-id' | 'latest-published-id' | 'published-version',
-  newValue: string
-): string {
-  const envFilePath = path.resolve(filePath);
-  const envContent = fs.readFileSync(envFilePath, 'utf-8');
-  const envLines = envContent.split('\n');
-
-  const networkSectionIndex = envLines.findIndex((line) => line.trim() === `[env.${networkType}]`);
-  if (networkSectionIndex === -1) {
-    console.log(`Network type [env.${networkType}] not found in the file.`);
-    return '';
-  }
-
-  let fieldIndex = -1;
-  let previousValue: string = '';
-  for (let i = networkSectionIndex + 1; i < envLines.length; i++) {
-    const line = envLines[i].trim();
-    if (line.startsWith('[')) break; // End of the current network section
-
-    if (line.startsWith(field)) {
-      fieldIndex = i;
-      previousValue = line.split('=')[1].trim().replace(/"/g, '');
-      break;
-    }
-  }
-
-  if (fieldIndex !== -1) {
-    envLines[fieldIndex] = `${field} = "${newValue}"`;
-    const newEnvContent = envLines.join('\n');
-    fs.writeFileSync(envFilePath, newEnvContent, 'utf-8');
-  } else {
-    console.log(`${field} not found for [env.${networkType}].`);
-  }
-
-  return previousValue;
-}
-
 export async function upgradeHandler(
   config: DubheConfig,
   name: string,
-  network: 'mainnet' | 'testnet' | 'devnet' | 'localnet'
+  network: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
+  bumpVersion: boolean = false,
+  fullnodeUrls?: string[]
 ) {
-  await switchEnv(network);
+  await switchEnv(network, fullnodeUrls?.[0]);
 
   const path = process.cwd();
   const projectPath = `${path}/src/${name}`;
 
-  const dubhe = initializeDubhe({ network });
+  const dubhe = initializeDubhe({ network, fullnodeUrls });
 
   let oldVersion = Number(await getVersion(projectPath, network));
   let oldPackageId = await getOldPackageId(projectPath, network);
   let upgradeCap = await getUpgradeCap(projectPath, network);
   let startCheckpoint = await getStartCheckpoint(projectPath, network);
-  let dappHub = await getDubheDappHub(network);
+  let dappHubId = await getDubheDappHubId(network);
+  let dappStorageId = await getDappStorageId(projectPath, network);
+  // For localnet the framework is deployed ephemerally; preserve its package ID in .history.
+  const frameworkPackageId =
+    network === 'localnet' ? await getOriginalDubhePackageId(network) : undefined;
   let onchainResources = await getOnchainResources(projectPath, network);
-  let onchainComponents = await getOnchainComponents(projectPath, network);
 
   let pendingMigration: Migration[] = [];
-  Object.entries(config.resources).forEach(([key, value]) => {
+  Object.entries(config.resources ?? {}).forEach(([key, value]) => {
     if (!onchainResources.hasOwnProperty(key)) {
       pendingMigration.push({ name: key, fields: value });
     }
   });
-  Object.entries(config.components).forEach(([key, value]) => {
-    if (!onchainComponents.hasOwnProperty(key)) {
-      pendingMigration.push({ name: key, fields: value });
-    }
-  });
 
   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.
-  if (tables.length > 0) {
-    updateGenesisUpgradeFunction(projectPath, tables);
+  // Trigger migration when new resources were detected (schema change) OR when the
+  // caller explicitly requested a version bump (--bump-version flag). The latter
+  // covers breaking logic changes and security fixes that must invalidate old clients
+  // even though no new resources were added.
+  const needsMigration = tables.length > 0 || bumpVersion;
+  if (needsMigration) {
+    if (bumpVersion && tables.length === 0) {
+      console.log(chalk.yellow('--bump-version: forcing version bump with no schema changes.'));
+    }
+    appendMigrateFunction(projectPath, config.name, oldVersion + 1);
   }
 
-  const original_published_id = replaceEnvField(
-    `${projectPath}/Move.lock`,
-    network,
-    'original-published-id',
-    '0x0000000000000000000000000000000000000000000000000000000000000000'
-  );
+  // Read original_published_id from Published.toml before clearing it.
+  // Published.toml is the canonical source of truth for deployed addresses;
+  // Move.lock [env.*] is owned by the Sui CLI and must not be read or written
+  // by our toolchain.
+  const original_published_id = readPublishedToml(projectPath)[network]?.originalId ?? '';
 
   // For persistent networks (testnet/mainnet): zero out Published.toml so the
   // package compiles with address 0x0 for upgrade.
@@ -125,10 +92,28 @@ export async function upgradeHandler(
   const savedPublishedEntry =
     network !== 'localnet' ? clearPublishedTomlEntry(projectPath, network) : undefined;
 
+  // Clear Move.lock [env.*] so the Sui CLI does not pick up a stale non-zero
+  // address and fail with PublishErrorNonZeroAddress during build.
+  // We intentionally do NOT write it back afterwards — Published.toml is the
+  // source of truth and the Sui CLI will regenerate the lock section if needed.
+  removeEnvFromMoveLock(`${projectPath}/Move.lock`, network);
+
+  // For testnet/mainnet: auto-sync src/dubhe/Published.toml to the canonical
+  // framework address from the SDK before building.  Prevents
+  // VMVerificationOrDeserializationError when the framework was redeployed
+  // since the Published.toml was last written.  Skip when upgrading dubhe itself.
+  if (name !== 'dubhe' && (network === 'testnet' || network === 'mainnet')) {
+    const chainId = await dubhe.suiInteractor.currentClient.getChainIdentifier();
+    syncDubheFrameworkAddress(path, network, chainId);
+  }
+
   // 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'];
@@ -146,15 +131,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}`;
       }
@@ -174,6 +176,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...');
@@ -223,15 +230,6 @@ export async function upgradeHandler(
       }
     });
 
-    replaceEnvField(
-      `${projectPath}/Move.lock`,
-      network,
-      'original-published-id',
-      original_published_id
-    );
-    replaceEnvField(`${projectPath}/Move.lock`, network, 'latest-published-id', newPackageId);
-    replaceEnvField(`${projectPath}/Move.lock`, network, 'published-version', oldVersion + 1 + '');
-
     // Update Published.toml with the new package ID after upgrade.
     // For localnet: savedPublishedEntry is undefined (we skip clearPublishedTomlEntry),
     // so fall back to reading the current Published.toml entry for chainId/originalId.
@@ -251,33 +249,62 @@ export async function upgradeHandler(
       network,
       startCheckpoint,
       newPackageId,
-      dappHub,
+      original_published_id, // originalPackageId: stable across all upgrades
+      dappHubId,
       upgradeCap,
       oldVersion + 1,
-      config.components,
-      config.resources,
-      config.enums
+      config.resources ?? {},
+      config.enums,
+      frameworkPackageId,
+      dappStorageId || undefined
     );
 
-    // Only run the migration transaction if there are pending schema changes.
-    // A "bug-fix" upgrade with no new fields does not need a migration call.
-    // The migrate_to_vX function is only generated by `dubhe schemagen` when
-    // new components / resources are added.
-    if (pendingMigration.length > 0) {
-      console.log(`\n🚀 Starting Migration Process...`);
-      pendingMigration.forEach((migration) => {
-        console.log('📋 Added Fields:', JSON.stringify(migration, null, 2));
-      });
-      await new Promise((resolve) => setTimeout(resolve, 5000));
+    // Append the new package ID to dubhe.config.json so the indexer can verify
+    // event.type_.address against all known package versions on next startup.
+    const configJsonPath = `${process.cwd()}/dubhe.config.json`;
+    appendPackageIdToConfig(configJsonPath, newPackageId);
+    if (fs.existsSync(configJsonPath)) {
+      console.log(chalk.green(`✅ Appended ${newPackageId} to dubhe.config.json package_ids`));
+    }
+
+    // Only run the migration transaction if there are pending schema changes or a
+    // forced version bump was requested via --bump-version.
+    // A pure "bug-fix" upgrade with no new fields and no --bump-version flag does
+    // not need a migration call — old and new package can coexist safely.
+    if (needsMigration) {
+      if (pendingMigration.length > 0) {
+        console.log(`\n🚀 Starting Migration Process...`);
+        pendingMigration.forEach((migration) => {
+          console.log('📋 Added Fields:', JSON.stringify(migration, null, 2));
+        });
+      } else {
+        console.log(`\n🚀 Starting Migration Process (forced version bump)...`);
+      }
+
+      // On localnet the indexer may lag behind the chain; give it time to register
+      // the newly upgraded package before the migration transaction references it.
+      // On testnet/mainnet the validator processes state immediately — no delay needed.
+      if (network === 'localnet') {
+        await new Promise((resolve) => setTimeout(resolve, 5000));
+      }
+
+      if (!dappStorageId) {
+        console.warn(
+          chalk.yellow(
+            'Warning: dappStorageId not found in latest.json. ' +
+              'Re-publish the contract to capture it, or pass DappStorage manually.'
+          )
+        );
+      }
 
       const migrateTx = new Transaction();
       const newVersion = oldVersion + 1;
       migrateTx.moveCall({
         target: `${newPackageId}::migrate::migrate_to_v${newVersion}`,
         arguments: [
-          migrateTx.object(dappHub),
-          migrateTx.pure.address(newPackageId),
-          migrateTx.pure.u32(newVersion)
+          migrateTx.object(dappHubId),
+          migrateTx.object(dappStorageId),
+          migrateTx.pure.address(newPackageId)
         ]
       });
 
@@ -297,7 +324,9 @@ export async function upgradeHandler(
       console.log(`\n✅ No schema changes — migration step skipped.`);
       // Brief delay to allow localnet to index the upgraded package before
       // subsequent on-chain queries.
-      await new Promise((resolve) => setTimeout(resolve, 2000));
+      if (network === 'localnet') {
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+      }
     }
   } catch (error: any) {
     // Restore Published.toml to original state on failure (persistent networks only)