movehat 0.0.1-alpha.0

package/src/commands/fork/list.ts

@@ -0,0 +1,67 @@
+import { join } from 'path';
+import { existsSync, readdirSync, statSync } from 'fs';
+import { ForkStorage } from '../../fork/storage.js';
+
+/**
+ * Fork list command: List all available forks
+ */
+export default async function forkListCommand() {
+  try {
+    const forksDir = join(process.cwd(), '.movehat', 'forks');
+
+    if (!existsSync(forksDir)) {
+      console.log('\n📂 No forks found\n');
+      console.log('Create a fork with:');
+      console.log('  movehat fork create --network testnet\n');
+      return;
+    }
+
+    const entries = readdirSync(forksDir);
+    const forkDirs = entries.filter((entry) => {
+      const fullPath = join(forksDir, entry);
+      return statSync(fullPath).isDirectory();
+    });
+
+    if (forkDirs.length === 0) {
+      console.log('\n📂 No forks found\n');
+      return;
+    }
+
+    console.log(`\n📂 Found ${forkDirs.length} fork(s):\n`);
+
+    for (const forkDir of forkDirs) {
+      const forkPath = join(forksDir, forkDir);
+      const storage = new ForkStorage(forkPath);
+
+      try {
+        if (storage.exists()) {
+          const metadata = storage.loadMetadata();
+          const accounts = storage.listAccounts();
+
+          console.log(`  ${forkDir}`);
+          console.log(`    Path: ${forkPath}`);
+          console.log(`    Network: ${metadata.network}`);
+          console.log(`    Chain ID: ${metadata.chainId}`);
+          console.log(`    Ledger Version: ${metadata.ledgerVersion}`);
+          console.log(`    Cached Accounts: ${accounts.length}`);
+          console.log(`    Created: ${new Date(metadata.createdAt).toLocaleString()}`);
+          console.log('');
+        } else {
+          console.log(`  ${forkDir} (invalid - missing metadata)`);
+          console.log('');
+        }
+      } catch (error) {
+        console.log(`  ${forkDir} (error reading metadata)`);
+        console.log('');
+      }
+    }
+
+    console.log('Usage:');
+    console.log('  movehat fork view-resource --fork <PATH> --account <ADDR> --resource <TYPE>');
+    console.log('  movehat fork fund --fork <PATH> --account <ADDR> --amount <AMOUNT>\n');
+
+  } catch (error: any) {
+    console.error(`\n❌ Error: ${error.message}\n`);
+    process.exit(1);
+  }
+}

package/src/commands/fork/serve.ts

@@ -0,0 +1,77 @@
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { loadUserConfig } from '../../core/config.js';
+import { ForkServer } from '../../fork/server.js';
+
+interface ForkServeOptions {
+  fork?: string;
+  port?: number;
+}
+
+/**
+ * Fork serve command: Start a local RPC server serving the fork
+ */
+export default async function forkServeCommand(options: ForkServeOptions): Promise<void> {
+  try {
+    // Determine fork path
+    let forkPath: string;
+
+    if (options.fork) {
+      // Use specified path
+      forkPath = options.fork;
+    } else {
+      // Use default fork path based on current network
+      const config = await loadUserConfig();
+      const networkName = process.env.MH_CLI_NETWORK || config.defaultNetwork || 'testnet';
+
+      // Lightweight validation: only check if network exists in config
+      // Don't validate accounts/keys since fork serve only reads data
+      if (!config.networks || !config.networks[networkName]) {
+        throw new Error(`Network "${networkName}" not found in config. Available networks: ${Object.keys(config.networks || {}).join(', ')}`);
+      }
+
+      forkPath = join(process.cwd(), '.movehat', 'forks', `${networkName}-fork`);
+    }
+
+    // Verify fork exists
+    if (!existsSync(join(forkPath, 'metadata.json'))) {
+      console.error(`\nError: Fork not found at ${forkPath}`);
+      console.error(`\nCreate a fork first with:`);
+      console.error(`  movehat fork create --network <network> --name <name>`);
+      process.exit(1);
+    }
+
+    // Get port (already validated by Commander's parsePort in cli.ts)
+    const port = options.port ?? 8080;
+
+    // Create and start server
+    const server = new ForkServer(forkPath, port);
+
+    // Handle graceful shutdown (use 'once' to prevent duplicate shutdowns)
+    const shutdown = async () => {
+      console.log('\n\nShutting down...');
+      await server.stop();
+      process.exit(0);
+    };
+
+    // Use named handlers so we can remove them if needed
+    const sigintHandler = () => { void shutdown(); };
+    const sigtermHandler = () => { void shutdown(); };
+
+    process.once('SIGINT', sigintHandler);
+    process.once('SIGTERM', sigtermHandler);
+
+    try {
+      // Start server
+      await server.start();
+    } finally {
+      // Remove handlers in case server is stopped by other means
+      process.removeListener('SIGINT', sigintHandler);
+      process.removeListener('SIGTERM', sigtermHandler);
+    }
+
+  } catch (error: any) {
+    console.error(`\nError starting fork server:`, error.message);
+    process.exit(1);
+  }
+}

