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

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

/**
 * @title StakingRewards
 * @dev Synthetix 스타일 스테이킹 컨트랙트
 *      - 분당 보상률로 이자 계산 (rewardRate)
 *      - 스테이킹 즉시 이자 누적 시작
 *      - 복리 계산: rewardPerTokenStored 활용
 *      - 긴급 정지(Pausable) 기능 포함
 */
contract StakingRewards is ReentrancyGuard, Pausable, Ownable {
    using SafeERC20 for IERC20;

    IERC20 public immutable stakingToken;   // 예치 토큰 (예: USDC)
    IERC20 public immutable rewardsToken;   // 보상 토큰 (예: 거버넌스 토큰)

    // 보상 분배 설정
    uint256 public duration    = 30 days;  // 보상 기간
    uint256 public finishAt;               // 보상 종료 시점
    uint256 public updatedAt;              // 마지막 업데이트 시점
    uint256 public rewardRate;             // 초당 보상 토큰 수
    
    // 복리 계산을 위한 누적값
    uint256 public rewardPerTokenStored;   // 토큰 1개당 누적 보상
    
    // 사용자별 상태
    mapping(address => uint256) public userRewardPerTokenPaid; // 사용자의 마지막 보상 기준점
    mapping(address => uint256) public rewards;                // 미청구 보상
    mapping(address => uint256) public balanceOf;             // 스테이킹 잔액
    
    uint256 public totalSupply; // 총 스테이킹량

    event Staked(address indexed user, uint256 amount);
    event Withdrawn(address indexed user, uint256 amount);
    event RewardsClaimed(address indexed user, uint256 reward);
    event RewardAdded(uint256 reward);

    constructor(address _stakingToken, address _rewardsToken) Ownable(msg.sender) {
        stakingToken = IERC20(_stakingToken);
        rewardsToken = IERC20(_rewardsToken);
    }

    // ===== 핵심 수식: 토큰 1개당 누적 보상 계산 =====
    function rewardPerToken() public view returns (uint256) {
        if (totalSupply == 0) return rewardPerTokenStored;
        return rewardPerTokenStored + (
            rewardRate * (lastTimeRewardApplicable() - updatedAt) * 1e18 / totalSupply
        );
    }

    // 보상 종료 시점 또는 현재 시점 중 작은 값
    function lastTimeRewardApplicable() public view returns (uint256) {
        return finishAt < block.timestamp ? finishAt : block.timestamp;
    }

    // 사용자가 받을 수 있는 보상 계산
    function earned(address account) public view returns (uint256) {
        return (
            (balanceOf[account] * (rewardPerToken() - userRewardPerTokenPaid[account])) / 1e18
        ) + rewards[account];
    }

    modifier updateReward(address account) {
        rewardPerTokenStored = rewardPerToken();
        updatedAt = lastTimeRewardApplicable();
        if (account != address(0)) {
            rewards[account] = earned(account);
            userRewardPerTokenPaid[account] = rewardPerTokenStored;
        }
        _;
    }

    /**
     * @notice 토큰 스테이킹
     */
    function stake(uint256 amount) external nonReentrant whenNotPaused updateReward(msg.sender) {
        require(amount > 0, "AMOUNT_ZERO");
        balanceOf[msg.sender] += amount;
        totalSupply += amount;
        stakingToken.safeTransferFrom(msg.sender, address(this), amount);
        emit Staked(msg.sender, amount);
    }

    /**
     * @notice 스테이킹 해제 (원금 회수)
     */
    function withdraw(uint256 amount) external nonReentrant updateReward(msg.sender) {
        require(amount > 0, "AMOUNT_ZERO");
        require(balanceOf[msg.sender] >= amount, "INSUFFICIENT");
        balanceOf[msg.sender] -= amount;
        totalSupply -= amount;
        stakingToken.safeTransfer(msg.sender, amount);
        emit Withdrawn(msg.sender, amount);
    }

    /**
     * @notice 보상 토큰 청구
     */
    function claimReward() external nonReentrant updateReward(msg.sender) {
        uint256 reward = rewards[msg.sender];
        if (reward > 0) {
            rewards[msg.sender] = 0;
            rewardsToken.safeTransfer(msg.sender, reward);
            emit RewardsClaimed(msg.sender, reward);
        }
    }

    /**
     * @notice 스테이킹 해제 + 보상 청구 한번에
     */
    function exit() external {
        withdraw(balanceOf[msg.sender]);
        claimReward();
    }

    /**
     * @notice 보상 풀 설정 (owner only)
     */
    function setRewardsDuration(uint256 _duration) external onlyOwner {
        require(block.timestamp > finishAt, "REWARD_ONGOING");
        duration = _duration;
    }

    function notifyRewardAmount(uint256 amount) external onlyOwner updateReward(address(0)) {
        if (block.timestamp >= finishAt) {
            rewardRate = amount / duration;
        } else {
            uint256 remainingRewards = (finishAt - block.timestamp) * rewardRate;
            rewardRate = (amount + remainingRewards) / duration;
        }
        require(rewardRate > 0, "REWARD_RATE_ZERO");
        require(rewardRate * duration <= rewardsToken.balanceOf(address(this)), "INSUFFICIENT_REWARDS");
        
        finishAt = block.timestamp + duration;
        updatedAt = block.timestamp;
        emit RewardAdded(amount);
    }
}

