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

package/src/utils/publishHandler.ts

@@ -6,127 +6,48 @@ import {
   updateMoveTomlAddress,
   switchEnv,
   delay,
-  getDubheDappHub,
+  getDubheDappHubId,
   initializeDubhe,
   saveMetadata,
   getOriginalDubhePackageId,
   updatePublishedToml,
+  syncDubheFrameworkAddress,
   updateEphemeralPubFile,
-  getEphemeralPubFilePath
+  getEphemeralPubFilePath,
+  getPublishedTomlEntry,
+  clearPublishedTomlEntry,
+  restorePublishedTomlEntry,
+  removeEnvFromMoveLock
 } from './utils';
 import { DubheConfig } from '@0xobelisk/sui-common';
 import * as fs from 'fs';
 import * as path from 'path';
 
-async function removeEnvContent(
-  filePath: string,
-  networkType: 'mainnet' | 'testnet' | 'devnet' | 'localnet'
-): Promise<void> {
-  if (!fs.existsSync(filePath)) {
-    return;
-  }
-  const content = fs.readFileSync(filePath, 'utf-8');
-  const regex = new RegExp(`\\[env\\.${networkType}\\][\\s\\S]*?(?=\\[|$)`, 'g');
-  const updatedContent = content.replace(regex, '');
-  fs.writeFileSync(filePath, updatedContent, 'utf-8');
-}
+/**
+ * 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');
 
-interface EnvConfig {
-  chainId: string;
-  originalPublishedId: string;
-  latestPublishedId: string;
-  publishedVersion: number;
-}
+  if (content.includes('localnet')) {
+    return null;
+  }
 
-function updateEnvFile(
-  filePath: string,
-  networkType: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
-  operation: 'publish' | 'upgrade',
-  chainId: string,
-  publishedId: string
-): void {
-  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}]`);
-  const config: EnvConfig = {
-    chainId: chainId,
-    originalPublishedId: '',
-    latestPublishedId: '',
-    publishedVersion: 0
-  };
-
-  if (networkSectionIndex === -1) {
-    // If network section is not found, add a new section
-    if (operation === 'publish') {
-      config.originalPublishedId = publishedId;
-      config.latestPublishedId = publishedId;
-      config.publishedVersion = 1;
-    } else {
-      throw new Error(
-        `Network type [env.${networkType}] not found in the file and cannot upgrade.`
-      );
-    }
+  let updatedContent: string;
+  if (content.includes('[environments]')) {
+    updatedContent = content.replace('[environments]', `[environments]\nlocalnet = "${chainId}"`);
   } else {
-    for (let i = networkSectionIndex + 1; i < envLines.length; i++) {
-      const line = envLines[i].trim();
-      if (line.startsWith('[')) break; // End of the current network section
-
-      const [key, value] = line.split('=').map((part) => part.trim().replace(/"/g, ''));
-      switch (key) {
-        case 'original-published-id':
-          config.originalPublishedId = value;
-          break;
-        case 'latest-published-id':
-          config.latestPublishedId = value;
-          break;
-        case 'published-version':
-          config.publishedVersion = parseInt(value, 10);
-          break;
-      }
-    }
-
-    if (operation === 'publish') {
-      config.originalPublishedId = publishedId;
-      config.latestPublishedId = publishedId;
-      config.publishedVersion = 1;
-    } else if (operation === 'upgrade') {
-      config.latestPublishedId = publishedId;
-      config.publishedVersion += 1;
-    }
+    updatedContent = content.trimEnd() + `\n\n[environments]\nlocalnet = "${chainId}"\n`;
   }
 
-  const updatedSection = `
-[env.${networkType}]
-chain-id = "${config.chainId}"
-original-published-id = "${config.originalPublishedId}"
-latest-published-id = "${config.latestPublishedId}"
-published-version = "${config.publishedVersion}"
-`;
-
-  const newEnvContent =
-    networkSectionIndex === -1
-      ? envContent + updatedSection
-      : envLines.slice(0, networkSectionIndex).join('\n') + updatedSection;
-
-  fs.writeFileSync(envFilePath, newEnvContent, 'utf-8');
+  fs.writeFileSync(moveTomlPath, updatedContent, 'utf-8');
+  return content;
 }
-// function capitalizeAndRemoveUnderscores(input: string): string {
-// 	return input
-// 		.split('_')
-// 		.map((word, index) => {
-// 			return index === 0
-// 				? word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
-// 				: word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
-// 		})
-// 		.join('');
-// }
-//
-// function getLastSegment(input: string): string {
-// 	const segments = input.split('::');
-// 	return segments.length > 0 ? segments[segments.length - 1] : '';
-// }
 
 /**
  * Build a Move package and return [modules, dependencies] as base64 arrays.
@@ -216,7 +137,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}`);
@@ -226,23 +149,74 @@ async function publishContract(
   const chainId = await waitForNode(dubhe);
   console.log('  ├─ Validating Environment...');
 
-  await removeEnvContent(`${projectPath}/Move.lock`, network);
+  removeEnvFromMoveLock(`${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...');
   // For localnet: pass the ephemeral pubfile so the build system can resolve
   // the dubhe dependency that was just published in publishDubheFramework().
-  const pubfilePath =
+  // 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;
+    }
+  }
 
-  // For localnet: temporarily remove Published.toml to prevent the testnet address
-  // (if it exists) from being picked up by --build-env testnet, which would cause
-  // PublishErrorNonZeroAddress. The pubfile supplies dubhe's localnet address instead.
+  // 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
@@ -256,6 +230,14 @@ async function publishContract(
     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);
@@ -263,9 +245,22 @@ async function publishContract(
     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...');
@@ -282,6 +277,17 @@ async function publishContract(
   } 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.'
+        )
+      );
+    }
     throw new Error(`Contract publication failed: ${error.message}`);
   }
 
@@ -292,9 +298,8 @@ async function publishContract(
   console.log('  ├─ Processing publication results...');
   let version = 1;
   let packageId = '';
-  let dappHub = '';
-  let components = dubheConfig.components;
-  let resources = dubheConfig.resources;
+  let dappHubId = '';
+  let resources = dubheConfig.resources ?? {};
   let enums = dubheConfig.enums;
   let upgradeCapId = '';
   let startCheckpoint = '';
@@ -319,7 +324,7 @@ async function publishContract(
       object.objectType &&
       object.objectType.includes('dapp_service::DappHub')
     ) {
-      dappHub = object.objectId || '';
+      dappHubId = object.objectId || '';
     }
     if (object.type === 'created') {
       printObjects.push(object);
@@ -328,7 +333,6 @@ 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...');
@@ -338,9 +342,14 @@ async function publishContract(
 
   const deployHookTx = new Transaction();
   let args = [];
-  let dubheDappHub = dubheConfig.name === 'dubhe' ? dappHub : await getDubheDappHub(network);
-  args.push(deployHookTx.object(dubheDappHub));
-  args.push(deployHookTx.object('0x6'));
+  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') {
+    args.push(deployHookTx.object('0x6'));
+  }
   deployHookTx.moveCall({
     target: `${packageId}::genesis::run`,
     arguments: args
@@ -359,6 +368,20 @@ async function publishContract(
     console.log('  ├─ Hook execution successful');
     console.log(`  ├─ Transaction: ${deployHookResult.digest}`);
 
+    // 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('dapp_service::DappStorage')
+      ) {
+        dappStorageId = object.objectId || '';
+        console.log(`  ├─ DappStorage: ${dappStorageId}`);
+      }
+    });
+
     console.log('\n📋 Created Objects:');
     printObjects.map((object: ObjectChange) => {
       console.log(`  ├─ ID: ${object.objectId}`);
@@ -370,22 +393,48 @@ async function publishContract(
       network,
       startCheckpoint,
       packageId,
-      dubheDappHub,
+      packageId, // originalPackageId: first publish, so original == current
+      frameworkDappHubId,
       upgradeCapId,
       version,
-      components,
       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,
+      dappStorageId || undefined
     );
 
-    await saveMetadata(dubheConfig.name, network, packageId);
+    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;
-    config.dubhe_object_id = dubheDappHub;
-    config.original_dubhe_package_id = await getOriginalDubhePackageId(network);
+    // 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.
+    // devnet has no fixed framework deployment so we skip this field.
+    if (dubheConfig.name === 'dubhe') {
+      config.original_dubhe_package_id = packageId;
+    } else if (network !== 'devnet') {
+      config.original_dubhe_package_id = 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));
 
@@ -400,10 +449,10 @@ 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'));
@@ -429,7 +478,15 @@ export async function publishDubheFramework(
 
   const chainId = await waitForNode(dubhe);
 
-  await removeEnvContent(`${projectPath}/Move.lock`, network);
+  removeEnvFromMoveLock(`${projectPath}/Move.lock`, network);
+  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.
+    removeEnvFromMoveLock(`${projectPath}/Move.lock`, 'testnet');
+  }
   await updateMoveTomlAddress(projectPath, '0x0');
 
   const startCheckpoint =
@@ -447,16 +504,25 @@ export async function publishDubheFramework(
     fs.unlinkSync(publishedTomlPath);
   }
 
+  // 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 {
-    // For localnet: use --build-env testnet (no pubfile needed — dubhe has no local deps).
-    // For testnet/mainnet: use -e <network> as usual.
     [modules, dependencies] = buildContract(projectPath, network);
   } finally {
-    // Always restore Published.toml (successful build or error)
+    // 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');
+    }
   }
 
   const tx = new Transaction();
@@ -478,7 +544,7 @@ export async function publishDubheFramework(
 
   let version = 1;
   let packageId = '';
-  let dappHub = '';
+  let dappHubId = '';
   let upgradeCapId = '';
 
   result.objectChanges!.map((object: ObjectChange) => {
@@ -497,15 +563,16 @@ export async function publishDubheFramework(
       object.objectType &&
       object.objectType.includes('dapp_service::DappHub')
     ) {
-      dappHub = object.objectId || '';
+      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}::genesis::run`,
-    arguments: [deployHookTx.object(dappHub), deployHookTx.object('0x6')]
+    arguments: [deployHookTx.object(dappHubId)]
   });
 
   let deployHookResult;
@@ -527,15 +594,17 @@ export async function publishDubheFramework(
     network,
     startCheckpoint,
     packageId,
-    dappHub,
+    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);
   updatePublishedToml(projectPath, network, chainId, packageId, packageId, 1);
 
   // For localnet: write dubhe's published address to Pub.localnet.toml so that
@@ -554,13 +623,15 @@ export async function publishDubheFramework(
 export async function publishHandler(
   dubheConfig: DubheConfig,
   network: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
-  _force: boolean,
-  gasBudget?: number
+  force: boolean,
+  gasBudget?: number,
+  fullnodeUrls?: string[]
 ) {
-  await switchEnv(network);
+  await switchEnv(network, fullnodeUrls?.[0]);
 
   const dubhe = initializeDubhe({
-    network
+    network,
+    fullnodeUrls
   });
 
   const path = process.cwd();
@@ -570,5 +641,5 @@ export async function publishHandler(
     await publishDubheFramework(dubhe, network);
   }
 
-  await publishContract(dubhe, dubheConfig, network, projectPath, gasBudget);
+  await publishContract(dubhe, dubheConfig, network, projectPath, gasBudget, force, fullnodeUrls);
 }

package/src/utils/storeConfig.ts

@@ -1,16 +1,53 @@
 import { mkdirSync, writeFileSync } from 'fs';
 import { dirname } from 'path';
 import { DubheConfig } from '@0xobelisk/sui-common';
-import { getDeploymentJson, getDubheDappHub } from './utils';
+import { getDeploymentJson, getDubheDappHubId, 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';
+/** Derive the stable dapp_key type string from the original (genesis) package ID.
+ *  Matches the Move-side `type_name::with_defining_ids<DappKey>().into_string()` output:
+ *  "<hex64>::dapp_key::DappKey"  (no "0x" prefix, address zero-padded to 64 hex chars).
+ */
+function buildDappKey(originalPackageId: string): string {
+  const hex = originalPackageId.replace(/^0x/i, '').padStart(64, '0');
+  return `${hex}::dapp_key::DappKey`;
+}
+
+async function storeConfig(
+  network: string,
+  packageId: string,
+  originalPackageId: string,
+  dappStorageId: string,
+  outputPath: string
+) {
+  const dappHubId = await getDubheDappHubId(network);
+
+  // Mirror getDubheDappHubId: for localnet the framework is deployed ephemerally so we
+  // read its package ID from src/dubhe/.history/sui_localnet/latest.json.
+  // For testnet/mainnet the hardcoded ID from @0xobelisk/sui-client defaultConfig is used.
+  // devnet has no fixed framework deployment, so frameworkPackageId stays undefined.
+  let frameworkPackageId: string | undefined;
+  if (network !== 'devnet') {
+    frameworkPackageId = await getOriginalDubhePackageId(network);
+  }
+
+  const frameworkIdLine =
+    frameworkPackageId !== undefined
+      ? `\n// Published package ID of the dubhe framework — required for proxy operations.\nexport const FrameworkPackageId: string | undefined = '${frameworkPackageId}';\n`
+      : `\n// Published package ID of the dubhe framework — required for proxy operations.\n// Not available for devnet (no fixed framework deployment).\nexport const FrameworkPackageId: string | undefined = undefined;\n`;
+
+  const dappKey = buildDappKey(originalPackageId);
+
+  const code = `type NetworkType = 'testnet' | 'mainnet' | 'devnet' | 'localnet';
 
-export const NETWORK: NetworkType = '${network}';
-export const PACKAGE_ID = '${packageId}';
-export const DUBHE_SCHEMA_ID = '${dubheDappHub}';
-`;
+export const Network: NetworkType = '${network}';
+export const PackageId = '${packageId}';
+/** The first-published (original) package ID — stable across upgrades. Used for dapp_key and indexer filtering. */
+export const OriginalPackageId = '${originalPackageId}';
+/** Canonical dapp_key type string derived from OriginalPackageId. Pass to the Dubhe SDK and GraphQL queries. */
+export const DappKey = '${dappKey}';
+export const DappHubId = '${dappHubId}';
+export const DappStorageId = '${dappStorageId}';
+${frameworkIdLine}`;
 
   writeOutput(code, outputPath, 'storeConfig');
 }
@@ -36,5 +73,14 @@ export async function storeConfigHandler(
   const path = process.cwd();
   const contractPath = `${path}/src/${dubheConfig.name}`;
   const deployment = await getDeploymentJson(contractPath, network);
-  await storeConfig(deployment.network, deployment.packageId, outputPath);
+  // Prefer the persisted originalPackageId; fall back to packageId for old deployments
+  // that were created before this field was introduced.
+  const originalPackageId = deployment.originalPackageId ?? deployment.packageId;
+  await storeConfig(
+    deployment.network,
+    deployment.packageId,
+    originalPackageId,
+    deployment.dappStorageId ?? '',
+    outputPath
+  );
 }