katour 1.0.0

package/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

package/README.md

@@ -0,0 +1,149 @@
+# ⛓ Katour CLI
+
+Multi-chain Solidity deployment CLI — compile, deploy, verify, and interact with contracts in one tool.
+
+## Installation
+
+```bash
+# Clone / copy the project
+cd katour
+npm install
+npm link   # makes `katour` available globally
+```
+
+## Quick Start
+
+```bash
+# 1. Initialize a project
+katour init
+
+# 2. Edit .env — add your PRIVATE_KEY and API keys
+
+# 3. Compile contracts
+katour compile
+
+# 4. Deploy
+katour deploy
+
+# 5. Interact with deployed contract
+katour interact <address>
+```
+
+---
+
+## Commands
+
+### `katour init`
+Scaffolds the project structure:
+```
+contracts/     ← put your .sol files here
+artifacts/     ← compiled output (auto-generated)
+deployments/   ← deployment records per network
+.env           ← config (private key, RPC, API keys)
+```
+
+---
+
+### `katour compile`
+Compiles all contracts in `./contracts/`.
+
+```bash
+katour compile                         # compile all
+katour compile -f contracts/Token.sol  # specific file
+katour compile -o ./out                # custom output dir
+```
+
+---
+
+### `katour deploy`
+Deploys a compiled contract. Interactive prompts if no flags set.
+
+```bash
+katour deploy                              # interactive
+katour deploy -c Token -n sepolia          # specific contract + network
+katour deploy -c Token -n mainnet --verify # deploy + auto verify
+katour deploy -c Token -n sepolia --dry-run # simulate only
+katour deploy -c Token -n polygon --args "MyToken" "MTK" 1000000
+```
+
+---
+
+### `katour verify`
+Verifies a deployed contract on the block explorer.
+
+```bash
+katour verify 0xAbC... -c Token -n sepolia
+katour verify 0xAbC... -c Token -n mainnet --args "MyToken" "MTK" 1000000
+```
+
+---
+
+### `katour interact`
+Interactive REPL to call any contract function.
+
+```bash
+katour interact 0xAbC...            # interactive network + contract selection
+katour interact 0xAbC... -n polygon -c Token
+```
+
+Lists all read (`view/pure`) and write functions with prompts for arguments.
+
+---
+
+## Supported Networks
+
+| Key           | Name                  | Explorer             |
+|---------------|-----------------------|----------------------|
+| `mainnet`     | Ethereum Mainnet      | etherscan.io         |
+| `sepolia`     | Sepolia Testnet       | sepolia.etherscan.io |
+| `polygon`     | Polygon Mainnet       | polygonscan.com      |
+| `mumbai`      | Polygon Mumbai        | mumbai.polygonscan   |
+| `bsc`         | BNB Smart Chain       | bscscan.com          |
+| `bscTestnet`  | BSC Testnet           | testnet.bscscan.com  |
+| `arbitrum`    | Arbitrum One          | arbiscan.io          |
+| `optimism`    | Optimism              | optimistic.etherscan |
+| `avalanche`   | Avalanche C-Chain     | snowtrace.io         |
+| `base`        | Base                  | basescan.org         |
+| `baseSepolia` | Base Sepolia          | sepolia.basescan.org |
+
+---
+
+## .env Reference
+
+```env
+# Required
+PRIVATE_KEY=your_wallet_private_key
+
+# Optional - custom RPC endpoints
+ETH_MAINNET_RPC=https://eth.llamarpc.com
+ETH_SEPOLIA_RPC=https://rpc.sepolia.org
+POLYGON_RPC=https://polygon-rpc.com
+BSC_RPC=https://bsc-dataseed.binance.org
+
+# For verification (get free keys from each explorer)
+ETHERSCAN_API_KEY=...
+POLYGONSCAN_API_KEY=...
+BSCSCAN_API_KEY=...
+ARBISCAN_API_KEY=...
+BASESCAN_API_KEY=...
+```
+
+---
+
+## Deployment Records
+
+Every successful deployment is saved to `./deployments/<network>.json`:
+
+```json
+{
+  "MyContract": {
+    "address": "0x...",
+    "txHash": "0x...",
+    "constructorArgs": ["Hello", "42"],
+    "deployedAt": "2024-01-01T00:00:00.000Z"
+  }
+}
+```
+
+---
+

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "katour",
+  "version": "1.0.0",
+  "description": "Multi-chain Solidity contract deployment CLI — compile, deploy, verify, interact",
+  "type": "module",
+  "bin": {
+    "katour": "./src/index.js"
+  },
+  "scripts": {
+    "dev": "node src/index.js",
+    "link": "npm link"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "ethers": "^6.13.0",
+    "figlet": "^1.7.0",
+    "inquirer": "^10.1.0",
+    "ora": "^8.0.1",
+    "solc": "^0.8.26",
+    "axios": "^1.7.0",
+    "dotenv": "^16.4.5",
+    "fs-extra": "^11.2.0",
+    "glob": "^11.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/commands/compile.js

@@ -0,0 +1,92 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { glob } from 'glob';
+import solc from 'solc';
+import chalk from 'chalk';
+import ora from 'ora';
+
+export async function compileCommand(options) {
+  const spinner = ora('Finding Solidity files...').start();
+
+  try {
+    const outputDir = options.output || './artifacts';
+    await fs.ensureDir(outputDir);
+
+    // Find contract files
+    let files = [];
+    if (options.file) {
+      if (!fs.existsSync(options.file)) {
+        spinner.fail(chalk.red(`File not found: ${options.file}`));
+        process.exit(1);
+      }
+      files = [options.file];
+    } else {
+      files = await glob('contracts/**/*.sol');
+      if (files.length === 0) {
+        spinner.fail(chalk.red('No .sol files found in ./contracts/'));
+        process.exit(1);
+      }
+    }
+
+    spinner.text = `Compiling ${files.length} contract(s)...`;
+
+    const compiled = [];
+
+    for (const filePath of files) {
+      const source = fs.readFileSync(filePath, 'utf8');
+      const fileName = path.basename(filePath);
+
+      // Build solc input
+      const input = {
+        language: 'Solidity',
+        sources: { [fileName]: { content: source } },
+        settings: {
+          outputSelection: {
+            '*': { '*': ['abi', 'evm.bytecode', 'evm.deployedBytecode', 'metadata'] },
+          },
+          optimizer: { enabled: true, runs: 200 },
+        },
+      };
+
+      const output = JSON.parse(solc.compile(JSON.stringify(input)));
+
+      // Check errors
+      if (output.errors) {
+        const errors = output.errors.filter(e => e.severity === 'error');
+        if (errors.length > 0) {
+          spinner.fail(chalk.red(`Compilation errors in ${fileName}:`));
+          errors.forEach(e => console.error(chalk.red(`  ${e.formattedMessage}`)));
+          process.exit(1);
+        }
+        const warnings = output.errors.filter(e => e.severity === 'warning');
+        warnings.forEach(w => console.warn(chalk.yellow(`  ⚠ ${w.message}`)));
+      }
+
+      // Save artifacts
+      for (const contractName of Object.keys(output.contracts[fileName] || {})) {
+        const artifact = {
+          contractName,
+          sourcePath: filePath,
+          abi: output.contracts[fileName][contractName].abi,
+          bytecode: output.contracts[fileName][contractName].evm.bytecode.object,
+          deployedBytecode: output.contracts[fileName][contractName].evm.deployedBytecode.object,
+          metadata: output.contracts[fileName][contractName].metadata,
+          compiledAt: new Date().toISOString(),
+        };
+
+        const outFile = path.join(outputDir, `${contractName}.json`);
+        await fs.writeJSON(outFile, artifact, { spaces: 2 });
+        compiled.push({ contractName, outFile });
+      }
+    }
+
+    spinner.succeed(chalk.green(`Compiled ${compiled.length} contract(s) successfully!`));
+    compiled.forEach(({ contractName, outFile }) => {
+      console.log(chalk.gray(`  ✔ ${contractName} → ${outFile}`));
+    });
+
+  } catch (err) {
+    spinner.fail(chalk.red(`Compilation failed: ${err.message}`));
+    process.exit(1);
+  }
+}

package/src/commands/deploy.js

@@ -0,0 +1,162 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { ethers } from 'ethers';
+import { getNetwork, NETWORKS } from '../config/networks.js';
+import { compileCommand } from './compile.js';
+import { verifyContract } from '../utils/verify.js';
+import { saveDeployment } from '../utils/deployments.js';
+import dotenv from 'dotenv';
+dotenv.config();
+
+export async function deployCommand(options) {
+  console.log(chalk.cyan('\n🚀 Katour Deploy\n'));
+
+  try {
+    // 1. Pick network interactively if not specified
+    let networkName = options.network;
+    if (!networkName) {
+      const { net } = await inquirer.prompt([{
+        type: 'list',
+        name: 'net',
+        message: 'Select target network:',
+        choices: Object.entries(NETWORKS).map(([key, v]) => ({
+          name: `${v.name} (${v.currency})`,
+          value: key,
+        })),
+      }]);
+      networkName = net;
+    }
+
+    const network = getNetwork(networkName);
+    console.log(chalk.gray(`  Network: ${network.name} (chainId: ${network.chainId})`));
+
+    // 2. Pick contract
+    let contractName = options.contract;
+    const artifactsDir = './artifacts';
+
+    if (!fs.existsSync(artifactsDir) || fs.readdirSync(artifactsDir).length === 0) {
+      console.log(chalk.yellow('  No artifacts found. Running compile first...\n'));
+      await compileCommand({ output: artifactsDir });
+    }
+
+    const artifacts = fs.readdirSync(artifactsDir)
+      .filter(f => f.endsWith('.json'))
+      .map(f => f.replace('.json', ''));
+
+    if (!contractName) {
+      if (artifacts.length === 1) {
+        contractName = artifacts[0];
+        console.log(chalk.gray(`  Contract: ${contractName} (auto-selected)`));
+      } else {
+        const { contract } = await inquirer.prompt([{
+          type: 'list',
+          name: 'contract',
+          message: 'Select contract to deploy:',
+          choices: artifacts,
+        }]);
+        contractName = contract;
+      }
+    }
+
+    const artifactPath = path.join(artifactsDir, `${contractName}.json`);
+    if (!fs.existsSync(artifactPath)) {
+      console.error(chalk.red(`Artifact not found: ${artifactPath}`));
+      process.exit(1);
+    }
+
+    const artifact = await fs.readJSON(artifactPath);
+
+    // 3. Constructor args
+    const constructorAbi = artifact.abi.find(x => x.type === 'constructor');
+    let constructorArgs = options.args || [];
+
+    if (constructorAbi && constructorAbi.inputs.length > 0 && constructorArgs.length === 0) {
+      console.log(chalk.yellow(`\n  Constructor requires ${constructorAbi.inputs.length} argument(s):`));
+      const answers = await inquirer.prompt(
+        constructorAbi.inputs.map((inp, i) => ({
+          type: 'input',
+          name: `arg_${i}`,
+          message: `  ${inp.name} (${inp.type}):`,
+        }))
+      );
+      constructorArgs = Object.values(answers);
+    }
+
+    // 4. Get private key
+    const privateKey = process.env.PRIVATE_KEY;
+    if (!privateKey) {
+      console.error(chalk.red('\n  ❌ PRIVATE_KEY not found in .env'));
+      console.log(chalk.gray('  Create a .env file with: PRIVATE_KEY=0xyour_key'));
+      process.exit(1);
+    }
+
+    // 5. Dry run check
+    const provider = new ethers.JsonRpcProvider(network.rpc);
+    const wallet = new ethers.Wallet(privateKey, provider);
+    const balance = await provider.getBalance(wallet.address);
+    const balanceEth = ethers.formatEther(balance);
+
+    console.log(chalk.gray(`\n  Deployer: ${wallet.address}`));
+    console.log(chalk.gray(`  Balance:  ${balanceEth} ${network.currency}`));
+
+    // Estimate gas
+    const factory = new ethers.ContractFactory(artifact.abi, artifact.bytecode, wallet);
+    const deployTx = await factory.getDeployTransaction(...constructorArgs);
+    const gasEstimate = await provider.estimateGas({ ...deployTx, from: wallet.address });
+    const feeData = await provider.getFeeData();
+    const estimatedCost = gasEstimate * (feeData.gasPrice || 0n);
+
+    console.log(chalk.gray(`  Gas est:  ${gasEstimate.toString()}`));
+    console.log(chalk.gray(`  Est cost: ~${ethers.formatEther(estimatedCost)} ${network.currency}\n`));
+
+    if (options.dryRun) {
+      console.log(chalk.yellow('  🔍 Dry run mode — no transaction sent.'));
+      return;
+    }
+
+    // 6. Confirm
+    const { confirmed } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirmed',
+      message: `Deploy ${contractName} to ${network.name}?`,
+      default: true,
+    }]);
+
+    if (!confirmed) {
+      console.log(chalk.yellow('  Deployment cancelled.'));
+      return;
+    }
+
+    // 7. Deploy
+    const spinner = ora(`Deploying ${contractName}...`).start();
+    const contract = await factory.deploy(...constructorArgs);
+    spinner.text = `Waiting for transaction... (${contract.deploymentTransaction().hash})`;
+
+    const receipt = await contract.deploymentTransaction().wait(1);
+    const address = await contract.getAddress();
+
+    spinner.succeed(chalk.green(`Deployed successfully!`));
+    console.log(chalk.green(`\n  ✅ Contract address: ${chalk.bold(address)}`));
+    console.log(chalk.gray(`  Tx hash: ${receipt.hash}`));
+    console.log(chalk.gray(`  Block:   ${receipt.blockNumber}`));
+    console.log(chalk.blue(`  Explorer: ${network.explorer}/address/${address}\n`));
+
+    // 8. Save deployment record
+    await saveDeployment({ contractName, address, network: networkName, txHash: receipt.hash, args: constructorArgs });
+
+    // 9. Auto verify if flag set
+    if (options.verify) {
+      await verifyContract({ contractName, address, networkName, constructorArgs, artifact });
+    } else {
+      console.log(chalk.gray(`  Tip: Run ${chalk.cyan(`katour verify ${address} -c ${contractName} -n ${networkName}`)} to verify\n`));
+    }
+
+  } catch (err) {
+    console.error(chalk.red(`\n  Deploy failed: ${err.message}`));
+    if (process.env.DEBUG) console.error(err);
+    process.exit(1);
+  }
+}