package/src/commands/fork/view-resource.ts

@@ -0,0 +1,46 @@
+import { join } from 'path';
+import { ForkManager } from '../../fork/manager.js';
+
+interface ForkViewResourceOptions {
+  fork?: string;
+  account: string;
+  resource: string;
+}
+
+/**
+ * Fork view-resource command: View a resource from the fork
+ */
+export default async function forkViewResourceCommand(options: ForkViewResourceOptions) {
+  try {
+    if (!options.account) {
+      throw new Error('--account is required');
+    }
+
+    if (!options.resource) {
+      throw new Error('--resource is required');
+    }
+
+    // Determine fork path
+    const forkPath = options.fork || join(process.cwd(), '.movehat', 'forks', 'testnet-fork');
+
+    console.log(`\n🔍 Viewing resource from fork`);
+    console.log(`   Fork: ${forkPath}`);
+    console.log(`   Account: ${options.account}`);
+    console.log(`   Resource: ${options.resource}\n`);
+
+    // Load fork
+    const forkManager = new ForkManager(forkPath);
+    forkManager.load();
+
+    // Get resource
+    const resource = await forkManager.getResource(options.account, options.resource);
+
+    // Display result
+    console.log(JSON.stringify(resource, null, 2));
+    console.log('');
+
+  } catch (error: any) {
+    console.error(`\n❌ Error: ${error.message}\n`);
+    process.exit(1);
+  }
+}

package/src/commands/init.ts

@@ -0,0 +1,150 @@
+import fs from "fs/promises";
+import path from "path";
+import { fileURLToPath } from "url";
+import prompts from "prompts";
+import { printMovehatBanner } from "../helpers/banner.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export default async function initCommand(projectName?: string) {
+  // Show banner only on init command
+  printMovehatBanner();
+
+  // if name is not given
+  if (!projectName) {
+    const response = await prompts({
+      type: 'text',
+      name: 'projectName',
+      message: 'Project name:',
+      initial: 'first-project'
+    });
+
+    // If the user cancels (Ctrl+C), exit
+    if (!response.projectName) {
+      console.log('\n❌ Project initialization cancelled.');
+      process.exit(0);
+    }
+
+    projectName = response.projectName;
+  }
+
+  const targetDir = projectName!;
+  const projectPath = path.resolve(process.cwd(), targetDir);
+
+  console.log(`\nInitializing new Movehat project in ${projectPath}...`);
+
+  try {
+    await fs.mkdir(projectPath, { recursive: true });
+
+    const templatesDir = path.join(__dirname, "..", "templates");
+
+    console.log("📁 Creating project structure...");
+
+    await copyFile(
+      path.join(templatesDir, "package.json"),
+      path.join(projectPath, "package.json"),
+      { projectName: projectName! }
+    );
+
+    await copyFile(
+      path.join(templatesDir, "tsconfig.json"),
+      path.join(projectPath, "tsconfig.json")
+    );
+
+    await copyFile(
+      path.join(templatesDir, ".mocharc.json"),
+      path.join(projectPath, ".mocharc.json")
+    );
+
+    await copyFile(
+      path.join(templatesDir, "movehat.config.ts"),
+      path.join(projectPath, "movehat.config.ts")
+    );
+
+    await copyFile(
+      path.join(templatesDir, ".env.example"),
+      path.join(projectPath, ".env.example")
+    );
+
+    await copyFile(
+      path.join(templatesDir, ".gitignore"),
+      path.join(projectPath, ".gitignore")
+    );
+
+    await copyFile(
+      path.join(templatesDir, "README.md"),
+      path.join(projectPath, "README.md"),
+      { projectName: projectName! }
+    );
+
+    // 3. Copiar carpeta move/
+    console.log("📦 Setting up Move project...");
+    await copyDir(
+      path.join(templatesDir, "move"),
+      path.join(projectPath, "move")
+    );
+
+    // 4. Copiar scripts/
+    console.log("📜 Adding deployment scripts...");
+    await copyDir(
+      path.join(templatesDir, "scripts"),
+      path.join(projectPath, "scripts")
+    );
+
+    // 5. Copiar tests/
+    console.log("🧪 Adding test files...");
+    await copyDir(
+      path.join(templatesDir, "tests"),
+      path.join(projectPath, "tests")
+    );
+
+    console.log("\n✅ Project created successfully!\n");
+    console.log("📝 Next steps:\n");
+    console.log(`   cd ${projectName}`);
+    console.log(`   cp .env.example .env`);
+    console.log(`   # Edit .env with your credentials`);
+    console.log(`   npm install`);
+    console.log(`   npx movehat compile`);
+    console.log(`   npm test\n`);
+  } catch (error) {
+    console.error(`Failed to initialize project: ${error}`);
+  }
+}
+
+async function copyFile(
+  src: string,
+  dest: string,
+  replacements?: Record<string, string>
+) {
+  let content = await fs.readFile(src, "utf-8");
+
+  if (replacements) {
+    for (const [key, value] of Object.entries(replacements)) {
+      const regex = new RegExp(`{{${key}}}`, "g");
+      content = content.replace(regex, value);
+    }
+  }
+  await fs.writeFile(dest, content);
+}
+
+async function copyDir(src: string, dest: string) {
+  await fs.mkdir(dest, { recursive: true });
+  const entries = await fs.readdir(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    // Skip template development files
+    if (entry.name === 'types' || entry.name === '.vscode') {
+      continue;
+    }
+
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      await copyDir(srcPath, destPath);
+    } else {
+      await fs.copyFile(srcPath, destPath);
+    }
+  }
+}

