create-fhevm-example 1.4.4 → 1.4.6

package/contracts/concepts/antipatterns/OperationsGasNoise.sol

@@ -0,0 +1,190 @@
+// SPDX-License-Identifier: BSD-3-Clause-Clear
+pragma solidity ^0.8.24;
+
+import {
+    FHE,
+    euint32,
+    euint256,
+    externalEuint32
+} from "@fhevm/solidity/lib/FHE.sol";
+import {ZamaEthereumConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
+
+/**
+ * @notice Operations, gas, and noise anti-patterns in FHE development.
+ *         Demonstrates performance issues, side-channel leaks, and
+ *         inefficient encrypted computation patterns.
+ *
+ * @dev Covers 4 patterns: gas/timing side channels, noise accumulation,
+ *      deprecated APIs, and type mismatches.
+ */
+contract FHEOperationsGasNoiseAntiPatterns is ZamaEthereumConfig {
+    euint32 private _secretValue;
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // ANTI-PATTERN 1: Gas/Timing Side Channel Attacks
+    // ═══════════════════════════════════════════════════════════════════════
+
+    /**
+     * ❌ WRONG: Different code paths have different gas costs
+     * @dev Gas consumption reveals which branch was taken
+     */
+    function wrongGasLeak(
+        externalEuint32 input,
+        bytes calldata inputProof
+    ) external {
+        euint32 value = FHE.fromExternal(input, inputProof);
+
+        // ❌ These operations have different gas costs!
+        // If value > 100: expensive operation
+        // If value <= 100: cheap operation
+        // Gas cost reveals the comparison result!
+
+        // Simulating different paths (commented to avoid actual leak)
+        // if (decrypt(value > 100)) {
+        //     // Expensive: 10 multiplications
+        // } else {
+        //     // Cheap: 1 addition
+        // }
+
+        _secretValue = value;
+        FHE.allowThis(_secretValue);
+    }
+
+    /**
+     * ✅ CORRECT: Constant-time operations
+     * @dev All paths consume same gas
+     */
+    function correctConstantTime(
+        externalEuint32 input,
+        bytes calldata inputProof
+    ) external {
+        euint32 value = FHE.fromExternal(input, inputProof);
+
+        // ✅ Always perform same operations regardless of value
+        euint32 result = FHE.mul(value, FHE.asEuint32(2));
+
+        _secretValue = result;
+        FHE.allowThis(_secretValue);
+        FHE.allow(_secretValue, msg.sender);
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // ANTI-PATTERN 2: Noise Accumulation (Too Many Operations)
+    // ═══════════════════════════════════════════════════════════════════════
+
+    /**
+     * ❌ WRONG: Long chain of FHE operations
+     * @dev Each operation adds noise, eventually corrupting ciphertext
+     */
+    function wrongNoiseAccumulation(
+        externalEuint32 input,
+        bytes calldata inputProof
+    ) external {
+        euint32 value = FHE.fromExternal(input, inputProof);
+
+        // ❌ Too many chained operations!
+        // Each mul adds significant noise
+        euint32 result = value;
+        for (uint i = 0; i < 5; i++) {
+            result = FHE.mul(result, FHE.asEuint32(2)); // High noise per operation
+        }
+
+        _secretValue = result;
+        FHE.allowThis(_secretValue);
+    }
+
+    /**
+     * ✅ CORRECT: Minimize operation chains
+     * @dev Use mathematical optimization to reduce operations
+     */
+    function correctMinimizeOperations(
+        externalEuint32 input,
+        bytes calldata inputProof
+    ) external {
+        euint32 value = FHE.fromExternal(input, inputProof);
+
+        // ✅ Instead of 5 multiplications by 2, use single multiplication
+        // 2^5 = 32
+        euint32 result = FHE.mul(value, FHE.asEuint32(32));
+
+        _secretValue = result;
+        FHE.allowThis(_secretValue);
+        FHE.allow(_secretValue, msg.sender);
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // ANTI-PATTERN 3: Using Deprecated FHEVM APIs
+    // ═══════════════════════════════════════════════════════════════════════
+
+    /**
+     * ❌ WRONG: Using old TFHE.decrypt() pattern
+     * @dev Deprecated in FHEVM v0.9+
+     */
+    function wrongDeprecatedAPI() external pure returns (string memory) {
+        // ❌ OLD (v0.8 and earlier):
+        // TFHE.decrypt() - went through Zama Oracle
+        //
+        // This pattern is deprecated and no longer supported
+
+        return "Don't use TFHE.decrypt() - it's deprecated";
+    }
+
+    /**
+     * ✅ CORRECT: Use modern FHEVM v0.9+ APIs
+     * @dev Use FHE.makePubliclyDecryptable() or userDecrypt pattern
+     */
+    function correctModernAPI() external pure returns (string memory) {
+        // ✅ NEW (v0.9+):
+        // - FHE.makePubliclyDecryptable() for public decryption
+        // - userDecrypt pattern via fhevm.js for user decryption
+
+        return "Use FHE.makePubliclyDecryptable() or fhevm.js userDecrypt()";
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // ANTI-PATTERN 4: Unnecessary Large Data Types
+    // ═══════════════════════════════════════════════════════════════════════
+
+    /**
+     * ❌ WRONG: Using euint256 when euint32 is sufficient
+     * @dev Larger types = more gas + more noise
+     */
+    function wrongOversizedType(
+        externalEuint32 input,
+        bytes calldata inputProof
+    ) external {
+        euint32 value = FHE.fromExternal(input, inputProof);
+
+        // ❌ Unnecessarily converting to euint256!
+        // euint256 operations are limited and more expensive
+        // This conversion is wasteful when euint32 would suffice
+        euint256 largeValue = FHE.asEuint256(value);
+
+        // Converting back to euint32 (double conversion waste!)
+        _secretValue = FHE.asEuint32(largeValue);
+        FHE.allowThis(_secretValue);
+    }
+
+    /**
+     * ✅ CORRECT: Use smallest sufficient data type
+     * @dev euint32 is cheaper than euint256
+     */
+    function correctRightSizedType(
+        externalEuint32 input,
+        bytes calldata inputProof
+    ) external {
+        euint32 value = FHE.fromExternal(input, inputProof);
+
+        // ✅ Keep using euint32 if values fit
+        euint32 result = FHE.mul(value, FHE.asEuint32(2));
+
+        _secretValue = result;
+        FHE.allowThis(_secretValue);
+        FHE.allow(_secretValue, msg.sender);
+    }
+
+    /// @notice Helper to get value for testing
+    function getValue() external view returns (euint32) {
+        return _secretValue;
+    }
+}

package/contracts/concepts/antipatterns/Permissions.sol

@@ -0,0 +1,254 @@
+// SPDX-License-Identifier: BSD-3-Clause-Clear
+pragma solidity ^0.8.24;
+
+import {FHE, euint32, externalEuint32} from "@fhevm/solidity/lib/FHE.sol";
+import {ZamaEthereumConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
+
+/**
+ * @notice Permission management anti-patterns in FHE development.
+ *         Demonstrates common mistakes with allowThis, allow, and
+ *         permission propagation across transfers and contracts.
+ *
+ * @dev Covers 6 critical patterns: missing allowThis, missing allow(user),
+ *      view functions without permissions, unauthenticated re-encryption,
+ *      transfer permission issues, and cross-contract delegation.
+ */
+contract FHEPermissionsAntiPatterns is ZamaEthereumConfig {
+    euint32 private _secretValue;
+    mapping(address => euint32) private _balances;
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // ANTI-PATTERN 1: Missing allowThis After Computation
+    // ═══════════════════════════════════════════════════════════════════════
+
+    /**
+     * ❌ WRONG: Compute but forget allowThis
+     * @dev Result exists but contract can't use it in future operations
+     */
+    function wrongMissingAllowThis(
+        externalEuint32 input,
+        bytes calldata inputProof
+    ) external {
+        _secretValue = FHE.fromExternal(input, inputProof);
+        euint32 doubled = FHE.mul(_secretValue, FHE.asEuint32(2));
+        _secretValue = doubled;
+
+        // ❌ Missing FHE.allowThis! Contract can't use this value later
+        FHE.allow(_secretValue, msg.sender);
+    }
+
+    /**
+     * ✅ CORRECT: Always grant allowThis after computation
+     * @dev Contract needs permission to use encrypted values
+     */
+    function correctWithAllowThis(
+        externalEuint32 input,
+        bytes calldata inputProof
+    ) external {
+        _secretValue = FHE.fromExternal(input, inputProof);
+        euint32 doubled = FHE.mul(_secretValue, FHE.asEuint32(2));
+        _secretValue = doubled;
+
+        FHE.allowThis(_secretValue);
+        FHE.allow(_secretValue, msg.sender);
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // ANTI-PATTERN 2: Missing allow(user)
+    // ═══════════════════════════════════════════════════════════════════════
+
+    /**
+     * ❌ WRONG: Only allowThis without user permission
+     * @dev No one can decrypt the value
+     */
+    function wrongMissingUserAllow(
+        externalEuint32 input,
+        bytes calldata inputProof
+    ) external {
+        _secretValue = FHE.fromExternal(input, inputProof);
+
+        // ❌ Contract can compute but no one can decrypt!
+        FHE.allowThis(_secretValue);
+    }
+
+    /**
+     * ✅ CORRECT: Grant both allowThis and allow(user)
+     * @dev User can decrypt after contract operations
+     */
+    function correctWithUserAllow(
+        externalEuint32 input,
+        bytes calldata inputProof
+    ) external {
+        _secretValue = FHE.fromExternal(input, inputProof);
+
+        FHE.allowThis(_secretValue);
+        FHE.allow(_secretValue, msg.sender);
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // ANTI-PATTERN 3: View Function Without Permissions
+    // ═══════════════════════════════════════════════════════════════════════
+
+    /**
+     * ❌ WRONG: Store value without granting permission to caller
+     * @dev When caller tries to get value via view, they can't decrypt it
+     */
+    function wrongStoreWithoutPermission(
+        externalEuint32 input,
+        bytes calldata inputProof
+    ) external {
+        _secretValue = FHE.fromExternal(input, inputProof);
+
+        // ❌ Only allowThis, caller has no permission!
+        FHE.allowThis(_secretValue);
+    }
+
+    /**
+     * ✅ CORRECT: Grant permission to caller when storing
+     * @dev Caller can now decrypt value returned from view function
+     */
+    function correctStoreWithPermission(
+        externalEuint32 input,
+        bytes calldata inputProof
+    ) external {
+        _secretValue = FHE.fromExternal(input, inputProof);
+
+        FHE.allowThis(_secretValue);
+        FHE.allow(_secretValue, msg.sender); // ✅ Grant permission!
+    }
+
+    /// @notice View function to get stored value
+    function getValue() external view returns (euint32) {
+        return _secretValue;
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // ANTI-PATTERN 4: Unauthenticated Re-encryption
+    // ═══════════════════════════════════════════════════════════════════════
+
+    /**
+     * ❌ WRONG: Re-encrypt without verifying public key ownership
+     * @dev Anyone can provide any public key and steal encrypted data
+     */
+    function wrongReencryptWithoutAuth(
+        bytes32 publicKey
+    ) external view returns (bytes memory) {
+        // ❌ SECURITY RISK: No verification that caller owns this public key!
+        // Attacker can provide victim's public key and get their data
+
+        // This would allow impersonation attacks:
+        // return Gateway.reencrypt(_secretValue, publicKey);
+
+        return ""; // Placeholder
+    }
+
+    /**
+     * ✅ CORRECT: Use FHEVM's built-in authentication
+     * @dev fhevm.js SDK verifies EIP-712 signature automatically
+     *      Only the owner of the public key can decrypt
+     */
+    function correctReencryptWithAuth() external view returns (euint32) {
+        // ✅ Return handle directly
+        // Client uses fhevm.instance.reencrypt() which:
+        // 1. Signs request with their private key (EIP-712)
+        // 2. Gateway verifies signature matches public key
+        // 3. Only then re-encrypts for that public key
+
+        return _secretValue;
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // ANTI-PATTERN 5: Transfer Without Permission Propagation
+    // ═══════════════════════════════════════════════════════════════════════
+
+    /**
+     * @notice Initialize balance for msg.sender
+     * @dev Required before using transfer functions
+     */
+    function initializeBalance(
+        externalEuint32 initialBalance,
+        bytes calldata inputProof
+    ) external {
+        _balances[msg.sender] = FHE.fromExternal(initialBalance, inputProof);
+        FHE.allowThis(_balances[msg.sender]);
+        FHE.allow(_balances[msg.sender], msg.sender);
+    }
+
+    /**
+     * ❌ WRONG: Transfer without granting permissions
+     * @dev Recipient gets balance but can't use or decrypt it
+     */
+    function wrongTransferWithoutPermission(
+        address recipient,
+        externalEuint32 amount,
+        bytes calldata inputProof
+    ) external {
+        euint32 transferAmount = FHE.fromExternal(amount, inputProof);
+
+        _balances[msg.sender] = FHE.sub(_balances[msg.sender], transferAmount);
+        _balances[recipient] = FHE.add(_balances[recipient], transferAmount);
+
+        // ❌ Recipient has no permission to use their new balance!
+    }
+
+    /**
+     * ✅ CORRECT: Grant permissions after transfer
+     * @dev Both parties can use and decrypt their updated balances
+     */
+    function correctTransferWithPermission(
+        address recipient,
+        externalEuint32 amount,
+        bytes calldata inputProof
+    ) external {
+        euint32 transferAmount = FHE.fromExternal(amount, inputProof);
+
+        _balances[msg.sender] = FHE.sub(_balances[msg.sender], transferAmount);
+        _balances[recipient] = FHE.add(_balances[recipient], transferAmount);
+
+        // ✅ Grant permissions to both parties
+        FHE.allowThis(_balances[msg.sender]);
+        FHE.allow(_balances[msg.sender], msg.sender);
+        FHE.allowThis(_balances[recipient]);
+        FHE.allow(_balances[recipient], recipient);
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // ANTI-PATTERN 6: Cross-Contract Permission Delegation
+    // ═══════════════════════════════════════════════════════════════════════
+
+    /**
+     * ❌ WRONG: Call another contract without granting permission
+     * @dev Other contract can't use the encrypted value
+     */
+    function wrongCrossContractCall(address processor) external returns (bool) {
+        // ❌ processor contract has no permission to use _secretValue!
+        // This call will fail or return garbage
+        (bool success, ) = processor.call(
+            abi.encodeWithSignature("process(uint256)", _secretValue)
+        );
+        return success;
+    }
+
+    /**
+     * ✅ CORRECT: Grant temporary permission before cross-contract call
+     * @dev Use allowTransient for gas-efficient temporary access
+     */
+    function correctCrossContractCall(
+        address processor
+    ) external returns (bool) {
+        // ✅ Grant temporary permission (expires at end of transaction)
+        FHE.allowTransient(_secretValue, processor);
+
+        // Now processor can use _secretValue in this transaction
+        (bool success, ) = processor.call(
+            abi.encodeWithSignature("process(uint256)", _secretValue)
+        );
+
+        return success;
+    }
+
+    /// @notice Helper to get balance for testing
+    function getBalance(address user) external view returns (euint32) {
+        return _balances[user];
+    }
+}

package/contracts/gaming/EncryptedLottery.sol

@@ -11,7 +11,11 @@ import {
 import {ZamaEthereumConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
 
 /**
- * @notice Encrypted Lottery with private ticket numbers - fair and verifiable!
+ * @notice Provably fair lottery with encrypted ticket numbers.
+ *         Players buy tickets with encrypted numbers. Winning number is generated
+ *         using FHE randomness. Winner is determined by comparing encrypted values
+ *         without revealing losing tickets. Ensures fairness and privacy - no one
+ *         can see ticket numbers before the draw.
  *
  * @dev Flow: buyTicket() → startDrawing() → checkAndClaim() → revealWinner()
  *      ⚡ Gas: Loop in checkAndClaim can be expensive with many tickets!

package/contracts/gaming/EncryptedPoker.sol

@@ -11,7 +11,11 @@ import {
 import {ZamaEthereumConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
 
 /**
- * @notice Encrypted Poker - Texas Hold'em with hidden hole cards!
+ * @notice On-chain Texas Hold'em poker with encrypted hole cards.
+ *         Two players receive encrypted hole cards that remain hidden throughout
+ *         the game. Hand strength is computed using FHE operations. Winner is
+ *         determined by comparing encrypted hand strengths. Demonstrates complex
+ *         game logic with multiple encrypted states and conditional operations.
  *
  * @dev Flow: joinGame() → bet()/fold() → showdown() → revealWinner()
  *      Hand strength = card1 + card2 (simplified for demo)

package/contracts/gaming/RockPaperScissors.sol

@@ -5,7 +5,11 @@ import {FHE, euint8, ebool, externalEuint8} from "@fhevm/solidity/lib/FHE.sol";
 import {ZamaEthereumConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
 
 /**
- * @notice Rock-Paper-Scissors game with encrypted moves - fair play guaranteed using FHE!
+ * @notice Fair Rock-Paper-Scissors game with encrypted moves.
+ *         Players submit encrypted moves (0=Rock, 1=Paper, 2=Scissors) ensuring
+ *         neither player can see the other's choice before committing. Winner is
+ *         determined using FHE operations and revealed publicly. No trusted third
+ *         party needed - cryptography guarantees fairness.
 
  * @dev Commit-reveal pattern without trusted third party.
  *      Move encoding: 0=Rock, 1=Paper, 2=Scissors

package/contracts/openzeppelin/ERC7984.sol

@@ -12,7 +12,12 @@ import {
 } from "@openzeppelin/confidential-contracts/token/ERC7984/ERC7984.sol";
 
 /**
- * @notice Confidential token using OpenZeppelin's ERC7984 standard
+ * @notice Confidential ERC20-compatible token using OpenZeppelin's ERC7984 standard.
+ *         Implements a fully private token where balances and transfer amounts
+ *         are encrypted. Compatible with standard ERC20 interfaces but with FHE
+ *         under the hood. Supports both visible minting (owner knows amount) and
+ *         confidential minting (fully private). Foundation for building private
+ *         DeFi applications.
  *
  * @dev Demonstrates minting and burning with both visible and encrypted amounts.
  *      Shows how to integrate FHE with standard token operations.

package/contracts/openzeppelin/ERC7984ERC20Wrapper.sol

@@ -9,7 +9,11 @@ import {
 } from "@openzeppelin/confidential-contracts/token/ERC7984/extensions/ERC7984ERC20Wrapper.sol";
 
 /**
- * @notice Wraps ERC20 tokens into confidential ERC7984 tokens
+ * @notice Bridge between public ERC20 and confidential ERC7984 tokens.
+ *         Allows users to wrap regular ERC20 tokens into privacy-preserving
+ *         ERC7984 tokens (public → private) and unwrap them back (private → public).
+ *         Wrapping is instant, unwrapping requires decryption proof from KMS.
+ *         Essential for bringing existing tokens into the confidential ecosystem.
  *
  * @dev WRAP: ERC20 → ERC7984 (public → private)
  *      UNWRAP: ERC7984 → ERC20 (private → public, requires decryption)

package/contracts/openzeppelin/SwapERC7984ToERC20.sol

@@ -12,7 +12,11 @@ import {
 import {ZamaEthereumConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
 
 /**
- * @notice Swap confidential ERC7984 tokens to regular ERC20 tokens
+ * @notice Atomic swap from confidential ERC7984 to public ERC20 tokens.
+ *         Two-step process: (1) Initiate swap with encrypted amount, request
+ *         decryption from KMS. (2) Finalize swap with decryption proof, receive
+ *         ERC20 tokens. Demonstrates the FHEVM v0.9 public decryption flow with
+ *         makePubliclyDecryptable() and checkSignatures() for trustless swaps.
  *
  * @dev Uses FHEVM v0.9 decryption flow:
  *      FHE.makePubliclyDecryptable() + FHE.checkSignatures()

package/contracts/openzeppelin/SwapERC7984ToERC7984.sol

@@ -8,7 +8,11 @@ import {
 import {ZamaEthereumConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
 
 /**
- * @notice Fully confidential swap between two ERC7984 tokens
+ * @notice Fully private atomic swap between two confidential ERC7984 tokens.
+ *         Both input and output amounts remain encrypted throughout the entire
+ *         swap process. No decryption needed - amounts stay private from start
+ *         to finish. Perfect for confidential DEX operations where trade sizes
+ *         must remain hidden. The ultimate privacy-preserving token exchange.
  *
  * @dev Both input and output amounts remain encrypted throughout the swap.
  */

package/contracts/openzeppelin/VestingWallet.sol

@@ -12,7 +12,12 @@ import {
 } from "@openzeppelin/confidential-contracts/interfaces/IERC7984.sol";
 
 /**
- * @notice Linear vesting wallet for ERC7984 tokens with fully encrypted amounts and schedules.
+ * @notice Time-locked vesting wallet with fully encrypted token amounts.
+ *         Implements linear vesting for ERC7984 confidential tokens. Vesting
+ *         schedule, amounts, and release calculations all happen on encrypted
+ *         values using FHE operations. Beneficiary can release vested tokens
+ *         over time without revealing the total allocation or vesting progress
+ *         to observers.
 
  * @dev Timeline: |--START--|---VESTING---|--END--| (0% → linear → 100%)
  *      All vesting calculations performed on encrypted values using FHE.

package/dist/scripts/commands/add-mode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"add-mode.d.ts","sourceRoot":"","sources":["../../../scripts/commands/add-mode.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA2OH;;GAEG;AACH,wBAAsB,UAAU,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA8ElE"}
+{"version":3,"file":"add-mode.d.ts","sourceRoot":"","sources":["../../../scripts/commands/add-mode.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAuOH;;GAEG;AACH,wBAAsB,UAAU,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA8ElE"}

package/dist/scripts/commands/add-mode.js

@@ -58,7 +58,7 @@ const utils_1 = require("../shared/utils");
 function detectHardhatProject(targetDir) {
     const packageJsonPath = path.join(targetDir, "package.json");
     const hardhatConfigTs = path.join(targetDir, "hardhat.config.ts");
-    const hardhatConfigJs = path.join(targetDir, "hardhat.config");
+    const hardhatConfigJs = path.join(targetDir, "hardhat.config.js");
     if (!fs.existsSync(packageJsonPath)) {
         return false;
     }
@@ -106,7 +106,7 @@ function updateHardhatConfig(targetDir) {
             ? configPathJs
             : null;
     if (!actualPath) {
-        throw new Error("hardhat.config.ts or hardhat.config.js not found");
+        throw new Error(utils_1.ERROR_MESSAGES.CONFIG_NOT_FOUND);
     }
     let content = fs.readFileSync(actualPath, "utf-8");
     if (content.includes("@fhevm/hardhat-plugin")) {
@@ -139,12 +139,12 @@ function updateHardhatConfig(targetDir) {
 function addExampleFiles(exampleName, targetDir) {
     const example = config_1.EXAMPLES[exampleName];
     if (!example) {
-        throw new Error(`Unknown example: ${exampleName}`);
+        throw new Error(utils_1.ERROR_MESSAGES.UNKNOWN_EXAMPLE(exampleName));
     }
     const rootDir = (0, utils_1.getRootDir)();
     const contractName = (0, utils_1.getContractName)(example.contract);
     if (!contractName) {
-        throw new Error("Could not extract contract name");
+        throw new Error(utils_1.ERROR_MESSAGES.CONTRACT_NAME_FAILED);
     }
     const contractSource = path.join(rootDir, example.contract);
     const testSource = path.join(rootDir, example.test);
@@ -154,15 +154,9 @@ function addExampleFiles(exampleName, targetDir) {
     if (!fs.existsSync(contractsDir)) {
         fs.mkdirSync(contractsDir, { recursive: true });
     }
-    if (fs.existsSync(contractDest)) {
-        // File exists - will be handled by caller with prompts
-        fs.copyFileSync(contractSource, contractDest);
-        p.log.success(`Overwritten: ${contractName}.sol`);
-    }
-    else {
-        fs.copyFileSync(contractSource, contractDest);
-        p.log.success(`Added: ${contractName}.sol`);
-    }
+    const isContractOverwrite = fs.existsSync(contractDest);
+    fs.copyFileSync(contractSource, contractDest);
+    p.log.success(`${isContractOverwrite ? "Overwritten" : "Added"}: ${contractName}.sol`);
     // Handle test file
     const testFileName = path.basename(example.test);
     const testDest = path.join(targetDir, "test", testFileName);
@@ -170,14 +164,9 @@ function addExampleFiles(exampleName, targetDir) {
     if (!fs.existsSync(testDir)) {
         fs.mkdirSync(testDir, { recursive: true });
     }
-    if (fs.existsSync(testDest)) {
-        fs.copyFileSync(testSource, testDest);
-        p.log.success(`Overwritten: ${testFileName}`);
-    }
-    else {
-        fs.copyFileSync(testSource, testDest);
-        p.log.success(`Added: ${testFileName}`);
-    }
+    const isTestOverwrite = fs.existsSync(testDest);
+    fs.copyFileSync(testSource, testDest);
+    p.log.success(`${isTestOverwrite ? "Overwritten" : "Added"}: ${testFileName}`);
     // Handle contract dependencies
     if (example.dependencies) {
         p.log.message("");

package/dist/scripts/commands/doctor.js

@@ -162,4 +162,7 @@ async function main() {
         p.outro(picocolors_1.default.green("✅ All checks passed! You are ready to develop. 🚀"));
     }
 }
-main().catch(console.error);
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});