movehat 0.1.8 → 0.2.0

package/src/runtime.ts

@@ -10,17 +10,14 @@ import { MovehatUserConfig } from "./types/config.js";
 import { loadUserConfig, resolveNetworkConfig } from "./core/config.js";
 import { getContract, MoveContract } from "./core/contract.js";
 import {
-  saveDeployment,
   loadDeployment,
   getAllDeployments,
   getDeployedAddress,
   DeploymentInfo,
-  validateSafeName,
 } from "./core/deployments.js";
-import { ModuleAlreadyDeployedError } from "./errors.js";
 import { AccountManager } from "./core/AccountManager.js";
-
-let cachedRuntime: MovehatRuntime | null = null;
+import { Publisher } from "./core/Publisher.js";
+import type { ChildProcessAdapter } from "./utils/childProcessAdapter.js";
 
 export interface InitRuntimeOptions {
   network?: string;
@@ -29,8 +26,18 @@ export interface InitRuntimeOptions {
 }
 
 /**
- * Initialize the Movehat Runtime Environment
- * This function loads the configuration and creates the runtime context
+ * Initialize the Movehat Runtime Environment.
+ *
+ * Lower-level construction utility — loads `movehat.config.ts`, resolves
+ * the active network, and builds a `MovehatRuntime` bound to it. Used
+ * internally by {@link Harness.createLive} (see `harness/Harness.ts`).
+ *
+ * **External callers should prefer the `Harness.create*` factories**
+ * (`Harness.createLocal` / `createFork` / `createLive`) for the Hardhat-
+ * style lifecycle + use-after-cleanup safety. `initRuntime` remains
+ * exported as a public utility for advanced use cases that need to
+ * skip the Harness abstraction (e.g. embedding movehat inside another
+ * framework).
  */
 export async function initRuntime(
   options: InitRuntimeOptions = {}
@@ -46,9 +53,11 @@ export async function initRuntime(
   // Resolve configuration for selected network
   const config = await resolveNetworkConfig(mergedUserConfig, options.network);
 
-  // Setup Aptos client
+  // Setup Movement TypeScript SDK client
+  // Movement Network uses custom chain IDs, so we need to use Network.CUSTOM
+  // and let the SDK fetch the actual chainId from the node
   const aptosConfig = new AptosConfig({
-    network: config.network as Network,
+    network: Network.CUSTOM,
     fullnode: config.rpc,
   });
   const aptos = new Aptos(aptosConfig);
@@ -81,251 +90,18 @@ export async function initRuntime(
     moduleName: string,
     options?: {
       packageDir?: string;
+      adapter?: ChildProcessAdapter;
     }
   ): Promise<DeploymentInfo> => {
-    // Validate moduleName early
-    validateSafeName(moduleName, "module");
-
-    const { exec } = await import("child_process");
-    const { promisify } = await import("util");
-    const { existsSync, mkdirSync, writeFileSync, chmodSync } = await import("fs");
-    const { join } = await import("path");
-    const { homedir } = await import("os");
-    const yaml = await import("js-yaml");
-    const { validateAndEscapePath, validateAndEscapeProfile } = await import("./core/shell.js");
-    const execAsync = promisify(exec);
-
-    // Check if --redeploy flag was passed via CLI
-    const forceRedeploy = process.env.MH_CLI_REDEPLOY === 'true';
-
-    // Check if already deployed
-    const existingDeployment = loadDeployment(config.network, moduleName);
-    if (existingDeployment && !forceRedeploy) {
-      // Build detailed error message with all deployment info
-      const errorDetails = [
-        `Module "${moduleName}" is already deployed on ${config.network}`,
-        `Address: ${existingDeployment.address}`,
-        `Deployed at: ${new Date(existingDeployment.timestamp).toLocaleString()}`,
-        existingDeployment.txHash ? `Transaction: ${existingDeployment.txHash}` : null,
-        `\nTo redeploy, run with the --redeploy flag:`,
-        `movehat run <script> --network ${config.network} --redeploy`,
-      ].filter(Boolean).join('\n');
-
-      // Log formatted error message for user
-      const formattedMessage = [
-        `\n❌ Module "${moduleName}" is already deployed on ${config.network}`,
-        `   Address: ${existingDeployment.address}`,
-        `   Deployed at: ${new Date(existingDeployment.timestamp).toLocaleString()}`,
-        existingDeployment.txHash ? `   Transaction: ${existingDeployment.txHash}` : null,
-        `\n💡 To redeploy, run with the --redeploy flag:`,
-        `   movehat run <script> --network ${config.network} --redeploy\n`,
-      ].filter(Boolean).join('\n');
-
-      console.error(formattedMessage);
-
-      // Throw custom error with complete context for programmatic handling
-      throw new ModuleAlreadyDeployedError(
-        errorDetails,
-        moduleName,
-        config.network,
-        existingDeployment.address,
-        existingDeployment.timestamp,
-        existingDeployment.txHash
-      );
-    }
-
-    if (forceRedeploy && existingDeployment) {
-      console.log(`🔄 Redeploying module "${moduleName}" on ${config.network}...`);
-    }
-
-    const dir = options?.packageDir || config.moveDir;
-    const profile = config.profile || "default";
-
-    // Validate and escape to prevent command injection
-    const safeDir = validateAndEscapePath(dir, "package directory");
-    const safeProfile = validateAndEscapeProfile(profile);
-
-    console.log(`📦 Publishing module "${moduleName}" from ${dir}...`);
-
-    try {
-      // Get the deployer address to use for named addresses
-      const deployerAddress = account.accountAddress.toString();
-
-      // Detect named addresses from Move files
-      const { extractNamedAddresses } = await import("./commands/compile.js");
-      const detectedAddresses = extractNamedAddresses(dir);
-
-      // Build named addresses argument - use deployer address for all detected addresses
-      let namedAddressesArg = "";
-      if (detectedAddresses.size > 0) {
-        const addressPairs = Array.from(detectedAddresses)
-          .map(name => `${name}=${deployerAddress}`)
-          .join(",");
-        namedAddressesArg = `--named-addresses ${addressPairs}`;
-      }
-
-      // Build first with named addresses
-      console.log("🔨 Building package...");
-      const buildCmd = `movement move build --package-dir ${safeDir} ${namedAddressesArg}`.trim();
-      const { stdout: buildOut } = await execAsync(buildCmd, {
-        timeout: 120000, // 2 minutes for git dependency downloads
-        maxBuffer: 10 * 1024 * 1024, // 10MB buffer for large outputs
-      });
-      if (buildOut) console.log(buildOut.trim());
-
-      // Publish using direct parameters (avoid config file issues)
-      console.log("📤 Publishing to blockchain...");
-
-      // Use parameters directly instead of relying on config file
-      // Strip any ed25519-priv- prefix if present
-      let cleanPrivateKey = config.privateKey;
-      if (cleanPrivateKey.startsWith('ed25519-priv-')) {
-        cleanPrivateKey = cleanPrivateKey.replace('ed25519-priv-', '');
-      }
-
-      // deployerAddress is already declared above
-
-      // Read Move.toml to update named addresses with deployer address
-      const moveTomlPath = join(dir, 'Move.toml');
-      let originalMoveToml = '';
-
-      if (existsSync(moveTomlPath)) {
-        const { readFile, writeFile } = await import('fs').then(fs => fs.promises);
-        originalMoveToml = await readFile(moveTomlPath, 'utf-8');
-
-        // Replace addresses in [addresses] section with deployer address
-        const updatedMoveToml = originalMoveToml.replace(
-          /\[addresses\]([\s\S]*?)(?=\n\[|$)/,
-          (match, addressesSection) => {
-            const updatedSection = addressesSection.replace(
-              /^([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*"0x[a-fA-F0-9]+"/gm,
-              `$1 = "${deployerAddress}"`
-            );
-            return `[addresses]${updatedSection}`;
-          }
-        );
-
-        // Write updated Move.toml temporarily
-        await writeFile(moveTomlPath, updatedMoveToml, 'utf-8');
-      }
-
-      let publishOut = '';
-      let publishErr = '';
-
-      // Setup Movement CLI config with private key securely
-      // Movement CLI uses .aptos config directory (not .movement)
-      const movementConfigDir = join(homedir(), '.aptos');
-      const movementConfigPath = join(movementConfigDir, 'config.yaml');
-      let originalMovementConfig = '';
-
-      try {
-        // Ensure .aptos directory exists
-        if (!existsSync(movementConfigDir)) {
-          mkdirSync(movementConfigDir, { recursive: true, mode: 0o700 });
-        }
-
-        // Backup original config if it exists
-        if (existsSync(movementConfigPath)) {
-          const { readFile } = await import('fs').then(fs => fs.promises);
-          originalMovementConfig = await readFile(movementConfigPath, 'utf-8');
-        }
-
-        // Create Movement config with private key
-        // Movement CLI reads from ~/.aptos/config.yaml
-        const movementConfig: any = originalMovementConfig ? yaml.load(originalMovementConfig) : {};
-
-        // Set profile with private key
-        // Use unescaped profile name as YAML key (YAML handles escaping automatically)
-        if (!movementConfig.profiles) {
-          movementConfig.profiles = {};
-        }
-        if (!movementConfig.profiles[profile]) {
-          movementConfig.profiles[profile] = {};
-        }
-
-        movementConfig.profiles[profile].private_key = cleanPrivateKey;
-        movementConfig.profiles[profile].public_key = account.publicKey.toString();
-        movementConfig.profiles[profile].account = deployerAddress;
-        movementConfig.profiles[profile].rest_url = config.rpc;
-
-        // Write config file with restrictive permissions
-        const configYaml = yaml.dump(movementConfig);
-        writeFileSync(movementConfigPath, configYaml, { mode: 0o600 });
-
-        // Execute publish command without exposing private key in CLI
-        // Include named addresses for publish as well
-        const publishCmd = `movement move publish --package-dir ${safeDir} --url ${config.rpc} --profile ${safeProfile} --assume-yes ${namedAddressesArg}`.trim();
-        const result = await execAsync(publishCmd, {
-          timeout: 120000, // 2 minutes for blockchain transactions
-          maxBuffer: 10 * 1024 * 1024, // 10MB buffer for large outputs
-        });
-        publishOut = result.stdout || '';
-        publishErr = result.stderr || '';
-        if (publishOut) console.log(publishOut.trim());
-        if (publishErr) console.error(publishErr.trim());
-      } finally {
-        // Restore original Movement config
-        if (existsSync(movementConfigPath)) {
-          if (originalMovementConfig) {
-            // Restore original config
-            writeFileSync(movementConfigPath, originalMovementConfig, { mode: 0o600 });
-          } else {
-            // Remove config file if it didn't exist before
-            const { unlink } = await import('fs').then(fs => fs.promises);
-            await unlink(movementConfigPath).catch(() => {});
-          }
-        }
-
-        // Restore original Move.toml
-        if (originalMoveToml && existsSync(moveTomlPath)) {
-          const { writeFile } = await import('fs').then(fs => fs.promises);
-          await writeFile(moveTomlPath, originalMoveToml, 'utf-8');
-        }
-      }
-
-      // Extract transaction hash from output
-      // Look for patterns like "Transaction hash: 0x..." or "Txn: 0x..." or just a 64-char hex
-      // The regex tries to match with context first, then falls back to any 64-char hex
-      let txHash: string | undefined;
-      const txHashMatchWithContext = publishOut.match(/(?:transaction\s*(?:hash)?|txn\s*(?:hash)?|hash):\s*(0x[a-fA-F0-9]{64})\b/i);
-      if (txHashMatchWithContext) {
-        txHash = txHashMatchWithContext[1];
-      } else {
-        // Fallback: try to find any 64-char hex string (exactly, not more)
-        const txHashMatch = publishOut.match(/\b(0x[a-fA-F0-9]{64})\b/);
-        if (txHashMatch) {
-          txHash = txHashMatch[1];
-        }
-      }
-
-      console.log(`✅ Module published successfully!`);
-
-      // Create deployment info
-      const deployment: DeploymentInfo = {
-        address: account.accountAddress.toString(),
-        moduleName,
-        network: config.network,
-        deployer: account.accountAddress.toString(),
-        timestamp: Date.now(),
-        txHash,
-      };
-
-      // Save deployment
-      saveDeployment(deployment);
-
-      return deployment;
-    } catch (error: any) {
-      // Enhanced error reporting with stderr if available
-      let errorMsg = error.message;
-      if (error.stderr) {
-        errorMsg += `\n${error.stderr}`;
-      }
-      if (error.stdout) {
-        console.log(error.stdout);
-      }
-      console.error(`❌ Failed to publish module: ${errorMsg}`);
-      throw error;
-    }
+    // Thin orchestrator over Publisher (M1.4 / #79). The 250-line closure
+    // body lives in core/Publisher.ts and carries the bug fixes for
+    // #36 / #37 / #38.
+    return new Publisher({ adapter: options?.adapter }).deploy({
+      moduleName,
+      config,
+      account,
+      packageDir: options?.packageDir,
+    });
   };
 
   const getDeployment = (moduleName: string): DeploymentInfo | null => {
@@ -349,16 +125,15 @@ export async function initRuntime(
   };
 
   const getAccountByIndex = (index: number): Account => {
-    if (index < 0 || index >= accounts.length) {
+    const acc = accounts[index];
+    if (!acc) {
       throw new Error(`Account index ${index} out of range. Available accounts: 0-${accounts.length - 1}`);
     }
-    return accounts[index];
+    return acc;
   };
 
-  const switchNetwork = async (networkName: string): Promise<void> => {
-    // Clear cache and reinitialize with new network
-    cachedRuntime = null;
-    await initRuntime({ ...options, network: networkName });
+  const switchNetwork = async (networkName: string): Promise<MovehatRuntime> => {
+    return initRuntime({ ...options, network: networkName });
   };
 
   // Build runtime object
@@ -379,37 +154,6 @@ export async function initRuntime(
     switchNetwork,
   };
 
-  cachedRuntime = runtime;
   return runtime;
 }
 
-/**
- * Get the current Movehat Runtime Environment
- * Throws error if runtime hasn't been initialized
- */
-export function getRuntime(): MovehatRuntime {
-  if (!cachedRuntime) {
-    throw new Error(
-      "Movehat Runtime not initialized. Call initRuntime() first or use getMovehat()."
-    );
-  }
-  return cachedRuntime;
-}
-
-/**
- * Get or initialize the Movehat Runtime Environment
- * This is a convenience function that initializes if needed
- */
-export async function getMovehat(): Promise<MovehatRuntime> {
-  if (cachedRuntime) {
-    return cachedRuntime;
-  }
-  return initRuntime();
-}
-
-// Export a default instance getter for convenience
-export const mh = {
-  get runtime() {
-    return getRuntime();
-  },
-};

package/src/templates/README.md

@@ -142,5 +142,5 @@ module counter::counter {  // ← "counter" is auto-detected
 ## Learn More
 
 - [Movement Documentation](https://docs.movementnetwork.xyz)
-- [Aptos Move Book](https://move-language.github.io/move/)
+- [Move Language Book](https://move-language.github.io/move/)
 - [Movehat GitHub](https://github.com/gilbertsahumada/movehat)

package/src/templates/movehat.config.ts

@@ -1,3 +1,13 @@
+// Movehat configuration.
+//
+// Movehat's primary public API is the Hardhat-style `Harness` class
+// (see scripts/deploy-counter.ts and tests/Counter.test.ts in this
+// template). The `Harness.create*` factories read this file via
+// `loadUserConfig` to resolve the active network + accounts.
+//
+// The `setupTestFixture()` helper also reads the same shape and
+// remains supported as a lighter-weight alternative to Harness.
+
 import dotenv from "dotenv";
 dotenv.config();
 

package/src/templates/package.json

@@ -12,7 +12,8 @@
   "dependencies": {
     "movehat": "latest",
     "@aptos-labs/ts-sdk": "^5.1.5",
-    "dotenv": "^17.2.3"
+    "dotenv": "^17.2.3",
+    "got": "^11.8.6"
   },
   "devDependencies": {
     "@types/chai": "^5.2.3",

package/src/templates/scripts/deploy-counter.ts

@@ -1,48 +1,56 @@
-import { getMovehat, ModuleAlreadyDeployedError } from "movehat";
+import { Harness } from "movehat";
 
 async function main() {
   console.log("🚀 Deploying Counter contract...\n");
 
-  // Get the Movehat Runtime Environment
-  const mh = await getMovehat();
-
-  console.log(`✅ Runtime initialized`);
-  console.log(`   Account: ${mh.account.accountAddress.toString()}`);
-  console.log(`   Network: ${mh.network.name}`);
-  console.log(`   RPC: ${mh.network.rpc}\n`);
-
-  // Deploy (publish) the module
-  // Automatically checks if already deployed and suggests --redeploy if needed
-  const deployment = await mh.deployContract("counter");
-
-  console.log(`\n✅ Module deployed at: ${deployment.address}::counter`);
-  if (deployment.txHash) {
-    console.log(`   Transaction: ${deployment.txHash}`);
+  // Hardhat-style Harness — primary public API since M2.
+  // createLive binds to a real running network (testnet / mainnet / a
+  // custom one defined in movehat.config.ts). No local process spawned.
+  const network = process.env.MOVEHAT_NETWORK ?? "testnet";
+  const harness = await Harness.createLive(network);
+  try {
+    console.log(`✅ Runtime initialized on ${harness.runtime.network.name}`);
+    console.log(`   Account: ${harness.runtime.account.accountAddress.toString()}`);
+    console.log(`   RPC: ${harness.runtime.network.rpc}\n`);
+
+    // Deploy as a code object via `movement move deploy-object`. If the
+    // Move.toml's named address differs from the module identifier
+    // (e.g. `module my_pkg::counter` with `[addresses] my_pkg = "_"`),
+    // pass `addressName: "my_pkg"` in addition to `moduleName: "counter"`.
+    //
+    // To redeploy an existing record, set MH_CLI_REDEPLOY=true.
+    const deployment = await harness.deployCodeObject({
+      moduleName: "counter",
+    });
+
+    console.log(`\n✅ Module deployed at: ${deployment.address}::counter`);
+    if (deployment.txHash) {
+      console.log(`   Transaction: ${deployment.txHash}`);
+    }
+
+    // Interact with the freshly deployed module via the runtime helper.
+    const counter = harness.runtime.getContract(deployment.address, "counter");
+
+    console.log("\n📝 Incrementing counter...");
+    const txResult = await counter.call(harness.runtime.account, "increment", []);
+    console.log(`✅ Transaction hash: ${txResult.hash}`);
+
+    // Use harness.runViewFunction directly when you have a fully
+    // qualified function id; counter.view<T>(...) is the shorter form.
+    const [value] = await harness.runViewFunction({
+      function: `${deployment.address}::counter::get`,
+      functionArguments: [harness.runtime.account.accountAddress.toString()],
+    });
+    console.log(`\n📊 Counter value: ${value}`);
+  } finally {
+    // Always release the Harness — cleanup() is idempotent and safe to
+    // call on a `createLive` instance even though no local process was
+    // spawned (it just flips the use-after-cleanup poison flag).
+    await harness.cleanup();
   }
-
-  // Get contract instance
-  const counter = mh.getContract(deployment.address, "counter");
-
-  // Initialize the counter
-  console.log("\n📝 Initializing counter...");
-  const txResult = await counter.call(mh.account, "init", []);
-
-  console.log(`✅ Transaction hash: ${txResult.hash}`);
-  console.log(`✅ Counter initialized successfully!`);
-
-  // Verify
-  const value = await counter.view<number>("get", [
-    mh.account.accountAddress.toString()
-  ]);
-
-  console.log(`\n📊 Initial counter value: ${value}`);
 }
 
 main().catch((error) => {
-  // ModuleAlreadyDeployedError is already logged with full details by deployContract()
-  // For other errors, show the message
-  if (!(error instanceof ModuleAlreadyDeployedError)) {
-    console.error("❌ Deployment failed:", error?.message || error);
-  }
+  console.error("❌ Deployment failed:", error?.message || error);
   process.exit(1);
 });

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

@@ -1,104 +1,102 @@
 // @ts-nocheck - This is a template file, dependencies are installed in user projects
 import { describe, it, before, after } from "mocha";
 import { expect } from "chai";
-import { setupTestFixture, teardownTestFixture, type TestFixture } from "movehat/helpers";
+import { Harness, AccountManager } from "movehat";
 
 describe("Counter Contract", () => {
-  let fixture: TestFixture<'counter'>;
+  let harness;
+  let counter;
+  let deployer, alice, bob;
 
   before(async function () {
     this.timeout(60000); // Allow time for local node startup + deployment
 
-    // Setup local testing environment with auto-deployment
-    // This will:
-    // 1. Start a local Movement blockchain node
-    // 2. Generate and fund test accounts from local faucet
-    // 3. Auto-deploy the counter module
-    // 4. Return everything ready to use
+    // Hardhat-style Harness — primary public API since M2.
+    // createLocal spins up a Movement local node, funds the labeled
+    // accounts from the local faucet, and (via autoDeploy) builds +
+    // publishes the named modules so they're ready to use.
     //
-    // By default uses 'local-node' mode (full blockchain)
-    // For faster tests on existing state, pass { mode: 'fork' }
-    //
-    // Note: Use 'as const' for type inference
-    fixture = await setupTestFixture(['counter'] as const, ['alice', 'bob']);
+    // The setupTestFixture helper still works if you prefer the older
+    // pattern; see `import { setupTestFixture } from "movehat/helpers"`.
+    harness = await Harness.createLocal({
+      accountLabels: ["deployer", "alice", "bob"],
+      autoDeploy: ["counter"],
+    });
+
+    const labeled = AccountManager.getLabeledAccounts();
+    deployer = labeled.deployer;
+    alice = labeled.alice;
+    bob = labeled.bob;
+
+    const counterAddr = harness.runtime.getDeploymentAddress("counter");
+    counter = harness.runtime.getContract(counterAddr, "counter");
 
     console.log(`\n✅ Testing on local blockchain`);
-    console.log(`   Deployer: ${fixture.accounts.deployer.accountAddress.toString()}`);
-    console.log(`   Alice: ${fixture.accounts.alice.accountAddress.toString()}`);
-    console.log(`   Bob: ${fixture.accounts.bob.accountAddress.toString()}\n`);
+    console.log(`   Deployer: ${deployer.accountAddress.toString()}`);
+    console.log(`   Alice: ${alice.accountAddress.toString()}`);
+    console.log(`   Bob: ${bob.accountAddress.toString()}\n`);
   });
 
   describe("Counter functionality", () => {
-    it("should initialize with value 0", async () => {
-      const counter = fixture.contracts.counter; // Type-safe, no `!` needed
-      const deployer = fixture.accounts.deployer;
+    it("should initialize counter for deployer", async () => {
+      // Initialize counter for deployer (required before get/increment)
+      const tx = await counter.call(deployer, "init", []);
+      console.log(`   Init transaction: ${tx.hash}`);
 
-      // Read counter value (returns string from view function)
-      const value = await counter.view<string>("get", [
-        deployer.accountAddress.toString()
-      ]);
+      // Read counter value via harness.runViewFunction (new in M2)
+      const [value] = await harness.runViewFunction({
+        function: `${counter.moduleAddress}::counter::get`,
+        functionArguments: [deployer.accountAddress.toString()],
+      });
 
       console.log(`   Counter value: ${value}`);
-
-      // Assert the counter is 0 (note: values from view are strings)
       expect(parseInt(value)).to.equal(0);
     });
 
     it("should increment counter", async () => {
-      const counter = fixture.contracts.counter;
-      const deployer = fixture.accounts.deployer;
-
-      // Increment the counter
       const tx = await counter.call(deployer, "increment", []);
       console.log(`   Transaction: ${tx.hash}`);
 
-      // Read new value
+      // counter.view is the shorter form when you already have the contract.
       const value = await counter.view<string>("get", [
-        deployer.accountAddress.toString()
+        deployer.accountAddress.toString(),
       ]);
 
       console.log(`   New counter value: ${value}`);
-
-      // Should be 1 now
       expect(parseInt(value)).to.equal(1);
     });
 
-    it("alice can also increment counter", async () => {
-      const counter = fixture.contracts.counter;
-      const alice = fixture.accounts.alice;
+    it("alice can initialize and increment her counter", async () => {
+      const initTx = await counter.call(alice, "init", []);
+      console.log(`   Alice init transaction: ${initTx.hash}`);
 
-      // Alice increments her own counter
       const tx = await counter.call(alice, "increment", []);
-      console.log(`   Alice's transaction: ${tx.hash}`);
+      console.log(`   Alice's increment transaction: ${tx.hash}`);
 
-      // Read counter value for Alice (each user has their own counter)
       const aliceValue = await counter.view<string>("get", [
-        alice.accountAddress.toString()
+        alice.accountAddress.toString(),
       ]);
 
       console.log(`   Alice's counter value: ${aliceValue}`);
       expect(parseInt(aliceValue)).to.equal(1);
 
-      // Deployer's counter should still be 1 (unchanged)
       const deployerValue = await counter.view<string>("get", [
-        fixture.accounts.deployer.accountAddress.toString()
+        deployer.accountAddress.toString(),
       ]);
 
       console.log(`   Deployer's counter value: ${deployerValue}`);
       expect(parseInt(deployerValue)).to.equal(1);
     });
 
-    it("bob can also increment the counter", async () => {
-      const counter = fixture.contracts.counter;
-      const bob = fixture.accounts.bob;
+    it("bob can initialize and increment his counter", async () => {
+      const initTx = await counter.call(bob, "init", []);
+      console.log(`   Bob init transaction: ${initTx.hash}`);
 
-      // Bob increments his own counter
       const tx = await counter.call(bob, "increment", []);
-      console.log(`   Bob's transaction: ${tx.hash}`);
+      console.log(`   Bob's increment transaction: ${tx.hash}`);
 
-      // Read counter value for Bob (each user has their own counter)
       const bobValue = await counter.view<string>("get", [
-        bob.accountAddress.toString()
+        bob.accountAddress.toString(),
       ]);
 
       console.log(`   Bob's counter value: ${bobValue}`);
@@ -107,7 +105,9 @@ describe("Counter Contract", () => {
   });
 
   after(async () => {
-    // Cleanup: Stop local node and clear account pool
-    await teardownTestFixture();
+    // harness.cleanup() stops the local node and poisons the harness —
+    // any further method call (other than cleanup itself) throws
+    // HarnessDisposedError synchronously.
+    await harness.cleanup();
   });
 });