🤔 ERC-20 토큰이 뭔데?

먼저 기본부터 짚고 넘어갈게요!
ERC-20은 이더리움 블록체인에서 토큰을 만들 때 따라야 하는 표준 규격이에요.

쉽게 말하면 "토큰 만들 때 이런 기능들은 꼭 넣어야 해!"라고 정해놓은 룰이죠 ㅋㅋㅋ
덕분에 모든 ERC-20 토큰은 같은 방식으로 작동해서 호환성이 엄청 좋아요! 🎯

🛠️ 개발 환경 준비하기

본격적으로 시작하기 전에 필요한 것들을 준비해볼게요!
생각보다 준비물이 많지만 하나씩 차근차근 설치하면 어렵지 않아요 😊

composer create-project laravel/laravel erc20-token-project
cd erc20-token-project
php artisan serve

이렇게 하면 http://localhost:8000 에서 라라벨이 실행돼요!
"Laravel" 환영 페이지가 보이면 성공 ㅋㅋㅋ 🎉

라라벨에서 이더리움 블록체인과 통신하려면 Web3 라이브러리가 필요해요!
PHP용 Web3 패키지를 설치해볼게요:

composer require sc0vu/web3.php
composer require kornrunner/keccak

web3.php는 PHP에서 이더리움 노드와 통신할 수 있게 해주는 라이브러리예요!
keccak은 이더리움 주소 생성할 때 필요한 해시 함수 라이브러리구요 🔐

📝 스마트 컨트랙트 작성하기

이제 진짜 핵심인 ERC-20 토큰 스마트 컨트랙트를 작성해볼게요!
스마트 컨트랙트는 Solidity라는 언어로 작성하는데, 자바스크립트랑 비슷해서 배우기 쉬워요 👍

스마트 컨트랙트 개발을 위해 Hardhat이나 Truffle 같은 프레임워크를 사용할 수 있어요.
여기서는 요즘 핫한 Hardhat을 사용해볼게요!

npm install --save-dev hardhat
npx hardhat init

초기화 과정에서 "Create a JavaScript project"를 선택하면 돼요!
그러면 contracts, scripts, test 폴더가 자동으로 생성됩니다 📁

이제 본격적으로 토큰 컨트랙트를 작성해볼게요!
OpenZeppelin 라이브러리를 사용하면 안전하고 검증된 ERC-20 구현을 쉽게 가져올 수 있어요 🛡️

npm install @openzeppelin/contracts

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

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

contract MyToken is ERC20, Ownable {
    // 토큰 초기 발행량 (1억 개)
    uint256 private constant INITIAL_SUPPLY = 100000000 * 10**18;
    
    constructor() ERC20("MyAwesomeToken", "MAT") Ownable(msg.sender) {
        // 컨트랙트 배포자에게 전체 토큰 발행
        _mint(msg.sender, INITIAL_SUPPLY);
    }
    
    // 토큰 추가 발행 함수 (소유자만 가능)
    function mint(address to, uint256 amount) public onlyOwner {
        _mint(to, amount);
    }
    
    // 토큰 소각 함수
    function burn(uint256 amount) public {
        _burn(msg.sender, amount);
    }
}

이 코드 진짜 간단하죠? ㅋㅋㅋ
OpenZeppelin 덕분에 복잡한 ERC-20 로직을 직접 구현할 필요가 없어요!

코드 설명:
• ERC20 - 기본 ERC-20 기능 제공
• Ownable - 소유자 권한 관리 기능
• constructor - 토큰 이름과 심볼 설정, 초기 발행
• mint - 추가 토큰 발행 (소유자만 가능)
• burn - 토큰 소각 기능

🧪 스마트 컨트랙트 테스트하기

배포하기 전에 꼭! 테스트를 해야 해요!
버그가 있는 컨트랙트를 배포하면 돈이 날아갈 수 있거든요 😱

