⛽ Gas 계산 예시

// ETH 단위 계층
const units = {
  wei:   1n,                          // 가장 작은 단위
  kwei:  1_000n,
  mwei:  1_000_000n,
  gwei:  1_000_000_000n,             // Gas 가격 (1 Gwei = 1 nanoETH)
  szabo: 1_000_000_000_000n,
  finney:1_000_000_000_000_000n,
  ether: 1_000_000_000_000_000_000n    // 1 ETH = 10^18 wei
};

// Ethers.js 단위 변환
const { ethers } = require('ethers');
ethers.parseEther('1.0')      // → 1000000000000000000n (wei)
ethers.formatEther(1000000000000000000n) // → "1.0"
ethers.parseUnits('100', 'gwei') // → 100000000000n

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;  // 버전 지정 (필수)

/**
 * @title HelloBlockchain
 * @dev 첫 번째 스마트 컨트랙트 — 기본 구조 이해
 */
contract HelloBlockchain {
    // ======= 상태 변수 (영구 저장) =======
    string public  greeting = "Hello, Blockchain!";
    address public owner;
    uint256 public count;

    // ======= 이벤트 =======
    event GreetingChanged(address indexed caller, string newGreeting);

    // ======= 생성자 =======
    constructor() {
        owner = msg.sender;  // 배포자 주소
    }

    // ======= 변경 함수 (트랜잭션 발생, Gas 소모) =======
    function setGreeting(string calldata _greeting) external {
        greeting = _greeting;
        count++;
        emit GreetingChanged(msg.sender, _greeting);
    }

    // ======= 읽기 함수 (Gas 무료) =======
    function getGreeting() external view returns (string memory) {
        return greeting;
    }
}

contract DataTypes {
    // 기본 자료형
    uint256 public price     = 1 ether;
    address public owner     = msg.sender;
    bool    public isActive  = true;
    bytes32 public docHash   = keccak256("document");

    // 컬렉션
    mapping(address => uint256) public balances;
    address[] public holders;

    // 구조체
    struct Token {
        string  name;
        uint256 supply;
        address creator;
    }
    Token public myToken = Token("MyCoin", 1_000_000, msg.sender);

    // 열거형
    enum Status { Pending, Active, Paused, Closed }
    Status public status = Status.Active;
}

contract AccessControl {
    address public owner;
    mapping(address => bool) private _admins;

    constructor() { owner = msg.sender; }

    // ===== modifier: 재사용 가능한 조건 검사 =====
    modifier onlyOwner() {
        require(msg.sender == owner, "Not owner");
        _;  // 이 위치에 함수 본문 실행
    }

    modifier onlyAdmin() {
        require(_admins[msg.sender] || msg.sender == owner, "Not admin");
        _;
    }

    // view: 상태 읽기만 (Gas 무료), pure: 상태 접근 없음
    function isAdmin(address addr) external view returns (bool) {
        return _admins[addr];
    }

    function addAdmin(address addr) external onlyOwner {
        _admins[addr] = true;
    }

    // payable: ETH 받을 수 있는 함수
    function deposit() external payable {
        require(msg.value > 0, "Send ETH");
    }

    // receive: 직접 ETH 전송 시 자동 실행
    receive() external payable {}

    // fallback: 매칭 함수 없을 때
    fallback() external payable {}
}

contract EventExample {
    // indexed: 필터링 가능 (최대 3개), 나머지는 data
    event Transfer(
        address indexed from,
        address indexed to,
        uint256         value
    );
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256         value
    );

    mapping(address => uint256) public balances;

    function transfer(address to, uint256 amount) external {
        require(balances[msg.sender] >= amount, "Insufficient balance");
        balances[msg.sender] -= amount;
        balances[to]         += amount;
        emit Transfer(msg.sender, to, amount);  // 이벤트 발생!
    }
}

// === Ethers.js에서 이벤트 구독 ===
// contract.on('Transfer', (from, to, value) => {
//   console.log('전송:', from, '->', to, formatEther(value), 'ETH');
// });

contract ErrorHandling {
    // Custom Error: Gas 절감 (0.8.4+), 최신 권장 방식
    error InsufficientBalance(uint256 requested, uint256 available);
    error Unauthorized(address caller);

    mapping(address => uint256) public balances;

    function withdraw(uint256 amount) external {
        // require: 조건 불만족 시 revert + 메시지
        require(amount > 0, "Amount must be positive");

        uint256 bal = balances[msg.sender];

        // Custom error: 에러 파라미터 전달 가능
        if (bal < amount)
            revert InsufficientBalance(amount, bal);

        balances[msg.sender] -= amount;
        (bool ok,) = msg.sender.call{value: amount}("");
        require(ok, "ETH transfer failed");
    }

    // assert: 절대 false여서는 안 되는 불변식 검사
    function checkInvariant() internal view {
        assert(address(this).balance >= 0); // 항상 true여야 함
    }
}

