# 프로젝트 폴더 생성
mkdir blockchain-voting
cd blockchain-voting

# npm 초기화
npm init -y

# Hardhat 설치
npm install --save-dev hardhat

# Hardhat 프로젝트 초기화
npx hardhat init
# → "Create a JavaScript project" 선택

# 추가 패키지 설치
npm install --save-dev @nomicfoundation/hardhat-toolbox
npm install ethers dotenv

blockchain-voting/
├── contracts/
│   └── Voting.sol          ← 스마트 컨트랙트
├── scripts/
│   └── deploy.js           ← 배포 스크립트
├── test/
│   └── Voting.test.js      ← 테스트 파일
├── frontend/
│   ├── index.html
│   ├── app.js              ← Ethers.js 연동
│   └── style.css
├── hardhat.config.js
└── .env                    ← 비밀키 (절대 깃에 올리지 마!)

// hardhat.config.js
require("@nomicfoundation/hardhat-toolbox");
require("dotenv").config();

module.exports = {
  solidity: "0.8.19",
  networks: {
    // 로컬 테스트 네트워크
    localhost: {
      url: "http://127.0.0.1:8545"
    },
    // Sepolia 테스트넷 (실제 배포 테스트용)
    sepolia: {
      url: process.env.SEPOLIA_RPC_URL,
      accounts: [process.env.PRIVATE_KEY]
    }
  }
};

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

/**
 * @title Voting - 블록체인 기반 투명 투표 시스템
 * @dev 탈중앙화된 투표를 위한 스마트 컨트랙트
 */
