movehat 0.2.6 → 0.2.8

package/dist/cli.js

@@ -66,7 +66,7 @@ program
 });
 program
     .command('compile')
-    .description('Compile Move smart contracts using Movement CLI')
+    .description('Compile Move smart contracts (auto-detects named addresses and updates Move.toml)')
     .action(compileCommand);
 program
     .command('run <script>')

package/dist/commands/fork/fund.js

@@ -34,9 +34,11 @@ export default async function forkFundCommand(options) {
         // Verify
         const resourceType = `0x1::coin::CoinStore<${coinType}>`;
         const coinStore = await forkManager.getResource(options.account, resourceType);
+        const { assertCoinStore } = await import('../../fork/validation.js');
+        const validated = assertCoinStore(coinStore);
         logger.newline();
         logger.success("Account funded successfully!");
-        logger.plain(`   New balance: ${coinStore.coin.value}`);
+        logger.plain(`   New balance: ${validated.coin.value}`);
         logger.newline();
     }
     catch (error) {

package/dist/commands/fork/serve.js

@@ -2,6 +2,7 @@ import { join } from 'path';
 import { existsSync } from 'fs';
 import { loadUserConfig } from '../../core/config.js';
 import { ForkServer } from '../../fork/server.js';
+import { logger } from '../../ui/index.js';
 /**
  * Fork serve command: Start a local RPC server serving the fork
  */
@@ -26,9 +27,11 @@ export default async function forkServeCommand(options) {
         }
         // 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>`);
+            logger.newline();
+            logger.error(`Fork not found at ${forkPath}`);
+            logger.newline();
+            logger.error("Create a fork first with:");
+            logger.error("  movehat fork create --network <network> --name <name>");
             process.exit(1);
         }
         // Get port (already validated by Commander's parsePort in cli.ts)
@@ -38,7 +41,8 @@ export default async function forkServeCommand(options) {
         const server = new ForkServer(forkPath, port, host);
         // Handle graceful shutdown (use 'once' to prevent duplicate shutdowns)
         const shutdown = async () => {
-            console.log('\n\nShutting down...');
+            logger.newline();
+            logger.step("Shutting down...");
             await server.stop();
             process.exit(0);
         };
@@ -59,7 +63,8 @@ export default async function forkServeCommand(options) {
     }
     catch (error) {
         const msg = error instanceof Error ? error.message : String(error);
-        console.error(`\nError starting fork server:`, msg);
+        logger.newline();
+        logger.error(`Error starting fork server: ${msg}`);
         process.exit(1);
     }
 }

package/dist/commands/test-move.js

@@ -1,7 +1,9 @@
 import { runMoveTests } from "../helpers/move-tests.js";