// ===== 인터페이스: 외부 컨트랙트와 통신 표준 =====
interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 amount) external returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
}

// ===== 추상 컨트랙트: 공통 로직 + 미구현 함수 =====
abstract contract Ownable {
    address public owner;
    event OwnershipTransferred(address indexed prev, address indexed next);

    constructor() { owner = msg.sender; }

    modifier onlyOwner() {
        require(msg.sender == owner, "Ownable: not owner"); _;
    }

    function transferOwnership(address newOwner) public onlyOwner {
        require(newOwner != address(0), "Zero address");
        emit OwnershipTransferred(owner, newOwner);
        owner = newOwner;
    }
}

abstract contract Pausable is Ownable {
    bool public paused;

    modifier whenNotPaused() {
        require(!paused, "Paused"); _;
    }

    function pause()   external onlyOwner { paused = true;  }
    function unpause() external onlyOwner { paused = false; }
}

// ===== 다중 상속 =====
contract MyToken is IERC20, Pausable {
    // Ownable + Pausable 기능 + IERC20 구현
}

// 라이브러리: 상태 변수 없음, 재배포 가능
library SafeTransfer {
    function safeTransfer(IERC20 token, address to, uint256 amount) internal {
        (bool success, bytes memory data) =
            address(token).call(abi.encodeWithSelector(token.transfer.selector, to, amount));
        require(success && (data.length == 0 || abi.decode(data, (bool))), "Transfer failed");
    }
}

contract Vault {
    using SafeTransfer for IERC20;  // IERC20 타입에 라이브러리 함수 붙이기

    function withdrawToken(IERC20 token, address to, uint256 amount) external {
        token.safeTransfer(to, amount);  // 메서드처럼 호출!
    }
}

// OpenZeppelin SafeMath (0.8.x는 기본 오버플로우 체크 내장)
// 구버전(0.7.x 이하)에서만 필요

contract StorageExample {
    uint256[] public data;  // storage

    // calldata: 외부에서 전달된 배열, 복사 없이 읽기
    function processArray(uint256[] calldata input) external {
        uint256 total = 0;
        for (uint256 i = 0; i < input.length; i++) {
            total += input[i];  // calldata 읽기
        }
        data.push(total);  // storage 쓰기
    }

    // storage 포인터 (복사 아님, 원본 참조)
    function modifyFirst() external {
        uint256[] storage ref = data;  // 포인터
        ref[0] = 999;  // data[0]이 실제로 변경됨
    }
}

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

contract MyERC20Token {
    // ===== 상태 변수 =====
    string  public name;
    string  public symbol;
    uint8   public decimals = 18;
    uint256 public totalSupply;
    address public owner;

    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    // ===== 이벤트 =====
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner_, address indexed spender, uint256 value);
    event Mint(address indexed to, uint256 amount);
    event Burn(address indexed from, uint256 amount);

    modifier onlyOwner() { require(msg.sender == owner, "Not owner"); _; }

    // ===== 생성자: 초기 토큰 발행 =====
    constructor(
        string memory _name,
        string memory _symbol,
        uint256 initialSupply
    ) {
        name        = _name;
        symbol      = _symbol;
        owner       = msg.sender;
        _mint(msg.sender, initialSupply * 10 ** decimals);
    }

    // ===== ERC-20 핵심 함수들 =====
    function transfer(address to, uint256 amount) external returns (bool) {
        _transfer(msg.sender, to, amount);
        return true;
    }

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        uint256 allowed = allowance[from][msg.sender];
        if (allowed != type(uint256).max) {
            require(allowed >= amount, "Allowance exceeded");
            allowance[from][msg.sender] -= amount;
        }
        _transfer(from, to, amount);
        return true;
    }

    // ===== 내부 함수 =====
    function _transfer(address from, address to, uint256 amount) internal {
        require(from != address(0) && to != address(0), "Zero address");
        require(balanceOf[from] >= amount, "Insufficient balance");
        balanceOf[from] -= amount;
        balanceOf[to]   += amount;
        emit Transfer(from, to, amount);
    }

    function _mint(address to, uint256 amount) internal {
        totalSupply    += amount;
        balanceOf[to]  += amount;
        emit Transfer(address(0), to, amount);
        emit Mint(to, amount);
    }

    // ===== 추가 기능 =====
    function mint(address to, uint256 amount) external onlyOwner {
        _mint(to, amount);
    }

    function burn(uint256 amount) external {
        require(balanceOf[msg.sender] >= amount, "Insufficient");
        balanceOf[msg.sender] -= amount;
        totalSupply           -= amount;
        emit Transfer(msg.sender, address(0), amount);
        emit Burn(msg.sender, amount);
    }
}