contract Voting {
    
    // ===== 데이터 구조 정의 =====
    
    // 후보자 구조체
    struct Candidate {
        uint256 id;          // 후보자 ID
        string name;         // 후보자 이름
        string description;  // 후보자 설명
        uint256 voteCount;   // 득표 수
    }
    
    // 투표 정보 구조체
    struct VoteInfo {
        string title;        // 투표 제목
        uint256 startTime;   // 시작 시간
        uint256 endTime;     // 종료 시간
        bool isActive;       // 활성화 여부
    }
    
    // ===== 상태 변수 =====
    
    address public owner;           // 컨트랙트 소유자 (선관위)
    VoteInfo public voteInfo;       // 투표 정보
    
    // 후보자 목록 (ID → 후보자)
    mapping(uint256 => Candidate) public candidates;
    uint256 public candidateCount;  // 총 후보자 수
    
    // 투표 여부 추적 (주소 → 투표했는지)
    mapping(address => bool) public hasVoted;
    
    // 유권자 등록 (주소 → 등록됐는지)
    mapping(address => bool) public registeredVoters;
    
    uint256 public totalVotes;      // 총 투표 수
    
    // ===== 이벤트 =====
    // 이벤트는 블록체인에 로그를 남겨서 프론트에서 감지 가능
    
    event VoterRegistered(address indexed voter);
    event VoteCast(address indexed voter, uint256 indexed candidateId);
    event VotingStarted(string title, uint256 startTime, uint256 endTime);
    event VotingEnded(uint256 timestamp);
    
    // ===== 수정자 (Modifier) =====
    
    modifier onlyOwner() {
        require(msg.sender == owner, "소유자만 실행 가능합니다");
        _;
    }
    
    modifier onlyRegisteredVoter() {
        require(registeredVoters[msg.sender], "등록된 유권자가 아닙니다");
        _;
    }
    
    modifier votingActive() {
        require(voteInfo.isActive, "투표가 진행 중이 아닙니다");
        require(block.timestamp >= voteInfo.startTime, "투표가 아직 시작되지 않았습니다");
        require(block.timestamp <= voteInfo.endTime, "투표가 종료되었습니다");
        _;
    }
    
    // ===== 생성자 =====
    
    constructor() {
        owner = msg.sender;  // 배포자가 소유자
    }
    
    // ===== 함수들 =====
    
    /**
     * @dev 투표 초기화 (소유자만 가능)
     * @param _title 투표 제목
     * @param _durationInMinutes 투표 지속 시간 (분)
     */
    function initializeVoting(
        string memory _title,
        uint256 _durationInMinutes
    ) public onlyOwner {
        require(!voteInfo.isActive, "이미 투표가 진행 중입니다");
        
        voteInfo = VoteInfo({
            title: _title,
            startTime: block.timestamp,
            endTime: block.timestamp + (_durationInMinutes * 1 minutes),
            isActive: true
        });
        
        emit VotingStarted(_title, voteInfo.startTime, voteInfo.endTime);
    }
    
    /**
     * @dev 후보자 추가 (소유자만 가능)
     * @param _name 후보자 이름
     * @param _description 후보자 설명
     */
    function addCandidate(
        string memory _name,
        string memory _description
    ) public onlyOwner {
        candidateCount++;
        candidates[candidateCount] = Candidate({
            id: candidateCount,
            name: _name,
            description: _description,
            voteCount: 0
        });
    }
    
    /**
     * @dev 유권자 등록 (소유자만 가능)
     * @param _voter 등록할 유권자 주소
     */
    function registerVoter(address _voter) public onlyOwner {
        require(!registeredVoters[_voter], "이미 등록된 유권자입니다");
        registeredVoters[_voter] = true;
        emit VoterRegistered(_voter);
    }
    
    /**
     * @dev 투표하기 (등록된 유권자만, 투표 진행 중에만)
     * @param _candidateId 투표할 후보자 ID
     */
    function castVote(uint256 _candidateId) 
        public 
        onlyRegisteredVoter 
        votingActive 
    {
        require(!hasVoted[msg.sender], "이미 투표하셨습니다");
        require(_candidateId > 0 && _candidateId <= candidateCount, "유효하지 않은 후보자입니다");
        
        hasVoted[msg.sender] = true;
        candidates[_candidateId].voteCount++;
        totalVotes++;
        
        emit VoteCast(msg.sender, _candidateId);
    }
    
    /**
     * @dev 투표 종료 (소유자만 가능)
     */
    function endVoting() public onlyOwner {
        require(voteInfo.isActive, "투표가 이미 종료되었습니다");
        voteInfo.isActive = false;
        emit VotingEnded(block.timestamp);
    }
    
    /**
     * @dev 특정 후보자 정보 조회
     * @param _candidateId 후보자 ID
     */
    function getCandidate(uint256 _candidateId) 
        public 
        view 
        returns (uint256, string memory, string memory, uint256) 
    {
        Candidate memory c = candidates[_candidateId];
        return (c.id, c.name, c.description, c.voteCount);
    }
    
    /**
     * @dev 현재 선두 후보자 조회
     */
    function getWinner() public view returns (string memory winnerName, uint256 winnerVotes) {
        require(!voteInfo.isActive || block.timestamp > voteInfo.endTime, 
                "투표가 아직 진행 중입니다");
        
        uint256 maxVotes = 0;
        uint256 winnerId = 0;
        
        for (uint256 i = 1; i <= candidateCount; i++) {
            if (candidates[i].voteCount > maxVotes) {
                maxVotes = candidates[i].voteCount;
                winnerId = i;
            }
        }
        
        return (candidates[winnerId].name, candidates[winnerId].voteCount);
    }
    
    /**
     * @dev 투표 현황 조회
     */
    function getVotingStatus() public view returns (
        string memory title,
        bool isActive,
        uint256 startTime,
        uint256 endTime,
        uint256 _totalVotes,
        uint256 _candidateCount
    ) {
        return (
            voteInfo.title,
            voteInfo.isActive,
            voteInfo.startTime,
            voteInfo.endTime,
            totalVotes,
            candidateCount
        );
    }
}

// 위임 기능 추가 버전

// 유권자 구조체 확장
struct Voter {
    bool isRegistered;
    bool hasVoted;
    uint256 votedCandidateId;
    address delegate;      // 위임받은 주소
    uint256 weight;        // 투표 가중치 (위임받으면 증가)
}

mapping(address => Voter) public voters;

/**
 * @dev 투표권 위임
 * @param _to 위임할 주소
 */
