create-dubhe 0.0.4 → 0.0.5

package/template/contract/sui-template/localnet/dubhe-framework/tests/init.move

@@ -0,0 +1,6 @@
+#[test_only]
+module dubhe::init_tests {
+    public fun init_dubhe_for_testing(ctx: &mut TxContext){
+        dubhe::dapps_schema::init_dapps_for_testing(ctx);
+    }
+}

package/template/contract/sui-template/localnet/dubhe-framework/tests/obelisk_framework_tests.move

@@ -0,0 +1,19 @@
+/*
+#[test_only]
+module dubhe_framework::dubhe_framework_tests {
+    // uncomment this line to import the module
+    // use dubhe_framework::dubhe_framework;
+
+    const ENotImplemented: u64 = 0;
+
+    #[test]
+    fun test_dubhe_framework() {
+        // pass
+    }
+
+    #[test, expected_failure(abort_code = ::dubhe_framework::dubhe_framework_tests::ENotImplemented)]
+    fun test_dubhe_framework_fail() {
+        abort ENotImplemented
+    }
+}
+*/

package/template/contract/sui-template/package.json

@@ -0,0 +1,28 @@
+{
+	"name": "dubhe-contract-template",
+	"version": "0.0.1",
+	"description": "Simple starter template",
+	"author": "team@0xobelisk.com",
+	"license": "MIT",
+	"scripts": {
+		"// Utility Commands": "----------------",
+		"schema:gen": "pnpm dubhe schemagen --configPath ./dubhe.config.ts",
+		"account:gen": "NODE_NO_WARNINGS=1 ts-node scripts/generateAccount.ts",
+		"start": "pnpm dubhe localnode start",
+		"faucet": "pnpm dubhe faucet --network",
+		"check-balance": "NODE_NO_WARNINGS=1 ts-node scripts/checkBalance.ts",
+		"deploy:localnet": "NODE_NO_WARNINGS=1 ts-node scripts/deployment/localnet/deploy.ts",
+		"deploy:testnet": "NODE_NO_WARNINGS=1 ts-node scripts/deployment/testnet/deploy.ts"
+	},
+	"dependencies": {
+		"@0xobelisk/sui-cli": "^0.5.25",
+		"@0xobelisk/sui-client": "^0.5.28",
+		"@0xobelisk/sui-common": "^0.5.21",
+		"dotenv": "^16.4.5",
+		"chalk": "^4.1.2"
+	},
+	"devDependencies": {
+		"ts-node": "^10.9.1",
+		"typescript": "5.1.6"
+	}
+}

package/template/contract/sui-template/scripts/checkBalance.ts

@@ -0,0 +1,40 @@
+import { Dubhe, NetworkType } from '@0xobelisk/sui-client';
+import chalk from 'chalk';
+import dotenv from 'dotenv';
+dotenv.config();
+
+async function checkBalance(network: string) {
+  try {
+    if (!process.env.PRIVATE_KEY) {
+      console.error(chalk.red('Please set the PRIVATE_KEY environment variable'));
+      process.exit(1);
+    }
+
+    if (!network) {
+      console.error(chalk.red('Network parameter is missing'));
+      process.exit(1);
+    }
+
+    const dubhe = new Dubhe({
+      secretKey: process.env.PRIVATE_KEY,
+      networkType: network as NetworkType,
+    });
+
+    const balance = await dubhe.getBalance();
+
+    if (balance.totalBalance === '0') {
+      console.log(chalk.yellow(`Account balance is 0, need to get ${network} coins`));
+      process.exit(1);
+    }
+
+    console.log(
+      chalk.green(`Current account balance: ${(Number(balance.totalBalance) / 1_000_000_000).toFixed(4)} SUI`),
+    );
+    process.exit(0);
+  } catch (error) {
+    console.error(chalk.red('Failed to check balance:', error));
+    process.exit(1);
+  }
+}
+
+checkBalance(process.argv[2] as NetworkType);

package/template/contract/sui-template/scripts/deployment/common.ts