package/src/commands/init.js

@@ -0,0 +1,109 @@
+import fs from 'fs-extra';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import path from 'path';
+
+const EXAMPLE_CONTRACT = `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+contract MyContract {
+    string public name;
+    address public owner;
+    uint256 public value;
+
+    event ValueUpdated(uint256 oldValue, uint256 newValue);
+
+    constructor(string memory _name, uint256 _initialValue) {
+        name = _name;
+        owner = msg.sender;
+        value = _initialValue;
+    }
+
+    modifier onlyOwner() {
+        require(msg.sender == owner, "Not owner");
+        _;
+    }
+
+    function setValue(uint256 _newValue) external onlyOwner {
+        emit ValueUpdated(value, _newValue);
+        value = _newValue;
+    }
+
+    function getValue() external view returns (uint256) {
+        return value;
+    }
+}
+`;
+
+const ENV_TEMPLATE = `# ========================================
+# Katour Environment Config
+# ========================================
+
+# Your deployer wallet private key (without 0x)
+PRIVATE_KEY=your_private_key_here
+
+# RPC endpoints (optional — defaults to public RPCs)
+ETH_MAINNET_RPC=https://eth.llamarpc.com
+ETH_SEPOLIA_RPC=https://rpc.sepolia.org
+POLYGON_RPC=https://polygon-rpc.com
+BSC_RPC=https://bsc-dataseed.binance.org
+
+# Block explorer API keys (for verification)
+ETHERSCAN_API_KEY=your_etherscan_key
+POLYGONSCAN_API_KEY=your_polygonscan_key
+BSCSCAN_API_KEY=your_bscscan_key
+ARBISCAN_API_KEY=your_arbiscan_key
+BASESCAN_API_KEY=your_basescan_key
+`;
+
+export async function initCommand() {
+  console.log(chalk.cyan('\n🛠  Katour Init\n'));
+
+  const { projectName } = await inquirer.prompt([{
+    type: 'input',
+    name: 'projectName',
+    message: 'Project name:',
+    default: path.basename(process.cwd()),
+  }]);
+
+  const { createExample } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'createExample',
+    message: 'Create example contract?',
+    default: true,
+  }]);
+
+  // Create folders
+  await fs.ensureDir('./contracts');
+  await fs.ensureDir('./artifacts');
+  await fs.ensureDir('./deployments');
+
+  // Create .env if not exists
+  if (!fs.existsSync('./.env')) {
+    await fs.writeFile('./.env', ENV_TEMPLATE);
+    console.log(chalk.green('  ✔ .env created'));
+  } else {
+    console.log(chalk.gray('  ℹ .env already exists, skipping'));
+  }
+
+  // .gitignore
+  const gitignore = `node_modules/\nartifacts/\n.env\ndeployments/\n`;
+  await fs.writeFile('./.gitignore', gitignore);
+  console.log(chalk.green('  ✔ .gitignore created'));
+
+  // Example contract
+  if (createExample) {
+    const contractPath = './contracts/MyContract.sol';
+    if (!fs.existsSync(contractPath)) {
+      await fs.writeFile(contractPath, EXAMPLE_CONTRACT);
+      console.log(chalk.green('  ✔ contracts/MyContract.sol created'));
+    }
+  }
+
+  console.log(chalk.green(`\n  ✅ Project "${projectName}" initialized!\n`));
+  console.log(chalk.cyan('  Next steps:'));
+  console.log(chalk.gray('  1. Edit .env and add your PRIVATE_KEY'));
+  console.log(chalk.gray('  2. Add your contracts to ./contracts/'));
+  console.log(chalk.gray('  3. Run: katour compile'));
+  console.log(chalk.gray('  4. Run: katour deploy\n'));
+}