function delegate(address _to) public onlyRegisteredVoter {
    Voter storage sender = voters[msg.sender];
    require(!sender.hasVoted, "이미 투표하셨습니다");
    require(_to != msg.sender, "자기 자신에게 위임할 수 없습니다");
    
    // 순환 위임 방지
    address delegateTo = _to;
    while (voters[delegateTo].delegate != address(0)) {
        delegateTo = voters[delegateTo].delegate;
        require(delegateTo != msg.sender, "순환 위임이 감지되었습니다");
    }
    
    sender.hasVoted = true;
    sender.delegate = delegateTo;
    
    Voter storage delegateVoter = voters[delegateTo];
    if (delegateVoter.hasVoted) {
        // 이미 투표한 경우 바로 가중치 추가
        candidates[delegateVoter.votedCandidateId].voteCount += sender.weight;
    } else {
        // 아직 투표 안 한 경우 가중치만 증가
        delegateVoter.weight += sender.weight;
    }
}

// 여러 후보에게 투표할 수 있는 버전 (예: 상위 3명 선택)

uint256 public maxChoices;  // 최대 선택 가능 수

mapping(address => uint256[]) public voterChoices;  // 유권자별 선택 목록

function castMultiVote(uint256[] memory _candidateIds) 
    public 
    onlyRegisteredVoter 
    votingActive 
{
    require(!hasVoted[msg.sender], "이미 투표하셨습니다");
    require(_candidateIds.length <= maxChoices, "최대 선택 수를 초과했습니다");
    require(_candidateIds.length > 0, "최소 1명은 선택해야 합니다");
    
    // 중복 선택 방지
    for (uint256 i = 0; i < _candidateIds.length; i++) {
        for (uint256 j = i + 1; j < _candidateIds.length; j++) {
            require(_candidateIds[i] != _candidateIds[j], "중복 선택 불가");
        }
        require(_candidateIds[i] > 0 && _candidateIds[i] <= candidateCount, 
                "유효하지 않은 후보자");
        candidates[_candidateIds[i]].voteCount++;
    }
    
    hasVoted[msg.sender] = true;
    voterChoices[msg.sender] = _candidateIds;
    totalVotes++;
    
    emit VoteCast(msg.sender, _candidateIds[0]);  // 첫 번째 선택 로그
}

// ZKP 기반 투표의 개념적 구현 (실제로는 snarkjs 라이브러리 필요)

// 투표 커밋먼트 (실제 투표 내용을 해시로 숨김)
mapping(bytes32 => bool) public voteCommitments;

/**
 * @dev 투표 커밋 (1단계: 투표 내용을 해시로 제출)
 * @param _commitment 투표 내용의 해시값
 */
function commitVote(bytes32 _commitment) public onlyRegisteredVoter {
    require(!hasVoted[msg.sender], "이미 투표하셨습니다");
    require(!voteCommitments[_commitment], "이미 사용된 커밋먼트");
    
    voteCommitments[_commitment] = true;
    hasVoted[msg.sender] = true;
}

/**
 * @dev 투표 공개 (2단계: 투표 종료 후 내용 공개)
 * @param _candidateId 실제 투표한 후보자
 * @param _nonce 랜덤 값 (해시 생성에 사용)
 */
function revealVote(uint256 _candidateId, uint256 _nonce) public {
    require(!voteInfo.isActive, "투표가 아직 진행 중입니다");
    
    // 커밋먼트 검증
    bytes32 commitment = keccak256(abi.encodePacked(_candidateId, _nonce, msg.sender));
    require(voteCommitments[commitment], "유효하지 않은 커밋먼트");
    
    candidates[_candidateId].voteCount++;
    voteCommitments[commitment] = false;  // 재사용 방지
}