// npm install @openzeppelin/contracts
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract BlockToken is ERC20, ERC20Burnable, ERC20Permit, Ownable {
    uint256 public constant MAX_SUPPLY = 100_000_000 * 10 ** 18; // 1억 BTKN

    constructor(address initialOwner)
        ERC20("BlockToken", "BTKN")
        ERC20Permit("BlockToken")
        Ownable(initialOwner)
    {
        _mint(initialOwner, 10_000_000 * 10 ** decimals()); // 1000만 초기 발행
    }

    function mint(address to, uint256 amount) public onlyOwner {
        require(totalSupply() + amount <= MAX_SUPPLY, "Max supply exceeded");
        _mint(to, amount);
    }
}

💡 OpenZeppelin ERC-20 확장 기능

pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

contract BlockchainNFT is ERC721URIStorage, Ownable {
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;

    uint256 public mintPrice   = 0.01 ether;
    uint256 public maxSupply   = 10_000;
    bool    public publicMint  = false;

    mapping(address => uint256) public mintedPerAddress;
    uint256 public constant MAX_PER_WALLET = 5;

    event NFTMinted(address indexed minter, uint256 indexed tokenId, string tokenURI);

    constructor(address initialOwner)
        ERC721("BlockchainNFT", "BNFT")
        Ownable(initialOwner)
    {}

    // ===== 공개 민팅 =====
    function mint(string calldata tokenURI_) external payable returns (uint256) {
        require(publicMint, "Minting not open");
        require(msg.value >= mintPrice, "Insufficient ETH");
        require(_tokenIds.current() < maxSupply, "Max supply reached");
        require(mintedPerAddress[msg.sender] < MAX_PER_WALLET, "Wallet limit");

        _tokenIds.increment();
        uint256 newTokenId = _tokenIds.current();

        _safeMint(msg.sender, newTokenId);
        _setTokenURI(newTokenId, tokenURI_);
        mintedPerAddress[msg.sender]++;

        emit NFTMinted(msg.sender, newTokenId, tokenURI_);
        return newTokenId;
    }

    // ===== 오너 전용 무료 민팅 =====
    function ownerMint(address to, string calldata tokenURI_) external onlyOwner {
        _tokenIds.increment();
        uint256 newTokenId = _tokenIds.current();
        _safeMint(to, newTokenId);
        _setTokenURI(newTokenId, tokenURI_);
    }

    // ===== 관리 함수 =====
    function setPublicMint(bool _status) external onlyOwner { publicMint = _status; }
    function setMintPrice(uint256 _price) external onlyOwner { mintPrice = _price; }

    function withdraw() external onlyOwner {
        (bool ok,) = owner().call{value: address(this).balance}("");
        require(ok, "Withdraw failed");
    }

    function totalSupply() external view returns (uint256) {
        return _tokenIds.current();
    }
}

// NFT 메타데이터 JSON 구조 (ERC-721 표준)
{
  "name": "BlockchainNFT #1",
  "description": "A unique blockchain developer NFT",
  "image": "ipfs://QmHash.../1.png",
  "external_url": "https://myproject.io/nft/1",
  "attributes": [
    { "trait_type": "Rarity",    "value": "Legendary" },
    { "trait_type": "Level",      "value": 99             },
    { "trait_type": "Background", "value": "Cosmic"    },
    { "display_type": "date", "trait_type": "Birthday", "value": 1711584000 }
  ]
}

📁 IPFS 업로드 (Pinata 사용)

npm install @pinata/sdk

const pinata = new PinataSDK(apiKey, apiSecret);
// 이미지 업로드
const imgResult = await pinata.pinFileToIPFS(fs.createReadStream('./nft.png'));
// → QmImageHash

// 메타데이터 업로드
const meta = { name: "NFT #1", image: "ipfs://QmImageHash", ... };
const metaResult = await pinata.pinJSONToIPFS(meta);
// → tokenURI = "ipfs://QmMetaHash"