@@ -0,0 +1,45 @@
+import { spawn } from 'child_process';
+import chalk from 'chalk';
+import { dubheConfig } from '../../dubhe.config';
+import * as fsAsync from 'fs/promises';
+import { DeploymentJsonType } from './types';
+
+export async function deployContract(
+  network: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
+  dappsObjectId?: string,
+): Promise<void> {
+  return new Promise((resolve, reject) => {
+    console.log(chalk.blue(`\n📦 Deploying ${dubheConfig.name} contract...`));
+
+    let args = ['dubhe', 'publish', '--network', network, '--configPath', './dubhe.config.ts'];
+    if (dappsObjectId) {
+      args.push('--dappsObjectId', dappsObjectId);
+    }
+
+    const childProcess = spawn('pnpm', args, {
+      shell: true,
+      stdio: 'inherit',
+    });
+
+    childProcess.on('exit', code => {
+      if (code === 0) {
+        console.log(chalk.green(`  ✅ ${dubheConfig.name} contract deployed successfully`));
+      } else {
+        console.error(chalk.red(`  ❌ Deployment failed. Exit code: ${code}`));
+        reject(new Error(`Deployment failed. Exit code: ${code}`));
+      }
+    });
+  });
+}
+
+export async function getContractDeploymentJson(projectPath: string, network: string): Promise<DeploymentJsonType> {
+  try {
+    const data = await fsAsync.readFile(
+      `${projectPath}/contracts/${dubheConfig.name}/.history/sui_${network}/latest.json`,
+      'utf8',
+    );
+    return JSON.parse(data) as DeploymentJsonType;
+  } catch {
+    throw new Error('Failed to read deployment history file');
+  }
+}

package/template/contract/sui-template/scripts/deployment/localnet/deploy.ts

@@ -0,0 +1,42 @@
+import chalk from 'chalk';
+import { deployFramework } from '../../framework/deploy';
+import { validateAndUpdatePackageId } from '../../framework/parse-history';
+import { deployContract } from '../common';
+
+async function delay(ms: number) {
+  await new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function main() {
+  try {
+    // 1. Deploy framework contract
+    console.log(chalk.blue('\n🏗️  Deploying framework contract...'));
+    await deployFramework();
+    console.log(chalk.green('  ✅ Framework contract deployed successfully'));
+    await delay(1000);
+
+    // 2. Parse framework information
+    console.log(chalk.blue('\n🔍 Parsing framework information...'));
+    const deploymentData = await validateAndUpdatePackageId();
+    console.log(chalk.green('  ✅ Framework information parsed successfully'));
+    await delay(1000);
+
+    // 3. Deploy contract
+    const dappsObjectId = deploymentData.dappsObjectId;
+    await deployContract('localnet', dappsObjectId);
+    console.log(chalk.green('\n✅ All operations completed successfully'));
+  } catch (error) {
+    console.error(chalk.red(`\n❌ Execution failed: ${error}`));
+    process.exit(1);
+  }
+}
+
+// Use IIFE (Immediately Invoked Function Expression) to ensure async code executes correctly
+(async () => {
+  try {
+    await main();
+  } catch (error) {
+    console.error(chalk.red(`\n❌ Main program execution failed: ${error}`));
+    process.exit(1);
+  }
+})();

package/template/contract/sui-template/scripts/deployment/testnet/deploy.ts

@@ -0,0 +1,48 @@
+import chalk from 'chalk';
+import { deployContract } from '../common';
+import { dubheConfig } from '../../../dubhe.config';
+import fs from 'fs/promises';
+import path from 'path';
+
+const TESTNET_FRAMEWORK_ID = '0x417ad1864a56a29ad0b5aaddd2e11bac1eeab6a68883ef53184a4cc5c293fec6';
+
+async function updateDubheMoveToml(projectName: string) {
+  try {
+    console.log(chalk.blue(`\n🔍 Updating Move.toml...`));
+    const moveTomlPath = path.join(process.cwd(), `contracts/${projectName}/Move.toml`);
+    let content = await fs.readFile(moveTomlPath, 'utf8');
+
+    content = content.replace(
+      /Dubhe = \{[^}]+\}/,
+      `Dubhe = { git = "https://github.com/0xobelisk/dubhe-framework.git", rev = "release-dubhe-v1.0.0-rc1" }`,
+    );
+
+    content = content.replace(/^dubhe\s+=\s+"0x[0-9a-fA-F]+"/m, `dubhe = "${TESTNET_FRAMEWORK_ID}"`);
+
+    await fs.writeFile(moveTomlPath, content);
+    console.log(chalk.green('  ✅ Move.toml updated successfully'));
+  } catch (error) {
+    throw new Error(`Failed to update Move.toml: ${error}`);
+  }
+}
+
+async function main() {
+  try {
+    await updateDubheMoveToml(dubheConfig.name);
+    await deployContract('testnet');
+    console.log(chalk.green('\n✅ All operations completed successfully'));
+  } catch (error) {
+    console.error(chalk.red(`\n❌ Execution failed: ${error}`));
+    process.exit(1);
+  }
+}
+
+// Use IIFE (Immediately Invoked Function Expression) to ensure async code executes correctly
+(async () => {
+  try {
+    await main();
+  } catch (error) {
+    console.error(chalk.red(`\n❌ Main program execution failed: ${error}`));
+    process.exit(1);
+  }
+})();