const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("MyToken Contract", function () {
    let myToken;
    let owner;
    let addr1;
    let addr2;

    beforeEach(async function () {
        [owner, addr1, addr2] = await ethers.getSigners();
        const MyToken = await ethers.getContractFactory("MyToken");
        myToken = await MyToken.deploy();
    });

    describe("배포 테스트", function () {
        it("올바른 이름과 심볼이 설정되어야 함", async function () {
            expect(await myToken.name()).to.equal("MyAwesomeToken");
            expect(await myToken.symbol()).to.equal("MAT");
        });

        it("초기 발행량이 소유자에게 할당되어야 함", async function () {
            const ownerBalance = await myToken.balanceOf(owner.address);
            expect(await myToken.totalSupply()).to.equal(ownerBalance);
        });
    });

    describe("토큰 전송 테스트", function () {
        it("계정 간 토큰 전송이 가능해야 함", async function () {
            await myToken.transfer(addr1.address, 1000);
            const addr1Balance = await myToken.balanceOf(addr1.address);
            expect(addr1Balance).to.equal(1000);
        });

        it("잔액 부족 시 전송 실패해야 함", async function () {
            const initialOwnerBalance = await myToken.balanceOf(owner.address);
            await expect(
                myToken.connect(addr1).transfer(owner.address, 1)
            ).to.be.reverted;
            expect(await myToken.balanceOf(owner.address)).to.equal(
                initialOwnerBalance
            );
        });
    });

    describe("Mint 기능 테스트", function () {
        it("소유자는 새 토큰을 발행할 수 있어야 함", async function () {
            await myToken.mint(addr1.address, 5000);
            expect(await myToken.balanceOf(addr1.address)).to.equal(5000);
        });

        it("소유자가 아닌 계정은 토큰 발행 불가", async function () {
            await expect(
                myToken.connect(addr1).mint(addr2.address, 5000)
            ).to.be.reverted;
        });
    });
});

테스트 실행은 이렇게 해요:

npx hardhat test

모든 테스트가 통과하면 초록색 체크마크가 쭉 나와요! ✅✅✅
하나라도 실패하면 코드를 다시 확인해야 합니다 ㅠㅠ

🚀 테스트넷에 배포하기

이제 진짜 블록체인에 배포할 차례예요!
처음엔 테스트넷(Sepolia, Goerli 등)에 배포해서 테스트하는 게 좋아요 🎯

먼저 프로젝트 루트에 .env 파일을 만들어요:

PRIVATE_KEY=여기에_메타마스크_개인키_입력
SEPOLIA_RPC_URL=https://sepolia.infura.io/v3/YOUR_INFURA_PROJECT_ID
ETHERSCAN_API_KEY=이더스캔_API_키

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

module.exports = {
    solidity: "0.8.20",
    networks: {
        sepolia: {
            url: process.env.SEPOLIA_RPC_URL,
            accounts: [process.env.PRIVATE_KEY],
            chainId: 11155111
        },
        hardhat: {
            chainId: 1337
        }
    },
    etherscan: {
        apiKey: process.env.ETHERSCAN_API_KEY
    }
};

const hre = require("hardhat");

async function main() {
    console.log("🚀 토큰 배포를 시작합니다...");
    
    // 컨트랙트 팩토리 가져오기
    const MyToken = await hre.ethers.getContractFactory("MyToken");
    
    // 배포 실행
    console.log("⏳ 배포 중...");
    const myToken = await MyToken.deploy();
    
    await myToken.waitForDeployment();
    
    const address = await myToken.getAddress();
    console.log("✅ MyToken 배포 완료!");
    console.log("📍 컨트랙트 주소:", address);
    
    // 배포 정보 출력
    console.log("\n📊 토큰 정보:");
    console.log("이름:", await myToken.name());
    console.log("심볼:", await myToken.symbol());
    console.log("총 발행량:", await myToken.totalSupply());
    
    console.log("\n🎉 배포가 성공적으로 완료되었습니다!");
    console.log("이더스캔에서 확인: https://sepolia.etherscan.io/address/" + address);
}

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

배포하려면 가스비로 쓸 테스트넷 ETH가 필요해요!
Sepolia Faucet에서 무료로 받을 수 있어요:

npx hardhat run scripts/deploy.js --network sepolia

짜잔! 🎊 이제 당신의 토큰이 블록체인에 올라갔어요!
출력된 컨트랙트 주소를 잘 저장해두세요. 나중에 필요합니다!

🔗 라라벨과 블록체인 연결하기

드디어 라라벨 파트예요! ㅋㅋㅋ
이제 라라벨 백엔드에서 배포한 토큰과 상호작용하는 방법을 알아볼게요 🎯

라라벨에서 블록체인과 통신하는 서비스 클래스를 만들어볼게요:

<?php

namespace App\Services;

use Web3\Web3;
use Web3\Contract;
use Web3\Utils;

class Web3Service
{
    private $web3;
    private $contract;
    private $contractAddress;
    private $abi;
    
    public function __construct()
    {
        // Infura 또는 Alchemy RPC URL 사용
        $rpcUrl = env('ETHEREUM_RPC_URL');
        $this->web3 = new Web3($rpcUrl);
        
        $this->contractAddress = env('TOKEN_CONTRACT_ADDRESS');
        $this->abi = json_decode(file_get_contents(storage_path('app/abi/MyToken.json')), true);
        
        $this->contract = new Contract($rpcUrl, $this->abi);
    }
    
    /**
     * 토큰 잔액 조회
     */
    public function getBalance($address)
    {
        $balance = null;
        
        $this->contract->at($this->contractAddress)->call('balanceOf', $address, function ($err, $result) use (&$balance) {
            if ($err !== null) {
                throw new \Exception('잔액 조회 실패: ' . $err->getMessage());
            }
            $balance = $result[0]->toString();
        });
        
        // Wei를 Ether로 변환 (18 decimals)
        return bcdiv($balance, bcpow('10', '18'), 18);
    }
    
    /**
     * 토큰 전송
     */
    public function transfer($fromPrivateKey, $toAddress, $amount)
    {
        $eth = $this->web3->eth;
        
        // Wei로 변환
        $amountInWei = bcmul($amount, bcpow('10', '18'));
        
        // 트랜잭션 데이터 생성
        $data = $this->contract->at($this->contractAddress)->getData('transfer', $toAddress, $amountInWei);
        
        // 가스 추정
        $gas = null;
        $eth->estimateGas([
            'to' => $this->contractAddress,
            'data' => $data
        ], function ($err, $result) use (&$gas) {
            if ($err !== null) {
                throw new \Exception('가스 추정 실패: ' . $err->getMessage());
            }
            $gas = $result->toString();
        });
        
        // 트랜잭션 전송
        // 실제 구현에서는 서명 및 전송 로직 추가 필요
        
        return [
            'success' => true,
            'gas' => $gas,
            'data' => $data
        ];
    }
    
    /**
     * 토큰 총 발행량 조회
     */
    public function getTotalSupply()
    {
        $supply = null;
        
        $this->contract->at($this->contractAddress)->call('totalSupply', function ($err, $result) use (&$supply) {
            if ($err !== null) {
                throw new \Exception('총 발행량 조회 실패: ' . $err->getMessage());
            }
            $supply = $result[0]->toString();
        });
        
        return bcdiv($supply, bcpow('10', '18'), 18);
    }
    
    /**
     * 토큰 이름 조회
     */
    public function getTokenName()
    {
        $name = null;
        
        $this->contract->at($this->contractAddress)->call('name', function ($err, $result) use (&$name) {
            if ($err !== null) {
                throw new \Exception('이름 조회 실패: ' . $err->getMessage());
            }
            $name = $result[0];
        });
        
        return $name;
    }
    
    /**
     * 토큰 심볼 조회
     */
    public function getTokenSymbol()
    {
        $symbol = null;
        
        $this->contract->at($this->contractAddress)->call('symbol', function ($err, $result) use (&$symbol) {
            if ($err !== null) {
                throw new \Exception('심볼 조회 실패: ' . $err->getMessage());
            }
            $symbol = $result[0];
        });
        
        return $symbol;
    }
}

라라벨의 .env 파일에 블록체인 관련 설정을 추가해요:

ETHEREUM_RPC_URL=https://sepolia.infura.io/v3/YOUR_PROJECT_ID
TOKEN_CONTRACT_ADDRESS=0x배포한_컨트랙트_주소
ETHEREUM_CHAIN_ID=11155111

php artisan make:controller TokenController

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Services\Web3Service;

class TokenController extends Controller
{
    private $web3Service;
    
    public function __construct(Web3Service $web3Service)
    {
        $this->web3Service = $web3Service;
    }
    
