@0xobelisk/sui-cli 1.2.0-pre.12 → 1.2.0-pre.121

package/src/utils/upgradeHandler.ts

@@ -7,49 +7,33 @@ import {
   getVersion,
   getUpgradeCap,
   saveContractData,
-  getOnchainSchemas,
   switchEnv,
-  getSchemaId,
-  getDubheSchemaId,
-  initializeDubhe
+  initializeDubhe,
+  getOnchainResources,
+  getStartCheckpoint,
+  appendMigrateFunction,
+  getDubheDappHubId,
+  getDappStorageId,
+  getOriginalDubhePackageId,
+  updatePublishedToml,
+  syncDubheFrameworkAddress,
+  clearPublishedTomlEntry,
+  restorePublishedTomlEntry,
+  readPublishedToml,
+  updateEphemeralPubFile,
+  getEphemeralPubFilePath,
+  updateMoveTomlAddress,
+  appendPackageIdToConfig
 } from './utils';
 import * as fs from 'fs';
 import * as path from 'path';
 import { DubheConfig } from '@0xobelisk/sui-common';
 
 type Migration = {
-  schemaName: string;
-  fields: string;
+  name: string;
+  fields: any;
 };
 
-function updateMigrateMethod(projectPath: string, migrations: Migration[]): void {
-  let filePath = `${projectPath}/sources/codegen/core/schema.move`;
-  const fileContent = fs.readFileSync(filePath, 'utf-8');
-  const migrateMethodRegex = new RegExp(
-    `public fun migrate\\(_schema: &mut Schema, _ctx: &mut TxContext\\) {[^}]*}`
-  );
-  const newMigrateMethod = `
-public fun migrate(_schema: &mut Schema, _ctx: &mut TxContext) {
-${migrations
-  .map((migration) => {
-    let storage_type = '';
-    if (migration.fields.includes('StorageValue')) {
-      storage_type = `storage_value::new(b"${migration.schemaName}", _ctx)`;
-    } else if (migration.fields.includes('StorageMap')) {
-      storage_type = `storage_map::new(b"${migration.schemaName}", _ctx)`;
-    } else if (migration.fields.includes('StorageDoubleMap')) {
-      storage_type = `storage_double_map::new(b"${migration.schemaName}", _ctx)`;
-    }
-    return `storage::add_field<${migration.fields}>(&mut _schema.id, b"${migration.schemaName}", ${storage_type});`;
-  })
-  .join('')}
-}
-`;
-
-  const updatedContent = fileContent.replace(migrateMethodRegex, newMigrateMethod);
-  fs.writeFileSync(filePath, updatedContent, 'utf-8');
-}
-
 function replaceEnvField(
   filePath: string,
   networkType: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
@@ -89,24 +73,51 @@ function replaceEnvField(
 
   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 schemaId = await getSchemaId(projectPath, network);
+  let startCheckpoint = await getStartCheckpoint(projectPath, 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 pendingMigration: Migration[] = [];
+  Object.entries(config.resources ?? {}).forEach(([key, value]) => {
+    if (!onchainResources.hasOwnProperty(key)) {
+      pendingMigration.push({ name: key, fields: value });
+    }
+  });
+
+  const tables = pendingMigration.map((migration) => migration.name);
+  // 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`,
@@ -115,33 +126,96 @@ export async function upgradeHandler(
     '0x0000000000000000000000000000000000000000000000000000000000000000'
   );
 
-  let pendingMigration: Migration[] = [];
-  let schemas = await getOnchainSchemas(projectPath, network);
-  Object.entries(config.schemas).forEach(([key, value]) => {
-    if (!schemas.hasOwnProperty(key)) {
-      pendingMigration.push({ schemaName: key, fields: value });
+  // For persistent networks (testnet/mainnet): zero out Published.toml so the
+  // package compiles with address 0x0 for upgrade.
+  // For localnet: we use --build-env testnet + Pub.localnet.toml, so Published.toml
+  // is not consulted during the build and does not need to be cleared.
+  const savedPublishedEntry =
+    network !== 'localnet' ? clearPublishedTomlEntry(projectPath, network) : undefined;
+
+  // 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' && name !== 'dubhe') {
+    const dubheProjectPath = `${cwd}/src/dubhe`;
+    const dubheEntries = readPublishedToml(dubheProjectPath);
+    const dubheEntry = dubheEntries['localnet'];
+    if (dubheEntry) {
+      const pubfilePath = getEphemeralPubFilePath(cwd, network);
+      const dubheUpgradeCap = await getUpgradeCap(dubheProjectPath, network).catch(() => '');
+      updateEphemeralPubFile(pubfilePath, dubheEntry.chainId, 'testnet', {
+        source: dubheProjectPath,
+        publishedAt: dubheEntry.publishedAt,
+        originalId: dubheEntry.originalId,
+        upgradeCap: dubheUpgradeCap
+      });
     }
-  });
-  updateMigrateMethod(projectPath, pendingMigration);
+  }
 
   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') {
+        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}`;
+      }
+
       const {
         modules: extractedModules,
         dependencies: extractedDependencies,
         digest: extractedDigest
-      } = JSON.parse(
-        execSync(`sui move build --dump-bytecode-as-base64 --path ${path}/src/${name}`, {
-          encoding: 'utf-8'
-        })
-      );
+      } = JSON.parse(execSync(buildCmd, { encoding: 'utf-8', stdio: 'pipe' }));
 
       modules = extractedModules;
       dependencies = extractedDependencies;
       digest = extractedDigest;
     } catch (error: any) {
-      throw new UpgradeError(error.stdout);
+      // Restore Published.toml before throwing (only for persistent networks)
+      if (savedPublishedEntry) {
+        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...');
@@ -200,51 +274,110 @@ export async function upgradeHandler(
     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.
+    const existingEntry = readPublishedToml(projectPath)[network];
+    const chainId = savedPublishedEntry?.chainId ?? existingEntry?.chainId ?? '';
+    updatePublishedToml(
+      projectPath,
+      network,
+      chainId,
+      newPackageId,
+      savedPublishedEntry?.originalId ?? existingEntry?.originalId ?? original_published_id,
+      oldVersion + 1
+    );
+
     saveContractData(
       name,
       network,
+      startCheckpoint,
       newPackageId,
-      schemaId,
+      original_published_id, // originalPackageId: stable across all upgrades
+      dappHubId,
       upgradeCap,
       oldVersion + 1,
-      config.schemas
+      config.resources ?? {},
+      config.enums,
+      frameworkPackageId,
+      dappStorageId || undefined
     );
 
-    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));
-
-    const migrateTx = new Transaction();
-    const newVersion = oldVersion + 1;
-    let args = [];
-    if (name !== 'dubhe') {
-      let dubheSchemaId = await getDubheSchemaId(network);
-      args.push(migrateTx.object(dubheSchemaId));
+    // 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`));
     }
