create-dubhe 0.0.1

package/template/nextjs/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/nextjs/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 = '0x1736475f476c5dec96f33c03c778843f572239d3a887d795eef66d2836484c28';
+
+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.git", subdir = "packages/dubhe-framework", rev = "main" }`,
+    );
+
+    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/nextjs/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/nextjs/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/nextjs/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/nextjs/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/nextjs/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/nextjs/sui-template/scripts/generateAccount.ts

@@ -0,0 +1,55 @@
+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();
+
+      // Only update key.ts file
+      const chainFolderPath = `${path}/src/chain`;
+      fs.mkdirSync(chainFolderPath, { recursive: true });
+
+      fs.writeFileSync(
+        `${path}/src/chain/key.ts`,
+        `export const PRIVATEKEY = '${privateKey}';
+export const ACCOUNT = '${keypair.toSuiAddress()}';
+`,
+      );
+
+      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}`);
+
+  fs.writeFileSync(
+    `${path}/src/chain/key.ts`,
+    `export const PRIVATEKEY = '${privateKey}';
+  export const ACCOUNT = '${keypair.toSuiAddress()}';
+  `,
+  );
+
+  console.log(`Generate new Account: ${keypair.toSuiAddress()}`);
+}
+
+generateAccount();

package/template/nextjs/sui-template/scripts/storeConfig.ts

@@ -0,0 +1,61 @@
+import * as fsAsync from 'fs/promises';
+import { mkdirSync, writeFileSync } from 'fs';
+import { exit } from 'process';
+import { dubheConfig } from '../dubhe.config';
+import { dirname } from 'path';
+
+export type schema = {
+  name: string;
+  objectId: string;
+};
+
+type DeploymentJsonType = {
+  projectName: string;
+  network: 'mainnet' | 'testnet' | 'devnet' | 'localnet';
+  packageId: string;
+  schemas: schema[];
+  upgradeCap: string;
+  version: number;
+};
+
+async function getDeploymentJson(projectPath: string, network: string) {
+  try {
+    const data = await fsAsync.readFile(`${projectPath}/.history/sui_${network}/latest.json`, 'utf8');
+    return JSON.parse(data) as DeploymentJsonType;
+  } catch {
+    console.log('store config failed.');
+    exit;
+  }
+}
+
+function storeConfig(network: string, packageId: string, schemas: schema[]) {
+  let code = `type NetworkType = 'testnet' | 'mainnet' | 'devnet' | 'localnet';
+
+export const NETWORK: NetworkType = '${network}';
+
+export const PACKAGE_ID = '${packageId}'
+
+${schemas.map(schema => `export const ${schema.name.split('::')[2]}_Object_Id = '${schema.objectId}'`).join('\n')}
+`;
+  const path = process.cwd();
+  writeOutput(code, `${path}/src/chain/config.ts`, 'storeConfig');
+}
+
+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}`);
+  }
+}
+
+async function main() {
+  const path = process.cwd();
+  const network = process.argv[2];
+  const contractPath = `${path}/contracts/${dubheConfig.name}`;
+  const deployment = await getDeploymentJson(contractPath, network);
+  storeConfig(deployment.network, deployment.packageId, deployment.schemas);
+}
+
+main();

package/template/nextjs/sui-template/scripts/waitNode.ts

@@ -0,0 +1,9 @@
+import chalk from 'chalk';
+
+async function waitNode(ms: number) {
+  // 1. Start local node
+  console.log(chalk.blue('\n🌐 Waiting for node to start...'));
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+waitNode(3000);

package/template/nextjs/sui-template/src/chain/config.ts

@@ -0,0 +1,7 @@
+type NetworkType = 'testnet' | 'mainnet' | 'devnet' | 'localnet';
+
+export const NETWORK: NetworkType = 'testnet';
+
+export const PACKAGE_ID = '0xde82669197017965ce955ea7a5bb67750218523ca5f942f395b45610a1ec82d0'
+
+export const Counter_Object_Id = '0x88b0fcdec5a83cdebb308cbc8e721b146938273bcb439917674155c25ef9e895'

package/template/nextjs/sui-template/src/components/Animation.tsx

@@ -0,0 +1,80 @@
+import * as React from 'react'
+import {motion} from "framer-motion";
+
+//滑动指定位置的动画效果
+const visible = { opacity: 1, y: 0, transition: { duration: 0.5 } };
+
+const itemVariants = {
+    hidden: { opacity: 0, y: 40 },
+    visible
+};
+const InertiaTitle = ({ children }: { children: React.ReactNode }) => {
+
+    return (
+        <motion.div
+            initial={{ opacity: 0 ,y:100}}
+            whileInView={{ opacity: 1 ,y:0 }}
+            exit={{ opacity: 0, transition: { duration: 1 } }}
+            variants={{ visible: {
+                    opacity: 1,
+                    transition: { duration: 2 }
+                } }}
+            transition={{ type: "inertia", velocity: 180 }}
+            viewport={{ once: true }}
+        >
+            <div  className="w-full">
+                {children}
+            </div>
+        </motion.div>
+
+
+    )
+}
+const TweenTitle = ({ children }: { children: React.ReactNode }) => {
+
+    return (
+        <motion.div
+            initial={{ opacity: 0 ,y:100}}
+            whileInView={{ opacity: 1 ,y:0 }}
+            exit={{ opacity: 0, transition: { duration: 1 } }}
+            variants={{ visible: {
+                    opacity: 1,
+                    transition: { duration: 2 }
+                } }}
+            transition={{ duration: 1, type: "tween",delay: 0.01 }}
+
+            viewport={{ once: true }}
+        >
+            <div  className="w-full">
+                {children}
+            </div>
+        </motion.div>
+
+
+    )
+}
+
+ const Animation = ({ children }: { children: React.ReactNode }) => {
+
+    return (
+        <motion.div
+            initial={{ opacity: 0 ,y:100}}
+            whileInView={{ opacity: 1 ,y:0 }}
+            exit={{ opacity: 0, transition: { duration: 1 } }}
+            variants={{ visible: {
+                    opacity: 1,
+                    transition: { duration: 2 }
+                } }}
+            transition={{ type: "spring", stiffness: 300 ,delay: 0.01}}
+            viewport={{ once: true }}
+        >
+            <div  className="w-full">
+                {children}
+            </div>
+        </motion.div>
+
+
+    )
+}
+
+export {InertiaTitle,Animation,TweenTitle}

package/template/nextjs/sui-template/src/components/Container.tsx

@@ -0,0 +1,11 @@
+import clsx from 'clsx'
+
+//组件公共样式
+export function Container({ className, ...props }) {
+  return (
+    <div
+      className={clsx('mx-auto  max-w-7xl px-4 sm:px-6 lg:px-8', className)}
+      {...props}
+    />
+  )
+}