@0xobelisk/sui-cli 1.2.0-pre.3 → 1.2.0-pre.34

package/src/utils/utils.ts

@@ -6,17 +6,19 @@ 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';
 
 export type DeploymentJsonType = {
   projectName: string;
   network: 'mainnet' | 'testnet' | 'devnet' | 'localnet';
   packageId: string;
-  schemaId: string;
+  dappHub: string;
   upgradeCap: string;
   version: number;
-  schemas: Record<string, string>;
+  components: Record<string, Component | MoveType | EmptyComponent>;
 };
 
 export function validatePrivateKey(privateKey: string): false | string {
@@ -75,43 +77,43 @@ 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;
+    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}/contracts/dubhe-framework`;
+  const contractPath = `${path}/src/dubhe`;
 
   switch (network) {
     case 'mainnet':
-      return await getDeploymentSchemaId(contractPath, 'mainnet');
+      return await getDeploymentDappHub(contractPath, 'mainnet');
     case 'testnet':
-      return '0xa565cbb3641fff8f7e8ef384b215808db5f1837aa72c1cca1803b5d973699aac';
+      return await getDeploymentDappHub(contractPath, 'testnet');
     case 'devnet':
-      return await getDeploymentSchemaId(contractPath, 'devnet');
+      return await getDeploymentDappHub(contractPath, 'devnet');
     case 'localnet':
-      return await getDeploymentSchemaId(contractPath, 'localnet');
+      return await getDeploymentDappHub(contractPath, 'localnet');
     default:
       throw new Error(`Invalid network: ${network}`);
   }
 }
 
-export async function getOnchainSchemas(
+export async function getOnchainComponents(
   projectPath: string,
   network: string
-): Promise<Record<string, string>> {
+): Promise<Record<string, Component | MoveType | EmptyComponent>> {
   const deployment = await getDeploymentJson(projectPath, network);
-  return deployment.schemas;
+  return deployment.components;
 }
 
 export async function getVersion(projectPath: string, network: string): Promise<number> {
@@ -132,9 +134,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> {
@@ -142,34 +144,62 @@ export async function getUpgradeCap(projectPath: string, network: string): Promi
   return deployment.upgradeCap;
 }
 
-export function saveContractData(
+export async function saveContractData(
   projectName: string,
   network: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
   packageId: string,
-  schemaId: string,
+  dappHub: string,
   upgradeCap: string,
   version: number,
-  schemas: Record<string, string>
+  components: Record<string, Component | MoveType | EmptyComponent>
 ) {
   const DeploymentData: DeploymentJsonType = {
     projectName,
     network,
     packageId,
-    schemaId,
-    schemas,
+    dappHub,
+    components,
     upgradeCap,
     version
   };
 
   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,
@@ -186,11 +216,11 @@ export async function writeOutput(
 function getDubheDependency(network: 'mainnet' | 'testnet' | 'devnet' | 'localnet'): string {
   switch (network) {
     case 'localnet':
-      return 'Dubhe = { local = "../dubhe-framework" }';
+      return 'Dubhe = { local = "../dubhe" }';
     case 'testnet':
-      return 'Dubhe = { git = "https://github.com/0xobelisk/dubhe-framework.git", subdir = "contracts/dubhe", rev = "develop" }';
+      return `Dubhe = { git = "https://github.com/0xobelisk/dubhe-wip.git", subdir = "packages/sui-framework/src/dubhe", rev = "v${packageJson.version}" }`;
     case 'mainnet':
-      return 'Dubhe = { git = "https://github.com/0xobelisk/dubhe-framework.git", subdir = "contracts/dubhe", rev = "develop" }';
+      return `Dubhe = { git = "https://github.com/0xobelisk/dubhe-wip.git", subdir = "packages/sui-framework/src/dubhe", rev = "v${packageJson.version}" }`;
     default:
       throw new Error(`Unsupported network: ${network}`);
   }
@@ -206,32 +236,147 @@ export async function updateDubheDependency(
   fs.writeFileSync(filePath, updatedContent, 'utf-8');
   console.log(`Updated Dubhe dependency in ${filePath} for ${network}.`);
 }
+
+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) => {
+      // 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 {
+        const 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 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}`));
+        if (code === 0) {
+          console.log(chalk.green(`Successfully switched to environment ${network}`));
+          resolve();
         } else {
-          resolve(); // Resolve promise on successful exit
+          const 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;
   }
 }
 
@@ -271,3 +416,114 @@ 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']
+        }
+      };
+    }
+
+    if (Object.keys(component as object).length === 0) {
+      return {
+        [name]: {
+          fields: [
+            { entity_id: 'address' }
+          ],
+          keys: ['entity_id']
+        }
+      };
+    }
+
+    const fields = (component as any).fields || {};
+    const keys = (component as any).keys || ['entity_id'];
+
+    // ensure entity_id field exists
+    if (!fields.entity_id && keys.includes('entity_id')) {
+      fields.entity_id = 'address';
+    }
+
+    return {
+      [name]: {
+        fields: Object.entries(fields).map(([fieldName, fieldType]) => ({
+          [fieldName]: fieldType
+        })),
+        keys: keys
+      }
+    };
+  });
+
+  const resources = Object.entries(config.resources).map(([name, resource]) => {
+    if (typeof resource === 'string') {
+      return {
+        [name]: {
+          fields: [
+            { value: resource }
+          ],
+          keys: []
+        }
+      };
+    }
+
+    if (Object.keys(resource as object).length === 0) {
+      return {
+        [name]: {
+          fields: [],
+          keys: []
+        }
+      };
+    }
+
+    const fields = (resource as any).fields || {};
+    const keys = (resource as any).keys || [];
+
+    return {
+      [name]: {
+        fields: Object.entries(fields).map(([fieldName, fieldType]) => ({
+          [fieldName]: fieldType
+        })),
+        keys: keys
+      }
+    };
+  });
+
+  // handle enums
+  const enums = Object.entries(config.enums || {}).map(([name, enumFields]) => {
+    // Sort enum values by first letter
+    let sortedFields = enumFields.sort((a, b) => a.localeCompare(b)).map((value, index) => ({
+      [index]: value
+    }));
+
+    return {
+      [name]: {
+        fields: sortedFields
+      }
+    };
+  });
+
+  return JSON.stringify({
+    components,
+    resources,
+    enums
+  }, null, 2);
+}
+
+/**
+ * Updates the dubhe address in Move.toml file
+ * @param path - Directory path containing Move.toml file
+ * @param packageAddress - New dubhe package address to set
+ */
+export function updateMoveTomlAddress(path: string, packageAddress: string) {
+  const moveTomlPath = `${path}/Move.toml`;
+  const moveTomlContent = fs.readFileSync(moveTomlPath, 'utf-8');
+  // Use regex to match any dubhe address, not just "0x0"
+  const updatedContent = moveTomlContent.replace(/dubhe\s*=\s*"[^"]*"/, `dubhe = "${packageAddress}"`);
+  fs.writeFileSync(moveTomlPath, updatedContent, 'utf-8');
+}