1.2 Hardhat 배포 스크립트 + 검증

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

async function main() {
  const [deployer] = await ethers.getSigners();
  console.log("배포 계정:", deployer.address);
  console.log("ETH 잔액:", ethers.utils.formatEther(await deployer.getBalance()));

  // 1. 스테이킹 토큰 배포 (USDC 대용)
  const StakingToken = await ethers.getContractFactory("StakingToken");
  const stakingToken = await StakingToken.deploy("Staking Token", "STK", ethers.utils.parseEther("1000000"));
  await stakingToken.deployed();
  console.log("StakingToken:", stakingToken.address);

  // 2. 보상 토큰 배포
  const RewardsToken = await ethers.getContractFactory("RewardsToken");
  const rewardsToken = await RewardsToken.deploy("Rewards Token", "RWD", ethers.utils.parseEther("100000"));
  await rewardsToken.deployed();
  console.log("RewardsToken:", rewardsToken.address);

  // 3. 스테이킹 컨트랙트 배포
  const StakingRewards = await ethers.getContractFactory("StakingRewards");
  const staking = await StakingRewards.deploy(stakingToken.address, rewardsToken.address);
  await staking.deployed();
  console.log("StakingRewards:", staking.address);

  // 4. 보상 풀 설정 (30일 동안 10000 RWD)
  await rewardsToken.transfer(staking.address, ethers.utils.parseEther("10000"));
  await staking.setRewardsDuration(30 * 24 * 60 * 60);
  await staking.notifyRewardAmount(ethers.utils.parseEther("10000"));
  console.log("보상 풀 설정 완료 — 30일 x 10000 RWD");

  // 5. Etherscan 소스 코드 검증 (Sepolia)
  if (network.name !== "hardhat") {
    await new Promise(r => setTimeout(r, 30000)); // 30초 대기 (블록 확인)
    await run("verify:verify", {
      address: staking.address,
      constructorArguments: [stakingToken.address, rewardsToken.address],
    });
    console.log("✅ Etherscan 검증 완료");
  }
}

main().catch(console.error);

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

import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";

/**
 * @title P2EGame
 * @dev P2E NFT 게임 스마트 컨트랙트
 *      캐릭터 민팅 → VRF 스탯 배정 → 전투 → 경험치/레벨업 → 보상
 */