package/src/commands/interact.js

@@ -0,0 +1,174 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import { ethers } from 'ethers';
+import fs from 'fs-extra';
+import path from 'path';
+import { getNetwork, NETWORKS } from '../config/networks.js';
+import dotenv from 'dotenv';
+dotenv.config();
+
+export async function interactCommand(address, options) {
+  console.log(chalk.cyan('\n⚡ Katour Interact\n'));
+
+  try {
+    // Network
+    let networkName = options.network;
+    if (!networkName) {
+      const { net } = await inquirer.prompt([{
+        type: 'list',
+        name: 'net',
+        message: 'Select network:',
+        choices: Object.entries(NETWORKS).map(([key, v]) => ({
+          name: `${v.name}`,
+          value: key,
+        })),
+      }]);
+      networkName = net;
+    }
+
+    const network = getNetwork(networkName);
+    const provider = new ethers.JsonRpcProvider(network.rpc);
+
+    // Load ABI
+    let contractName = options.contract;
+    if (!contractName) {
+      const artifacts = fs.readdirSync('./artifacts').filter(f => f.endsWith('.json'));
+      if (artifacts.length === 0) {
+        console.error(chalk.red('  No artifacts found. Run katour compile first.'));
+        process.exit(1);
+      }
+      const { c } = await inquirer.prompt([{
+        type: 'list',
+        name: 'c',
+        message: 'Select contract (for ABI):',
+        choices: artifacts.map(f => f.replace('.json', '')),
+      }]);
+      contractName = c;
+    }
+
+    const artifact = await fs.readJSON(path.join('./artifacts', `${contractName}.json`));
+    const abi = artifact.abi;
+
+    // Get all callable functions
+    const readFns = abi.filter(x => x.type === 'function' && (x.stateMutability === 'view' || x.stateMutability === 'pure'));
+    const writeFns = abi.filter(x => x.type === 'function' && x.stateMutability !== 'view' && x.stateMutability !== 'pure');
+
+    // Create contract instance (read-only first)
+    let contract = new ethers.Contract(address, abi, provider);
+
+    console.log(chalk.gray(`  Contract: ${address}`));
+    console.log(chalk.gray(`  Network:  ${network.name}`));
+    console.log(chalk.gray(`  Read fns: ${readFns.length}  |  Write fns: ${writeFns.length}\n`));
+
+    // Interactive loop
+    while (true) {
+      const allFunctions = [
+        ...readFns.map(f => ({ name: `📖 ${f.name}(${f.inputs.map(i => i.type).join(', ')}) [read]`, value: { fn: f, type: 'read' } })),
+        ...writeFns.map(f => ({ name: `✏️  ${f.name}(${f.inputs.map(i => i.type).join(', ')}) [write]`, value: { fn: f, type: 'write' } })),
+        new inquirer.Separator(),
+        { name: '🚪 Exit', value: null },
+      ];
+
+      const { selected } = await inquirer.prompt([{
+        type: 'list',
+        name: 'selected',
+        message: 'Select a function to call:',
+        choices: allFunctions,
+        pageSize: 20,
+      }]);
+
+      if (!selected) break;
+
+      const { fn, type } = selected;
+
+      // Collect inputs
+      let callArgs = [];
+      if (fn.inputs.length > 0) {
+        const answers = await inquirer.prompt(
+          fn.inputs.map((inp, i) => ({
+            type: 'input',
+            name: `arg_${i}`,
+            message: `  ${inp.name || `arg${i}`} (${inp.type}):`,
+          }))
+        );
+        callArgs = fn.inputs.map((inp, i) => {
+          const val = answers[`arg_${i}`];
+          // Parse arrays and tuples
+          if (inp.type.endsWith('[]') || inp.type === 'tuple') {
+            try { return JSON.parse(val); } catch { return val; }
+          }
+          return val;
+        });
+      }
+
+      if (type === 'read') {
+        // Read call
+        const spinner = ora(`Calling ${fn.name}...`).start();
+        try {
+          const result = await contract[fn.name](...callArgs);
+          spinner.succeed(chalk.green(`Result:`));
+          if (Array.isArray(result)) {
+            result.forEach((r, i) => console.log(chalk.cyan(`  [${i}]: ${r.toString()}`)));
+          } else {
+            console.log(chalk.cyan(`  → ${result.toString()}`));
+          }
+        } catch (err) {
+          spinner.fail(chalk.red(`Error: ${err.message}`));
+        }
+      } else {
+        // Write call - need wallet
+        const privateKey = process.env.PRIVATE_KEY;
+        if (!privateKey) {
+          console.error(chalk.red('  PRIVATE_KEY not set in .env'));
+          continue;
+        }
+
+        const wallet = new ethers.Wallet(privateKey, provider);
+        contract = contract.connect(wallet);
+
+        // Check if payable
+        let value = 0n;
+        if (fn.stateMutability === 'payable') {
+          const { ethValue } = await inquirer.prompt([{
+            type: 'input',
+            name: 'ethValue',
+            message: `  ETH to send (in ${network.currency}):`,
+            default: '0',
+          }]);
+          value = ethers.parseEther(ethValue || '0');
+        }
+
+        const { confirmed } = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'confirmed',
+          message: `Send transaction to call ${fn.name}?`,
+          default: true,
+        }]);
+
+        if (!confirmed) continue;
+
+        const spinner = ora(`Sending transaction...`).start();
+        try {
+          const tx = await contract[fn.name](...callArgs, { value });
+          spinner.text = `Waiting for confirmation... (${tx.hash})`;
+          const receipt = await tx.wait(1);
+          spinner.succeed(chalk.green(`Transaction confirmed!`));
+          console.log(chalk.gray(`  Tx hash: ${receipt.hash}`));
+          console.log(chalk.gray(`  Block:   ${receipt.blockNumber}`));
+          console.log(chalk.blue(`  ${network.explorer}/tx/${receipt.hash}`));
+        } catch (err) {
+          spinner.fail(chalk.red(`Transaction failed: ${err.message}`));
+        }
+      }
+
+      console.log('');
+    }
+
+    console.log(chalk.gray('\n  Goodbye! 👋\n'));
+
+  } catch (err) {
+    console.error(chalk.red(`\n  Error: ${err.message}`));
+    process.exit(1);
+  }
+}