// ❌ 취약한 코드
contract VulnerableVault {
    mapping(address => uint256) public balances;

    function withdraw() external {
        uint256 amount = balances[msg.sender];
        (bool ok,) = msg.sender.call{value: amount}("");  // ← ETH 먼저 전송
        require(ok);
        balances[msg.sender] = 0;  // ← 잔액 업데이트 나중에 → 재진입 공격 가능!
    }
}

// ✅ 안전한 코드 — Checks-Effects-Interactions 패턴
contract SecureVault {
    mapping(address => uint256) public balances;
    bool private _locked;

    // ReentrancyGuard modifier
    modifier nonReentrant() {
        require(!_locked, "Reentrant call");
        _locked = true;
        _;
        _locked = false;
    }

    function withdraw() external nonReentrant {
        uint256 amount = balances[msg.sender];  // 1. Checks
        require(amount > 0, "Nothing to withdraw");

        balances[msg.sender] = 0;                 // 2. Effects (상태 먼저!)

        (bool ok,) = msg.sender.call{value: amount}(""); // 3. Interactions
        require(ok, "Transfer failed");
    }
}

# 프로젝트 초기화
mkdir my-dapp && cd my-dapp
npm init -y
npm install --save-dev hardhat @nomicfoundation/hardhat-toolbox
npx hardhat init  # "Create a JavaScript project" 선택

# OpenZeppelin 라이브러리
npm install @openzeppelin/contracts

# 프로젝트 구조
my-dapp/
├── contracts/          # Solidity 파일
│   ├── BlockToken.sol
│   └── BlockchainNFT.sol
├── scripts/            # 배포 스크립트
│   └── deploy.js
├── test/               # 테스트 파일
│   └── BlockToken.test.js
├── ignition/           # Hardhat Ignition 배포 모듈
└── hardhat.config.js   # 설정 파일

// hardhat.config.js — 완전한 설정
require("@nomicfoundation/hardhat-toolbox");
require("dotenv").config();

module.exports = {
  solidity: {
    version: "0.8.20",
    settings: {
      optimizer: { enabled: true, runs: 200 }  // Gas 최적화
    }
  },
  networks: {
    hardhat: { chainId: 31337 },              // 로컬 테스트넷
    sepolia: {
      url: process.env.SEPOLIA_RPC_URL,
      accounts: [process.env.PRIVATE_KEY],
      chainId: 11155111
    },
    mainnet: {
      url: process.env.MAINNET_RPC_URL,
      accounts: [process.env.PRIVATE_KEY],
      chainId: 1
    }
  },
  etherscan: {
    apiKey: process.env.ETHERSCAN_API_KEY   // 소스코드 검증
  },
  gasReporter: {
    enabled: true,
    currency: "USD"
  }
};

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

describe("BlockToken", function() {
  let token, owner, alice, bob;

  // 각 테스트 전 실행 (초기화)
  beforeEach(async function() {
    [owner, alice, bob] = await ethers.getSigners();
    const BlockToken = await ethers.getContractFactory("BlockToken");
    token = await BlockToken.deploy(owner.address);
    await token.waitForDeployment();
  });

  describe("Deployment", function() {
    it("올바른 이름과 심볼 설정", async function() {
      expect(await token.name()).to.equal("BlockToken");
      expect(await token.symbol()).to.equal("BTKN");
    });

    it("오너에게 초기 공급량 할당", async function() {
      const ownerBal = await token.balanceOf(owner.address);
      expect(ownerBal).to.equal(ethers.parseEther("10000000"));
    });
  });

  describe("Transfers", function() {
    it("토큰 전송 성공", async function() {
      const amount = ethers.parseEther("100");
      await token.transfer(alice.address, amount);
      expect(await token.balanceOf(alice.address)).to.equal(amount);
    });

    it("잔액 부족 시 revert", async function() {
      await expect(
        token.connect(alice).transfer(bob.address, 1n)
      ).to.be.revertedWith("ERC20: transfer amount exceeds balance");
    });

    it("Transfer 이벤트 발생", async function() {
      await expect(token.transfer(alice.address, ethers.parseEther("50")))
        .to.emit(token, "Transfer")
        .withArgs(owner.address, alice.address, ethers.parseEther("50"));
    });
  });

  describe("Minting", function() {
    it("오너만 민팅 가능", async function() {
      await expect(
        token.connect(alice).mint(bob.address, 100)
      ).to.be.revertedWithCustomError(token, "OwnableUnauthorizedAccount");
    });
  });
});