    /**
     * 토큰 정보 조회
     */
    public function getTokenInfo()
    {
        try {
            $info = [
                'name' => $this->web3Service->getTokenName(),
                'symbol' => $this->web3Service->getTokenSymbol(),
                'totalSupply' => $this->web3Service->getTotalSupply(),
            ];
            
            return response()->json([
                'success' => true,
                'data' => $info
            ]);
        } catch (\Exception $e) {
            return response()->json([
                'success' => false,
                'message' => $e->getMessage()
            ], 500);
        }
    }
    
    /**
     * 주소별 잔액 조회
     */
    public function getBalance(Request $request)
    {
        $request->validate([
            'address' => 'required|string|size:42'
        ]);
        
        try {
            $balance = $this->web3Service->getBalance($request->address);
            
            return response()->json([
                'success' => true,
                'address' => $request->address,
                'balance' => $balance
            ]);
        } catch (\Exception $e) {
            return response()->json([
                'success' => false,
                'message' => $e->getMessage()
            ], 500);
        }
    }
    
    /**
     * 토큰 전송
     */
    public function transfer(Request $request)
    {
        $request->validate([
            'from_private_key' => 'required|string',
            'to_address' => 'required|string|size:42',
            'amount' => 'required|numeric|min:0'
        ]);
        
        try {
            $result = $this->web3Service->transfer(
                $request->from_private_key,
                $request->to_address,
                $request->amount
            );
            
            return response()->json([
                'success' => true,
                'data' => $result
            ]);
        } catch (\Exception $e) {
            return response()->json([
                'success' => false,
                'message' => $e->getMessage()
            ], 500);
        }
    }
}

<?php

use Illuminate\Support\Facades\Route;
use App\Http\Controllers\TokenController;

Route::prefix('token')->group(function () {
    Route::get('/info', [TokenController::class, 'getTokenInfo']);
    Route::post('/balance', [TokenController::class, 'getBalance']);
    Route::post('/transfer', [TokenController::class, 'transfer']);
});

이제 API 엔드포인트가 준비됐어요! 🎉
http://localhost:8000/api/token/info 같은 주소로 접근할 수 있어요!

🎨 프론트엔드 구현하기

백엔드 API가 준비됐으니 이제 사용자가 볼 화면을 만들어볼게요!
Vue.js나 React를 쓸 수도 있지만, 여기서는 간단하게 Blade 템플릿으로 해볼게요 😊