package/src/commands/run.ts

@@ -0,0 +1,59 @@
+import { spawn } from "child_process";
+import { resolve, extname, dirname, join } from "path";
+import { existsSync } from "fs";
+import { fileURLToPath } from "url";
+
+export default async function runCommand(scriptPath: string) {
+  if (!scriptPath) {
+    console.error("❌ Error: No script path provided");
+    console.error("Usage: movehat run <script-path> [--network <name>]");
+    console.error("Example: movehat run scripts/deploy-counter.ts --network testnet");
+    process.exit(1);
+  }
+
+  const fullPath = resolve(process.cwd(), scriptPath);
+
+  // Check if file exists
+  if (!existsSync(fullPath)) {
+    console.error(`❌ Script not found: ${scriptPath}`);
+    process.exit(1);
+  }
+
+  // Check if it's a TypeScript or JavaScript file
+  const ext = extname(fullPath);
+  if (![".ts", ".js", ".mjs"].includes(ext)) {
+    console.error(`❌ Unsupported file type: ${ext}`);
+    console.error("Supported extensions: .ts, .js, .mjs");
+    process.exit(1);
+  }
+
+  const network = process.env.MH_CLI_NETWORK;
+  console.log(`🚀 Running script: ${scriptPath}`);
+  if (network) {
+    console.log(`   Network: ${network}`);
+  }
+  console.log();
+
+  // Find tsx from movehat's node_modules
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = dirname(__filename);
+  const tsxPath = join(__dirname, "..", "..", "node_modules", ".bin", "tsx");
+
+  // Execute script with tsx (handles both .ts and .js files)
+  const child = spawn(tsxPath, [fullPath], {
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      // MH_CLI_NETWORK is already set by the CLI hook
+    },
+  });
+
+  child.on("exit", (code) => {
+    process.exit(code || 0);
+  });
+
+  child.on("error", (error) => {
+    console.error(`❌ Failed to execute script: ${error.message}`);
+    process.exit(1);
+  });
+}

package/src/commands/test.ts