contract P2EGame is ERC721URIStorage, VRFConsumerBaseV2, ReentrancyGuard {

    VRFCoordinatorV2Interface immutable COORDINATOR;
    uint64  subscriptionId;
    bytes32 keyHash;
    uint32  callbackGasLimit = 200000;
    uint16  requestConfirmations = 3;

    // 캐릭터 스탯 구조체
    struct Character {
        string  name;
        uint256 hp;         // 최대 체력 (50-200)
        uint256 attack;     // 공격력 (10-100)
        uint256 defense;    // 방어력 (5-50)
        uint256 speed;      // 속도 (1-10)
        uint256 level;      // 현재 레벨
        uint256 exp;        // 현재 경험치
        uint256 lastFight;  // 마지막 전투 시간 (쿨다운)
    }

    // 몬스터 구조체
    struct Monster {
        string  name;
        uint256 hp;
        uint256 attack;
        uint256 expReward;
        uint256 tokenReward; // wei 단위 ETH 보상
    }

    // tokenId → Character
    mapping(uint256 => Character) public characters;
    // requestId → tokenId (VRF 콜백용)
    mapping(uint256 => uint256) public vrfRequestToToken;

    // 몬스터 배열
    Monster[] public monsters;

    uint256 public nextTokenId;
    uint256 public constant MINT_PRICE = 0.01 ether;
    uint256 public constant FIGHT_COOLDOWN = 1 hours;
    uint256 public constant EXP_PER_LEVEL = 100;

    IERC20 public gameToken; // 보상 토큰

    event CharacterMinted(uint256 indexed tokenId, address indexed owner);
    event StatsAssigned(uint256 indexed tokenId, uint256 hp, uint256 atk, uint256 def);
    event BattleResult(uint256 indexed tokenId, uint256 monsterId, bool won, uint256 expGained, uint256 reward);
    event LevelUp(uint256 indexed tokenId, uint256 newLevel);

    constructor(
        address vrfCoordinator,
        uint64 _subscriptionId,
        bytes32 _keyHash,
        address _gameToken
    ) ERC721("P2E Heroes", "HERO") VRFConsumerBaseV2(vrfCoordinator) {
        COORDINATOR = VRFCoordinatorV2Interface(vrfCoordinator);
        subscriptionId = _subscriptionId;
        keyHash = _keyHash;
        gameToken = IERC20(_gameToken);

        // 초기 몬스터 설정
        monsters.push(Monster("슬라임",      50,  5, 20, 0.001 ether));
        monsters.push(Monster("고블린",     100, 15, 50, 0.003 ether));
        monsters.push(Monster("오크",       200, 30, 100, 0.005 ether));
        monsters.push(Monster("드래곤",     500, 80, 300, 0.02 ether));
    }

    /**
     * @notice NFT 캐릭터 민팅 + VRF 스탯 요청
     */
    function mintCharacter(string calldata name) external payable returns (uint256 tokenId) {
        require(msg.value >= MINT_PRICE, "INSUFFICIENT_ETH");
        
        tokenId = nextTokenId++;
        _safeMint(msg.sender, tokenId);
        
        // 기본 스탯으로 초기화 (VRF 콜백 전까지)
        characters[tokenId] = Character({
            name:      name,
            hp:        50,  // 임시값
            attack:    10,
            defense:   5,
            speed:     1,
            level:     1,
            exp:       0,
            lastFight: 0
        });

        // VRF 난수 요청 (스탯 결정용)
        uint256 requestId = COORDINATOR.requestRandomWords(
            keyHash, subscriptionId, requestConfirmations,
            callbackGasLimit, 4 // 4개 난수: hp, attack, defense, speed
        );
        vrfRequestToToken[requestId] = tokenId;
        
        emit CharacterMinted(tokenId, msg.sender);
    }

    /**
     * @notice Chainlink VRF 콜백 — 스탯 배정
     */
    function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords) internal override {
        uint256 tokenId = vrfRequestToToken[requestId];
        
        characters[tokenId].hp      = 50  + (randomWords[0] % 151);  // 50~200
        characters[tokenId].attack  = 10  + (randomWords[1] % 91);   // 10~100
        characters[tokenId].defense = 5   + (randomWords[2] % 46);   // 5~50
        characters[tokenId].speed   = 1   + (randomWords[3] % 10);   // 1~10
        
        emit StatsAssigned(tokenId, characters[tokenId].hp,
                           characters[tokenId].attack, characters[tokenId].defense);
    }

    /**
     * @notice 전투 시스템 — 몬스터와 싸우기
     * @param tokenId    내 캐릭터 NFT tokenId
     * @param monsterId  상대 몬스터 인덱스
     */
    function fight(uint256 tokenId, uint256 monsterId) external nonReentrant {
        require(ownerOf(tokenId) == msg.sender, "NOT_OWNER");
        require(monsterId < monsters.length, "INVALID_MONSTER");
        require(
            block.timestamp >= characters[tokenId].lastFight + FIGHT_COOLDOWN,
            "COOLDOWN"
        );

        Character storage ch = characters[tokenId];
        Monster memory mon = monsters[monsterId];

        // 간단한 전투 결과 계산
        // DPS = attack / monster_defense
        // 플레이어 DPS > 몬스터 DPS 시 승리
        uint256 playerDPS  = ch.attack * 100 / (mon.defense > 0 ? mon.defense : 1);
        uint256 monsterDPS = mon.attack * 100 / (ch.defense > 0 ? ch.defense : 1);
        
        bool won = playerDPS > monsterDPS;
        ch.lastFight = block.timestamp;

        uint256 expGained = 0;
        uint256 tokenReward = 0;

        if (won) {
            expGained   = mon.expReward;
            tokenReward = mon.tokenReward;
            ch.exp += expGained;
            
            // 레벨업 체크
            uint256 newLevel = 1 + ch.exp / EXP_PER_LEVEL;
            if (newLevel > ch.level) {
                ch.level = newLevel;
                // 레벨업 시 스탯 증가
                ch.hp      += 20;
                ch.attack  += 5;
                ch.defense += 3;
                emit LevelUp(tokenId, newLevel);
            }

            // 토큰 보상 지급
            if (tokenReward > 0) {
                gameToken.transfer(msg.sender, tokenReward);
            }
        }

        emit BattleResult(tokenId, monsterId, won, expGained, tokenReward);
    }

    // 캐릭터 정보 조회
    function getCharacter(uint256 tokenId) external view returns (Character memory) {
        return characters[tokenId];
    }
}