// test/Voting.test.js
const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("Voting Contract", function () {
    let voting;
    let owner, voter1, voter2, voter3;
    
    // 각 테스트 전에 새로운 컨트랙트 배포
    beforeEach(async function () {
        [owner, voter1, voter2, voter3] = await ethers.getSigners();
        
        const Voting = await ethers.getContractFactory("Voting");
        voting = await Voting.deploy();
        await voting.waitForDeployment();
        
        // 기본 설정
        await voting.addCandidate("김철수", "경제 전문가");
        await voting.addCandidate("이영희", "환경 운동가");
        await voting.addCandidate("박민준", "교육 개혁가");
        
        // 유권자 등록
        await voting.registerVoter(voter1.address);
        await voting.registerVoter(voter2.address);
        await voting.registerVoter(voter3.address);
        
        // 투표 시작 (60분)
        await voting.initializeVoting("2024 시장 선거", 60);
    });
    
    // ===== 기본 기능 테스트 =====
    
    describe("후보자 관리", function () {
        it("후보자가 올바르게 추가되어야 함", async function () {
            const [id, name, desc, votes] = await voting.getCandidate(1);
            expect(name).to.equal("김철수");
            expect(votes).to.equal(0);
        });
        
        it("소유자가 아닌 사람은 후보자 추가 불가", async function () {
            await expect(
                voting.connect(voter1).addCandidate("무단후보", "설명")
            ).to.be.revertedWith("소유자만 실행 가능합니다");
        });
    });
    
    describe("투표 기능", function () {
        it("등록된 유권자는 투표 가능", async function () {
            await voting.connect(voter1).castVote(1);
            const [,,,voteCount] = await voting.getCandidate(1);
            expect(voteCount).to.equal(1);
        });
        
        it("이중 투표 방지", async function () {
            await voting.connect(voter1).castVote(1);
            await expect(
                voting.connect(voter1).castVote(2)
            ).to.be.revertedWith("이미 투표하셨습니다");
        });
        
        it("미등록 유권자는 투표 불가", async function () {
            const [, , , unregistered] = await ethers.getSigners();
            await expect(
                voting.connect(unregistered).castVote(1)
            ).to.be.revertedWith("등록된 유권자가 아닙니다");
        });
        
        it("유효하지 않은 후보자 ID로 투표 불가", async function () {
            await expect(
                voting.connect(voter1).castVote(99)
            ).to.be.revertedWith("유효하지 않은 후보자입니다");
        });
    });
    
    describe("투표 결과", function () {
        it("가장 많은 표를 받은 후보자가 당선", async function () {
            await voting.connect(voter1).castVote(2);  // 이영희
            await voting.connect(voter2).castVote(2);  // 이영희
            await voting.connect(voter3).castVote(1);  // 김철수
            
            await voting.endVoting();
            
            const [winnerName, winnerVotes] = await voting.getWinner();
            expect(winnerName).to.equal("이영희");
            expect(winnerVotes).to.equal(2);
        });
        
        it("투표 진행 중에는 결과 조회 불가", async function () {
            await expect(voting.getWinner()).to.be.revertedWith(
                "투표가 아직 진행 중입니다"
            );
        });
    });
    
    describe("이벤트 발생", function () {
        it("투표 시 VoteCast 이벤트 발생", async function () {
            await expect(voting.connect(voter1).castVote(1))
                .to.emit(voting, "VoteCast")
                .withArgs(voter1.address, 1);
        });
        
        it("유권자 등록 시 VoterRegistered 이벤트 발생", async function () {
            const [, , , , newVoter] = await ethers.getSigners();
            await expect(voting.registerVoter(newVoter.address))
                .to.emit(voting, "VoterRegistered")
                .withArgs(newVoter.address);
        });
    });
    
    describe("시간 기반 테스트", function () {
        it("투표 종료 후에는 투표 불가", async function () {
            // 시간을 61분 앞으로 이동
            await ethers.provider.send("evm_increaseTime", [61 * 60]);
            await ethers.provider.send("evm_mine");
            
            await expect(
                voting.connect(voter1).castVote(1)
            ).to.be.revertedWith("투표가 종료되었습니다");
        });
    });
});

# 테스트 실행
npx hardhat test

# 가스 사용량 리포트와 함께
REPORT_GAS=true npx hardhat test

# 커버리지 확인
npx hardhat coverage

// scripts/deploy.js
const { ethers } = require("hardhat");