package/template/contract/sui-template/scripts/deployment/types.ts

@@ -0,0 +1,13 @@
+export type schema = {
+  name: string;
+  objectId: string;
+};
+
+export type DeploymentJsonType = {
+  projectName: string;
+  network: 'mainnet' | 'testnet' | 'devnet' | 'localnet';
+  packageId: string;
+  schemas: schema[];
+  upgradeCap: string;
+  version: number;
+};

package/template/contract/sui-template/scripts/framework/common.ts

@@ -0,0 +1,17 @@
+import * as fsAsync from 'fs/promises';
+import { FrameworkDeploymentJsonType } from './types';
+
+export async function getFrameworkDeploymentJson(
+  projectPath: string,
+  network: string,
+): Promise<FrameworkDeploymentJsonType> {
+  try {
+    const data = await fsAsync.readFile(
+      `${projectPath}/localnet/dubhe-framework/.history/sui_${network}/latest.json`,
+      'utf8',
+    );
+    return JSON.parse(data) as FrameworkDeploymentJsonType;
+  } catch {
+    throw new Error('Failed to read deployment history file');
+  }
+}

package/template/contract/sui-template/scripts/framework/deploy.ts

@@ -0,0 +1,199 @@
+import { Dubhe, loadMetadata, Transaction } from '@0xobelisk/sui-client';
+import { execSync } from 'child_process';
+import * as fsAsync from 'fs/promises';
+import { mkdirSync, writeFileSync } from 'fs';
+import { dirname } from 'path';
+import chalk from 'chalk';
+import { FrameworkDeploymentJsonType } from './types';
+import { getFrameworkDeploymentJson } from './common';
+import dotenv from 'dotenv';
+dotenv.config();
+
+export async function writeOutput(output: string, fullOutputPath: string, logPrefix?: string): Promise<void> {
+  mkdirSync(dirname(fullOutputPath), { recursive: true });
+
+  writeFileSync(fullOutputPath, output);
+  if (logPrefix !== undefined) {
+    console.log(`${logPrefix}: ${fullOutputPath}`);
+  }
+}
+
+export function saveContractData(
+  projectName: string,
+  network: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
+  packageId: string,
+  upgradeCap: string,
+  dappsObjectId: string,
+  version: number,
+) {
+  const DeploymentData: FrameworkDeploymentJsonType = {
+    projectName,
+    network,
+    packageId,
+    upgradeCap,
+    dappsObjectId,
+    version,
+  };
+
+  const path = process.cwd();
+  const storeDeploymentData = JSON.stringify(DeploymentData, null, 2);
+  writeOutput(
+    storeDeploymentData,
+    `${path}/localnet/dubhe-framework/.history/sui_${network}/latest.json`,
+    'Updated deployment log',
+  );
+}
+
+async function updateFrameworkMoveToml(frameworkPath: string, packageId: string | null = null) {
+  const moveTomlPath = `${frameworkPath}/Move.toml`;
+
+  try {
+    let content = await fsAsync.readFile(moveTomlPath, 'utf8');
+
+    if (packageId === null) {
+      // Pre-deployment: Reset addresses to 0x0
+      content = content.replace(/^published-at = "0x[0-9a-fA-F]+"/m, 'published-at = "0x0"');
+      content = content.replace(/^dubhe = "0x[0-9a-fA-F]+"/m, 'dubhe = "0x0"');
+      console.log(chalk.blue('Reset dubhe-framework addresses in Move.toml to 0x0'));
+    } else {
+      // Post-deployment: Update to new packageId
+      content = content.replace(/^published-at = "0x[0-9a-fA-F]+"/m, `published-at = "${packageId}"`);
+      content = content.replace(/^dubhe = "0x[0-9a-fA-F]+"/m, `dubhe = "${packageId}"`);
+      console.log(chalk.blue(`Updated dubhe-framework addresses in Move.toml to ${packageId}`));
+    }
+
+    await fsAsync.writeFile(moveTomlPath, content);
+  } catch (error) {
+    console.error(chalk.red(`Failed to update Move.toml: ${error}`));
+    throw error;
+  }
+}
+
+export async function deployFramework() {
+  const network = 'localnet';
+  const path = process.cwd();
+  const name = 'dubhe_framework';
+  const frameworkPath = `${path}/localnet/dubhe-framework`;
+
+  try {
+    // Try to get historical deployment information
+    const deploymentData = await getFrameworkDeploymentJson(path, network);
+
+    // Check if the contract exists
+    try {
+      const metadata = await loadMetadata(network, deploymentData.packageId);
+      if (metadata) {
+        console.log(chalk.yellow('Framework contract already deployed on local network'));
+        return; // Contract already exists, return directly
+      }
+    } catch (error) {
+      console.log(
+        chalk.yellow('Previous deployment found but contract not accessible, proceeding with new deployment'),
+      );
+    }
+  } catch (error) {
+    console.log(chalk.yellow('No previous deployment found, proceeding with new deployment'));
+  }
+
+  // Reset Move.toml addresses before compilation
+  await updateFrameworkMoveToml(frameworkPath);
+
+  // Check for private key in environment variables
+  const privateKey = process.env.PRIVATE_KEY;
+  if (!privateKey) {
+    throw new Error('Missing PRIVATE_KEY environment variable');
+  }
+
+  // Initialize Dubhe client
+  const dubhe = new Dubhe({
+    networkType: network,
+    secretKey: privateKey,
+  });
+  const keypair = dubhe.getKeypair();
+
+  const balance = await dubhe.getBalance();
+  console.log(chalk.blue(`Deployer Balance: ${(Number(balance.totalBalance) / 1_000_000_000).toFixed(4)} SUI`));
+
+  if (BigInt(balance.totalBalance) < BigInt(1000000000)) {
+    console.log(chalk.yellow('Balance is less than 1 SUI, requesting from faucet...'));
+    await dubhe.requestFaucet();
+    console.log(chalk.green('Successfully received SUI from faucet'));
+  }
+
+  // Compile and get bytecode
+  let modules, dependencies;
+  try {
+    const buildResult = JSON.parse(
+      execSync(`sui move build --dump-bytecode-as-base64 --path ${frameworkPath}`, {
+        encoding: 'utf-8',
+      }),
+    );
+    modules = buildResult.modules;
+    dependencies = buildResult.dependencies;
+  } catch (error: any) {
+    console.error(chalk.red('Error executing sui move build:'));
+    console.error(error.stdout);
+    process.exit(1);
+  }
+
+  console.log(chalk.blue(`Deployer Address: ${keypair.toSuiAddress()}`));
+
+  // Create publish transaction
+  const tx = new Transaction();
+  const [upgradeCap] = tx.publish({
+    modules,
+    dependencies,
+  });
+  tx.transferObjects([upgradeCap], keypair.toSuiAddress());
+
+  // Execute transaction
+  try {
+    const result = await dubhe.signAndSendTxn(tx);
+
+    if (result.effects?.status.status === 'failure') {
+      console.log(chalk.red(`Failed to execute publish`));
+      process.exit(1);
+    }
+
+    let packageId = '';
+    let upgradeCapId = '';
+    let dappsObjectId = '';
+
+    // Output deployment information
+    result.objectChanges!.map(object => {
+      if (object.type === 'published') {
+        console.log(chalk.blue(`Framework PackageId: ${object.packageId}`));
+        packageId = object.packageId;
+      }
+      if (object.type === 'created' && object.objectType === '0x2::package::UpgradeCap') {
+        console.log(chalk.blue(`Framework UpgradeCap: ${object.objectId}`));
+        upgradeCapId = object.objectId;
+      }
+      if (object.type === 'created' && object.objectType.includes('dapps_schema::Dapps')) {
+        console.log(chalk.blue(`Framework Dapps ObjectId: ${object.objectId}`));
+        dappsObjectId = object.objectId;
+      }
+    });
+
+    // Update Move.toml addresses with new packageId
+    await updateFrameworkMoveToml(frameworkPath, packageId);
+
+    console.log(chalk.green(`Publish transaction digest: ${result.digest}`));
+
+    // Save contract data
+    saveContractData(
+      name,
+      network,
+      packageId,
+      upgradeCapId,
+      dappsObjectId,
+      1, // Initial version is 1
+    );
+  } catch (error: any) {
+    console.error(chalk.red(`Failed to execute publish`));
+    console.error(error.message);
+    process.exit(1);
+  }
+}
+
+// deployFramework();