# hardhat.config.js — 멀티체인 네트워크 설정
require("@nomicfoundation/hardhat-toolbox");
require("dotenv").config();

module.exports = {
  solidity: {
    version: "0.8.19",
    settings: {
      optimizer: { enabled: true, runs: 200 },
      viaIR: true, // IR 컴파일러 활성화 (가스 최적화)
    },
  },
  networks: {
    // Testnet
    sepolia: {
      url: process.env.SEPOLIA_RPC_URL,
      accounts: [process.env.PRIVATE_KEY],
      chainId: 11155111,
    },
    polygonMumbai: {
      url: process.env.POLYGON_MUMBAI_RPC_URL,
      accounts: [process.env.PRIVATE_KEY],
      chainId: 80001,
    },
    arbitrumGoerli: {
      url: process.env.ARBITRUM_GOERLI_RPC_URL,
      accounts: [process.env.PRIVATE_KEY],
      chainId: 421613,
    },
    // Mainnet
    mainnet: {
      url: process.env.MAINNET_RPC_URL,
      accounts: [process.env.PRIVATE_KEY],
      chainId: 1,
      gasPrice: "auto", // EIP-1559 자동
    },
    polygon: {
      url: process.env.POLYGON_RPC_URL,
      accounts: [process.env.PRIVATE_KEY],
      chainId: 137,
    },
    arbitrum: {
      url: process.env.ARBITRUM_RPC_URL,
      accounts: [process.env.PRIVATE_KEY],
      chainId: 42161,
    },
    base: {
      url: process.env.BASE_RPC_URL,
      accounts: [process.env.PRIVATE_KEY],
      chainId: 8453,
    },
  },
  etherscan: {
    apiKey: {
      mainnet:       process.env.ETHERSCAN_API_KEY,
      sepolia:       process.env.ETHERSCAN_API_KEY,
      polygon:       process.env.POLYGONSCAN_API_KEY,
      arbitrumOne:   process.env.ARBISCAN_API_KEY,
      base:          process.env.BASESCAN_API_KEY,
    },
  },
  gasReporter: {
    enabled: process.env.REPORT_GAS === "true",
    currency: "USD",
    coinmarketcap: process.env.COINMARKETCAP_API_KEY,
  },
};