package/src/commands/verify.js

@@ -0,0 +1,33 @@
+import chalk from 'chalk';
+import { getNetwork } from '../config/networks.js';
+import { verifyContract } from '../utils/verify.js';
+import fs from 'fs-extra';
+import path from 'path';
+
+export async function verifyCommand(address, options) {
+  console.log(chalk.cyan('\n🔍 Katour Verify\n'));
+
+  const networkName = options.network || 'mainnet';
+  const contractName = options.contract;
+
+  if (!contractName) {
+    console.error(chalk.red('  Please provide contract name with -c flag'));
+    process.exit(1);
+  }
+
+  const artifactPath = path.join('./artifacts', `${contractName}.json`);
+  if (!fs.existsSync(artifactPath)) {
+    console.error(chalk.red(`  Artifact not found: ${artifactPath}. Run katour compile first.`));
+    process.exit(1);
+  }
+
+  const artifact = await fs.readJSON(artifactPath);
+
+  await verifyContract({
+    contractName,
+    address,
+    networkName,
+    constructorArgs: options.args || [],
+    artifact,
+  });
+}

package/src/config/networks.js

@@ -0,0 +1,127 @@
+// Supported networks config
+export const NETWORKS = {
+  // Ethereum
+  mainnet: {
+    name: 'Ethereum Mainnet',
+    chainId: 1,
+    rpc: process.env.ETH_MAINNET_RPC || 'https://eth.llamarpc.com',
+    explorer: 'https://etherscan.io',
+    explorerApi: 'https://api.etherscan.io/api',
+    explorerApiKeyEnv: 'ETHERSCAN_API_KEY',
+    currency: 'ETH',
+  },
+  sepolia: {
+    name: 'Sepolia Testnet',
+    chainId: 11155111,
+    rpc: process.env.ETH_SEPOLIA_RPC || 'https://rpc.sepolia.org',
+    explorer: 'https://sepolia.etherscan.io',
+    explorerApi: 'https://api-sepolia.etherscan.io/api',
+    explorerApiKeyEnv: 'ETHERSCAN_API_KEY',
+    currency: 'ETH',
+  },
+  goerli: {
+    name: 'Goerli Testnet',
+    chainId: 5,
+    rpc: process.env.ETH_GOERLI_RPC || 'https://rpc.ankr.com/eth_goerli',
+    explorer: 'https://goerli.etherscan.io',
+    explorerApi: 'https://api-goerli.etherscan.io/api',
+    explorerApiKeyEnv: 'ETHERSCAN_API_KEY',
+    currency: 'ETH',
+  },
+  // Polygon
+  polygon: {
+    name: 'Polygon Mainnet',
+    chainId: 137,
+    rpc: process.env.POLYGON_RPC || 'https://polygon-rpc.com',
+    explorer: 'https://polygonscan.com',
+    explorerApi: 'https://api.polygonscan.com/api',
+    explorerApiKeyEnv: 'POLYGONSCAN_API_KEY',
+    currency: 'MATIC',
+  },
+  mumbai: {
+    name: 'Polygon Mumbai',
+    chainId: 80001,
+    rpc: process.env.POLYGON_MUMBAI_RPC || 'https://rpc-mumbai.maticvigil.com',
+    explorer: 'https://mumbai.polygonscan.com',
+    explorerApi: 'https://api-testnet.polygonscan.com/api',
+    explorerApiKeyEnv: 'POLYGONSCAN_API_KEY',
+    currency: 'MATIC',
+  },
+  // BSC
+  bsc: {
+    name: 'BNB Smart Chain',
+    chainId: 56,
+    rpc: process.env.BSC_RPC || 'https://bsc-dataseed.binance.org',
+    explorer: 'https://bscscan.com',
+    explorerApi: 'https://api.bscscan.com/api',
+    explorerApiKeyEnv: 'BSCSCAN_API_KEY',
+    currency: 'BNB',
+  },
+  bscTestnet: {
+    name: 'BSC Testnet',
+    chainId: 97,
+    rpc: process.env.BSC_TESTNET_RPC || 'https://data-seed-prebsc-1-s1.binance.org:8545',
+    explorer: 'https://testnet.bscscan.com',
+    explorerApi: 'https://api-testnet.bscscan.com/api',
+    explorerApiKeyEnv: 'BSCSCAN_API_KEY',
+    currency: 'BNB',
+  },
+  // Arbitrum
+  arbitrum: {
+    name: 'Arbitrum One',
+    chainId: 42161,
+    rpc: process.env.ARBITRUM_RPC || 'https://arb1.arbitrum.io/rpc',
+    explorer: 'https://arbiscan.io',
+    explorerApi: 'https://api.arbiscan.io/api',
+    explorerApiKeyEnv: 'ARBISCAN_API_KEY',
+    currency: 'ETH',
+  },
+  // Optimism
+  optimism: {
+    name: 'Optimism',
+    chainId: 10,
+    rpc: process.env.OPTIMISM_RPC || 'https://mainnet.optimism.io',
+    explorer: 'https://optimistic.etherscan.io',
+    explorerApi: 'https://api-optimistic.etherscan.io/api',
+    explorerApiKeyEnv: 'OPTIMISM_API_KEY',
+    currency: 'ETH',
+  },
+  // Avalanche
+  avalanche: {
+    name: 'Avalanche C-Chain',
+    chainId: 43114,
+    rpc: process.env.AVALANCHE_RPC || 'https://api.avax.network/ext/bc/C/rpc',
+    explorer: 'https://snowtrace.io',
+    explorerApi: 'https://api.snowtrace.io/api',
+    explorerApiKeyEnv: 'SNOWTRACE_API_KEY',
+    currency: 'AVAX',
+  },
+  // Base
+  base: {
+    name: 'Base',
+    chainId: 8453,
+    rpc: process.env.BASE_RPC || 'https://mainnet.base.org',
+    explorer: 'https://basescan.org',
+    explorerApi: 'https://api.basescan.org/api',
+    explorerApiKeyEnv: 'BASESCAN_API_KEY',
+    currency: 'ETH',
+  },
+  baseSepolia: {
+    name: 'Base Sepolia',
+    chainId: 84532,
+    rpc: process.env.BASE_SEPOLIA_RPC || 'https://sepolia.base.org',
+    explorer: 'https://sepolia.basescan.org',
+    explorerApi: 'https://api-sepolia.basescan.org/api',
+    explorerApiKeyEnv: 'BASESCAN_API_KEY',
+    currency: 'ETH',
+  },
+};
+
+export function getNetwork(name) {
+  const net = NETWORKS[name];
+  if (!net) {
+    const available = Object.keys(NETWORKS).join(', ');
+    throw new Error(`Unknown network "${name}". Available: ${available}`);
+  }
+  return net;
+}