// 실행: npx hardhat test
// 커버리지: npx hardhat coverage

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

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

  // 컨트랙트 배포
  const BlockToken = await ethers.getContractFactory("BlockToken");
  const token = await BlockToken.deploy(deployer.address);
  await token.waitForDeployment();

  const address = await token.getAddress();
  console.log("BlockToken 배포 완료:", address);

  // Etherscan 검증 (30초 대기 후)
  if (network.name !== "hardhat") {
    console.log("Etherscan 검증 대기 중...");
    await new Promise(r => setTimeout(r, 30000));
    await run("verify:verify", {
      address,
      constructorArguments: [deployer.address]
    });
    console.log("✅ Etherscan 검증 완료!");
  }
}

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

// 실행 명령어
// 로컬: npx hardhat run scripts/deploy.js --network hardhat
// 테스트넷: npx hardhat run scripts/deploy.js --network sepolia

// dapp.js — 완전한 DApp 프론트엔드 로직
import { ethers } from 'ethers';
import BlockTokenABI from './abis/BlockToken.json';

const CONTRACT_ADDRESS = '0xYourContractAddress...';

class DApp {
  constructor() {
    this.provider = null;
    this.signer   = null;
    this.contract = null;
  }

  // 1. MetaMask 연결
  async connect() {
    if (!window.ethereum) throw new Error("MetaMask가 설치되어 있지 않습니다!");

    this.provider = new ethers.BrowserProvider(window.ethereum);
    this.signer   = await this.provider.getSigner();
    this.contract = new ethers.Contract(CONTRACT_ADDRESS, BlockTokenABI, this.signer);

    const address = await this.signer.getAddress();
    console.log(`✅ 연결됨: ${address}`);
    return address;
  }

  // 2. 잔액 조회 (view 함수 — Gas 없음)
  async getBalance(address) {
    const bal = await this.contract.balanceOf(address);
    return ethers.formatEther(bal);
  }

  // 3. 토큰 전송 (트랜잭션 — Gas 필요)
  async transfer(to, amount) {
    const amountWei = ethers.parseEther(amount.toString());
    const tx = await this.contract.transfer(to, amountWei);
    console.log(`📤 트랜잭션 전송: ${tx.hash}`);

    const receipt = await tx.wait();  // 컨펌 대기
    console.log(`✅ 컨펌됨! 블록: ${receipt.blockNumber}`);
    return receipt;
  }

  // 4. 이벤트 실시간 구독
  subscribeTransfer(callback) {
    this.contract.on('Transfer', (from, to, value, event) => {
      callback({
        from, to,
        amount: ethers.formatEther(value),
        txHash: event.log.transactionHash,
        blockNumber: event.log.blockNumber
      });
    });
  }

  // 5. 과거 이벤트 조회
  async getTransferHistory(address) {
    const filter = this.contract.filters.Transfer(address);  // from=address
    const events = await this.contract.queryFilter(filter, -10000);
    return events.map(e => ({
      to: e.args.to,
      amount: ethers.formatEther(e.args.value),
      block: e.blockNumber
    }));
  }

  // 6. Gas 예상 & 전송
  async estimateAndSend(to, amount) {
    const amountWei = ethers.parseEther(amount);
    const gasEst = await this.contract.transfer.estimateGas(to, amountWei);
    console.log(`예상 Gas: ${gasEst}`);

    const tx = await this.contract.transfer(to, amountWei, {
      gasLimit: gasEst * 110n / 100n  // 10% 여유
    });
    return tx.wait();
  }
}

// ===== 사용 예시 =====
const dapp = new DApp();
const myAddress = await dapp.connect();
const balance = await dapp.getBalance(myAddress);
console.log(`잔액: ${balance} BTKN`);

dapp.subscribeTransfer(({ from, to, amount }) => {
  console.log(`🔔 전송: ${from} → ${to}: ${amount} BTKN`);
});

pragma solidity ^0.8.20;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

/**
 * @title SimpleAMM - x*y=k 유동성 풀
 * @dev Uniswap V2 핵심 메커니즘 간소화 버전
 */