package/template/contract/sui-template/scripts/framework/parse-history.ts

@@ -0,0 +1,76 @@
+import { loadMetadata } from '@0xobelisk/sui-client';
+import { dubheConfig } from '../../dubhe.config';
+import * as fsAsync from 'fs/promises';
+import * as path from 'path';
+import chalk from 'chalk';
+import { FrameworkDeploymentJsonType } from './types';
+import { getFrameworkDeploymentJson } from './common';
+
+async function updateMoveToml(packageName: string, dubhePackageId: string) {
+  const moveTomlPath = path.join(process.cwd(), 'contracts', packageName, 'Move.toml');
+
+  try {
+    let content = await fsAsync.readFile(moveTomlPath, 'utf8');
+
+    // Update Dubhe dependency
+    content = content.replace(/Dubhe = \{[^}]+\}/, `Dubhe = { local = "../../localnet/dubhe-framework" }`);
+
+    // Update regex to match possible multiple spaces
+    content = content.replace(/^dubhe\s+=\s+"0x[0-9a-fA-F]+"/m, `dubhe = "${dubhePackageId}"`);
+
+    await fsAsync.writeFile(moveTomlPath, content);
+    console.log(chalk.green(`Successfully updated ${moveTomlPath}`));
+  } catch (error) {
+    console.error(chalk.red(`Failed to update Move.toml: ${error}`));
+    throw error;
+  }
+}
+
+export async function validateAndUpdatePackageId(): Promise<FrameworkDeploymentJsonType> {
+  const network = 'localnet';
+  const projectPath = process.cwd();
+
+  try {
+    const packageName = dubheConfig.name;
+
+    if (!packageName) {
+      throw new Error('Package name not found in the config file');
+    }
+
+    // Get historical deployment information
+    const deploymentData = await getFrameworkDeploymentJson(projectPath, network);
+
+    // Verify if packageId exists on chain
+    try {
+      const metadata = await loadMetadata(network, deploymentData.packageId);
+      if (!metadata) {
+        throw new Error('PackageId does not exist on chain');
+      }
+
+      console.log(chalk.green(`Verification successful: PackageId ${deploymentData.packageId} exists on chain`));
+
+      // Update Move.toml file
+      await updateMoveToml(packageName, deploymentData.packageId);
+
+      console.log(chalk.green('All updates completed successfully'));
+      return deploymentData;
+    } catch (error) {
+      console.error(chalk.red(`Verification failed: ${error}`));
+      throw error;
+    }
+  } catch (error) {
+    console.error(chalk.red(`Processing failed: ${error}`));
+    throw error;
+  }
+}
+
+// Export main function
+export async function parseAndUpdateFramework() {
+  try {
+    const packageId = await validateAndUpdatePackageId();
+    return packageId;
+  } catch (error) {
+    console.error(chalk.red(`Framework update failed: ${error}`));
+    process.exit(1);
+  }
+}