package/src/index.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import chalk from 'chalk';
+import figlet from 'figlet';
+import { deployCommand } from './commands/deploy.js';
+import { compileCommand } from './commands/compile.js';
+import { verifyCommand } from './commands/verify.js';
+import { interactCommand } from './commands/interact.js';
+import { initCommand } from './commands/init.js';
+
+// Banner
+console.log(
+  chalk.cyan(figlet.textSync('katour', { font: 'Small' }))
+);
+console.log(chalk.gray('  ⛓  Multi-chain Solidity Deployment CLI\n'));
+
+program
+  .name('katour')
+  .description('Deploy, compile, verify, and interact with Solidity contracts')
+  .version('1.0.0');
+
+// katour init
+program
+  .command('init')
+  .description('Initialize a new katour project')
+  .action(initCommand);
+
+// katour compile
+program
+  .command('compile')
+  .description('Compile Solidity contracts')
+  .option('-f, --file <path>', 'specific contract file to compile')
+  .option('-o, --output <dir>', 'output directory for artifacts', './artifacts')
+  .action(compileCommand);
+
+// katour deploy
+program
+  .command('deploy')
+  .description('Deploy a compiled contract')
+  .option('-c, --contract <name>', 'contract name to deploy')
+  .option('-n, --network <name>', 'target network (mainnet/sepolia/polygon/bsc/arbitrum...)')
+  .option('--args <args...>', 'constructor arguments')
+  .option('--verify', 'verify on Etherscan after deploy')
+  .option('--dry-run', 'simulate deployment without broadcasting')
+  .action(deployCommand);
+
+// katour verify
+program
+  .command('verify')
+  .description('Verify a deployed contract on block explorer')
+  .argument('<address>', 'deployed contract address')
+  .option('-c, --contract <name>', 'contract name')
+  .option('-n, --network <name>', 'network name')
+  .option('--args <args...>', 'constructor arguments used during deployment')
+  .action(verifyCommand);
+
+// katour interact
+program
+  .command('interact')
+  .description('Interact with a deployed contract')
+  .argument('<address>', 'deployed contract address')
+  .option('-c, --contract <name>', 'contract name (for ABI lookup)')
+  .option('-n, --network <name>', 'network name')
+  .action(interactCommand);
+
+program.parse(process.argv);

