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

package/src/utils/utils.ts

@@ -1,23 +1,27 @@
 import * as fsAsync from 'fs/promises';
 import { mkdirSync, writeFileSync } from 'fs';
-import { dirname } from 'path';
+import { dirname, join as pathJoin } from 'path';
 import { SUI_PRIVATE_KEY_PREFIX } from '@mysten/sui/cryptography';
 import { FsIibError } from './errors';
 import * as fs from 'fs';
 import chalk from 'chalk';
 import { spawn } from 'child_process';
-import { Dubhe, NetworkType, SuiMoveNormalizedModules } from '@0xobelisk/sui-client';
+import { Dubhe, NetworkType, SuiMoveNormalizedModules, loadMetadata } from '@0xobelisk/sui-client';
 import { DubheCliError } from './errors';
-import packageJson from '../../package.json';
+import { Component, MoveType, EmptyComponent, DubheConfig } from '@0xobelisk/sui-common';
+import { TESTNET_DUBHE_HUB_OBJECT_ID, TESTNET_ORIGINAL_DUBHE_PACKAGE_ID } from './constants';
 
 export type DeploymentJsonType = {
   projectName: string;
   network: 'mainnet' | 'testnet' | 'devnet' | 'localnet';
+  startCheckpoint: string;
   packageId: string;
-  schemaId: string;
+  dappHub: string;
   upgradeCap: string;
   version: number;
-  schemas: Record<string, string>;
+  components: Record<string, Component | MoveType | EmptyComponent>;
+  resources: Record<string, Component | MoveType>;
+  enums?: Record<string, string[]>;
 };
 
 export function validatePrivateKey(privateKey: string): false | string {
@@ -76,43 +80,68 @@ export async function getDeploymentJson(
   }
 }
 