async function main() {
    console.log("🚀 블록체인 투표 시스템 배포 시작...\n");
    
    // 배포자 정보
    const [deployer] = await ethers.getSigners();
    console.log("배포자 주소:", deployer.address);
    console.log("배포자 잔액:", ethers.formatEther(
        await ethers.provider.getBalance(deployer.address)
    ), "ETH\n");
    
    // 컨트랙트 배포
    const Voting = await ethers.getContractFactory("Voting");
    const voting = await Voting.deploy();
    await voting.waitForDeployment();
    
    const contractAddress = await voting.getAddress();
    console.log("✅ Voting 컨트랙트 배포 완료!");
    console.log("컨트랙트 주소:", contractAddress, "\n");
    
    // 초기 설정
    console.log("📋 초기 설정 중...");
    
    // 후보자 추가
    const candidates = [
        { name: "김철수", desc: "경제 전문가 - 일자리 창출 공약" },
        { name: "이영희", desc: "환경 운동가 - 탄소중립 공약" },
        { name: "박민준", desc: "교육 개혁가 - 교육비 절감 공약" }
    ];
    
    for (const candidate of candidates) {
        const tx = await voting.addCandidate(candidate.name, candidate.desc);
        await tx.wait();
        console.log(`  ✓ 후보자 추가: ${candidate.name}`);
    }
    
    // 투표 시작 (24시간)
    const tx = await voting.initializeVoting("2024 시장 선거", 24 * 60);
    await tx.wait();
    console.log("\n🗳️ 투표 시작! (24시간 진행)");
    
    // 배포 정보 저장
    const deployInfo = {
        contractAddress,
        deployer: deployer.address,
        network: (await ethers.provider.getNetwork()).name,
        timestamp: new Date().toISOString()
    };
    
    const fs = require("fs");
    fs.writeFileSync(
        "deployment.json",
        JSON.stringify(deployInfo, null, 2)
    );
    
    console.log("\n📄 배포 정보가 deployment.json에 저장되었습니다.");
    console.log("🎉 배포 완료!\n");
}

main()
    .then(() => process.exit(0))
    .catch((error) => {
        console.error(error);
        process.exit(1);
    });

# 로컬 네트워크에 배포 (테스트용)
npx hardhat node  # 터미널 1: 로컬 노드 실행
npx hardhat run scripts/deploy.js --network localhost  # 터미널 2: 배포

# Sepolia 테스트넷에 배포 (실제 테스트)
npx hardhat run scripts/deploy.js --network sepolia

# 배포 후 Etherscan 검증 (소스코드 공개)
npx hardhat verify --network sepolia DEPLOYED_CONTRACT_ADDRESS

<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>🗳️ 블록체인 투표 시스템</title>
    <script src="https://cdn.ethers.io/lib/ethers-5.7.2.umd.min.js"></script>
</head>
<body>
    <div id="app">
        <header>
            <h1>🗳️ 블록체인 투명 투표</h1>
            <div id="wallet-info">
                <button id="connect-btn">지갑 연결하기</button>
                <span id="wallet-address"></span>
            </div>
        </header>
        
        <main>
            <section id="vote-info">
                <h2 id="vote-title">투표 정보 로딩 중...</h2>
                <div id="vote-status"></div>
                <div id="vote-timer"></div>
            </section>
            
            <section id="candidates">
                <h2>후보자 목록</h2>
                <div id="candidate-list"></div>
            </section>
            
            <section id="results">
                <h2>실시간 현황</h2>
                <div id="results-chart"></div>
            </section>
        </main>
    </div>
    
    <script src="app.js"></script>
</body>
</html>

// app.js - 블록체인 투표 시스템 프론트엔드

// 배포된 컨트랙트 주소와 ABI
const CONTRACT_ADDRESS = "0x..."; // deployment.json에서 가져오기
const CONTRACT_ABI = [
    // Solidity 컴파일 후 artifacts/contracts/Voting.sol/Voting.json에서 복사
    "function castVote(uint256 _candidateId) public",
    "function getCandidate(uint256 _candidateId) public view returns (uint256, string, string, uint256)",
    "function getVotingStatus() public view returns (string, bool, uint256, uint256, uint256, uint256)",
    "function hasVoted(address) public view returns (bool)",
    "function candidateCount() public view returns (uint256)",
    "function totalVotes() public view returns (uint256)",
    "event VoteCast(address indexed voter, uint256 indexed candidateId)"
];

let provider, signer, contract;
let userAddress = null;