package/src/utils/deployments.js

@@ -0,0 +1,34 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+export async function saveDeployment({ contractName, address, network, txHash, args }) {
+  await fs.ensureDir('./deployments');
+  
+  const filePath = `./deployments/${network}.json`;
+  let existing = {};
+  
+  try {
+    if (fs.existsSync(filePath)) {
+      existing = await fs.readJSON(filePath);
+    }
+  } catch {}
+
+  existing[contractName] = {
+    address,
+    txHash,
+    constructorArgs: args,
+    deployedAt: new Date().toISOString(),
+  };
+
+  await fs.writeJSON(filePath, existing, { spaces: 2 });
+}
+
+export async function getDeployment(contractName, network) {
+  const filePath = `./deployments/${network}.json`;
+  try {
+    const data = await fs.readJSON(filePath);
+    return data[contractName] || null;
+  } catch {
+    return null;
+  }
+}

package/src/utils/verify.js

@@ -0,0 +1,112 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import axios from 'axios';
+import { getNetwork } from '../config/networks.js';
+import { ethers } from 'ethers';
+import dotenv from 'dotenv';
+dotenv.config();
+
+export async function verifyContract({ contractName, address, networkName, constructorArgs = [], artifact }) {
+  const network = getNetwork(networkName);
+  const apiKeyEnv = network.explorerApiKeyEnv;
+  const apiKey = process.env[apiKeyEnv];
+
+  if (!apiKey) {
+    console.warn(chalk.yellow(`\n  ⚠ ${apiKeyEnv} not set — skipping verification`));
+    console.log(chalk.gray(`  Get a key at ${network.explorer} and add to .env`));
+    return;
+  }
+
+  const spinner = ora(`Verifying ${contractName} on ${network.name}...`).start();
+
+  try {
+    // Encode constructor args
+    let encodedArgs = '';
+    if (constructorArgs.length > 0) {
+      const constructorAbi = artifact.abi.find(x => x.type === 'constructor');
+      if (constructorAbi) {
+        const types = constructorAbi.inputs.map(i => i.type);
+        encodedArgs = ethers.AbiCoder.defaultAbiCoder()
+          .encode(types, constructorArgs)
+          .slice(2); // remove 0x
+      }
+    }
+
+    // Extract solc version from metadata
+    let compilerVersion = '0.8.20';
+    try {
+      const metadata = JSON.parse(artifact.metadata || '{}');
+      compilerVersion = metadata.compiler?.version || compilerVersion;
+    } catch {}
+
+    // Submit verification
+    const params = new URLSearchParams({
+      apikey: apiKey,
+      module: 'contract',
+      action: 'verifysourcecode',
+      contractaddress: address,
+      sourceCode: artifact.metadata || '',
+      codeformat: 'solidity-single-file',
+      contractname: contractName,
+      compilerversion: `v${compilerVersion}`,
+      optimizationUsed: '1',
+      runs: '200',
+      constructorArguements: encodedArgs,
+      licenseType: '3', // MIT
+    });
+
+    const res = await axios.post(network.explorerApi, params.toString(), {
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+    });
+
+    if (res.data.status === '1') {
+      const guid = res.data.result;
+      spinner.text = 'Waiting for verification result...';
+
+      // Poll for result
+      for (let i = 0; i < 10; i++) {
+        await sleep(5000);
+        const check = await axios.get(network.explorerApi, {
+          params: {
+            apikey: apiKey,
+            module: 'contract',
+            action: 'checkverifystatus',
+            guid,
+          },
+        });
+
+        if (check.data.result === 'Pass - Verified') {
+          spinner.succeed(chalk.green(`Contract verified!`));
+          console.log(chalk.blue(`  ${network.explorer}/address/${address}#code\n`));
+          return;
+        }
+
+        if (check.data.result.includes('Fail')) {
+          spinner.fail(chalk.red(`Verification failed: ${check.data.result}`));
+          return;
+        }
+
+        spinner.text = `Checking... (${check.data.result})`;
+      }
+
+      spinner.warn(chalk.yellow('Verification pending — check explorer manually'));
+      console.log(chalk.gray(`  ${network.explorer}/address/${address}`));
+
+    } else {
+      // Already verified is OK
+      if (res.data.result?.includes('already verified')) {
+        spinner.succeed(chalk.green('Already verified!'));
+        console.log(chalk.blue(`  ${network.explorer}/address/${address}#code\n`));
+      } else {
+        spinner.fail(chalk.red(`Verification request failed: ${res.data.result}`));
+      }
+    }
+
+  } catch (err) {
+    spinner.fail(chalk.red(`Verification error: ${err.message}`));
+  }
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}