contract SimpleAMM is ERC20 {
    IERC20 public immutable tokenA;
    IERC20 public immutable tokenB;

    uint256 public reserveA;
    uint256 public reserveB;

    uint256 private constant FEE_NUMERATOR   = 997;
    uint256 private constant FEE_DENOMINATOR = 1000;  // 0.3% 수수료

    event LiquidityAdded(address indexed provider, uint256 amtA, uint256 amtB, uint256 lpTokens);
    event Swapped(address indexed trader, address tokenIn, uint256 amtIn, uint256 amtOut);

    constructor(address _tokenA, address _tokenB) ERC20("LP Token", "LP") {
        tokenA = IERC20(_tokenA);
        tokenB = IERC20(_tokenB);
    }

    // ===== 유동성 공급 =====
    function addLiquidity(uint256 amtA, uint256 amtB) external returns (uint256 lpTokens) {
        tokenA.transferFrom(msg.sender, address(this), amtA);
        tokenB.transferFrom(msg.sender, address(this), amtB);

        if (totalSupply() == 0) {
            lpTokens = _sqrt(amtA * amtB);  // 초기 LP = sqrt(A*B)
        } else {
            // 비율에 맞게 LP 발행
            lpTokens = _min(
                amtA * totalSupply() / reserveA,
                amtB * totalSupply() / reserveB
            );
        }

        reserveA += amtA;
        reserveB += amtB;
        _mint(msg.sender, lpTokens);
        emit LiquidityAdded(msg.sender, amtA, amtB, lpTokens);
    }

    // ===== 스왑: tokenA → tokenB =====
    function swapAforB(uint256 amtAIn, uint256 minAmtBOut) external returns (uint256) {
        tokenA.transferFrom(msg.sender, address(this), amtAIn);

        // x*y=k 공식으로 출력량 계산 (수수료 포함)
        uint256 amtAWithFee = amtAIn * FEE_NUMERATOR;
        uint256 amtBOut = (amtAWithFee * reserveB) /
                          (reserveA * FEE_DENOMINATOR + amtAWithFee);

        require(amtBOut >= minAmtBOut, "Slippage exceeded");

        reserveA += amtAIn;
        reserveB -= amtBOut;
        tokenB.transfer(msg.sender, amtBOut);

        emit Swapped(msg.sender, address(tokenA), amtAIn, amtBOut);
        return amtBOut;
    }

    // ===== 현재 가격 조회 =====
    function getPrice() external view returns (uint256) {
        return (reserveB * 1e18) / reserveA;  // 1 tokenA 기준 tokenB 가격
    }

    function _sqrt(uint256 y) internal pure returns (uint256 z) {
        if (y > 3) { z = y; uint256 x = y / 2 + 1; while (x < z) { z = x; x = (y/x + x)/2; } }
    }
    function _min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; }
}

contract Staking {
    IERC20 public immutable stakingToken;  // 예치 토큰
    IERC20 public immutable rewardToken;   // 보상 토큰

    uint256 public rewardRate = 100;        // 초당 보상
    uint256 public lastUpdateTime;
    uint256 public rewardPerTokenStored;

    mapping(address => uint256) public userRewardPerTokenPaid;
    mapping(address => uint256) public rewards;
    mapping(address => uint256) public stakedBalance;
    uint256 public totalStaked;

    modifier updateReward(address account) {
        rewardPerTokenStored = rewardPerToken();
        lastUpdateTime = block.timestamp;
        if (account != address(0)) {
            rewards[account] = earned(account);
            userRewardPerTokenPaid[account] = rewardPerTokenStored;
        }
        _;
    }

    function rewardPerToken() public view returns (uint256) {
        if (totalStaked == 0) return rewardPerTokenStored;
        return rewardPerTokenStored +
            (rewardRate * (block.timestamp - lastUpdateTime) * 1e18) / totalStaked;
    }

    function earned(address account) public view returns (uint256) {
        return (stakedBalance[account] * (rewardPerToken() - userRewardPerTokenPaid[account])) / 1e18
               + rewards[account];
    }

    function stake(uint256 amount) external updateReward(msg.sender) {
        require(amount > 0, "Cannot stake 0");
        totalStaked += amount;
        stakedBalance[msg.sender] += amount;
        stakingToken.transferFrom(msg.sender, address(this), amount);
    }

    function claimReward() external updateReward(msg.sender) {
        uint256 reward = rewards[msg.sender];
        if (reward > 0) {
            rewards[msg.sender] = 0;
            rewardToken.transfer(msg.sender, reward);
        }
    }
}

📌 다음 편 예고: BlockchainDevGuide0004

개발 환경 & 테스트넷 배포 완전 정복

Hardhat Ignition · Foundry · 테스트넷 Faucet · Etherscan API · IPFS 배포 · CI/CD 파이프라인