@@ -0,0 +1,42 @@
+import { spawn } from "child_process";
+import { join } from "path";
+import { existsSync } from "fs";
+
+export default async function testCommand() {
+  const testDir = join(process.cwd(), "tests");
+
+  if (!existsSync(testDir)) {
+    console.error("❌ No tests directory found.");
+    console.error("   Create a 'tests' directory with your TypeScript test files.");
+    process.exit(1);
+  }
+
+  console.log("🧪 Running TypeScript tests with Mocha...\n");
+
+  // Find mocha from project's node_modules
+  const mochaPath = join(process.cwd(), "node_modules", ".bin", "mocha");
+
+  if (!existsSync(mochaPath)) {
+    console.error("❌ Mocha not found in project dependencies.");
+    console.error("   Install it with: npm install --save-dev mocha");
+    process.exit(1);
+  }
+
+  // Run mocha with TypeScript support
+  const child = spawn(mochaPath, [], {
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      // Inherit network if set
+    },
+  });
+
+  child.on("exit", (code) => {
+    process.exit(code || 0);
+  });
+
+  child.on("error", (error) => {
+    console.error(`❌ Failed to run tests: ${error.message}`);
+    process.exit(1);
+  });
+}

package/src/core/config.ts

@@ -0,0 +1,151 @@
+import { pathToFileURL } from "url";
+import { join } from "path";
+import { existsSync } from "fs";
+import { MovehatConfig, MovehatUserConfig } from "../types/config.js";
+
+/**
+ * Loads the user's movehat.config.js from the current working directory.
+ * 
+ * @throws {Error} If the configuration file is not found or fails to load
+ * @security This function loads and executes code from the current working directory.
+ *           It should only be called from trusted project directories.
+ */
+export async function loadUserConfig(): Promise<MovehatUserConfig> {
+  const cwd = process.cwd();
+
+  // Try to find config file (.ts first, then .js)
+  const possiblePaths = [
+    join(cwd, "movehat.config.ts"),
+    join(cwd, "movehat.config.js"),
+  ];
+
+  let configPath: string | null = null;
+  for (const path of possiblePaths) {
+    if (existsSync(path)) {
+      configPath = path;
+      break;
+    }
+  }
+
+  if (!configPath) {
+    throw new Error(
+      "Configuration file not found. Expected 'movehat.config.ts' or 'movehat.config.js' in the current directory."
+    );
+  }
+
+  try {
+    let configModule;
+
+    if (configPath.endsWith('.ts')) {
+      // For TypeScript files, we need to use tsx's import system
+      // Register tsx loader for .ts files
+      const { register } = await import('tsx/esm/api');
+      const unregister = register();
+
+      try {
+        const configUrl = pathToFileURL(configPath).href;
+        configModule = await import(configUrl + '?t=' + Date.now());
+      } finally {
+        unregister();
+      }
+    } else {
+      // For .js files, use standard import
+      const configUrl = pathToFileURL(configPath).href;
+      configModule = await import(configUrl + '?t=' + Date.now());
+    }
+
+    const userConfig = configModule.default as MovehatUserConfig;
+
+    // Validate that networks are defined
+    if (!userConfig.networks || Object.keys(userConfig.networks).length === 0) {
+      throw new Error(
+        "No networks defined in configuration. Add at least one network in the 'networks' field."
+      );
+    }
+
+    return userConfig;
+  } catch (error) {
+    throw new Error(`Failed to load configuration file '${configPath}': ${error}`);
+  }
+}
+
+/**
+ * Resolve configuration for a specific network
+ * Merges global settings with network-specific settings
+ */
+export async function resolveNetworkConfig(
+  userConfig: MovehatUserConfig,
+  networkName?: string
+): Promise<MovehatConfig> {
+  // Determine which network to use
+  const selectedNetwork =
+    networkName ||
+    process.env.MH_CLI_NETWORK ||
+    process.env.MH_DEFAULT_NETWORK ||
+    userConfig.defaultNetwork ||
+    "testnet";
+
+  // Check if network exists in config
+  const networkConfig = userConfig.networks[selectedNetwork];
+  if (!networkConfig) {
+    const availableNetworks = Object.keys(userConfig.networks).join(", ");
+    throw new Error(
+      `Network '${selectedNetwork}' not found in configuration.\nAvailable networks: ${availableNetworks}`
+    );
+  }
+
+  // Get accounts using Hardhat-style resolution:
+  // 1. Network-specific accounts (if defined)
+  // 2. Global accounts from config (if defined)
+  // 3. PRIVATE_KEY environment variable (Hardhat-style, no MH_ prefix)
+  // 4. Error if nothing found
+
+  let accounts: string[] = [];
+
+  // 1. Check network-specific accounts
+  if (networkConfig.accounts && networkConfig.accounts.length > 0) {
+    accounts = [...networkConfig.accounts].filter(Boolean);
+  }
+
+  // 2. If no network-specific accounts, use global accounts
+  if (accounts.length === 0 && userConfig.accounts && userConfig.accounts.length > 0) {
+    accounts = [...userConfig.accounts].filter(Boolean);
+  }
+
+  // 3. If still no accounts, check PRIVATE_KEY env var (Hardhat-style)
+  if (accounts.length === 0 && process.env.PRIVATE_KEY) {
+    accounts = [process.env.PRIVATE_KEY];
+  }
+
+  // 4. Validate we have at least one account
+  if (accounts.length === 0 || !accounts[0]) {
+    throw new Error(
+      `Network '${selectedNetwork}' has no accounts configured.\n` +
+      `Options:\n` +
+      `  1. Set PRIVATE_KEY in your .env file (recommended)\n` +
+      `  2. Add 'accounts: ["0x..."]' globally in movehat.config.ts\n` +
+      `  3. Add 'accounts: ["0x..."]' to the '${selectedNetwork}' network config`
+    );
+  }
+
+  // Merge named addresses (network-specific overrides global)
+  const mergedNamedAddresses = {
+    ...(userConfig.namedAddresses || {}),
+    ...(networkConfig.namedAddresses || {}),
+  };
+
+  // Build resolved config
+  const resolvedConfig: MovehatConfig = {
+    network: selectedNetwork,
+    rpc: networkConfig.url,
+    privateKey: accounts[0],
+    allAccounts: accounts,
+    profile: networkConfig.profile || "default",
+    moveDir: userConfig.moveDir || "./move",
+    account: "", // Will be derived from privateKey in runtime
+    namedAddresses: mergedNamedAddresses,
+    networkConfig: networkConfig,
+  };
+
+  return resolvedConfig;
+}