+import { logger } from "../ui/index.js";
 export default async function testMoveCommand(options = {}) {
     try {
-        console.log("Running Move unit tests...\n");
+        logger.step("Running Move unit tests...");
+        logger.newline();
         await runMoveTests({
             filter: options.filter,
             ignoreWarnings: options.ignoreWarnings,
@@ -10,10 +12,11 @@ export default async function testMoveCommand(options = {}) {
         process.exit(0);
     }
     catch (err) {
-        console.error("\n✗ Move tests failed");
+        logger.newline();
+        logger.error("Move tests failed");
         const msg = err instanceof Error ? err.message : String(err);
         if (msg) {
-            console.error(`   ${msg}`);
+            logger.error(`   ${msg}`);
         }
         process.exit(1);
     }

package/dist/core/AccountManager.d.ts

@@ -14,183 +14,165 @@ export interface SaveAccountPoolOptions {
      */
     includeImported?: boolean | undefined;
 }
+export interface AccountManagerOptions {
+    /**
+     * Filesystem location where `saveAccountPool` writes `test-pool.json`
+     * and `loadAccountPool` reads from. When omitted, the path is computed
+     * LAZILY on each call from `join(process.cwd(), ".movehat", "accounts")`
+     * — so `process.chdir()` between construction and pool I/O is respected.
+     *
+     * Pass an explicit value when per-instance isolation matters (parallel
+     * test files, harness pools that must not collide with another suite's).
+     *
+     * The process-wide static facade exposed on the `AccountManager` class
+     * itself uses a separate singleton whose `poolPath` is EAGERLY captured
+     * at module-import time. That preserves the legacy F8(b) behavior for
+     * any code still on the static API during the 0.2.7 deprecation window;
+     * the static facade is removed in 0.3.0.
+     */
+    poolPath?: string | undefined;
+}
 /**
  * Centralized Account Manager for movehat
  *
  * Manages all account creation, loading, and lifecycle operations.
- * Provides a pool of reusable test accounts with labels for better test readability.
+ * Provides a pool of reusable test accounts with labels for better test
+ * readability.
+ *
+ * Two API surfaces are exposed:
+ *
+ * **Instance API (recommended; M9.1+)** — `new AccountManager(options?)`
+ * gives a fully isolated pool. Two instances in the same process have
+ * independent labelMaps, private-key maps, and account pools. Each
+ * `Harness` constructed in 0.3.0+ will own one of these; user code
+ * accesses labeled accounts via `harness.accounts.<label>` (Harness
+ * snapshots them at construction time).
+ *
+ * **Static facade (deprecated; will be removed in 0.3.0)** — every
+ * former static method (`AccountManager.createAccount(...)`, etc.) still
+ * works and forwards to a single process-wide singleton. This preserves
+ * the existing label-sharing behavior across calls during the
+ * deprecation window. Migration target is the instance API; see M9 meta
+ * (#270) and migration guide at `/docs/upgrading/0.3.0` (published in
+ * M9.4).
  */
 export declare class AccountManager {
-    private static pool;
-    private static privateKeys;
-    private static labelMap;
-    private static generatedAccountAddresses;
-    private static poolLoaded;
-    private static defaultPoolPath;
-    /**
-     * Get a test account from the pool. If label is provided and exists, returns that account.
-     * Otherwise creates a new account with the optional label.
-     *
-     * @param label Optional label for the account (e.g., "alice", "bob", "deployer")
+    private readonly pool;
+    private readonly privateKeys;
+    private readonly labelMap;
+    private readonly generatedAccountAddresses;
+    private poolLoaded;
+    private readonly poolPathOverride;
+    constructor(options?: AccountManagerOptions);
+    /**
+     * Resolved pool directory. When the caller supplied an explicit
+     * `poolPath` to the constructor, that value is returned verbatim.
+     * Otherwise the path is computed LAZILY from the current
+     * `process.cwd()` on each access — so `process.chdir()` performed
+     * between construction and pool I/O takes effect, unlike the legacy
+     * static-only API which captured cwd at module import time
+     * (audit finding F8(b)).
+     */
+    private get poolPath();
+    /**
+     * Get a test account from the pool. If label is provided and exists,
+     * returns that account. Otherwise creates a new account with the
+     * optional label.
+     *
+     * @param label Optional label for the account (e.g., "alice", "bob")
      * @returns An Account instance
-     *
-     * @example
-     * const alice = AccountManager.getTestAccount("alice");
-     * const randomAccount = AccountManager.getTestAccount();
      */
-    static getTestAccount(label?: string): Account;
+    getTestAccount(label?: string): Account;
     /**
-     * Create a new account and optionally add it to the pool with a label
-     *
-     * @param label Optional label for the account
-     * @param fund Whether to fund the account (handled externally)
-     * @returns A new Account instance
-     *
-     * @example
-     * const deployer = AccountManager.createAccount("deployer");
-     * const bob = AccountManager.createAccount("bob", true);
+     * Create a new account and optionally add it to the pool with a
+     * label. The `fund` parameter is accepted for API symmetry; actual
+     * funding is the caller's responsibility.
      */
-    static createAccount(label?: string, fund?: boolean): Account;
+    createAccount(label?: string, _fund?: boolean): Account;
     /**
-     * Get an account by its label
-     *
-     * @param label The label to look up
-     * @returns The Account if found, undefined otherwise
-     *
-     * @example
-     * const alice = AccountManager.getAccountByLabel("alice");
-     * if (alice) {
-     *   console.log(`Alice's address: ${alice.accountAddress.toString()}`);
-     * }
+     * Get an account by its label, or undefined if not present.
      */
-    static getAccountByLabel(label: string): Account | undefined;
+    getAccountByLabel(label: string): Account | undefined;
     /**
-     * Load account from environment variable
-     *
-     * @param envVar The environment variable name (defaults to "PRIVATE_KEY")
-     * @returns Account instance
-     * @throws Error if environment variable is not set
+     * Load account from environment variable.
      *
-     * @example
-     * const account = AccountManager.loadAccountFromEnv("MH_PRIVATE_KEY");
+     * @throws Error if the environment variable is not set
      */
-    static loadAccountFromEnv(envVar?: string): Account;
+    loadAccountFromEnv(envVar?: string): Account;
     /**
-     * Load account from a private key hex string
-     *
-     * @param privateKeyHex The private key as a hex string (with or without 0x prefix)
-     * @returns Account instance
-     *
-     * @example
-     * const account = AccountManager.loadAccountFromPrivateKey("0xabc123...");
+     * Load account from a private key hex string (with or without 0x prefix).
      */
-    static loadAccountFromPrivateKey(privateKeyHex: string): Account;
+    loadAccountFromPrivateKey(privateKeyHex: string): Account;
     /**
-     * Load all accounts from movehat config
-     *
-     * @param config The resolved MovehatConfig
-     * @returns Array of Account instances
-     *
-     * @example
-     * const config = await resolveNetworkConfig(userConfig);
-     * const accounts = AccountManager.loadAccountsFromConfig(config);
+     * Load all accounts from movehat config.
      */
-    static loadAccountsFromConfig(config: MovehatConfig): Account[];
+    loadAccountsFromConfig(config: MovehatConfig): Account[];
     /**
-     * Get all labeled accounts in the pool
-     *
-     * @returns Record of label to Account mappings
-     *
-     * @example
-     * const labeled = AccountManager.getLabeledAccounts();
-     * console.log(`Deployer: ${labeled.deployer?.accountAddress.toString()}`);
+     * Get all labeled accounts in the pool.
      */
-    static getLabeledAccounts(): Record<string, Account>;
+    getLabeledAccounts(): Record<string, Account>;
     /**
-     * Save the current account pool to disk for persistence
-     *
-     * @param poolPath Optional custom path (defaults to .movehat/accounts)
-     *
-     * @example
-     * AccountManager.saveAccountPool();
+     * Save the current account pool to disk for persistence.
      */
-    static saveAccountPool(): void;
-    static saveAccountPool(poolPath: string): void;
-    static saveAccountPool(options: SaveAccountPoolOptions): void;
-    static saveAccountPool(poolPath: string, options: SaveAccountPoolOptions): void;
+    saveAccountPool(): void;
+    saveAccountPool(poolPath: string): void;
+    saveAccountPool(options: SaveAccountPoolOptions): void;
+    saveAccountPool(poolPath: string, options: SaveAccountPoolOptions): void;
     /**
-     * Load account pool from disk
-     *
-     * @param poolPath Optional custom path (defaults to .movehat/accounts)
-     * @returns true if pool was loaded, false if file doesn't exist
-     *
-     * @example
-     * if (AccountManager.loadAccountPool()) {
-     *   console.log("Pool loaded successfully");
-     * }
+     * Load account pool from disk. Returns true if a pool file was found
+     * and parsed, false if the file does not exist or parsing failed.
      */
-    static loadAccountPool(poolPath?: string): boolean;
+    loadAccountPool(poolPath?: string): boolean;
     /**
-     * Clear the entire account pool
-     * Useful for test isolation
-     *
-     * @example
-     * after(() => {
-     *   AccountManager.clearPool();
-     * });
+     * Clear the entire account pool. Useful for test isolation.
      */
-    static clearPool(): void;
+    clearPool(): void;
     /**
-     * Get the current size of the account pool
-     *
-     * @returns Number of accounts in the pool
+     * Number of accounts in the pool.
      */
-    static getPoolSize(): number;
+    getPoolSize(): number;
     /**
-     * Get all accounts in the pool
-     *
-     * @returns Array of all Account instances
+     * All accounts in the pool.
      */
-    static getAllAccounts(): Account[];
+    getAllAccounts(): Account[];
     /**
-     * Check if a label is already in use
-     *
-     * @param label The label to check
-     * @returns true if label exists, false otherwise
+     * Whether a label is currently bound to an account in this pool.
      */
-    static hasLabel(label: string): boolean;
+    hasLabel(label: string): boolean;
     /**
-     * Get or create an account with a specific label
-     * If the label exists, returns the existing account
-     * Otherwise creates a new account with that label
-     *
-     * @param label The label for the account
-     * @returns Account instance
-     *
-     * @example
-     * const alice = AccountManager.getOrCreateLabeled("alice");
-     * const aliceAgain = AccountManager.getOrCreateLabeled("alice"); // Same account
+     * Get or create an account with a specific label.
      */
-    static getOrCreateLabeled(label: string): Account;
+    getOrCreateLabeled(label: string): Account;
     /**
-     * Batch create multiple labeled accounts
-     *
-     * @param labels Array of labels to create
-     * @returns Record of label to Account mappings
-     *
-     * @example
-     * const accounts = AccountManager.createBatch(["alice", "bob", "charlie"]);
-     * console.log(accounts.alice.accountAddress.toString());
+     * Batch create multiple labeled accounts.
      */
-    static createBatch(labels: readonly string[]): Record<string, Account>;
+    createBatch(labels: readonly string[]): Record<string, Account>;
     /**
-     * Export account private keys for backup/sharing
-     * WARNING: Only use this for test accounts, never production keys
-     *
-     * @param labels Optional array of labels to export (exports all if not provided)
-     * @returns Record of label/address to private key hex string
+     * Export account private keys for backup/sharing.
+     * WARNING: Only use this for test accounts, never production keys.
      */
+    exportPrivateKeys(labels?: string[]): Record<string, string>;
+    private accountFromPrivateKey;
+    private trackAccount;
+    static getTestAccount(label?: string): Account;
+    static createAccount(label?: string, fund?: boolean): Account;
+    static getAccountByLabel(label: string): Account | undefined;
+    static loadAccountFromEnv(envVar?: string): Account;
+    static loadAccountFromPrivateKey(privateKeyHex: string): Account;
+    static loadAccountsFromConfig(config: MovehatConfig): Account[];
+    static getLabeledAccounts(): Record<string, Account>;
+    static saveAccountPool(): void;
+    static saveAccountPool(poolPath: string): void;
+    static saveAccountPool(options: SaveAccountPoolOptions): void;
+    static saveAccountPool(poolPath: string, options: SaveAccountPoolOptions): void;
+    static loadAccountPool(poolPath?: string): boolean;
+    static clearPool(): void;
+    static getPoolSize(): number;
+    static getAllAccounts(): Account[];
+    static hasLabel(label: string): boolean;
+    static getOrCreateLabeled(label: string): Account;
+    static createBatch(labels: readonly string[]): Record<string, Account>;
     static exportPrivateKeys(labels?: string[]): Record<string, string>;
-    private static accountFromPrivateKey;
-    private static trackAccount;
 }
+/** @internal — test-only. Resets the once-per-method dedup Set. */
+export declare function _resetDeprecationWarnings(): void;