// ===== 지갑 연결 =====
async function connectWallet() {
    if (typeof window.ethereum === 'undefined') {
        alert('MetaMask를 설치해주세요! metamask.io');
        return;
    }
    
    try {
        // MetaMask 연결 요청
        provider = new ethers.providers.Web3Provider(window.ethereum);
        await provider.send("eth_requestAccounts", []);
        signer = provider.getSigner();
        userAddress = await signer.getAddress();
        
        // 컨트랙트 인스턴스 생성
        contract = new ethers.Contract(CONTRACT_ADDRESS, CONTRACT_ABI, signer);
        
        // UI 업데이트
        document.getElementById('wallet-address').textContent = 
            `${userAddress.slice(0, 6)}...${userAddress.slice(-4)}`;
        document.getElementById('connect-btn').textContent = '연결됨 ✅';
        document.getElementById('connect-btn').disabled = true;
        
        // 데이터 로드
        await loadVotingData();
        await checkVotingStatus();
        
        // 이벤트 리스너 등록
        listenToEvents();
        
        console.log("지갑 연결 성공:", userAddress);
    } catch (error) {
        console.error("지갑 연결 실패:", error);
        alert("지갑 연결에 실패했습니다: " + error.message);
    }
}

// ===== 투표 데이터 로드 =====
async function loadVotingData() {
    try {
        // 투표 현황 조회
        const [title, isActive, startTime, endTime, totalVotes, candidateCount] = 
            await contract.getVotingStatus();
        
        document.getElementById('vote-title').textContent = title;
        
        // 남은 시간 계산
        const now = Math.floor(Date.now() / 1000);
        const remaining = endTime.toNumber() - now;
        
        if (isActive && remaining > 0) {
            startTimer(remaining);
            document.getElementById('vote-status').innerHTML = 
                '<span style="color:green">🟢 투표 진행 중</span>';
        } else {
            document.getElementById('vote-status').innerHTML = 
                '<span style="color:red">🔴 투표 종료</span>';
        }
        
        // 후보자 목록 로드
        await loadCandidates(candidateCount.toNumber(), totalVotes.toNumber());
        
    } catch (error) {
        console.error("데이터 로드 실패:", error);
    }
}

// ===== 후보자 목록 로드 =====
async function loadCandidates(count, totalVotes) {
    const container = document.getElementById('candidate-list');
    container.innerHTML = '';
    
    // 이미 투표했는지 확인
    const voted = userAddress ? await contract.hasVoted(userAddress) : false;
    
    for (let i = 1; i <= count; i++) {
        const [id, name, description, voteCount] = await contract.getCandidate(i);
        
        const percentage = totalVotes > 0 
            ? Math.round((voteCount.toNumber() / totalVotes) * 100) 
            : 0;
        
        const card = document.createElement('div');
        card.className = 'candidate-card';
        card.innerHTML = `
            <h3>${name}</h3>
            <p>${description}</p>
            <div class="vote-bar">
                <div class="vote-fill" style="width:${percentage}%"></div>
            </div>
            <span>${voteCount}표 (${percentage}%)</span>
            ${!voted ? `<button onclick="castVote(${id})">투표하기</button>` : ''}
        `;
        container.appendChild(card);
    }
}

// ===== 투표 실행 =====
async function castVote(candidateId) {
    if (!userAddress) {
        alert("먼저 지갑을 연결해주세요!");
        return;
    }
    
    try {
        // 투표 트랜잭션 전송
        const tx = await contract.castVote(candidateId);
        
        // 트랜잭션 대기 중 UI 업데이트
        showLoading("트랜잭션 처리 중... ⏳");
        
        // 트랜잭션 완료 대기
        const receipt = await tx.wait();
        
        console.log("투표 완료! 트랜잭션 해시:", receipt.transactionHash);
        alert(`✅ 투표가 완료되었습니다!\n트랜잭션: ${receipt.transactionHash}`);
        
        // 데이터 새로고침
        await loadVotingData();
        
    } catch (error) {
        if (error.code === 4001) {
            alert("사용자가 트랜잭션을 취소했습니다.");
        } else {
            console.error("투표 실패:", error);
            alert("투표 실패: " + (error.reason || error.message));
        }
    }
}

// ===== 실시간 이벤트 리스닝 =====
function listenToEvents() {
    // VoteCast 이벤트 구독
    contract.on("VoteCast", async (voter, candidateId) => {
        console.log(`새 투표: ${voter} → 후보자 ${candidateId}`);
        
        // 실시간 업데이트
        await loadVotingData();
        
        // 내 투표인 경우 알림
        if (voter.toLowerCase() === userAddress.toLowerCase()) {
            showNotification("내 투표가 블록체인에 기록되었습니다! 🎉");
        }
    });
}

