@0xobelisk/sui-cli 1.2.0-pre.11 → 1.2.0-pre.112

package/src/utils/upgradeHandler.ts

@@ -7,48 +7,28 @@ import {
   getVersion,
   getUpgradeCap,
   saveContractData,
-  getOnchainSchemas,
   switchEnv,
-  getSchemaId,
-  initializeDubhe
+  initializeDubhe,
+  getOnchainResources,
+  getStartCheckpoint,
+  updateGenesisUpgradeFunction,
+  getDubheDappHub,
+  updatePublishedToml,
+  clearPublishedTomlEntry,
+  restorePublishedTomlEntry,
+  readPublishedToml,
+  updateEphemeralPubFile,
+  getEphemeralPubFilePath
 } 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',
@@ -88,6 +68,7 @@ function replaceEnvField(
 
   return previousValue;
 }
+
 export async function upgradeHandler(
   config: DubheConfig,
   name: string,
@@ -96,16 +77,32 @@ export async function upgradeHandler(
   await switchEnv(network);
 
   const path = process.cwd();
-  const projectPath = `${path}/contracts/${name}`;
+  const projectPath = `${path}/src/${name}`;
 
-  const dubhe = initializeDubhe({
-    network
-  });
+  const dubhe = initializeDubhe({ network });
 
   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 dappHub = await getDubheDappHub(network);
+  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);
+  // 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);
+  }
 
   const original_published_id = replaceEnvField(
     `${projectPath}/Move.lock`,
@@ -114,33 +111,62 @@ 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 localnet upgrades: refresh Pub.localnet.toml with dubhe's current address
+  // so that the build can resolve the dubhe dependency.
+  const cwd = process.cwd();
+  if (network === 'localnet') {
+    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;
     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).
+      // 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}`;
+      } 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}/contracts/${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);
     }
 
     console.log('\n🚀 Starting Upgrade Process...');
@@ -199,51 +225,78 @@ 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,
+      dappHub,
       upgradeCap,
       oldVersion + 1,
-      config.schemas
+      config.resources,
+      config.enums
     );
 
-    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 getSchemaId(`${process.cwd()}/contracts/dubhe-framework`, network);
-      args.push(migrateTx.object(dubheSchemaId));
-    }
-    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
-    });
+    // 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));
 
-    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);
-      }
-    });
+      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)
+        ]
+      });
+
+      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.
+      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;
   }
 }