-    args.push(migrateTx.object(schemaId));
-    args.push(migrateTx.pure.address(newPackageId));
-    args.push(migrateTx.pure.u32(newVersion));
-    migrateTx.moveCall({
-      target: `${newPackageId}::${name}_migrate::migrate_to_v${newVersion}`,
-      arguments: args
-    });
 
-    await dubhe.signAndSendTxn({
-      tx: migrateTx,
-      onSuccess: (result) => {
-        console.log(chalk.green(`Migration Transaction Digest: ${result.digest}`));
-      },
-      onError: (error) => {
-        console.log(
-          chalk.red('Migration Transaction failed!, Please execute the migration manually.')
+    // 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.'
+          )
         );
-        console.error(error);
       }
-    });
+
+      const migrateTx = new Transaction();
+      const newVersion = oldVersion + 1;
+      migrateTx.moveCall({
+        target: `${newPackageId}::migrate::migrate_to_v${newVersion}`,
+        arguments: [
+          migrateTx.object(dappHubId),
+          migrateTx.object(dappStorageId),
+          migrateTx.pure.address(newPackageId)
+        ]
+      });
+
+      await dubhe.signAndSendTxn({
+        tx: migrateTx,
+        onSuccess: (result) => {
+          console.log(chalk.green(`Migration Transaction Digest: ${result.digest}`));
+        },
+        onError: (error) => {
+          console.log(
+            chalk.red('Migration Transaction failed!, Please execute the migration manually.')
+          );
+          console.error(error);
+        }
+      });
+    } else {
+      console.log(`\n✅ No schema changes — migration step skipped.`);
+      // Brief delay to allow localnet to index the upgraded package before
+      // subsequent on-chain queries.
+      if (network === 'localnet') {
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+      }
+    }
   } catch (error: any) {
+    // Restore Published.toml to original state on failure (persistent networks only)
+    if (savedPublishedEntry) {
+      restorePublishedTomlEntry(projectPath, network, savedPublishedEntry);
+    }
     console.log(chalk.red('upgrade handler execution failed!'));
-    console.error(error.message);
+    throw error;
   }
 }