-export async function getDeploymentSchemaId(projectPath: string, network: string): Promise<string> {
+export async function getDeploymentDappHub(projectPath: string, network: string): Promise<string> {
   try {
     const data = await fsAsync.readFile(
       `${projectPath}/.history/sui_${network}/latest.json`,
       'utf8'
     );
     const deployment = JSON.parse(data) as DeploymentJsonType;
-    return deployment.schemaId;
-  } catch (error) {
+    return deployment.dappHub;
+  } catch (_error) {
     return '';
   }
 }
 
-export async function getDubheSchemaId(network: string) {
+export async function getDubheDappHub(network: string) {
+  const path = process.cwd();
+  const contractPath = `${path}/src/dubhe`;
+
+  switch (network) {
+    case 'mainnet':
+      return TESTNET_DUBHE_HUB_OBJECT_ID;
+    case 'testnet':
+      return TESTNET_DUBHE_HUB_OBJECT_ID;
+    case 'devnet':
+      return TESTNET_DUBHE_HUB_OBJECT_ID;
+    case 'localnet':
+      return await getDeploymentDappHub(contractPath, 'localnet');
+    default:
+      throw new Error(`Invalid network: ${network}`);
+  }
+}
+
+export async function getOriginalDubhePackageId(network: string) {
   const path = process.cwd();
-  const contractPath = `${path}/contracts/dubhe-framework`;
+  const contractPath = `${path}/src/dubhe`;
 
   switch (network) {
     case 'mainnet':
-      return await getDeploymentSchemaId(contractPath, 'mainnet');
+      return TESTNET_ORIGINAL_DUBHE_PACKAGE_ID;
     case 'testnet':
-      return '0xa565cbb3641fff8f7e8ef384b215808db5f1837aa72c1cca1803b5d973699aac';
+      return TESTNET_ORIGINAL_DUBHE_PACKAGE_ID;
     case 'devnet':
-      return await getDeploymentSchemaId(contractPath, 'devnet');
+      return TESTNET_ORIGINAL_DUBHE_PACKAGE_ID;
     case 'localnet':
-      return await getDeploymentSchemaId(contractPath, 'localnet');
+      return await getOldPackageId(contractPath, network);
     default:
       throw new Error(`Invalid network: ${network}`);
   }
 }
+export async function getOnchainComponents(
+  projectPath: string,
+  network: string
+): Promise<Record<string, Component | MoveType | EmptyComponent>> {
+  const deployment = await getDeploymentJson(projectPath, network);
+  return deployment.components;
+}
 
-export async function getOnchainSchemas(
+export async function getOnchainResources(
   projectPath: string,
   network: string
-): Promise<Record<string, string>> {
+): Promise<Record<string, Component | MoveType>> {
   const deployment = await getDeploymentJson(projectPath, network);
-  return deployment.schemas;
+  return deployment.resources;
 }
 
 export async function getVersion(projectPath: string, network: string): Promise<number> {
@@ -133,9 +162,9 @@ export async function getOldPackageId(projectPath: string, network: string): Pro
   return deployment.packageId;
 }
 
-export async function getSchemaId(projectPath: string, network: string): Promise<string> {
+export async function getDappHub(projectPath: string, network: string): Promise<string> {
   const deployment = await getDeploymentJson(projectPath, network);
-  return deployment.schemaId;
+  return deployment.dappHub;
 }
 
 export async function getUpgradeCap(projectPath: string, network: string): Promise<string> {
@@ -143,34 +172,73 @@ export async function getUpgradeCap(projectPath: string, network: string): Promi
   return deployment.upgradeCap;
 }
 
-export function saveContractData(
+export async function getStartCheckpoint(projectPath: string, network: string): Promise<string> {
+  const deployment = await getDeploymentJson(projectPath, network);
+  return deployment.startCheckpoint;
+}
+
+export async function saveContractData(
   projectName: string,
   network: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
+  startCheckpoint: string,
   packageId: string,
-  schemaId: string,
+  dappHub: string,
   upgradeCap: string,
   version: number,
-  schemas: Record<string, string>
+  components: Record<string, Component | MoveType | EmptyComponent>,
+  resources: Record<string, Component | MoveType>,
+  enums?: Record<string, string[]>
 ) {
   const DeploymentData: DeploymentJsonType = {
     projectName,
     network,
+    startCheckpoint,
     packageId,
-    schemaId,
-    schemas,
+    dappHub,
     upgradeCap,
-    version
+    version,
+    components,
+    resources,
+    enums
   };
 
   const path = process.cwd();
   const storeDeploymentData = JSON.stringify(DeploymentData, null, 2);
-  writeOutput(
+  await writeOutput(
     storeDeploymentData,
-    `${path}/contracts/${projectName}/.history/sui_${network}/latest.json`,
+    `${path}/src/${projectName}/.history/sui_${network}/latest.json`,
     'Update deploy log'
   );
 }
 
+export async function saveMetadata(
+  projectName: string,
+  network: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
+  packageId: string
+) {
+  const path = process.cwd();
+
+  // Save metadata files
+  try {
+    const metadata = await loadMetadata(network, packageId);
+    if (metadata) {
+      const metadataJson = JSON.stringify(metadata, null, 2);
+
+      // Save packageId-specific metadata file
+      await writeOutput(
+        metadataJson,
+        `${path}/src/${projectName}/.history/sui_${network}/${packageId}.json`,
+        'Save package metadata'
+      );
+
+      // Save latest metadata.json
+      await writeOutput(metadataJson, `${path}/metadata.json`, 'Save latest metadata');
+    }
+  } catch (error) {
+    console.warn(chalk.yellow(`Warning: Failed to save metadata: ${error}`));
+  }
+}
+
 export async function writeOutput(
   output: string,
   fullOutputPath: string,
@@ -184,55 +252,486 @@ export async function writeOutput(
   }
 }
 
-function getDubheDependency(network: 'mainnet' | 'testnet' | 'devnet' | 'localnet'): string {
-  switch (network) {
-    case 'localnet':
-      return 'Dubhe = { local = "../dubhe" }';
-    case 'testnet':
-      return `Dubhe = { git = "https://github.com/0xobelisk/dubhe-wip.git", subdir = "packages/sui-framework/contracts/dubhe", rev = "${packageJson.version}" }`;
-    case 'mainnet':
-      return `Dubhe = { git = "https://github.com/0xobelisk/dubhe-wip.git", subdir = "packages/sui-framework/contracts/dubhe", rev = "${packageJson.version}" }`;
-    default:
-      throw new Error(`Unsupported network: ${network}`);
-  }
-}
-
 export async function updateDubheDependency(
   filePath: string,
   network: 'mainnet' | 'testnet' | 'devnet' | 'localnet'
 ) {
-  const fileContent = fs.readFileSync(filePath, 'utf-8');
-  const newDependency = getDubheDependency(network);
-  const updatedContent = fileContent.replace(/Dubhe = \{.*\}/, newDependency);
-  fs.writeFileSync(filePath, updatedContent, 'utf-8');
-  console.log(`Updated Dubhe dependency in ${filePath} for ${network}.`);
+  // With the new --build-env mechanism, we keep Dubhe as local dependency for all networks.
+  // The Published.toml in ../dubhe resolves the correct on-chain address per environment.
+  // This function is kept for backward compatibility but is a no-op for non-localnet.
+  if (network === 'localnet') {
+    const fileContent = fs.readFileSync(filePath, 'utf-8');
+    const localDependency = 'Dubhe = { local = "../dubhe" }';
+    if (!fileContent.includes(localDependency)) {
+      const updatedContent = fileContent.replace(/Dubhe = \{[^}]*\}/, localDependency);
+      fs.writeFileSync(filePath, updatedContent, 'utf-8');
+      console.log(`Ensured local Dubhe dependency in ${filePath} for localnet.`);
+    }
+  }
+}
+
+// Published.toml management for the new Sui CLI (v1.44+) publishing mechanism.
+// Published.toml tracks on-chain package addresses per environment.
+// It SHOULD be committed to source control.
+
+interface PublishedEntry {
+  chainId: string;
+  publishedAt: string;
+  originalId: string;
+  version: number;
+}
+
+export function readPublishedToml(packagePath: string): Record<string, PublishedEntry> {
+  const filePath = pathJoin(packagePath, 'Published.toml');
+  if (!fs.existsSync(filePath)) {
+    return {};
+  }
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const result: Record<string, PublishedEntry> = {};
+
+  const sectionRegex = /\[published\.(\w+)\]([\s\S]*?)(?=\[published\.|$)/g;
+  let match;
+  while ((match = sectionRegex.exec(content)) !== null) {
+    const env = match[1];
+    const body = match[2];
+    const getValue = (key: string) => {
+      const m = body.match(new RegExp(`${key}\\s*=\\s*"([^"]*)"`));
+      return m ? m[1] : '';
+    };
+    const versionMatch = body.match(/version\s*=\s*(\d+)/);
+    result[env] = {
+      chainId: getValue('chain-id'),
+      publishedAt: getValue('published-at'),
+      originalId: getValue('original-id'),
+      version: versionMatch ? parseInt(versionMatch[1], 10) : 1
+    };
+  }
+  return result;
+}
+
+export function writePublishedToml(
+  packagePath: string,
+  entries: Record<string, PublishedEntry>
+): void {
+  const filePath = pathJoin(packagePath, 'Published.toml');
+  let content =
+    '# Generated by Move\n' +
+    '# This file contains metadata about published versions of this package in different environments\n' +
+    '# This file SHOULD be committed to source control\n';
+
+  for (const [env, entry] of Object.entries(entries)) {
+    content += `\n[published.${env}]\n`;
+    content += `chain-id = "${entry.chainId}"\n`;
+    content += `published-at = "${entry.publishedAt}"\n`;
+    content += `original-id = "${entry.originalId}"\n`;
+    content += `version = ${entry.version}\n`;
+  }
+
+  fs.writeFileSync(filePath, content, 'utf-8');
+}
+
+export function updatePublishedToml(
+  packagePath: string,
+  network: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
+  chainId: string,
+  packageId: string,
+  originalId?: string,
+  version?: number
+): void {
+  const entries = readPublishedToml(packagePath);
+  const existing = entries[network];
+
+  entries[network] = {
+    chainId,
+    publishedAt: packageId,
+    originalId: originalId ?? existing?.originalId ?? packageId,
+    version: version ?? (existing ? existing.version + 1 : 1)
+  };
+
+  writePublishedToml(packagePath, entries);
+  console.log(`Updated Published.toml in ${packagePath} for ${network}.`);
+}
+
+export function getPublishedTomlEntry(
+  packagePath: string,
+  network: string
+): PublishedEntry | undefined {
+  const entries = readPublishedToml(packagePath);
+  return entries[network];
+}
+
+export function clearPublishedTomlEntry(
+  packagePath: string,
+  network: string
+): PublishedEntry | undefined {
+  const entries = readPublishedToml(packagePath);
+  const existing = entries[network];
+  if (!existing) return undefined;
+
+  entries[network] = {
+    ...existing,
+    publishedAt: '0x0000000000000000000000000000000000000000000000000000000000000000',
+    originalId: '0x0000000000000000000000000000000000000000000000000000000000000000'
+  };
+  writePublishedToml(packagePath, entries);
+  return existing;
+}
+
+export function restorePublishedTomlEntry(
+  packagePath: string,
+  network: string,
+  entry: PublishedEntry
+): void {
+  const entries = readPublishedToml(packagePath);
+  entries[network] = entry;
+  writePublishedToml(packagePath, entries);
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Ephemeral publication file (Pub.<env>.toml)
+//
+// Per the Sui package management docs (v1.63+), localnet / devnet deployments
+// should use ephemeral publication files rather than the shared Published.toml.
+// The ephemeral file holds the localnet addresses so that subsequent builds
+// (e.g. for upgrades) can resolve local dependencies correctly.
+//
+// Reference: https://docs.sui.io/guides/developer/packages/move-package-management
+// ─────────────────────────────────────────────────────────────────────────────
+
+export interface EphemeralPubEntry {
+  /** Absolute path to the package source directory */
+  source: string;
+  /** Current on-chain address of the package */
+  publishedAt: string;
+  /** Address of the first published version (same as publishedAt for v1) */
+  originalId: string;
+  /** Object ID of the upgrade capability */
+  upgradeCap: string;
+  /** Package version (required by Sui CLI parser) */
+  version?: number;
+}
+
+/**
+ * Return the canonical path for the ephemeral publication file.
+ * For localnet this is <contractsDir>/Pub.localnet.toml.
+ */
+export function getEphemeralPubFilePath(contractsDir: string, network: string): string {
+  return pathJoin(contractsDir, `Pub.${network}.toml`);
 }
+
+/**
+ * Update (or create) an entry in the ephemeral publication file.
+ * Preserves existing entries for other packages.
+ */
+export function updateEphemeralPubFile(
+  pubfilePath: string,
+  chainId: string,
+  buildEnv: string,
+  entry: EphemeralPubEntry
+): void {
+  const existing: EphemeralPubEntry[] = [];
+  // Always use the provided buildEnv and chainId parameters.
+  // The chainId passed in comes from the live network and is authoritative.
+  const currentBuildEnv = buildEnv;
+  const currentChainId = chainId;
+
+  if (fs.existsSync(pubfilePath)) {
+    const content = fs.readFileSync(pubfilePath, 'utf-8');
+
+    // Check if the file was written for a different chain (e.g. previous localnet run).
+    // If chain-id changed, discard all existing entries — they belong to a dead chain.
+    const chainIdMatch = content.match(/^chain-id\s*=\s*"([^"]*)"/m);
+    const fileChainId = chainIdMatch ? chainIdMatch[1] : '';
+    const chainChanged = fileChainId !== '' && fileChainId !== chainId;
+
+    if (!chainChanged) {
+      // Same chain: parse existing [[published]] blocks and preserve them.
+      // source field is an inline table: source = { local = "..." }
+      const blockRegex = /\[\[published\]\]([\s\S]*?)(?=\[\[published\]\]|$)/g;
+      let blockMatch;
+      while ((blockMatch = blockRegex.exec(content)) !== null) {
+        const block = blockMatch[1];
+        const get = (key: string) => {
+          const m = block.match(new RegExp(`^${key}\\s*=\\s*"([^"]*)"`, 'm'));
+          return m ? m[1] : '';
+        };
+        // source = { local = "/path/to/package" }
+        const srcMatch = block.match(/^source\s*=\s*\{\s*local\s*=\s*"([^"]*)"\s*\}/m);
+        const src = srcMatch ? srcMatch[1] : '';
+        if (src) {
+          existing.push({
+            source: src,
+            publishedAt: get('published-at'),
+            originalId: get('original-id'),
+            upgradeCap: get('upgrade-cap')
+          });
+        }
+      }
+    } else {
+      console.log(`  Pub file chain-id changed (${fileChainId} → ${chainId}), resetting entries.`);
+    }
+  }
+
+  // Update override or add the entry
+  const idx = existing.findIndex((e) => e.source === entry.source);
+  if (idx >= 0) {
+    existing[idx] = entry;
+  } else {
+    existing.push(entry);
+  }
+
+  // Write the file
+  let content =
+    '# generated by dubhe cli\n' +
+    '# this file contains metadata from ephemeral publications\n' +
+    '# this file should NOT be committed to source control\n\n';
+  content += `build-env = "${currentBuildEnv}"\n`;
+  content += `chain-id = "${currentChainId}"\n`;
+
+  for (const e of existing) {
+    content += '\n[[published]]\n';
+    // source must be a LocalDepInfo struct (not a plain string)
+    content += `source = { local = "${e.source}" }\n`;
+    content += `published-at = "${e.publishedAt}"\n`;
+    content += `original-id = "${e.originalId}"\n`;
+    content += `upgrade-cap = "${e.upgradeCap}"\n`;
+    // version is required by Sui CLI parser (even though docs omit it)
+    content += `version = 1\n`;
+  }
+
+  fs.writeFileSync(pubfilePath, content, 'utf-8');
+  console.log(
+    `  Updated ${pathJoin(pubfilePath.split('/').slice(-1)[0])} for ${
+      entry.source.split('/').slice(-1)[0]
+    }.`
+  );
+}
+
+async function checkRpcAvailability(rpcUrl: string): Promise<boolean> {
+  try {
+    const response = await fetch(rpcUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'sui_getLatestCheckpointSequenceNumber',
+        params: []
+      })
+    });
+
+    if (!response.ok) {
+      return false;
+    }
+
+    const data = await response.json();
+    return !data.error;
+  } catch (_error) {
+    return false;
+  }
+}
+
+export async function addEnv(
+  network: 'mainnet' | 'testnet' | 'devnet' | 'localnet'
+): Promise<void> {
+  const rpcMap = {
+    localnet: 'http://127.0.0.1:9000',
+    devnet: 'https://fullnode.devnet.sui.io:443/',
+    testnet: 'https://fullnode.testnet.sui.io:443/',
+    mainnet: 'https://fullnode.mainnet.sui.io:443/'
+  };
+
+  const rpcUrl = rpcMap[network];
+
+  // Check RPC availability first
+  const isRpcAvailable = await checkRpcAvailability(rpcUrl);
+  if (!isRpcAvailable) {
+    throw new Error(
+      `RPC endpoint ${rpcUrl} is not available. Please check your network connection or try again later.`
+    );
+  }
+
+  return new Promise<void>((resolve, reject) => {
+    let errorOutput = '';
+    let stdoutOutput = '';
+
+    const suiProcess = spawn(
+      'sui',
+      ['client', 'new-env', '--alias', network, '--rpc', rpcMap[network]],
+      {
+        env: { ...process.env },
+        stdio: 'pipe'
+      }
+    );
+
+    // Capture standard output
+    suiProcess.stdout.on('data', (data) => {
+      stdoutOutput += data.toString();
+    });
+
+    // Capture error output
+    suiProcess.stderr.on('data', (data) => {
+      errorOutput += data.toString();
+    });
+
+    // Handle process errors (e.g., command not found)
+    suiProcess.on('error', (error) => {
+      console.error(chalk.red(`\n❌ Failed to execute sui command: ${error.message}`));
+      reject(new Error(`Failed to execute sui command: ${error.message}`));
+    });
+
+    // Handle process exit
+    suiProcess.on('exit', (code, signal) => {
+      // Check if "already exists" message is present
+      if (errorOutput.includes('already exists') || stdoutOutput.includes('already exists')) {
+        console.log(chalk.yellow(`Environment ${network} already exists, proceeding...`));
+        resolve();
+        return;
+      }
+
+      if (code === 0) {
+        console.log(chalk.green(`Successfully added environment ${network}`));
+        resolve();
+      } else {
+        let finalError: string;
+        if (code === null) {
+          // Process was killed by a signal
+          finalError =
+            errorOutput ||
+            stdoutOutput ||
+            `Process was terminated by signal ${signal || 'unknown'}`;
+        } else {
+          finalError = errorOutput || stdoutOutput || `Process exited with code ${code}`;
+        }
+        console.error(chalk.red(`\n❌ Failed to add environment ${network}`));
+        console.error(chalk.red(`  └─ ${finalError.trim()}`));
+        reject(new Error(finalError));
+      }
+    });
+  });
+}
+
+export type NetworkAlias = 'testnet' | 'mainnet' | 'devnet' | 'localnet';
+
+export interface Endpoint {
+  alias: NetworkAlias;
+  rpc: string;
+  ws: string | null;
+  basic_auth: { username: string; password: string } | null;
+}
+
+// mainly is a tuple of [endpoint list, current active alias]
+export type ConfigTuple = [Endpoint[], NetworkAlias];
+
+export async function envsJSON(): Promise<ConfigTuple> {
+  try {
+    return new Promise<ConfigTuple>((resolve, reject) => {
+      let errorOutput = '';
+      let stdoutOutput = '';
+
+      const suiProcess = spawn('sui', ['client', 'envs', '--json'], {
+        env: { ...process.env },
+        stdio: 'pipe'
+      });
+
+      suiProcess.stdout.on('data', (data) => {
+        stdoutOutput += data.toString();
+      });
+
+      suiProcess.stderr.on('data', (data) => {
+        errorOutput += data.toString();
+      });
+
+      suiProcess.on('error', (error) => {
+        console.error(chalk.red(`\n❌ Failed to execute sui command: ${error.message}`));
+        reject(new Error(`Failed to execute sui command: ${error.message}`));
+      });
+
+      suiProcess.on('exit', (code, signal) => {
+        if (code === 0) {
+          resolve(JSON.parse(stdoutOutput) as ConfigTuple);
+        } else {
+          let finalError: string;
+          if (code === null) {
+            // Process was killed by a signal
+            finalError =
+              errorOutput ||
+              stdoutOutput ||
+              `Process was terminated by signal ${signal || 'unknown'}`;
+          } else {
+            finalError = errorOutput || stdoutOutput || `Process exited with code ${code}`;
+          }
+          console.error(chalk.red(`\n❌ Failed to get envs`));
+          console.error(chalk.red(`  └─ ${finalError.trim()}`));
+          reject(new Error(finalError));
+        }
+      });
+    });
+  } catch (error) {
+    // Re-throw the error for the caller to handle
+    throw error;
+  }
+}
+
+export async function getDefaultNetwork(): Promise<NetworkAlias> {
+  const [_, currentAlias] = await envsJSON();
+  return currentAlias as NetworkAlias;
+}
+
 export async function switchEnv(network: 'mainnet' | 'testnet' | 'devnet' | 'localnet') {
   try {
+    // First, try to add the environment
+    await addEnv(network);
+
+    // Then switch to the specified environment
     return new Promise<void>((resolve, reject) => {
+      let errorOutput = '';
+      let stdoutOutput = '';
+
       const suiProcess = spawn('sui', ['client', 'switch', '--env', network], {
         env: { ...process.env },
         stdio: 'pipe'
       });
 
+      suiProcess.stdout.on('data', (data) => {
+        stdoutOutput += data.toString();
+      });
+
+      suiProcess.stderr.on('data', (data) => {
+        errorOutput += data.toString();
+      });
+
       suiProcess.on('error', (error) => {
-        console.error(chalk.red('\n❌ Failed to Switch Env'));
-        console.error(chalk.red(`  Error: ${error.message}`));
-        reject(error); // Reject promise on error
+        console.error(chalk.red(`\n❌ Failed to execute sui command: ${error.message}`));
+        reject(new Error(`Failed to execute sui command: ${error.message}`));
       });
 
-      suiProcess.on('exit', (code) => {
-        if (code !== 0) {
-          console.error(chalk.red(`\n❌ Process exited with code: ${code}`));
-          reject(new Error(`Process exited with code: ${code}`));
+      suiProcess.on('exit', (code, signal) => {
+        if (code === 0) {
+          console.log(chalk.green(`Successfully switched to environment ${network}`));
+          resolve();
         } else {
-          resolve(); // Resolve promise on successful exit
+          let finalError: string;
+          if (code === null) {
+            // Process was killed by a signal
+            finalError =
+              errorOutput ||
+              stdoutOutput ||
+              `Process was terminated by signal ${signal || 'unknown'}`;
+          } else {
+            finalError = errorOutput || stdoutOutput || `Process exited with code ${code}`;
+          }
+          console.error(chalk.red(`\n❌ Failed to switch to environment ${network}`));
+          console.error(chalk.red(`  └─ ${finalError.trim()}`));
+          reject(new Error(finalError));
         }
       });
     });
   } catch (error) {
-    console.error(chalk.red('\n❌ Failed to Switch Env'));
-    console.error(chalk.red(`  └─ Error: ${error}`));
+    // Re-throw the error for the caller to handle
+    throw error;
   }
 }
 
@@ -272,3 +771,220 @@ export function initializeDubhe({
     metadata
   });
 }
+
+export function generateConfigJson(config: DubheConfig): string {
+  const components = Object.entries(config.components).map(([name, component]) => {
+    if (typeof component === 'string') {
+      return {
+        [name]: {
+          fields: [{ entity_id: 'address' }, { value: component }],
+          keys: ['entity_id'],
+          offchain: false
+        }
+      };
+    }
+
+    if (Object.keys(component as object).length === 0) {
+      return {
+        [name]: {
+          fields: [{ entity_id: 'address' }],
+          keys: ['entity_id'],
+          offchain: false
+        }
+      };
+    }
+
+    const fields = (component as any).fields || {};
+    const keys = (component as any).keys || ['entity_id'];
+    const offchain = (component as any).offchain ?? false;
+
+    // ensure entity_id field exists
+    if (!fields.entity_id && keys.includes('entity_id')) {
+      fields.entity_id = 'address';
+    }
+
+    // prepare fields with entity_id first
+    const fieldEntries = Object.entries(fields);
+    const entityIdField = fieldEntries.find(([key]) => key === 'entity_id');
+    const otherFields = fieldEntries.filter(([key]) => key !== 'entity_id');
+    const orderedFields = entityIdField ? [entityIdField, ...otherFields] : otherFields;
+
+    return {
+      [name]: {
+        fields: orderedFields.map(([fieldName, fieldType]) => ({
+          [fieldName]: fieldType
+        })),
+        keys: keys,
+        offchain: offchain
+      }
+    };
+  });
+
+  const resources = Object.entries(config.resources).map(([name, resource]) => {
+    // Simple type shorthand (e.g., counter1: 'u32') – entity-keyed by account (entity_id: String).
+    if (typeof resource === 'string') {
+      return {
+        [name]: {
+          fields: [{ entity_id: 'String' }, { value: resource }],
+          keys: ['entity_id'],
+          offchain: false
+        }
+      };
+    }
+
+    // Empty resource object – only the implicit entity key.
+    if (Object.keys(resource as object).length === 0) {
+      return {
+        [name]: {
+          fields: [{ entity_id: 'String' }],
+          keys: ['entity_id'],
+          offchain: false
+        }
+      };
+    }
+
+    const fields = (resource as any).fields || {};
+    const keys = (resource as any).keys || [];
+    const offchain = (resource as any).offchain ?? false;
+
+    // Full Component format with no explicit keys: auto-inject 'entity_id: String'.
+    if (keys.length === 0) {
+      const fieldEntries = Object.entries(fields);
+      const orderedFields: [string, unknown][] = [['entity_id', 'String'], ...fieldEntries];
+      return {
+        [name]: {
+          fields: orderedFields.map(([fieldName, fieldType]) => ({
+            [fieldName]: fieldType
+          })),
+          keys: ['entity_id'],
+          offchain: offchain
+        }
+      };
+    }
+
+    // Full Component format with explicit custom keys: inject 'entity_id: String' as the first
+    // field and first key so that key_tuple[0] (the BCS-encoded account injected by the indexer)
+    // maps correctly, followed by the user-defined keys.
+    const fieldEntries = Object.entries(fields);
+    const orderedFields: [string, unknown][] = [['entity_id', 'String'], ...fieldEntries];
+    return {
+      [name]: {
+        fields: orderedFields.map(([fieldName, fieldType]) => ({
+          [fieldName]: fieldType
+        })),
+        keys: ['entity_id', ...keys],
+        offchain: offchain
+      }
+    };
+  });
+
+  // Auto-append Dubhe framework fee state resource (entity-keyed by account string).
+  if (!resources.some((resource) => 'dapp_fee_state' in resource)) {
+    resources.push({
+      dapp_fee_state: {
+        fields: [
+          { entity_id: 'String' },
+          { base_fee: 'u256' },
+          { byte_fee: 'u256' },
+          { free_credit: 'u256' },
+          { total_bytes_size: 'u256' },
+          { total_recharged: 'u256' },
+          { total_paid: 'u256' }
+        ],
+        keys: ['entity_id'],
+        offchain: false
+      }
+    });
+  }
+
+  // handle enums
+  const enums = Object.entries(config.enums || {}).map(([name, enumFields]) => {
+    // Sort enum values by first letter
+    const sortedFields = enumFields.sort((a, b) => a.localeCompare(b)).map((value) => value);
+
+    return {
+      [name]: sortedFields
+    };
+  });
+
+  return JSON.stringify(
+    {
+      components,
+      resources,
+      enums
+    },
+    null,
+    2
+  );
+}
+
+/**
+ * Updates the dubhe address and published-at in Move.toml file
+ * @param path - Directory path containing Move.toml file
+ * @param packageAddress - New dubhe package address to set
+ *
+ * Logic:
+ * - If packageAddress is "0x0": only set dubhe = "0x0", remove published-at line
+ * - Otherwise: set both dubhe and published-at to packageAddress
+ */
+export function updateMoveTomlAddress(path: string, packageAddress: string) {
+  const moveTomlPath = `${path}/Move.toml`;
+  const moveTomlContent = fs.readFileSync(moveTomlPath, 'utf-8');
+
+  let updatedContent = moveTomlContent;
+
+  if (packageAddress === '0x0') {
+    // Case 1: Address is "0x0" - set dubhe to "0x0" and remove published-at line
+    updatedContent = updatedContent.replace(/dubhe\s*=\s*"[^"]*"/, `dubhe = "0x0"`);
+
+    // Remove published-at line (including the line break)
+    updatedContent = updatedContent.replace(/published-at\s*=\s*"[^"]*"\r?\n?/, '');
+  } else {
+    // Case 2: Address is not "0x0" - set both dubhe and published-at
+    updatedContent = updatedContent.replace(/dubhe\s*=\s*"[^"]*"/, `dubhe = "${packageAddress}"`);
+
+    // Check if published-at already exists
+    if (/published-at\s*=\s*"[^"]*"/.test(updatedContent)) {
+      // Replace existing published-at
+      updatedContent = updatedContent.replace(
+        /published-at\s*=\s*"[^"]*"/,
+        `published-at = "${packageAddress}"`
+      );
+    } else {
+      // Add published-at after [package] line if it doesn't exist
+      updatedContent = updatedContent.replace(
+        /(\[package\][^\n]*\n)/,
+        `$1published-at = "${packageAddress}"\n`
+      );
+    }
+  }
+
+  fs.writeFileSync(moveTomlPath, updatedContent, 'utf-8');
+}
+
+export function updateGenesisUpgradeFunction(path: string, tables: string[]) {
+  const genesisPath = `${path}/sources/codegen/genesis.move`;
+  const genesisContent = fs.readFileSync(genesisPath, 'utf-8');
+
+  // Match the first pair of // ========================================== lines (with any content, including empty, between them)
+  const separatorRegex =
+    /(\/\/ ==========================================)[\s\S]*?(\/\/ ==========================================)/;
+  const match = genesisContent.match(separatorRegex);
+
+  if (!match) {
+    throw new Error('Could not find separator comments in genesis.move');
+  }
+
+  // Generate new table registration code
+  const registerTablesCode = tables
+    .map((table) => `    ${table}::register_table(dapp_hub, ctx);`)
+    .join('\n');
+
+  // Build new content, preserve separators, replace middle content
+  const newContent = `${match[1]}\n${registerTablesCode}\n${match[2]}`;
+
+  // Replace matched content
+  const updatedContent = genesisContent.replace(separatorRegex, newContent);
+
+  fs.writeFileSync(genesisPath, updatedContent, 'utf-8');
+}