<!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.jsdelivr.net/npm/axios/dist/axios.min.js"></script>
    <style>
        * { margin: 0; padding: 0; box-sizing: border-box; }
        body { font-family: 'Segoe UI', sans-serif; background: #f5f7fa; padding: 20px; }
        .container { max-width: 800px; margin: 0 auto; }
        .card { background: white; border-radius: 12px; padding: 25px; margin-bottom: 20px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); }
        .card-title { font-size: 24px; font-weight: bold; color: #2d3748; margin-bottom: 20px; }
        .info-row { display: flex; justify-content: space-between; padding: 12px 0; border-bottom: 1px solid #e2e8f0; }
        .info-label { font-weight: 600; color: #4a5568; }
        .info-value { color: #667eea; font-weight: bold; }
        .input-group { margin-bottom: 15px; }
        .input-group label { display: block; margin-bottom: 5px; font-weight: 600; color: #4a5568; }
        .input-group input { width: 100%; padding: 10px; border: 2px solid #e2e8f0; border-radius: 8px; font-size: 14px; }
        .btn { padding: 12px 24px; border: none; border-radius: 8px; font-weight: bold; cursor: pointer; font-size: 16px; }
        .btn-primary { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; }
        .btn-primary:hover { opacity: 0.9; }
        .loading { text-align: center; padding: 20px; color: #667eea; }
    </style>
</head>
<body>
    <div class="container">
        <div class="card">
            <h1 class="card-title">🪙 토큰 정보</h1>
            <div id="tokenInfo" class="loading">로딩 중...</div>
        </div>

        <div class="card">
            <h2 class="card-title">💰 잔액 조회</h2>
            <div class="input-group">
                <label>지갑 주소</label>
                <input type="text" id="addressInput" placeholder="0x...">
            </div>
            <button class="btn btn-primary" onclick="checkBalance()">잔액 확인</button>
            <div id="balanceResult" style="margin-top: 15px;"></div>
        </div>

        <div class="card">
            <h2 class="card-title">📤 토큰 전송</h2>
            <div class="input-group">
                <label>받는 주소</label>
                <input type="text" id="toAddress" placeholder="0x...">
            </div>
            <div class="input-group">
                <label>전송 수량</label>
                <input type="number" id="amount" placeholder="0.0">
            </div>
            <button class="btn btn-primary" onclick="transferToken()">전송하기</button>
            <div id="transferResult" style="margin-top: 15px;"></div>
        </div>
    </div>

    <script>
        // 페이지 로드 시 토큰 정보 가져오기
        window.onload = function() {
            loadTokenInfo();
        };

        async function loadTokenInfo() {
            try {
                const response = await axios.get('/api/token/info');
                const data = response.data.data;
                
                document.getElementById('tokenInfo').innerHTML = `
                    <div class="info-row">
                        <span class="info-label">토큰 이름</span>
                        <span class="info-value">${data.name}</span>
                    </div>
                    <div class="info-row">
                        <span class="info-label">토큰 심볼</span>
                        <span class="info-value">${data.symbol}</span>
                    </div>
                    <div class="info-row">
                        <span class="info-label">총 발행량</span>
                        <span class="info-value">${parseFloat(data.totalSupply).toLocaleString()} ${data.symbol}</span>
                    </div>
                `;
            } catch (error) {
                document.getElementById('tokenInfo').innerHTML = 
                    '<p style="color: red;">정보를 불러오는데 실패했습니다.</p>';
            }
        }

        async function checkBalance() {
            const address = document.getElementById('addressInput').value;
            
            if (!address || !address.startsWith('0x')) {
                alert('올바른 주소를 입력해주세요!');
                return;
            }

            try {
                const response = await axios.post('/api/token/balance', { address });
                const balance = response.data.balance;
                
                document.getElementById('balanceResult').innerHTML = `
                    <div style="padding: 15px; background: #f0f4ff; border-radius: 8px;">
                        <strong>잔액:</strong> ${parseFloat(balance).toLocaleString()} 토큰
                    </div>
                `;
            } catch (error) {
                document.getElementById('balanceResult').innerHTML = 
                    '<p style="color: red;">잔액 조회 실패</p>';
            }
        }

        async function transferToken() {
            const toAddress = document.getElementById('toAddress').value;
            const amount = document.getElementById('amount').value;

            if (!toAddress || !amount) {
                alert('모든 필드를 입력해주세요!');
                return;
            }

            try {
                // 실제로는 MetaMask 연동 필요
                alert('실제 전송 기능은 MetaMask 연동이 필요합니다!');
                
                // const response = await axios.post('/api/token/transfer', {
                //     to_address: toAddress,
                //     amount: amount
                // });
                
                document.getElementById('transferResult').innerHTML = `
                    <div style="padding: 15px; background: #d1f2eb; border-radius: 8px;">
                        <strong>전송 준비 완료!</strong> MetaMask로 서명하세요.
                    </div>
                `;
            } catch (error) {
                document.getElementById('transferResult').innerHTML = 
                    '<p style="color: red;">전송 실패</p>';
            }
        }
    </script>
</body>
</html>

<?php

use Illuminate\Support\Facades\Route;

Route::get('/token/dashboard', function () {
    return view('token.dashboard');
});

이제 http://localhost:8000/token/dashboard로 접속하면
깔끔한 토큰 대시보드를 볼 수 있어요! 🎨

🦊 MetaMask 연동하기

진짜 블록체인 앱처럼 만들려면 MetaMask 연동이 필수예요!
사용자가 직접 지갑으로 서명하고 트랜잭션을 보낼 수 있게 해볼게요 🔐

<script src="https://cdn.ethers.io/lib/ethers-5.2.umd.min.js"></script>
<script>
    let provider;
    let signer;
    let contract;
    
    const contractAddress = '0x배포한_컨트랙트_주소';
    const contractABI = [
        // ABI는 컴파일 후 생성된 JSON에서 가져오기
        "function balanceOf(address) view returns (uint256)",
        "function transfer(address to, uint256 amount) returns (bool)",
        "function name() view returns (string)",
        "function symbol() view returns (string)"
    ];
    
    // MetaMask 연결
    async function connectWallet() {
        if (typeof window.ethereum !== 'undefined') {
            try {
                // 지갑 연결 요청
                await window.ethereum.request({ method: 'eth_requestAccounts' });
                
                provider = new ethers.providers.Web3Provider(window.ethereum);
                signer = provider.getSigner();
                contract = new ethers.Contract(contractAddress, contractABI, signer);
                
                const address = await signer.getAddress();
                console.log('연결된 주소:', address);
                
                alert('지갑 연결 성공! 🎉');
                
                // 잔액 자동 조회
                await updateBalance(address);
                
            } catch (error) {
                console.error('연결 실패:', error);
                alert('지갑 연결에 실패했습니다.');
            }
        } else {
            alert('MetaMask를 설치해주세요!');
            window.open('https://metamask.io/download/', '_blank');
        }
    }
    
    // 잔액 조회
    async function updateBalance(address) {
        try {
            const balance = await contract.balanceOf(address);
            const formattedBalance = ethers.utils.formatEther(balance);
            
            document.getElementById('userBalance').innerHTML = `
                <strong>내 잔액:</strong> ${parseFloat(formattedBalance).toLocaleString()} 토큰
            `;
        } catch (error) {
            console.error('잔액 조회 실패:', error);
        }
    }
    
    // 토큰 전송
    async function sendToken() {
        const toAddress = document.getElementById('sendToAddress').value;
        const amount = document.getElementById('sendAmount').value;
        
        if (!toAddress || !amount) {
            alert('주소와 수량을 입력해주세요!');
            return;
        }
        
        try {
            // Wei로 변환
            const amountInWei = ethers.utils.parseEther(amount);
            
            // 트랜잭션 전송
            const tx = await contract.transfer(toAddress, amountInWei);
            
            alert('트랜잭션 전송 중... ⏳');
            
            // 트랜잭션 완료 대기
            await tx.wait();
            
            alert('전송 완료! ✅');
            
            // 잔액 업데이트
            const address = await signer.getAddress();
            await updateBalance(address);
            
        } catch (error) {
            console.error('전송 실패:', error);
            alert('전송에 실패했습니다: ' + error.message);
        }
    }
    
    // 네트워크 변경 감지
    window.ethereum.on('chainChanged', () => {
        window.location.reload();
    });
    
    // 계정 변경 감지
    window.ethereum.on('accountsChanged', (accounts) => {
        if (accounts.length === 0) {
            alert('지갑 연결이 해제되었습니다.');
        } else {
            updateBalance(accounts[0]);
        }
    });
</script>

이제 사용자가 MetaMask로 직접 트랜잭션에 서명할 수 있어요!
라라벨 백엔드는 읽기 전용 작업만 하고, 쓰기 작업은 클라이언트에서 처리하는 거죠 ㅋㅋㅋ

📊 거래 내역 저장하기

블록체인의 모든 거래는 영구적으로 기록되지만,
사용자 편의를 위해 데이터베이스에도 저장해두면 좋아요!
빠른 조회와 통계 분석이 가능하거든요 📈

php artisan make:migration create_token_transactions_table

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    public function up()
    {
        Schema::create('token_transactions', function (Blueprint $table) {
            $table->id();
            $table->string('transaction_hash', 66)->unique();
            $table->string('from_address', 42);
            $table->string('to_address', 42);
            $table->decimal('amount', 36, 18);
            $table->string('status', 20)->default('pending');
            $table->integer('block_number')->nullable();
            $table->decimal('gas_used', 20, 0)->nullable();
            $table->decimal('gas_price', 20, 0)->nullable();
            $table->timestamp('confirmed_at')->nullable();
            $table->timestamps();
            
            $table->index('from_address');
            $table->index('to_address');
            $table->index('status');
        });
    }

    public function down()
    {
        Schema::dropIfExists('token_transactions');
    }
};

php artisan migrate

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class TokenTransaction extends Model
{
    protected $fillable = [
        'transaction_hash',
        'from_address',
        'to_address',
        'amount',
        'status',
        'block_number',
        'gas_used',
        'gas_price',
        'confirmed_at'
    ];
    
    protected $casts = [
        'amount' => 'decimal:18',
        'gas_used' => 'decimal:0',
        'gas_price' => 'decimal:0',
        'confirmed_at' => 'datetime'
    ];
    
    // 상태별 조회
    public function scopePending($query)
    {
        return $query->where('status', 'pending');
    }
    
    public function scopeConfirmed($query)
    {
        return $query->where('status', 'confirmed');
    }
    
    public function scopeFailed($query)
    {
        return $query->where('status', 'failed');
    }
    
    // 주소별 조회
    public function scopeByAddress($query, $address)
    {
        return $query->where('from_address', $address)
                    ->orWhere('to_address', $address);
    }
}

<?php

namespace App\Services;

use App\Models\TokenTransaction;
use Carbon\Carbon;

class TransactionService
{
    private $web3Service;
    
    public function __construct(Web3Service $web3Service)
    {
        $this->web3Service = $web3Service;
    }
    
    /**
     * 트랜잭션 저장
     */
    public function saveTransaction($txHash, $fromAddress, $toAddress, $amount)
    {
        return TokenTransaction::create([
            'transaction_hash' => $txHash,
            'from_address' => $fromAddress,
            'to_address' => $toAddress,
            'amount' => $amount,
            'status' => 'pending'
        ]);
    }
    
    /**
     * 트랜잭션 상태 업데이트
     */
    public function updateTransactionStatus($txHash)
    {
        $transaction = TokenTransaction::where('transaction_hash', $txHash)->first();
        
        if (!$transaction) {
            return null;
        }
        
        try {
            // 블록체인에서 트랜잭션 정보 조회
            $receipt = $this->web3Service->getTransactionReceipt($txHash);
            
            if ($receipt) {
                $transaction->update([
                    'status' => $receipt['status'] ? 'confirmed' : 'failed',
                    'block_number' => hexdec($receipt['blockNumber']),
                    'gas_used' => hexdec($receipt['gasUsed']),
                    'confirmed_at' => Carbon::now()
                ]);
            }
            
            return $transaction;
        } catch (\Exception $e) {
            return null;
        }
    }
    
    /**
     * 사용자별 거래 내역 조회
     */
    public function getUserTransactions($address, $limit = 20)
    {
        return TokenTransaction::byAddress($address)
            ->orderBy('created_at', 'desc')
            ->limit($limit)
            ->get();
    }
    
    /**
     * 대기 중인 트랜잭션 확인
     */
    public function checkPendingTransactions()
    {
        $pending = TokenTransaction::pending()->get();
        
        foreach ($pending as $tx) {
            $this->updateTransactionStatus($tx->transaction_hash);
        }
    }
}

이제 모든 토큰 거래가 데이터베이스에 기록돼요!
사용자는 자신의 거래 내역을 빠르게 확인할 수 있죠 😊

⚡ 실시간 이벤트 리스닝

블록체인에서 발생하는 이벤트를 실시간으로 감지하면
더 역동적인 애플리케이션을 만들 수 있어요!
예를 들어 토큰이 전송되면 자동으로 알림을 보내는 거죠 🔔

<?php

namespace App\Services;

use Web3\Web3;
use Web3\Contract;

class EventListenerService
{
    private $web3;
    private $contract;
    
    public function __construct()
    {
        $rpcUrl = env('ETHEREUM_RPC_URL');
        $this->web3 = new Web3($rpcUrl);
        
        $abi = json_decode(file_get_contents(storage_path('app/abi/MyToken.json')), true);
        $this->contract = new Contract($rpcUrl, $abi);
    }
    
    /**
     * Transfer 이벤트 리스닝
     */
    public function listenTransferEvents($fromBlock = 'latest')
    {
        $contractAddress = env('TOKEN_CONTRACT_ADDRESS');
        
        // Transfer 이벤트 필터
        $filter = [
            'fromBlock' => $fromBlock,
            'toBlock' => 'latest',
            'address' => $contractAddress,
            'topics' => [
                // Transfer(address,address,uint256) 이벤트 시그니처
                '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef'
            ]
        ];
        
        $this->web3->eth->getLogs($filter, function ($err, $logs) {
            if ($err !== null) {
                \Log::error('이벤트 조회 실패: ' . $err->getMessage());
                return;
            }
            
            foreach ($logs as $log) {
                $this->processTransferEvent($log);
            }
        });
    }
    
    /**
     * Transfer 이벤트 처리
     */
    private function processTransferEvent($log)
    {
        // 이벤트 데이터 파싱
        $from = '0x' . substr($log->topics[1], 26);
        $to = '0x' . substr($log->topics[2], 26);
        $amount = hexdec($log->data);
        
        // 데이터베이스에 저장
        \App\Models\TokenTransaction::create([
            'transaction_hash' => $log->transactionHash,
            'from_address' => $from,
            'to_address' => $to,
            'amount' => bcdiv($amount, bcpow('10', '18'), 18),
            'status' => 'confirmed',
            'block_number' => hexdec($log->blockNumber),
            'confirmed_at' => now()
        ]);
        
        // 알림 발송 등 추가 처리
        $this->sendNotification($from, $to, $amount);
    }
    
    /**
     * 알림 발송
     */
    private function sendNotification($from, $to, $amount)
    {
        // 이메일, 푸시 알림 등 구현
        \Log::info("토큰 전송 감지: {$from} -> {$to}, 수량: {$amount}");
    }
}

<?php

namespace App\Console;

use Illuminate\Console\Scheduling\Schedule;
use Illuminate\Foundation\Console\Kernel as ConsoleKernel;

class Kernel extends ConsoleKernel
{
    protected function schedule(Schedule $schedule)
    {
        // 1분마다 대기 중인 트랜잭션 확인
        $schedule->call(function () {
            $service = app(\App\Services\TransactionService::class);
            $service->checkPendingTransactions();
        })->everyMinute();
        
        // 5분마다 새로운 이벤트 확인
        $schedule->call(function () {
            $service = app(\App\Services\EventListenerService::class);
            $service->listenTransferEvents();
        })->everyFiveMinutes();
    }
}

스케줄러를 실행하려면:

php artisan schedule:work

이제 블록체인의 모든 토큰 전송이 자동으로 감지되고 저장돼요! 🎯

🛡️ 보안 고려사항

블록체인 앱은 돈과 직결되기 때문에 보안이 정말 중요해요!
꼭 지켜야 할 보안 원칙들을 정리해볼게요 🔐

🚀 성능 최적화

블록체인 통신은 느릴 수 있어서 최적화가 중요해요!
사용자 경험을 개선하는 몇 가지 팁을 알려드릴게요 ⚡

// 토큰 정보 캐싱 (1시간)
$tokenInfo = Cache::remember('token_info', 3600, function () {
    return [
        'name' => $this->web3Service->getTokenName(),
        'symbol' => $this->web3Service->getTokenSymbol(),
        'totalSupply' => $this->web3Service->getTotalSupply()
    ];
});

// 트랜잭션 확인 작업을 큐로 처리
dispatch(new CheckTransactionJob($txHash))->delay(now()->addMinutes(1));

💰 가스비 최적화

이더리움 가스비는 비쌀 수 있어요! 😱
스마트 컨트랙트를 효율적으로 작성하면 가스비를 많이 절약할 수 있어요!

function batchTransfer(address[] memory recipients, uint256[] memory amounts) public {
    require(recipients.length == amounts.length, "Length mismatch");
    for (uint i = 0; i < recipients.length; i++) {
        _transfer(msg.sender, recipients[i], amounts[i]);
    }
}

🎓 실전 활용 사례

이제 배운 내용을 실제로 어떻게 활용할 수 있는지 알아볼게요!
다양한 비즈니스 모델에 적용할 수 있어요 💡

🎬 마무리하며

와! 여기까지 오느라 수고 많으셨어요! 👏👏👏

라라벨에서 ERC-20 토큰을 생성하고 배포하는 전 과정을 다뤄봤는데요,
생각보다 복잡하지 않죠? ㅋㅋㅋ

물론 실제 프로덕션 환경에서는 더 많은 고려사항이 있지만,
이 가이드가 여러분의 블록체인 프로젝트 시작에 도움이 되었으면 좋겠어요! 🚀

핵심 정리:
✅ ERC-20은 이더리움 토큰의 표준 규격
✅ OpenZeppelin으로 안전한 컨트랙트 구현
✅ Hardhat으로 개발 및 배포
✅ 라라벨로 백엔드 API 구축
✅ Web3.php로 블록체인 통신
✅ MetaMask로 사용자 지갑 연동
✅ 보안과 최적화는 필수!

블록체인 개발이 처음이라면 재능넷에서 경험 많은 멘토를 찾아보는 것도 좋은 방법이에요!
실전 경험이 있는 개발자에게 배우면 시행착오를 많이 줄일 수 있거든요 😊

여러분도 멋진 토큰 프로젝트를 만들어보세요!
Web3 세상에서 만나요! 🌐✨