// ===== 카운트다운 타이머 =====
function startTimer(seconds) {
    const timerEl = document.getElementById('vote-timer');
    
    const interval = setInterval(() => {
        const h = Math.floor(seconds / 3600);
        const m = Math.floor((seconds % 3600) / 60);
        const s = seconds % 60;
        
        timerEl.textContent = `⏱️ 남은 시간: ${h}시간 ${m}분 ${s}초`;
        
        if (seconds <= 0) {
            clearInterval(interval);
            timerEl.textContent = "⏰ 투표가 종료되었습니다";
            loadVotingData();
        }
        seconds--;
    }, 1000);
}

// ===== 이벤트 바인딩 =====
document.getElementById('connect-btn').addEventListener('click', connectWallet);

// MetaMask 계정 변경 감지
if (window.ethereum) {
    window.ethereum.on('accountsChanged', (accounts) => {
        if (accounts.length === 0) {
            userAddress = null;
            document.getElementById('wallet-address').textContent = '';
        } else {
            location.reload();
        }
    });
    
    window.ethereum.on('chainChanged', () => {
        location.reload();
    });
}

// OpenZeppelin AccessControl 사용 예시
import "@openzeppelin/contracts/access/AccessControl.sol";

contract SecureVoting is AccessControl {
    bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
    bytes32 public constant REGISTRAR_ROLE = keccak256("REGISTRAR_ROLE");
    
    constructor() {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(ADMIN_ROLE, msg.sender);
    }
    
    // 유권자 등록은 REGISTRAR_ROLE만 가능
    function registerVoter(address _voter) public onlyRole(REGISTRAR_ROLE) {
        // ...
    }
}

// 가스 최적화: 후보자 수 제한
uint256 public constant MAX_CANDIDATES = 50;

function addCandidate(string memory _name, string memory _desc) public onlyOwner {
    require(candidateCount < MAX_CANDIDATES, "최대 후보자 수 초과");
    // ...
}

// 가스 최적화: storage 대신 memory 사용
function getAllCandidates() public view returns (Candidate[] memory) {
    Candidate[] memory result = new Candidate[](candidateCount);
    for (uint256 i = 1; i <= candidateCount; i++) {
        result[i-1] = candidates[i];  // storage → memory 복사
    }
    return result;
}

# OpenZeppelin 설치
npm install @openzeppelin/contracts

// 사용 예시
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

contract SecureVoting is Ownable, Pausable, ReentrancyGuard {
    
    // 긴급 상황 시 투표 일시 중지
    function pauseVoting() public onlyOwner {
        _pause();
    }
    
    // 재진입 공격 방지
    function castVote(uint256 _candidateId) 
        public 
        nonReentrant  // 재진입 방지
        whenNotPaused // 일시 중지 상태 체크
    {
        // ...
    }
}

// Snapshot 스페이스 설정 파일 예시 (snapshot.json)
{
  "name": "My DAO",
  "about": "우리 DAO의 거버넌스 투표 공간입니다",
  "avatar": "ipfs://QmXxx...",
  "network": "1",  // 1: 이더리움 메인넷
  "symbol": "MYDAO",
  "strategies": [
    {
      "name": "erc20-balance-of",
      "params": {
        "address": "0x토큰컨트랙트주소",
        "symbol": "MYDAO",
        "decimals": 18
      }
    }
  ],
  "admins": ["0x관리자주소"],
  "members": [],
  "filters": {
    "minScore": 100,  // 최소 100 토큰 보유자만 투표 가능
    "onlyMembers": false
  },
  "voting": {
    "delay": 86400,    // 제안 후 24시간 후 투표 시작
    "period": 259200,  // 투표 기간 72시간
    "type": "single-choice",  // 단순 선택
    "quorum": 0
  }
}

// 이차 투표 구현 예시
function quadraticVote(uint256 _candidateId, uint256 _votes) public {
    uint256 cost = _votes * _votes;  // 비용 = 표 수의 제곱
    
    require(
        governanceToken.balanceOf(msg.sender) >= cost,
        "토큰이 부족합니다"
    );
    
    // 토큰 소각 (투표 비용 지불)
    governanceToken.burnFrom(msg.sender, cost);
    
    candidates[_candidateId].voteCount += _votes;
    
    emit QuadraticVoteCast(msg.sender, _candidateId, _votes, cost);
}