package/src/core/contract.ts

@@ -0,0 +1,97 @@
+import {
+  Account,
+  Aptos,
+  type InputViewFunctionData,
+  type MoveFunctionId,
+} from "@aptos-labs/ts-sdk";
+
+export interface TransactionResult {
+  hash: string;
+  success: boolean;
+  vm_status: string;
+}
+
+export class MoveContract {
+  constructor(
+    private aptos: Aptos,
+    private moduleAddress: string,
+    private moduleName: string
+  ) {}
+
+  async call(
+    signer: Account,
+    functionName: string,
+    args: any[] = [],
+    typeArgs: string[] = []
+  ): Promise<TransactionResult> {
+    const functionFullName = `${this.moduleAddress}::${this.moduleName}::${functionName}`;
+
+    console.log(`📝 Calling ${functionFullName}...`);
+
+    const transaction = await this.aptos.transaction.build.simple({
+      sender: signer.accountAddress,
+      data: {
+        function: functionFullName as MoveFunctionId,
+        typeArguments: typeArgs,
+        functionArguments: args,
+      },
+    });
+
+    const signature = this.aptos.transaction.sign({
+      signer,
+      transaction,
+    });
+
+    const committedTxn = await this.aptos.transaction.submit.simple({
+      transaction,
+      senderAuthenticator: signature,
+    });
+
+    const response = await this.aptos.waitForTransaction({
+      transactionHash: committedTxn.hash,
+    });
+
+    console.log(
+      `✅ Transaction ${committedTxn.hash} committed with status: ${response.vm_status}\n`
+    );
+
+    return {
+      hash: committedTxn.hash,
+      success: response.success,
+      vm_status: response.vm_status,
+    };
+  }
+
+  async view<T = any>(
+    functionName: string,
+    args: any[] = [],
+    typeArgs: string[] = []
+  ): Promise<T> {
+    const functionFullName = `${this.moduleAddress}::${this.moduleName}::${functionName}`;
+
+    const payload: InputViewFunctionData = {
+      function: functionFullName as MoveFunctionId,
+      typeArguments: typeArgs,
+      functionArguments: args,
+    };
+
+    const result = await this.aptos.view({ payload });
+
+    return (result.length === 1 ? result[0] : result) as T;
+  }
+
+  getModuleId(): string {
+    return `${this.moduleAddress}::${this.moduleName}`;
+  }
+}
+
+/**
+ * Factory function to create a contract instance
+ */
+export function getContract(
+    aptos: Aptos,
+    moduleAddress: string,
+    moduleName: string
+): MoveContract {
+    return new MoveContract(aptos, moduleAddress, moduleName);
+}