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

package/src/utils/publishHandler.ts

@@ -3,19 +3,50 @@ import { execSync } from 'child_process';
 import chalk from 'chalk';
 import {
   saveContractData,
-  updateDubheDependency,
+  updateMoveTomlAddress,
   switchEnv,
   delay,
-  getDubheSchemaId,
-  initializeDubhe
+  getDubheDappHubId,
+  initializeDubhe,
+  saveMetadata,
+  getOriginalDubhePackageId,
+  updatePublishedToml,
+  syncDubheFrameworkAddress,
+  updateEphemeralPubFile,
+  getEphemeralPubFilePath,
+  getPublishedTomlEntry,
+  clearPublishedTomlEntry,
+  restorePublishedTomlEntry
 } from './utils';
 import { DubheConfig } from '@0xobelisk/sui-common';
 import * as fs from 'fs';
 import * as path from 'path';
 
-const MAX_RETRIES = 60; // 60s timeout
-const RETRY_INTERVAL = 1000; // 1s retry interval
-const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+/**
+ * Temporarily add localnet to Move.toml [environments] section before building.
+ * Sui CLI 1.40+ requires the active environment to be declared in Move.toml even
+ * when --build-env is specified. This patches the file and returns the original
+ * content so the caller can restore it in a finally block.
+ * Returns null if no changes were needed.
+ */
+function patchMoveTomlWithLocalnetEnv(moveTomlPath: string, chainId: string): string | null {
+  if (!fs.existsSync(moveTomlPath)) return null;
+  const content = fs.readFileSync(moveTomlPath, 'utf-8');
+
+  if (content.includes('localnet')) {
+    return null;
+  }
+
+  let updatedContent: string;
+  if (content.includes('[environments]')) {
+    updatedContent = content.replace('[environments]', `[environments]\nlocalnet = "${chainId}"`);
+  } else {
+    updatedContent = content.trimEnd() + `\n\n[environments]\nlocalnet = "${chainId}"\n`;
+  }
+
+  fs.writeFileSync(moveTomlPath, updatedContent, 'utf-8');
+  return content;
+}
 
 async function removeEnvContent(
   filePath: string,
@@ -127,21 +158,53 @@ published-version = "${config.publishedVersion}"
 // 	return segments.length > 0 ? segments[segments.length - 1] : '';
 // }
 
-function buildContract(projectPath: string): string[][] {
+/**
+ * Build a Move package and return [modules, dependencies] as base64 arrays.
+ *
+ * For localnet (ephemeral) networks:
+ *   - Uses --build-env testnet so dependency addresses are resolved via testnet
+ *     Published.toml (no need to add 'localnet' to Move.toml [environments]).
+ *   - Optionally reads a Pub.localnet.toml pubfile for already-published local deps.
+ *   - This matches the Sui docs approach:
+ *     https://docs.sui.io/guides/developer/packages/move-package-management
+ *
+ * For persistent networks (testnet/mainnet/devnet): uses -e <network> as before.
+ */
+function buildContract(
+  projectPath: string,
+  network?: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
+  pubfilePath?: string
+): string[][] {
   let modules: any, dependencies: any;
   try {
+    let buildEnvFlag: string;
+    if (network === 'localnet') {
+      // Ephemeral approach: resolve deps via testnet configuration.
+      // --pubfile-path supplies already-published local dep addresses (e.g. dubhe).
+      buildEnvFlag = ' --build-env testnet';
+      if (pubfilePath) {
+        buildEnvFlag += ` --pubfile-path ${pubfilePath}`;
+      }
+    } else {
+      buildEnvFlag = network ? ` -e ${network}` : '';
+    }
+
+    // --no-tree-shaking avoids on-chain RPC calls during build.
     const buildResult = JSON.parse(
-      execSync(`sui move build --dump-bytecode-as-base64 --path ${projectPath}`, {
-        encoding: 'utf-8',
-        stdio: 'pipe'
-      })
+      execSync(
+        `sui move build --dump-bytecode-as-base64 --no-tree-shaking${buildEnvFlag} --path ${projectPath}`,
+        {
+          encoding: 'utf-8',
+          stdio: 'pipe'
+        }
+      )
     );
     modules = buildResult.modules;
     dependencies = buildResult.dependencies;
   } catch (error: any) {
     console.error(chalk.red('  └─ Build failed'));
-    console.error(error.stdout);
-    process.exit(1);
+    console.error(error.stdout || error.stderr);
+    throw new Error(`Build failed: ${error.stdout || error.stderr || error.message}`);
   }
   return [modules, dependencies];
 }
@@ -154,132 +217,28 @@ interface ObjectChange {
 }
 
 async function waitForNode(dubhe: Dubhe): Promise<string> {
-  let retryCount = 0;
-  let spinnerIndex = 0;
-  const startTime = Date.now();
-  let isInterrupted = false;
-  let chainId = '';
-  let hasShownBalanceWarning = false;
-
-  const handleInterrupt = () => {
-    isInterrupted = true;
-    process.stdout.write('\r' + ' '.repeat(50) + '\r');
-    console.log('\n  └─ Operation cancelled by user');
-    process.exit(0);
-  };
-  process.on('SIGINT', handleInterrupt);
-
-  try {
-    // 第一阶段：等待获取 chainId
-    while (retryCount < MAX_RETRIES && !isInterrupted && !chainId) {
-      try {
-        chainId = await dubhe.suiInteractor.currentClient.getChainIdentifier();
-      } catch (error) {
-        // 忽略错误，继续重试
-      }
-
-      if (isInterrupted) break;
-
-      if (!chainId) {
-        retryCount++;
-        if (retryCount === MAX_RETRIES) {
-          console.log(chalk.red(`  └─ Failed to connect to node after ${MAX_RETRIES} attempts`));
-          console.log(chalk.red('  └─ Please check if the Sui node is running.'));
-          process.exit(1);
-        }
-
-        const elapsedTime = Math.floor((Date.now() - startTime) / 1000);
-        const spinner = SPINNER[spinnerIndex % SPINNER.length];
-        spinnerIndex++;
-
-        process.stdout.write(`\r  ├─ ${spinner} Waiting for node... (${elapsedTime}s)`);
-        await new Promise((resolve) => setTimeout(resolve, RETRY_INTERVAL));
-      }
-    }
-
-    // 显示 chainId
-    process.stdout.write('\r' + ' '.repeat(50) + '\r');
-    console.log(`  ├─ ChainId: ${chainId}`);
-
-    // 第二阶段：检查部署账户余额
-    retryCount = 0;
-    while (retryCount < MAX_RETRIES && !isInterrupted) {
-      try {
-        const address = dubhe.getAddress();
-        const coins = await dubhe.suiInteractor.currentClient.getCoins({
-          owner: address,
-          coinType: '0x2::sui::SUI'
-        });
-
-        if (coins.data.length > 0) {
-          const balance = coins.data.reduce((sum, coin) => sum + Number(coin.balance), 0);
-          if (balance > 0) {
-            process.stdout.write('\r' + ' '.repeat(50) + '\r');
-            console.log(`  ├─ Deployer balance: ${balance / 10 ** 9} SUI`);
-            return chainId;
-          } else if (!hasShownBalanceWarning) {
-            process.stdout.write('\r' + ' '.repeat(50) + '\r');
-            console.log(
-              chalk.yellow(
-                `  ├─ Deployer balance: 0 SUI, please ensure your account has sufficient SUI balance`
-              )
-            );
-            hasShownBalanceWarning = true;
-          }
-        } else if (!hasShownBalanceWarning) {
-          process.stdout.write('\r' + ' '.repeat(50) + '\r');
-          console.log(
-            chalk.yellow(
-              `  ├─ No SUI coins found in deployer account, please ensure your account has sufficient SUI balance`
-            )
-          );
-          hasShownBalanceWarning = true;
-        }
-
-        retryCount++;
-        if (retryCount === MAX_RETRIES) {
-          console.log(
-            chalk.red(`  └─ Deployer account has no SUI balance after ${MAX_RETRIES} attempts`)
-          );
-          console.log(chalk.red('  └─ Please ensure your account has sufficient SUI balance.'));
-          process.exit(1);
-        }
-
-        const elapsedTime = Math.floor((Date.now() - startTime) / 1000);
-        const spinner = SPINNER[spinnerIndex % SPINNER.length];
-        spinnerIndex++;
-
-        process.stdout.write(`\r  ├─ ${spinner} Checking deployer balance... (${elapsedTime}s)`);
-        await new Promise((resolve) => setTimeout(resolve, RETRY_INTERVAL));
-      } catch (error) {
-        if (isInterrupted) break;
-
-        retryCount++;
-        if (retryCount === MAX_RETRIES) {
-          console.log(
-            chalk.red(`  └─ Failed to check deployer balance after ${MAX_RETRIES} attempts`)
-          );
-          console.log(chalk.red('  └─ Please check your account and network connection.'));
-          process.exit(1);
-        }
-
-        const elapsedTime = Math.floor((Date.now() - startTime) / 1000);
-        const spinner = SPINNER[spinnerIndex % SPINNER.length];
-        spinnerIndex++;
+  const chainId = await dubhe.suiInteractor.currentClient.getChainIdentifier();
+  console.log(`  ├─ ChainId: ${chainId}`);
+  const address = dubhe.getAddress();
+  const coins = await dubhe.suiInteractor.currentClient.getCoins({
+    owner: address,
+    coinType: '0x2::sui::SUI'
+  });
 
-        process.stdout.write(`\r  ├─ ${spinner} Checking deployer balance... (${elapsedTime}s)`);
-        await new Promise((resolve) => setTimeout(resolve, RETRY_INTERVAL));
-      }
+  if (coins.data.length > 0) {
+    const balance = coins.data.reduce((sum, coin) => sum + Number(coin.balance), 0);
+    if (balance > 0) {
+      console.log(`  ├─ Deployer balance: ${balance / 10 ** 9} SUI`);
+      return chainId;
+    } else {
+      console.log(
+        chalk.yellow(
+          `  ├─ Deployer balance: 0 SUI, please ensure your account has sufficient SUI balance`
+        )
+      );
     }
-  } finally {
-    process.removeListener('SIGINT', handleInterrupt);
-  }
-
-  if (isInterrupted) {
-    process.exit(0);
   }
-
-  throw new Error('Failed to connect to node');
+  return chainId;
 }
 
 async function publishContract(
@@ -287,7 +246,9 @@ async function publishContract(
   dubheConfig: DubheConfig,
   network: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
   projectPath: string,
-  gasBudget?: number
+  gasBudget?: number,
+  force?: boolean,
+  fullnodeUrls?: string[]
 ) {
   console.log('\n🚀 Starting Contract Publication...');
   console.log(`  ├─ Project: ${projectPath}`);
@@ -300,8 +261,116 @@ async function publishContract(
   await removeEnvContent(`${projectPath}/Move.lock`, network);
   console.log(`  └─ Account: ${dubhe.getAddress()}`);
 
+  // Ensure src/dubhe/Published.toml references the canonical framework address
+  // for this network before building.  This is a no-op when the address is
+  // already current, and automatically corrects stale entries whenever the
+  // framework is redeployed on testnet/mainnet without a manual file update.
+  if (dubheConfig.name !== 'dubhe') {
+    syncDubheFrameworkAddress(process.cwd(), network, chainId);
+  }
+
   console.log('\n📦 Building Contract...');
-  const [modules, dependencies] = buildContract(projectPath);
+  // For localnet: pass the ephemeral pubfile so the build system can resolve
+  // the dubhe dependency that was just published in publishDubheFramework().
+  // If the file was written for a different chain (node restarted with
+  // --force-regenesis), discard it to avoid a chain-id mismatch build error.
+  let pubfilePath =
+    network === 'localnet' ? getEphemeralPubFilePath(process.cwd(), network) : undefined;
+  if (pubfilePath && fs.existsSync(pubfilePath)) {
+    const pubfileContent = fs.readFileSync(pubfilePath, 'utf-8');
+    const chainIdMatch = pubfileContent.match(/^chain-id\s*=\s*"([^"]*)"/m);
+    const pubfileChainId = chainIdMatch ? chainIdMatch[1] : '';
+    if (pubfileChainId && pubfileChainId !== chainId) {
+      console.log(
+        chalk.yellow(
+          `  ├─ Stale Pub.localnet.toml (chain ${pubfileChainId} → ${chainId}), discarding`
+        )
+      );
+      fs.unlinkSync(pubfilePath);
+      pubfilePath = 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
+  // the chain rejects with PublishErrorNonZeroAddress.
+  const contractPublishedTomlPath = `${projectPath}/Published.toml`;
+  let savedContractPublishedToml: string | null = null;
+  let savedContractPublishedEntry: {
+    network: string;
+    entry: Exclude<ReturnType<typeof getPublishedTomlEntry>, undefined>;
+  } | null = null;
+  if (network === 'localnet' && fs.existsSync(contractPublishedTomlPath)) {
+    savedContractPublishedToml = fs.readFileSync(contractPublishedTomlPath, 'utf-8');
+    fs.unlinkSync(contractPublishedTomlPath);
+  } else if (network === 'testnet' || network === 'mainnet' || network === 'devnet') {
+    const entry = getPublishedTomlEntry(projectPath, network);
+    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');
+    }
+  }
+
+  // For localnet: also temporarily remove dubhe's Published.toml when building the
+  // contract package. After publishDubheFramework restores dubhe/Published.toml, its
+  // testnet entry's original-id may be "0x0", which collides with the contract package's
+  // own address (also 0x0 before publish), triggering a spurious cyclic-dependency error.
+  const dubhePublishedTomlPath = path.join(path.dirname(projectPath), 'dubhe', 'Published.toml');
+  let savedDubhePublishedToml: string | null = null;
+  if (network === 'localnet' && fs.existsSync(dubhePublishedTomlPath)) {
+    savedDubhePublishedToml = fs.readFileSync(dubhePublishedTomlPath, 'utf-8');
+    fs.unlinkSync(dubhePublishedTomlPath);
+  }
+
+  // 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.
+  if (network === 'localnet') {
+    savedContractMoveToml = patchMoveTomlWithLocalnetEnv(contractMoveTomlPath, chainId);
+    savedDubheMoveToml = patchMoveTomlWithLocalnetEnv(dubheMoveTomlPath, chainId);
+  }
+
+  let modules: any, dependencies: any;
+  try {
+    [modules, dependencies] = buildContract(projectPath, network, pubfilePath);
+  } finally {
+    if (savedContractPublishedToml !== null) {
+      fs.writeFileSync(contractPublishedTomlPath, savedContractPublishedToml, 'utf-8');
+    }
+    if (savedContractPublishedEntry !== null) {
+      restorePublishedTomlEntry(
+        projectPath,
+        savedContractPublishedEntry.network,
+        savedContractPublishedEntry.entry
+      );
+    }
+    if (savedDubhePublishedToml !== null) {
+      fs.writeFileSync(dubhePublishedTomlPath, savedDubhePublishedToml, 'utf-8');
+    }
+    if (savedContractMoveToml !== null) {
+      fs.writeFileSync(contractMoveTomlPath, savedContractMoveToml, 'utf-8');
+    }
+    if (savedDubheMoveToml !== null) {
+      fs.writeFileSync(dubheMoveTomlPath, savedDubheMoveToml, 'utf-8');
+    }
+  }
 
   console.log('\n🔄 Publishing Contract...');
   const tx = new Transaction();
@@ -311,63 +380,38 @@ async function publishContract(
   const [upgradeCap] = tx.publish({ modules, dependencies });
   tx.transferObjects([upgradeCap], dubhe.getAddress());
 
-  let result: any = null;
-  let retryCount = 0;
-  let spinnerIndex = 0;
-  const startTime = Date.now();
-  let isInterrupted = false;
-
-  const handleInterrupt = () => {
-    isInterrupted = true;
-    process.stdout.write('\r' + ' '.repeat(50) + '\r');
-    console.log('\n  └─ Operation cancelled by user');
-    process.exit(0);
-  };
-  process.on('SIGINT', handleInterrupt);
-
+  let result;
   try {
-    while (retryCount < MAX_RETRIES && !result && !isInterrupted) {
-      try {
-        result = await dubhe.signAndSendTxn({ tx });
-      } catch (error) {
-        if (isInterrupted) break;
-
-        retryCount++;
-        if (retryCount === MAX_RETRIES) {
-          console.log(chalk.red(`  └─ Publication failed after ${MAX_RETRIES} attempts`));
-          console.log(chalk.red('  └─ Please check your network connection and try again later.'));
-          process.exit(1);
-        }
-
-        const elapsedTime = Math.floor((Date.now() - startTime) / 1000);
-        const spinner = SPINNER[spinnerIndex % SPINNER.length];
-        spinnerIndex++;
-
-        process.stdout.write(`\r  ├─ ${spinner} Retrying... (${elapsedTime}s)`);
-        await new Promise((resolve) => setTimeout(resolve, RETRY_INTERVAL));
-      }
+    result = await dubhe.signAndSendTxn({ tx });
+  } catch (error: any) {
+    console.error(chalk.red('  └─ Publication failed'));
+    console.error(error.message);
+    if (
+      !force &&
+      (network === 'testnet' || network === 'mainnet' || network === 'devnet') &&
+      /PublishErrorNonZeroAddress/i.test(String(error?.message))
+    ) {
+      console.error(
+        chalk.yellow(
+          '  Tip: This package may already be published on this network. Use --force to clear the stored address and publish as new, or use "dubhe upgrade" to update the existing package.'
+        )
+      );
     }
-  } finally {
-    process.removeListener('SIGINT', handleInterrupt);
+    throw new Error(`Contract publication failed: ${error.message}`);
   }
 
-  if (isInterrupted) {
-    process.exit(0);
-  }
-
-  process.stdout.write('\r' + ' '.repeat(50) + '\r');
-
   if (!result || result.effects?.status.status === 'failure') {
-    console.log(chalk.red('  └─ Publication failed'));
-    process.exit(1);
+    throw new Error('Contract publication transaction failed');
   }
 
   console.log('  ├─ Processing publication results...');
   let version = 1;
   let packageId = '';
-  let schemaId = '';
-  let schemas = dubheConfig.schemas;
+  let dappHubId = '';
+  let resources = dubheConfig.resources ?? {};
+  let enums = dubheConfig.enums;
   let upgradeCapId = '';
+  let startCheckpoint = '';
 
   let printObjects: any[] = [];
 
@@ -384,6 +428,13 @@ async function publishContract(
       console.log(`  ├─ Upgrade Cap: ${object.objectId}`);
       upgradeCapId = object.objectId || '';
     }
+    if (
+      object.type === 'created' &&
+      object.objectType &&
+      object.objectType.includes('dapp_service::DappHub')
+    ) {
+      dappHubId = object.objectId || '';
+    }
     if (object.type === 'created') {
       printObjects.push(object);
     }
@@ -392,19 +443,25 @@ async function publishContract(
   console.log(`  └─ Transaction: ${result.digest}`);
 
   updateEnvFile(`${projectPath}/Move.lock`, network, 'publish', chainId, packageId);
+  updatePublishedToml(projectPath, network, chainId, packageId, packageId, 1);
 
   console.log('\n⚡ Executing Deploy Hook...');
   await delay(5000);
 
+  startCheckpoint = await dubhe.suiInteractor.currentClient.getLatestCheckpointSequenceNumber();
+
   const deployHookTx = new Transaction();
   let args = [];
+  let frameworkDappHubId =
+    dubheConfig.name === 'dubhe' ? dappHubId : await getDubheDappHubId(network);
+  args.push(deployHookTx.object(frameworkDappHubId));
+  // Dubhe framework genesis::run(dapp_hub, ctx) does not take clock.
+  // DApp genesis::run(dapp_hub, clock, ctx) still takes clock.
   if (dubheConfig.name !== 'dubhe') {
-    let dubheSchemaId = await getDubheSchemaId(network);
-    args.push(deployHookTx.object(dubheSchemaId));
+    args.push(deployHookTx.object('0x6'));
   }
-  args.push(deployHookTx.object('0x6'));
   deployHookTx.moveCall({
-    target: `${packageId}::${dubheConfig.name}_genesis::run`,
+    target: `${packageId}::genesis::run`,
     arguments: args
   });
 
@@ -414,53 +471,82 @@ async function publishContract(
   } catch (error: any) {
     console.error(chalk.red('  └─ Deploy hook execution failed'));
     console.error(error.message);
-    process.exit(1);
+    throw new Error(`genesis::run failed: ${error.message}`);
   }
 
   if (deployHookResult.effects?.status.status === 'success') {
     console.log('  ├─ Hook execution successful');
     console.log(`  ├─ Transaction: ${deployHookResult.digest}`);
 
-    console.log('\n📋 Created Objects:');
-    deployHookResult.objectChanges?.map((object: ObjectChange) => {
+    // Capture the DappStorage object created by genesis::run so we can persist
+    // its ID for later use in migrate_to_vN transactions during upgrades.
+    let dappStorageId = '';
+    deployHookResult.objectChanges!.map((object: ObjectChange) => {
       if (
         object.type === 'created' &&
         object.objectType &&
-        object.objectType.includes('schema::Schema')
+        object.objectType.includes('dapp_service::DappStorage')
       ) {
-        schemaId = object.objectId || '';
-      }
-      if (
-        object.type === 'created' &&
-        object.objectType &&
-        object.objectType.includes('schema') &&
-        !object.objectType.includes('dynamic_field')
-      ) {
-        printObjects.push(object);
+        dappStorageId = object.objectId || '';
+        console.log(`  ├─ DappStorage: ${dappStorageId}`);
       }
     });
 
+    console.log('\n📋 Created Objects:');
     printObjects.map((object: ObjectChange) => {
-      console.log(`  ├─ Type: ${object.objectType}`);
-      console.log(`  └─ ID: ${object.objectId}`);
+      console.log(`  ├─ ID: ${object.objectId}`);
+      console.log(`  └─ Type: ${object.objectType}`);
     });
 
-    saveContractData(
+    await saveContractData(
       dubheConfig.name,
       network,
+      startCheckpoint,
       packageId,
-      schemaId,
+      packageId, // originalPackageId: first publish, so original == current
+      frameworkDappHubId,
       upgradeCapId,
       version,
-      schemas
+      resources,
+      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,
+      dappStorageId || undefined
     );
+
+    await saveMetadata(dubheConfig.name, network, packageId, fullnodeUrls);
+
+    // Insert package id to dubhe config
+    let config = JSON.parse(fs.readFileSync(`${process.cwd()}/dubhe.config.json`, 'utf-8'));
+    config.original_package_id = packageId;
+    // Initialize the trusted package address list. The indexer uses this list to verify
+    // event.type_.address so that forged events from other contracts are rejected even
+    // when they embed the same dapp_key string.
+    config.package_ids = [packageId];
+    config.dubhe_object_id = frameworkDappHubId;
+    // 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;
+    // Canonical dapp_key type string: stable across upgrades, no "0x" prefix, padded to 64 hex chars.
+    // Matches the Move type_name::with_defining_ids<DappKey>().into_string() format.
+    const pkgHex = packageId.replace(/^0x/i, '').padStart(64, '0');
+    config.dapp_key = `${pkgHex}::dapp_key::DappKey`;
+    // Persist the DappStorage object ID so store-config can include it in deployment.ts
+    // and upgrade transactions can reference it without reading from .history.
+    if (dappStorageId) {
+      config.dapp_storage_id = dappStorageId;
+    }
+
+    fs.writeFileSync(`${process.cwd()}/dubhe.config.json`, JSON.stringify(config, null, 2));
+
     console.log('\n✅ Contract Publication Complete\n');
   } else {
-    console.log(chalk.yellow('  └─ Deploy hook execution failed'));
-    console.log(chalk.yellow('     Please republish or manually call deploy_hook::run'));
-    console.log(chalk.yellow('     Please check the transaction digest:'));
-    console.log(chalk.yellow(`     ${deployHookResult.digest}`));
-    process.exit(1);
+    throw new Error(`genesis::run transaction failed. Digest: ${deployHookResult.digest}`);
   }
 }
 
@@ -469,15 +555,13 @@ async function checkDubheFramework(projectPath: string): Promise<boolean> {
     console.log(chalk.yellow('\nℹ️ Dubhe Framework Files Not Found'));
     console.log(chalk.yellow('  ├─ Expected Path:'), projectPath);
     console.log(chalk.yellow('  ├─ To set up Dubhe Framework:'));
-    console.log(chalk.yellow('  │  1. Create directory: mkdir -p contracts/dubhe'));
+    console.log(chalk.yellow('  │  1. Create directory: mkdir -p src/dubhe'));
     console.log(
       chalk.yellow(
-        '  │  2. Clone repository: git clone https://github.com/0xobelisk/dubhe contracts/dubhe'
+        '  │  2. Clone repository: git clone https://github.com/0xobelisk/dubhe src/dubhe'
       )
     );
-    console.log(
-      chalk.yellow('  │  3. Or download from: https://github.com/0xobelisk/dubhe')
-    );
+    console.log(chalk.yellow('  │  3. Or download from: https://github.com/0xobelisk/dubhe'));
     console.log(chalk.yellow('  └─ After setup, restart the local node'));
     return false;
   }
@@ -488,8 +572,8 @@ export async function publishDubheFramework(
   dubhe: Dubhe,
   network: 'mainnet' | 'testnet' | 'devnet' | 'localnet'
 ) {
-  const path = process.cwd();
-  const projectPath = `${path}/src/dubhe`;
+  const cwd = process.cwd();
+  const projectPath = `${cwd}/src/dubhe`;
 
   if (!(await checkDubheFramework(projectPath))) {
     return;
@@ -501,66 +585,72 @@ export async function publishDubheFramework(
   const chainId = await waitForNode(dubhe);
 
   await removeEnvContent(`${projectPath}/Move.lock`, network);
-  const [modules, dependencies] = buildContract(projectPath);
-  const tx = new Transaction();
-  const [upgradeCap] = tx.publish({ modules, dependencies });
-  tx.transferObjects([upgradeCap], dubhe.getAddress());
+  if (network === 'localnet') {
+    // When building with --build-env testnet, Sui CLI reads Move.lock's [env.testnet] section
+    // and bakes its original-published-id (non-zero for a previously published dubhe) into the
+    // bytecode as the package self-address. Publishing then fails with PublishErrorNonZeroAddress
+    // because Sui requires the self-address to be 0x0 for a first-time publish.
+    // Fix: clear the testnet env section before building so the CLI uses 0x0 from Move.toml.
+    await removeEnvContent(`${projectPath}/Move.lock`, 'testnet');
+  }
+  await updateMoveTomlAddress(projectPath, '0x0');
+
+  const startCheckpoint =
+    await dubhe.suiInteractor.currentClient.getLatestCheckpointSequenceNumber();
+
+  // For localnet: --build-env testnet is used to resolve git dependencies, but the
+  // Move CLI will also read Published.toml and use any existing testnet address for
+  // dubhe — causing PublishErrorNonZeroAddress if a testnet entry already exists.
+  // Fix: temporarily remove Published.toml before the build, then restore it.
+  // This ensures the dubhe package compiles with address 0x0 (from Move.toml).
+  const publishedTomlPath = `${projectPath}/Published.toml`;
+  let savedPublishedTomlContent: string | null = null;
+  if (network === 'localnet' && fs.existsSync(publishedTomlPath)) {
+    savedPublishedTomlContent = fs.readFileSync(publishedTomlPath, 'utf-8');
+    fs.unlinkSync(publishedTomlPath);
+  }
 
-  let result: any = null;
-  let retryCount = 0;
-  let spinnerIndex = 0;
-  const startTime = Date.now();
-  let isInterrupted = false;
-
-  const handleInterrupt = () => {
-    isInterrupted = true;
-    process.stdout.write('\r' + ' '.repeat(50) + '\r');
-    console.log('\n  └─ Operation cancelled by user');
-    process.exit(0);
-  };
-  process.on('SIGINT', handleInterrupt);
+  // 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].
+  const moveTomlPath = `${projectPath}/Move.toml`;
+  let savedMoveTomlContent: string | null = null;
+  if (network === 'localnet') {
+    savedMoveTomlContent = patchMoveTomlWithLocalnetEnv(moveTomlPath, chainId);
+  }
 
+  let modules: any, dependencies: any;
   try {
-    while (retryCount < MAX_RETRIES && !result && !isInterrupted) {
-      try {
-        result = await dubhe.signAndSendTxn({ tx });
-      } catch (error) {
-        if (isInterrupted) break;
-
-        retryCount++;
-        if (retryCount === MAX_RETRIES) {
-          console.log(chalk.red(`  └─ Publication failed after ${MAX_RETRIES} attempts`));
-          console.log(chalk.red('  └─ Please check your network connection and try again later.'));
-          process.exit(1);
-        }
-
-        const elapsedTime = Math.floor((Date.now() - startTime) / 1000);
-        const spinner = SPINNER[spinnerIndex % SPINNER.length];
-        spinnerIndex++;
-
-        process.stdout.write(`\r  ├─ ${spinner} Retrying... (${elapsedTime}s)`);
-        await new Promise((resolve) => setTimeout(resolve, RETRY_INTERVAL));
-      }
-    }
+    [modules, dependencies] = buildContract(projectPath, network);
   } finally {
-    process.removeListener('SIGINT', handleInterrupt);
+    // Always restore Published.toml and Move.toml (successful build or error)
+    if (savedPublishedTomlContent !== null) {
+      fs.writeFileSync(publishedTomlPath, savedPublishedTomlContent, 'utf-8');
+    }
+    if (savedMoveTomlContent !== null) {
+      fs.writeFileSync(moveTomlPath, savedMoveTomlContent, 'utf-8');
+    }
   }
 
-  if (isInterrupted) {
-    process.exit(0);
-  }
+  const tx = new Transaction();
+  const [upgradeCap] = tx.publish({ modules, dependencies });
+  tx.transferObjects([upgradeCap], dubhe.getAddress());
 
-  process.stdout.write('\r' + ' '.repeat(50) + '\r');
+  let result;
+  try {
+    result = await dubhe.signAndSendTxn({ tx });
+  } catch (error: any) {
+    console.error(chalk.red('  └─ Publication failed'));
+    console.error(error.message);
+    throw new Error(`Dubhe framework publication failed: ${error.message}`);
+  }
 
   if (!result || result.effects?.status.status === 'failure') {
-    console.log(chalk.red('  └─ Publication failed'));
-    process.exit(1);
+    throw new Error('Dubhe framework publication transaction failed');
   }
 
   let version = 1;
   let packageId = '';
-  let schemaId = '';
-  let schemas: Record<string, string> = {};
+  let dappHubId = '';
   let upgradeCapId = '';
 
   result.objectChanges!.map((object: ObjectChange) => {
@@ -574,14 +664,21 @@ export async function publishDubheFramework(
     ) {
       upgradeCapId = object.objectId || '';
     }
+    if (
+      object.type === 'created' &&
+      object.objectType &&
+      object.objectType.includes('dapp_service::DappHub')
+    ) {
+      dappHubId = object.objectId || '';
+    }
   });
 
   await delay(3000);
-
   const deployHookTx = new Transaction();
+  // Dubhe framework genesis::run(dapp_hub, ctx) — clock no longer required.
   deployHookTx.moveCall({
-    target: `${packageId}::dubhe_genesis::run`,
-    arguments: [deployHookTx.object('0x6')]
+    target: `${packageId}::genesis::run`,
+    arguments: [deployHookTx.object(dappHubId)]
   });
 
   let deployHookResult;
@@ -590,44 +687,66 @@ export async function publishDubheFramework(
   } catch (error: any) {
     console.error(chalk.red('  └─ Deploy hook execution failed'));
     console.error(error.message);
-    process.exit(1);
+    throw new Error(`Dubhe genesis::run failed: ${error.message}`);
   }
 
-  if (deployHookResult.effects?.status.status === 'success') {
-    deployHookResult.objectChanges?.map((object: ObjectChange) => {
-      if (
-        object.type === 'created' &&
-        object.objectType &&
-        object.objectType.includes('dubhe_schema::Schema')
-      ) {
-        schemaId = object.objectId || '';
-      }
-    });
+  if (deployHookResult.effects?.status.status !== 'success') {
+    throw new Error('Deploy hook execution failed');
   }
 
-  saveContractData('dubhe', network, packageId, schemaId, upgradeCapId, version, schemas);
+  await updateMoveTomlAddress(projectPath, packageId);
+  await saveContractData(
+    'dubhe',
+    network,
+    startCheckpoint,
+    packageId,
+    packageId, // originalPackageId: first publish, original == current
+    dappHubId,
+    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);
-  await delay(1000);
+  updatePublishedToml(projectPath, network, chainId, packageId, packageId, 1);
+
+  // For localnet: write dubhe's published address to Pub.localnet.toml so that
+  // the counter package build (next step) can resolve the dubhe dependency.
+  if (network === 'localnet') {
+    const pubfilePath = getEphemeralPubFilePath(cwd, network);
+    updateEphemeralPubFile(pubfilePath, chainId, 'testnet', {
+      source: projectPath,
+      publishedAt: packageId,
+      originalId: packageId,
+      upgradeCap: upgradeCapId
+    });
+  }
 }
 
 export async function publishHandler(
   dubheConfig: DubheConfig,
   network: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
-  gasBudget?: number
+  force: boolean,
+  gasBudget?: number,
+  fullnodeUrls?: string[]
 ) {
-  await switchEnv(network);
+  await switchEnv(network, fullnodeUrls?.[0]);
 
   const dubhe = initializeDubhe({
-    network
+    network,
+    fullnodeUrls
   });
 
-  if (network === 'localnet') {
+  const path = process.cwd();
+  const projectPath = `${path}/src/${dubheConfig.name}`;
+
+  if (network === 'localnet' && dubheConfig.name !== 'dubhe') {
     await publishDubheFramework(dubhe, network);
   }
 
-  const path = process.cwd();
-  const projectPath = `${path}/src/${dubheConfig.name}`;
-  await updateDubheDependency(`${projectPath}/Move.toml`, network);
-  await publishContract(dubhe, dubheConfig, network, projectPath, gasBudget);
+  await publishContract(dubhe, dubheConfig, network, projectPath, gasBudget, force, fullnodeUrls);
 }