package/template/contract/sui-template/scripts/framework/types.ts

@@ -0,0 +1,8 @@
+export type FrameworkDeploymentJsonType = {
+  projectName: string;
+  network: 'mainnet' | 'testnet' | 'devnet' | 'localnet';
+  packageId: string;
+  upgradeCap: string;
+  dappsObjectId: string;
+  version: number;
+};

package/template/contract/sui-template/scripts/generateAccount.ts

@@ -0,0 +1,37 @@
+import { Dubhe } from '@0xobelisk/sui-client';
+import * as fs from 'fs';
+
+async function generateAccount() {
+  const path = process.cwd();
+
+  // Check if .env file exists and has content
+  let privateKey: string;
+  try {
+    const envContent = fs.readFileSync(`${path}/.env`, 'utf8');
+    const match = envContent.match(/PRIVATE_KEY=(.+)/);
+    if (match && match[1]) {
+      privateKey = match[1];
+      const dubhe = new Dubhe({ secretKey: privateKey });
+      const keypair = dubhe.getKeypair();
+
+      console.log(`Using existing Account: ${keypair.toSuiAddress()}`);
+      return;
+    }
+  } catch (error) {
+    // .env file doesn't exist or failed to read, continue to generate new account
+  }
+
+  // If no existing private key, generate new account
+  const dubhe = new Dubhe();
+  const keypair = dubhe.getKeypair();
+  privateKey = keypair.getSecretKey();
+
+  const chainFolderPath = `${path}/src/chain`;
+  fs.mkdirSync(chainFolderPath, { recursive: true });
+
+  fs.writeFileSync(`${path}/.env`, `PRIVATE_KEY=${privateKey}`);
+
+  console.log(`Generate new Account: ${keypair.toSuiAddress()}`);
+}
+
+generateAccount();

package/template/contract/sui-template/tsconfig.json

@@ -0,0 +1,35 @@
+{
+  "ts-node": {
+    "compilerOptions": {
+      "module": "CommonJS"
+    }
+  },
+  "compilerOptions": {
+    "target": "es6",
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": false,
+    "forceConsistentCasingInFileNames": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}

package/template/nextjs/sui-template/contracts/counter/Move.toml

@@ -5,9 +5,9 @@ edition = "2024.beta"
 
 [dependencies]
 Sui = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/sui-framework", rev = "mainnet-v1.36.2" }
-Dubhe = { git = "https://github.com/0xobelisk/dubhe.git", subdir = "packages/dubhe-framework", rev = "main" }
+Dubhe = { git = "https://github.com/0xobelisk/dubhe-framework.git", rev = "release-dubhe-v1.0.0-rc1" }
 
 [addresses]
 sui = "0x2"
-dubhe = "0x1736475f476c5dec96f33c03c778843f572239d3a887d795eef66d2836484c28"
-counter = "0x0"
+dubhe = "0x417ad1864a56a29ad0b5aaddd2e11bac1eeab6a68883ef53184a4cc5c293fec6"
+counter = "0x0"