movehat 0.0.6-alpha.0 → 0.0.8-alpha.0

package/dist/templates/movehat.config.ts

@@ -3,18 +3,28 @@ dotenv.config();
 
 export default {
   // Default network to use when no --network flag is provided
+  // "testnet" = Movement testnet (public, auto-generates test accounts)
+  // "mainnet" = Movement mainnet (requires PRIVATE_KEY in .env)
+  // "local" = Fork server running on localhost:8080
   defaultNetwork: "testnet",
 
   // Network configurations
   networks: {
+    // Movement Testnet - Public test network (recommended for development)
+    // Auto-generates test accounts - no local setup required
+    // Perfect for running tests with transaction simulation
     testnet: {
       url: process.env.MOVEMENT_RPC_URL || "https://testnet.movementnetwork.xyz/v1",
       chainId: "testnet",
     },
+    // Movement Mainnet - Production network
+    // REQUIRES PRIVATE_KEY in .env - uses real MOVE tokens
     mainnet: {
       url: "https://mainnet.movementnetwork.xyz/v1",
       chainId: "mainnet",
     },
+    // Local fork server (requires: movehat fork serve)
+    // Useful for testing against a snapshot of real network state
     local: {
       url: "http://localhost:8080/v1",
       chainId: "local",

package/dist/templates/package.json

@@ -8,7 +8,7 @@
     "deploy": "movehat run scripts/deploy-counter.ts"
   },
   "dependencies": {
-    "movehat": "^0.0.6-alpha.0",
+    "movehat": "latest",
     "@aptos-labs/ts-sdk": "^5.1.5",
     "dotenv": "^17.2.3"
   },

package/dist/templates/tests/Counter.test.ts

@@ -1,75 +1,72 @@
-import { describe, it, before, after } from "mocha";
+// @ts-nocheck - This is a template file, dependencies are installed in user projects
+import { describe, it, before } from "mocha";
 import { expect } from "chai";
 import { getMovehat, type MovehatRuntime } from "movehat";
-import type { MoveContract } from "movehat/helpers";
-import { assertTransactionSuccess, snapshot } from "movehat/helpers";
 
 describe("Counter Contract", () => {
   let mh: MovehatRuntime;
-  let counter: MoveContract;
+  let contractAddress: string;
 
   before(async function () {
     this.timeout(30000);
 
     // Initialize Movehat Runtime Environment
+    // Uses testnet by default - no local setup required
     mh = await getMovehat();
 
-    console.log(`\n✅ Testing on ${mh.network.name}`);
-    console.log(`   Account: ${mh.account.accountAddress.toString()}\n`);
+    contractAddress = mh.account.accountAddress.toString();
 
-    // Get counter contract instance
-    counter = mh.getContract(
-      mh.account.accountAddress.toString(),
-      "counter"
-    );
+    console.log(`\nTesting on ${mh.network.name}`);
+    console.log(`Account: ${contractAddress}\n`);
   });
 
   describe("Counter functionality", () => {
-    it("should initialize counter", async function () {
+    it("should initialize counter using simulation", async function () {
       this.timeout(30000);
 
-      const txResult = await counter.call(mh.account, "init", []);
-      assertTransactionSuccess(txResult);
-
-      const value = await counter.view<number>("get", [
-        mh.account.accountAddress.toString()
-      ]);
-
-      expect(value).to.equal(0);
-      console.log(`   ✓ Counter initialized with value: ${value}`);
+      // Build transaction
+      const transaction = await mh.aptos.transaction.build.simple({
+        sender: mh.account.accountAddress,
+        data: {
+          function: `${contractAddress}::counter::init`,
+          functionArguments: []
+        }
+      });
+
+      // Simulate transaction (no gas cost, instant)
+      const [simulation] = await mh.aptos.transaction.simulate.simple({
+        signerPublicKey: mh.account.publicKey,
+        transaction
+      });
+
+      // Verify simulation succeeded
+      expect(simulation.success).to.be.true;
+      console.log(`Counter init simulated successfully`);
+      console.log(`Gas used: ${simulation.gas_used}`);
     });
 
-    it("should increment counter", async function () {
+    it("should increment counter using simulation", async function () {
       this.timeout(30000);
 
-      const initialValue = await counter.view<number>("get", [
-        mh.account.accountAddress.toString()
-      ]);
-
-      const txResult = await counter.call(mh.account, "increment", []);
-      assertTransactionSuccess(txResult);
-
-      const newValue = await counter.view<number>("get", [
-        mh.account.accountAddress.toString()
-      ]);
-
-      expect(newValue).to.equal(initialValue + 1);
-      console.log(`   ✓ Counter incremented: ${initialValue} → ${newValue}`);
+      // Build increment transaction
+      const transaction = await mh.aptos.transaction.build.simple({
+        sender: mh.account.accountAddress,
+        data: {
+          function: `${contractAddress}::counter::increment`,
+          functionArguments: []
+        }
+      });
+
+      // Simulate transaction
+      const [simulation] = await mh.aptos.transaction.simulate.simple({
+        signerPublicKey: mh.account.publicKey,
+        transaction
+      });
+
+      // Verify simulation succeeded
+      expect(simulation.success).to.be.true;
+      console.log(`Counter increment simulated successfully`);
+      console.log(`Gas used: ${simulation.gas_used}`);
     });
   });
-
-  // Optional: Create a snapshot after tests for debugging
-  // Uncomment to enable
-  /*
-  after(async function () {
-    this.timeout(30000);
-
-    const snapshotPath = await snapshot({
-      name: 'counter-test-final'
-    });
-
-    console.log(`\n📸 Snapshot created: ${snapshotPath}`);
-    console.log(`   Use 'aptos move sim view-resource --session ${snapshotPath}' to inspect state\n`);
-  });
-  */
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "movehat",
-  "version": "0.0.6-alpha.0",
+  "version": "0.0.8-alpha.0",
   "type": "module",
   "description": "Hardhat-like development framework for Movement L1 and Aptos Move smart contracts",
   "bin": {

package/src/commands/compile.ts

@@ -4,6 +4,72 @@ import { exec } from "child_process";
 import { loadUserConfig } from "../core/config.js";
 import { validateAndEscapePath, escapeShellArg } from "../core/shell.js";
 
+/**
+ * Recursively find all .move files in a directory
+ * @param dir - Directory to search
+ * @param maxDepth - Maximum recursion depth (default: 10)
+ * @param currentDepth - Current recursion depth (internal use)
+ */
+function findMoveFiles(dir: string, maxDepth: number = 10, currentDepth: number = 0): string[] {
+  const files: string[] = [];
+
+  // Prevent infinite loops from excessive recursion
+  if (currentDepth > maxDepth) {
+    return files;
+  }
+
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+
+    if (entry.isDirectory()) {
+      // Skip symlinks to prevent directory traversal and infinite loops
+      if (entry.isSymbolicLink()) {
+        continue;
+      }
+      files.push(...findMoveFiles(fullPath, maxDepth, currentDepth + 1));
+    } else if (entry.name.endsWith('.move')) {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+/**
+ * Extract named addresses used in Move files
+ * Looks for patterns like: module <address>::<module_name>
+ */
+function extractNamedAddresses(moveDir: string): Set<string> {
+  const addresses = new Set<string>();
+  const moveFiles = findMoveFiles(moveDir);
+
+  for (const file of moveFiles) {
+    let content = fs.readFileSync(file, 'utf-8');
+
+    // Strip comments to avoid false positives
+    // Remove block comments /* ... */ (non-greedy, handles newlines)
+    content = content.replace(/\/\*[\s\S]*?\*\//g, ' ');
+    // Remove line comments // ... to end of line
+    content = content.replace(/\/\/.*$/gm, ' ');
+
+    // Match: module <address>::<module_name>
+    const moduleRegex = /module\s+([a-zA-Z_][a-zA-Z0-9_]*)::/g;
+    let match;
+
+    while ((match = moduleRegex.exec(content)) !== null) {
+      const address = match[1];
+      // Skip standard addresses
+      if (address !== 'std' && address !== 'aptos_framework' && address !== 'aptos_std') {
+        addresses.add(address);
+      }
+    }
+  }
+
+  return addresses;
+}
+
 function run(command: string, cwd: string) {
   return new Promise<void>((resolve, reject) => {
     exec(command, { cwd }, (error, stdout, stderr) => {
@@ -23,11 +89,11 @@ export default async function compileCommand() {
     // Compile is network-independent - only uses global config
     const userConfig = await loadUserConfig();
 
-    console.log("📦 Compiling Move contracts (network-independent)...");
+    console.log("Compiling Move contracts...");
 
     const moveDir = path.resolve(process.cwd(), userConfig.moveDir || "./move");
     if (!fs.existsSync(moveDir)) {
-      console.error(`❌ Move directory not found: ${moveDir}`);
+      console.error(`Move directory not found: ${moveDir}`);
       console.error(`   Update movehat.config.ts -> moveDir`);
       return;
     }
@@ -35,8 +101,21 @@ export default async function compileCommand() {
     // Validate and escape to prevent command injection
     const safeMoveDir = validateAndEscapePath(moveDir, "Move directory");
 
-    // Use global named addresses for compilation
-    const namedAddresses = userConfig.namedAddresses ?? {};
+    // Auto-detect named addresses from Move files
+    const detectedAddresses = extractNamedAddresses(moveDir);
+
+    // Merge user-configured addresses with auto-detected ones
+    const namedAddresses = { ...(userConfig.namedAddresses ?? {}) };
+    const autoAssignedAddresses: string[] = [];
+
+    // For any detected address not in config, use a dev address
+    for (const addr of detectedAddresses) {
+      if (!namedAddresses[addr]) {
+        namedAddresses[addr] = "0xcafe"; // Dev address for compilation
+        autoAssignedAddresses.push(addr);
+      }
+    }
+
     let namedAddressesArg = "";
 
     if (Object.keys(namedAddresses).length > 0) {
@@ -70,15 +149,21 @@ export default async function compileCommand() {
     const command = `movement move build --package-dir ${safeMoveDir} ${namedAddressesArg}`.trim();
 
     console.log(`   Move directory: ${moveDir}`);
-    if (Object.keys(namedAddresses).length > 0) {
-      console.log(`   Named addresses: ${Object.keys(namedAddresses).join(", ")}`);
+    if (detectedAddresses.size > 0) {
+      console.log(`   Detected addresses: ${Array.from(detectedAddresses).join(", ")}`);
+    }
+    if (Object.keys(userConfig.namedAddresses ?? {}).length > 0) {
+      console.log(`   Configured addresses: ${Object.keys(userConfig.namedAddresses!).join(", ")}`);
+    }
+    if (autoAssignedAddresses.length > 0) {
+      console.log(`   Auto-assigned dev address (0xcafe): ${autoAssignedAddresses.join(", ")}`);
     }
     console.log();
 
     await run(command, moveDir);
-    console.log("✅ Compilation finished successfully.");
+    console.log("Compilation finished successfully.");
   } catch (err: any) {
-    console.error("❌ Compilation failed:", err.message ?? err);
+    console.error("Compilation failed:", err.message ?? err);
     process.exit(1);
   }
 }

package/src/commands/init.ts

@@ -22,7 +22,7 @@ export default async function initCommand(projectName?: string) {
 
     // If the user cancels (Ctrl+C), exit
     if (!response.projectName) {
-      console.log('\n❌ Project initialization cancelled.');
+      console.log('\nProject initialization cancelled.');
       process.exit(0);
     }
 
@@ -39,7 +39,7 @@ export default async function initCommand(projectName?: string) {
 
     const templatesDir = path.join(__dirname, "..", "templates");
 
-    console.log("📁 Creating project structure...");
+    console.log("Creating project structure...");
 
     await copyFile(
       path.join(templatesDir, "package.json"),
@@ -79,7 +79,7 @@ export default async function initCommand(projectName?: string) {
     );
 
     // 3. Copiar carpeta move/
-    console.log("📦 Setting up Move project...");
+    console.log("Setting up Move project...");
     await copyDir(
       path.join(templatesDir, "move"),
       path.join(projectPath, "move"),
@@ -87,21 +87,21 @@ export default async function initCommand(projectName?: string) {
     );
 
     // 4. Copiar scripts/
-    console.log("📜 Adding deployment scripts...");
+    console.log("Adding deployment scripts...");
     await copyDir(
       path.join(templatesDir, "scripts"),
       path.join(projectPath, "scripts")
     );
 
     // 5. Copiar tests/
-    console.log("🧪 Adding test files...");
+    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("\nProject 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`);

package/src/commands/test.ts

@@ -6,18 +6,18 @@ export default async function testCommand() {
   const testDir = join(process.cwd(), "tests");
 
   if (!existsSync(testDir)) {
-    console.error("❌ No tests directory found.");
+    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");
+  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("Mocha not found in project dependencies.");
     console.error("   Install it with: npm install --save-dev mocha");
     process.exit(1);
   }
@@ -36,7 +36,7 @@ export default async function testCommand() {
   });
 
   child.on("error", (error) => {
-    console.error(`❌ Failed to run tests: ${error.message}`);
+    console.error(`Failed to run tests: ${error.message}`);
     process.exit(1);
   });
 }

package/src/core/config.ts

@@ -78,6 +78,7 @@ export async function resolveNetworkConfig(
   networkName?: string
 ): Promise<MovehatConfig> {
   // Determine which network to use
+  // Default to "testnet" for testing with simulation
   const selectedNetwork =
     networkName ||
     process.env.MH_CLI_NETWORK ||
@@ -86,11 +87,31 @@ export async function resolveNetworkConfig(
     "testnet";
 
   // Check if network exists in config
-  const networkConfig = userConfig.networks[selectedNetwork];
+  let networkConfig = userConfig.networks[selectedNetwork];
+
+  // Special case: Auto-generate config for testnet (public test network)
+  // This provides a better dev experience - no local setup required
+  if (!networkConfig && selectedNetwork === "testnet") {
+    networkConfig = {
+      url: "https://testnet.movementnetwork.xyz/v1",
+      chainId: "testnet",
+    };
+    console.log(`testnet not found in config - using default Movement testnet configuration`);
+  }
+
+  // Special case: Auto-generate config for local fork server
+  if (!networkConfig && selectedNetwork === "local") {
+    networkConfig = {
+      url: "http://localhost:8080/v1",
+      chainId: "local",
+    };
+    console.log(`Local network not found in config - using default fork server configuration`);
+  }
+
   if (!networkConfig) {
     const availableNetworks = Object.keys(userConfig.networks).join(", ");
     throw new Error(
-      `Network '${selectedNetwork}' not found in configuration.\nAvailable networks: ${availableNetworks}`
+      `Network '${selectedNetwork}' not found in configuration.\nAvailable networks: ${availableNetworks}, testnet (auto-generated), local (auto-generated)`
     );
   }
 
@@ -117,15 +138,38 @@ export async function resolveNetworkConfig(
     accounts = [process.env.PRIVATE_KEY];
   }
 
-  // 4. Validate we have at least one account
+  // 4. Validate we have at least one account (unless using testnet/local)
   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`
-    );
+    // Special case: Auto-generate test accounts for testing networks
+    // testnet = public Movement test network (recommended)
+    // local = local fork server
+    if (selectedNetwork === "testnet" || selectedNetwork === "local") {
+      // Security: Using a deterministic test account (like Hardhat's default accounts)
+      // This is SAFE because:
+      // 1. Only used for testnet/local (never mainnet - that throws error below)
+      // 2. Perfect for transaction simulation (no real funds)
+      // 3. Deterministic = consistent test results
+      const testPrivateKey = "0x0000000000000000000000000000000000000000000000000000000000000001";
+      accounts = [testPrivateKey];
+      console.log(`\n[TESTNET] Using auto-generated test account (safe for testing only)`);
+      console.log(`[TESTNET] For mainnet, set PRIVATE_KEY in .env\n`);
+    } else {
+      // For any other network (especially mainnet), REQUIRE explicit configuration
+      // This prevents accidentally using the test key on production networks
+      throw new Error(
+        `Network '${selectedNetwork}' has no accounts configured.\n` +
+        `\n` +
+        `SECURITY: This network requires explicit account configuration.\n` +
+        `\n` +
+        `Options:\n` +
+        `  1. Set PRIVATE_KEY in your .env file (recommended for ${selectedNetwork})\n` +
+        `  2. Add 'accounts: ["0x..."]' globally in movehat.config.ts\n` +
+        `  3. Add 'accounts: ["0x..."]' to the '${selectedNetwork}' network config\n` +
+        `\n` +
+        `For testing without configuration, use:\n` +
+        `  movehat <command> --network testnet (auto-generates safe test accounts)`
+      );
+    }
   }
 
   // Merge named addresses (network-specific overrides global)

package/src/templates/README.md

@@ -1,11 +1,18 @@
-# {{PROJECT_NAME}}
+# {{projectName}}
 
 A Move smart contract project built with Movehat.
 
 ## Prerequisites
 
-- Node.js v18+
-- [Movement CLI](https://docs.movementnetwork.xyz/devs/movementCLI)
+**Required:**
+- **Node.js v18+** - [Download](https://nodejs.org/)
+- **Movement CLI** - **REQUIRED** for compiling contracts
+
+  Install: [Movement CLI Installation Guide](https://docs.movementnetwork.xyz/devs/movementCLI)
+
+  Verify: `movement --version`
+
+**⚠️ Important:** Without Movement CLI, compilation will fail!
 
 ## Getting Started
 
@@ -25,41 +32,36 @@ cp .env.example .env
 
 Edit `.env`:
 ```
-MH_PRIVATE_KEY=your_private_key_here
-MH_ACCOUNT=your_account_address_here
-MH_NETWORK=testnet
-```
-
-### 3. Update Move.toml
-
-Edit `move/Move.toml` and set the `counter` address to your account address:
-
-```toml
-[addresses]
-counter = "0xYOUR_ACCOUNT_ADDRESS"
+PRIVATE_KEY=your_private_key_here
 ```
 
-### 4. Compile contracts
+### 3. Compile contracts
 
 ```bash
 npm run compile
 ```
 
-### 5. Deploy
+**How it works:**
+- Movehat automatically detects named addresses from your Move files
+- No need to manually configure addresses in `Move.toml`
+- Just add any new `.move` file and it will compile automatically (like Hardhat!)
 
-```bash
-npx tsx scripts/deploy-counter.ts
-```
+### 4. Run tests
 
-Or use the Movement CLI directly:
 ```bash
-movement move publish --package-dir ./move --profile default --assume-yes
+npm test
 ```
 
-### 6. Run tests
+**How it works:**
+- Tests use **Transaction Simulation** - no real blockchain required
+- Runs instantly without gas costs
+- Uses Movement testnet by default with auto-generated test accounts
+- Perfect for TDD and CI/CD workflows
+
+### 5. Deploy (optional)
 
 ```bash
-npm test
+npx movehat run scripts/deploy-counter.ts
 ```
 
 ## Project Structure
@@ -80,10 +82,37 @@ npm test
 
 ## Available Commands
 
-- `npm run compile` - Compile Move contracts
+- `npm run compile` - Compile Move contracts (auto-detects addresses)
 - `npm test` - Run integration tests
 - `npm run test:watch` - Run tests in watch mode
-- `npx tsx scripts/deploy-counter.ts` - Deploy and initialize counter
+- `npx movehat run scripts/deploy-counter.ts` - Deploy and initialize counter
+
+## How Named Addresses Work
+
+Movehat automatically detects named addresses from your Move code:
+
+```move
+module counter::counter {  // ← "counter" is auto-detected
+  // ...
+}
+```
+
+- **For development:** Movehat uses temp addresses (`0xcafe`) automatically
+- **For production:** Specify real addresses in `movehat.config.ts`
+
+**Adding new contracts:**
+1. Create `move/sources/MyContract.move`
+2. Write: `module mycontract::mycontract { ... }`
+3. Run `npm run compile`
+4. It just works! (like Hardhat)
+
+## Troubleshooting
+
+| Error | Solution |
+|-------|----------|
+| `movement: command not found` | Install Movement CLI (see Prerequisites) |
+| `Cannot find package 'dotenv'` | Run `npm install` |
+| Compilation failed | Ensure Movement CLI is installed: `movement --version` |
 
 ## Learn More
 

package/src/templates/move/Move.toml

@@ -7,6 +7,8 @@ authors = []
 counter = "_"
 
 [dev-addresses]
+# Dev addresses are auto-detected by movehat during compilation
+# You can also add them manually here if needed
 
 [dependencies.AptosFramework]
 git = "https://github.com/movementlabsxyz/aptos-core.git"

package/src/templates/movehat.config.ts

@@ -3,18 +3,28 @@ dotenv.config();
 
 export default {
   // Default network to use when no --network flag is provided
+  // "testnet" = Movement testnet (public, auto-generates test accounts)
+  // "mainnet" = Movement mainnet (requires PRIVATE_KEY in .env)
+  // "local" = Fork server running on localhost:8080
   defaultNetwork: "testnet",
 
   // Network configurations
   networks: {
+    // Movement Testnet - Public test network (recommended for development)
+    // Auto-generates test accounts - no local setup required
+    // Perfect for running tests with transaction simulation
     testnet: {
       url: process.env.MOVEMENT_RPC_URL || "https://testnet.movementnetwork.xyz/v1",
       chainId: "testnet",
     },
+    // Movement Mainnet - Production network
+    // REQUIRES PRIVATE_KEY in .env - uses real MOVE tokens
     mainnet: {
       url: "https://mainnet.movementnetwork.xyz/v1",
       chainId: "mainnet",
     },
+    // Local fork server (requires: movehat fork serve)
+    // Useful for testing against a snapshot of real network state
     local: {
       url: "http://localhost:8080/v1",
       chainId: "local",

package/src/templates/package.json

@@ -8,7 +8,7 @@
     "deploy": "movehat run scripts/deploy-counter.ts"
   },
   "dependencies": {
-    "movehat": "^0.0.6-alpha.0",
+    "movehat": "latest",
     "@aptos-labs/ts-sdk": "^5.1.5",
     "dotenv": "^17.2.3"
   },