// 멀티체인 배포 스크립트
// npx hardhat run scripts/deploy.js --network polygon
// npx hardhat run scripts/deploy.js --network arbitrum
// npx hardhat run scripts/deploy.js --network base

# .github/workflows/ci.yml — 스마트 컨트랙트 CI/CD
name: Smart Contract CI/CD

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
        with:
          submodules: recursive

      - name: Install Node.js
        uses: actions/setup-node@v3
        with:
          node-version: 20
          cache: npm

      - name: Install dependencies
        run: npm ci

      - name: Run Hardhat tests
        run: npx hardhat test

      - name: Run coverage
        run: npx hardhat coverage
        env:
          COVERAGE_THRESHOLD: 90

      - name: Run Slither analysis
        uses: crytic/slither-action@v0.3.0
        with:
          target: contracts/
          slither-args: --exclude-dependencies
          fail-on: high  # High 심각도 발견 시 CI 실패

      - name: Gas report
        run: REPORT_GAS=true npx hardhat test
        env:
          COINMARKETCAP_API_KEY: secrets.CMC_API_KEY

  deploy-testnet:
    needs: test
    runs-on: ubuntu-latest
    if: github.ref == refs/heads/develop
    steps:
      - uses: actions/checkout@v3
      - run: npm ci
      - name: Deploy to Sepolia
        run: npx hardhat run scripts/deploy.js --network sepolia
        env:
          SEPOLIA_RPC_URL: secrets.SEPOLIA_RPC_URL
          PRIVATE_KEY: secrets.DEPLOY_PRIVATE_KEY

  deploy-mainnet:
    needs: test
    runs-on: ubuntu-latest
    if: github.ref == refs/heads/main
    environment: production   # 수동 승인 필요
    steps:
      - uses: actions/checkout@v3
      - run: npm ci
      - name: Deploy to Mainnet
        run: npx hardhat run scripts/deploy.js --network mainnet
        env:
          MAINNET_RPC_URL: secrets.MAINNET_RPC_URL
          PRIVATE_KEY: secrets.DEPLOY_PRIVATE_KEY

# Tenderly 실시간 모니터링 설정
# tenderly.yaml

version: v1.0
project_slug: my-defi-project

contracts:
  - name: StakingRewards
    address: "0xYourContractAddress"
    network: 1  # Ethereum Mainnet

# 알림 설정 (대규모 출금 감지)
alerts:
  - name: "Large Withdrawal Alert"
    type: tx_event
    filter:
      contract: StakingRewards
      event_name: Withdrawn
      condition: amount > 100000000000000000000  # 100 토큰 이상
    notifications:
      - type: slack
        webhook_url: YOUR_SLACK_WEBHOOK
      - type: email
        email: security@yourprotocol.com

  - name: "Emergency Pause Trigger"
    type: tx_event
    filter:
      contract: StakingRewards
      event_name: Paused
    notifications:
      - type: pagerduty
        routing_key: YOUR_PAGERDUTY_KEY