📦 필수 설치 항목

1. Node.js와 npm
자바스크립트 런타임 환경이야. 블록체인 개발 도구들이 대부분 Node.js 기반이라서 필수야!

# Node.js 설치 확인
node --version
npm --version

2. Composer
PHP 의존성 관리 도구로, 라라벨 설치에 필요해.

# Composer 설치 확인
composer --version

3. PHP 8.0 이상
라라벨 최신 버전을 사용하려면 PHP 8.0 이상이 필요해.

4. MySQL 또는 PostgreSQL
사용자 정보, 트랜잭션 기록 등을 저장할 데이터베이스야.

5. Ganache
로컬 이더리움 블록체인 개발 환경이야. 실제 이더리움 네트워크에 배포하기 전에 테스트할 수 있어!

6. MetaMask
브라우저 기반 이더리움 지갑이야. 테스트할 때 유용하게 쓰여.

7. Truffle 또는 Hardhat
스마트 컨트랙트 개발, 테스트, 배포를 도와주는 프레임워크야.

# Truffle 설치
npm install -g truffle

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

🚀 라라벨 프로젝트 생성

자, 이제 라라벨 프로젝트를 만들어보자!

# 라라벨 설치
composer create-project laravel/laravel token-system

# 프로젝트 디렉토리로 이동
cd token-system

# 개발 서버 실행
php artisan serve

브라우저에서 http://localhost:8000에 접속하면 라라벨 환영 페이지가 보일 거야! 🎊

⚙️ 환경 설정 파일 구성

.env 파일을 열어서 데이터베이스 설정을 해줘:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=token_system
DB_USERNAME=root
DB_PASSWORD=your_password

# 블록체인 관련 설정 추가
BLOCKCHAIN_NETWORK=http://127.0.0.1:7545
CONTRACT_ADDRESS=
OWNER_PRIVATE_KEY=

데이터베이스를 생성하고 마이그레이션을 실행해:

# 데이터베이스 생성 (MySQL CLI에서)
CREATE DATABASE token_system;

# 라라벨 마이그레이션 실행
php artisan migrate

📝 Truffle 프로젝트 초기화

라라벨 프로젝트 루트에 블록체인 폴더를 만들자:

# 블록체인 디렉토리 생성
mkdir blockchain
cd blockchain

# Truffle 초기화
truffle init

이렇게 하면 다음과 같은 구조가 생성돼:

blockchain/
├── contracts/        # 스마트 컨트랙트 소스 코드
├── migrations/       # 배포 스크립트
├── test/            # 테스트 파일
└── truffle-config.js # 설정 파일

✍️ 토큰 컨트랙트 작성

contracts/MyToken.sol 파일을 생성하고 다음 코드를 작성해:

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

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

contract MyToken is ERC20, Ownable {
    // 토큰의 소수점 자리수
    uint8 private _decimals;
    
    // 최대 발행량 (옵션)
    uint256 private _cap;
    
    // 이벤트 정의
    event TokensMinted(address indexed to, uint256 amount);
    event TokensBurned(address indexed from, uint256 amount);
    
    constructor(
        string memory name,
        string memory symbol,
        uint8 decimals_,
        uint256 initialSupply,
        uint256 cap_
    ) ERC20(name, symbol) {
        _decimals = decimals_;
        _cap = cap_;
        
        // 초기 공급량 발행
        _mint(msg.sender, initialSupply * 10 ** decimals_);
    }
    
    // 소수점 자리수 반환
    function decimals() public view virtual override returns (uint8) {
        return _decimals;
    }
    
    // 최대 발행량 반환
    function cap() public view returns (uint256) {
        return _cap;
    }
    
    // 토큰 발행 (소유자만 가능)
    function mint(address to, uint256 amount) public onlyOwner {
        require(to != address(0), "Cannot mint to zero address");
        
        if (_cap > 0) {
            require(totalSupply() + amount <= _cap, "Cap exceeded");
        }
        
        _mint(to, amount);
        emit TokensMinted(to, amount);
    }
    
    // 토큰 소각
    function burn(uint256 amount) public {
        _burn(msg.sender, amount);
        emit TokensBurned(msg.sender, amount);
    }
    
    // 특정 주소의 토큰 소각 (승인 필요)
    function burnFrom(address account, uint256 amount) public {
        uint256 currentAllowance = allowance(account, msg.sender);
        require(currentAllowance >= amount, "Burn amount exceeds allowance");
        
        _approve(account, msg.sender, currentAllowance - amount);
        _burn(account, amount);
        emit TokensBurned(account, amount);
    }
    
    // 일괄 전송 기능
    function batchTransfer(address[] memory recipients, uint256[] memory amounts) 
        public 
        returns (bool) 
    {
        require(recipients.length == amounts.length, "Arrays length mismatch");
        require(recipients.length > 0, "Empty arrays");
        
        for (uint256 i = 0; i < recipients.length; i++) {
            require(recipients[i] != address(0), "Invalid recipient");
            _transfer(msg.sender, recipients[i], amounts[i]);
        }
        
        return true;
    }
}

와! 코드가 좀 길지? 하나씩 뜯어보자! 🔍

📦 OpenZeppelin 설치

위 코드에서 OpenZeppelin 라이브러리를 사용했으니 설치해줘야 해:

# blockchain 디렉토리에서 실행
npm init -y
npm install @openzeppelin/contracts

⚙️ Truffle 설정

truffle-config.js 파일을 수정해:

module.exports = {
  networks: {
    development: {
      host: "127.0.0.1",
      port: 7545,  // Ganache 기본 포트
      network_id: "*",
    },
    testnet: {
      provider: () => new HDWalletProvider(
        process.env.MNEMONIC,
        `https://rinkeby.infura.io/v3/${process.env.INFURA_KEY}`
      ),
      network_id: 4,
      gas: 5500000,
    }
  },
  
  compilers: {
    solc: {
      version: "0.8.17",
      settings: {
        optimizer: {
          enabled: true,
          runs: 200
        }
      }
    }
  }
};

🚀 배포 스크립트 작성

migrations/2_deploy_token.js 파일을 생성해:

const MyToken = artifacts.require("MyToken");

module.exports = function(deployer) {
  const name = "JaeNung Token";
  const symbol = "JNT";
  const decimals = 18;
  const initialSupply = 1000000;  // 100만 개
  const cap = 10000000;  // 최대 1000만 개
  
  deployer.deploy(
    MyToken,
    name,
    symbol,
    decimals,
    initialSupply,
    cap
  );
};

이제 Ganache를 실행하고 컨트랙트를 배포해보자!

# 컴파일
truffle compile

# 배포
truffle migrate --network development

성공하면 컨트랙트 주소가 출력될 거야. 이 주소를 잘 기억해둬! 나중에 라라벨에서 사용할 거거든. 📝

📚 Web3.php 라이브러리 설치

PHP에서 이더리움과 통신하려면 Web3.php 라이브러리가 필요해:

# 라라벨 프로젝트 루트에서 실행
composer require web3p/web3.php

또는 더 간단한 방법으로 Guzzle HTTP 클라이언트를 사용해서 JSON-RPC 호출을 직접 만들 수도 있어:

composer require guzzlehttp/guzzle

🛠️ 블록체인 서비스 클래스 생성

app/Services/BlockchainService.php 파일을 만들어:

<?php

namespace App\Services;

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

class BlockchainService
{
    private $web3;
    private $contract;
    private $contractAddress;
    private $ownerAddress;
    private $ownerPrivateKey;
    
    public function __construct()
    {
        $this->web3 = new Web3(env('BLOCKCHAIN_NETWORK'));
        $this->contractAddress = env('CONTRACT_ADDRESS');
        $this->ownerPrivateKey = env('OWNER_PRIVATE_KEY');
        
        // 컨트랙트 ABI 로드
        $abi = json_decode(file_get_contents(
            base_path('blockchain/build/contracts/MyToken.json')
        ), true)['abi'];
        
        $this->contract = new Contract(
            $this->web3->provider,
            $abi
        );
        
        $this->contract->at($this->contractAddress);
    }
    
    /**
     * 토큰 잔액 조회
     */
    public function getBalance($address)
    {
        $balance = null;
        
        $this->contract->call('balanceOf', $address, function ($err, $result) use (&$balance) {
            if ($err !== null) {
                throw new \Exception($err->getMessage());
            }
            $balance = $result[0]->toString();
        });
        
        return $balance;
    }
    
    /**
     * 토큰 전송
     */
    public function transfer($from, $to, $amount, $privateKey)
    {
        // 트랜잭션 데이터 생성
        $data = $this->contract->getData('transfer', $to, $amount);
        
        // 가스 추정
        $gas = $this->estimateGas($from, $this->contractAddress, $data);
        
        // 트랜잭션 서명 및 전송
        $txHash = $this->sendSignedTransaction([
            'from' => $from,
            'to' => $this->contractAddress,
            'gas' => $gas,
            'data' => $data
        ], $privateKey);
        
        return $txHash;
    }
    
    /**
     * 토큰 발행 (소유자만)
     */
    public function mint($to, $amount)
    {
        $data = $this->contract->getData('mint', $to, $amount);
        
        $txHash = $this->sendSignedTransaction([
            'from' => $this->ownerAddress,
            'to' => $this->contractAddress,
            'gas' => '200000',
            'data' => $data
        ], $this->ownerPrivateKey);
        
        return $txHash;
    }
    
    /**
     * 토큰 소각
     */
    public function burn($from, $amount, $privateKey)
    {
        $data = $this->contract->getData('burn', $amount);
        
        $txHash = $this->sendSignedTransaction([
            'from' => $from,
            'to' => $this->contractAddress,
            'gas' => '100000',
            'data' => $data
        ], $privateKey);
        
        return $txHash;
    }
    
    /**
     * 총 공급량 조회
     */
    public function totalSupply()
    {
        $supply = null;
        
        $this->contract->call('totalSupply', function ($err, $result) use (&$supply) {
            if ($err !== null) {
                throw new \Exception($err->getMessage());
            }
            $supply = $result[0]->toString();
        });
        
        return $supply;
    }
    
    /**
     * 트랜잭션 영수증 조회
     */
    public function getTransactionReceipt($txHash)
    {
        $receipt = null;
        
        $this->web3->eth->getTransactionReceipt($txHash, function ($err, $result) use (&$receipt) {
            if ($err !== null) {
                throw new \Exception($err->getMessage());
            }
            $receipt = $result;
        });
        
        return $receipt;
    }
    
    /**
     * 가스 추정
     */
    private function estimateGas($from, $to, $data)
    {
        $gas = null;
        
        $this->web3->eth->estimateGas([
            'from' => $from,
            'to' => $to,
            'data' => $data
        ], function ($err, $result) use (&$gas) {
            if ($err !== null) {
                throw new \Exception($err->getMessage());
            }
            $gas = $result->toString();
        });
        
        return $gas;
    }
    
    /**
     * 서명된 트랜잭션 전송
     */
    private function sendSignedTransaction($transaction, $privateKey)
    {
        // 실제 구현에서는 트랜잭션 서명 로직 필요
        // ethers.js나 web3.js를 Node.js로 호출하거나
        // PHP 암호화 라이브러리 사용
        
        $txHash = null;
        
        // 간단한 예시 (실제로는 더 복잡함)
        $this->web3->eth->sendTransaction($transaction, function ($err, $result) use (&$txHash) {
            if ($err !== null) {
                throw new \Exception($err->getMessage());
            }
            $txHash = $result;
        });
        
        return $txHash;
    }
}

이 서비스 클래스가 블록체인과의 모든 상호작용을 담당해! 마치 통역사처럼 라라벨과 블록체인 사이에서 메시지를 전달하는 거지. 🗣️

🗄️ 데이터베이스 모델 생성

블록체인 트랜잭션 기록을 데이터베이스에도 저장해두면 좋아. 빠른 조회와 통계를 위해서 말이야!

# 마이그레이션 생성
php artisan make:migration create_transactions_table
php artisan make:migration create_wallets_table

database/migrations/xxxx_create_transactions_table.php:

<?php

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

class CreateTransactionsTable extends Migration
{
    public function up()
    {
        Schema::create('transactions', function (Blueprint $table) {
            $table->id();
            $table->foreignId('user_id')->constrained()->onDelete('cascade');
            $table->string('tx_hash')->unique();
            $table->string('from_address');
            $table->string('to_address');
            $table->string('amount');
            $table->enum('type', ['transfer', 'mint', 'burn']);
            $table->enum('status', ['pending', 'confirmed', 'failed'])->default('pending');
            $table->integer('block_number')->nullable();
            $table->text('error_message')->nullable();
            $table->timestamps();
            
            $table->index(['user_id', 'created_at']);
            $table->index('tx_hash');
        });
    }
    
    public function down()
    {
        Schema::dropIfExists('transactions');
    }
}

database/migrations/xxxx_create_wallets_table.php:

<?php

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

class CreateWalletsTable extends Migration
{
    public function up()
    {
        Schema::create('wallets', function (Blueprint $table) {
            $table->id();
            $table->foreignId('user_id')->constrained()->onDelete('cascade');
            $table->string('address')->unique();
            $table->text('encrypted_private_key')->nullable();
            $table->boolean('is_primary')->default(true);
            $table->timestamps();
            
            $table->index('user_id');
            $table->index('address');
        });
    }
    
    public function down()
    {
        Schema::dropIfExists('wallets');
    }
}

# 마이그레이션 실행
php artisan migrate

이제 모델도 만들어줘:

# 모델 생성
php artisan make:model Transaction
php artisan make:model Wallet

app/Models/Transaction.php:

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Transaction extends Model
{
    protected $fillable = [
        'user_id',
        'tx_hash',
        'from_address',
        'to_address',
        'amount',
        'type',
        'status',
        'block_number',
        'error_message'
    ];
    
    protected $casts = [
        'block_number' => 'integer',
    ];
    
    public function user()
    {
        return $this->belongsTo(User::class);
    }
    
    public function scopePending($query)
    {
        return $query->where('status', 'pending');
    }
    
    public function scopeConfirmed($query)
    {
        return $query->where('status', 'confirmed');
    }
}

🎯 토큰 컨트롤러 생성

# 컨트롤러 생성
php artisan make:controller Api/TokenController

app/Http/Controllers/Api/TokenController.php:

<?php

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use App\Services\BlockchainService;
use App\Models\Transaction;
use App\Models\Wallet;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Validator;
use Illuminate\Support\Facades\DB;

class TokenController extends Controller
{
    private $blockchain;
    
    public function __construct(BlockchainService $blockchain)
    {
        $this->blockchain = $blockchain;
    }
    
    /**
     * 토큰 잔액 조회
     */
    public function balance(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'address' => 'required|string|size:42'
        ]);
        
        if ($validator->fails()) {
            return response()->json([
                'success' => false,
                'errors' => $validator->errors()
            ], 422);
        }
        
        try {
            $balance = $this->blockchain->getBalance($request->address);
            
            return response()->json([
                'success' => true,
                'data' => [
                    'address' => $request->address,
                    'balance' => $balance,
                    'formatted_balance' => number_format($balance / 1e18, 4)
                ]
            ]);
        } catch (\Exception $e) {
            return response()->json([
                'success' => false,
                'message' => '잔액 조회 실패: ' . $e->getMessage()
            ], 500);
        }
    }
    
    /**
     * 토큰 전송
     */
    public function transfer(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'to_address' => 'required|string|size:42',
            'amount' => 'required|numeric|min:0.0001'
        ]);
        
        if ($validator->fails()) {
            return response()->json([
                'success' => false,
                'errors' => $validator->errors()
            ], 422);
        }
        
        DB::beginTransaction();
        
        try {
            $user = $request->user();
            $wallet = $user->wallets()->where('is_primary', true)->first();
            
            if (!$wallet) {
                throw new \Exception('지갑을 찾을 수 없습니다.');
            }
            
            // Wei 단위로 변환 (1 토큰 = 10^18 Wei)
            $amountInWei = bcmul($request->amount, '1000000000000000000');
            
            // 잔액 확인
            $balance = $this->blockchain->getBalance($wallet->address);
            if (bccomp($balance, $amountInWei) < 0) {
                throw new \Exception('잔액이 부족합니다.');
            }
            
            // 트랜잭션 전송
            $txHash = $this->blockchain->transfer(
                $wallet->address,
                $request->to_address,
                $amountInWei,
                decrypt($wallet->encrypted_private_key)
            );
            
            // DB에 기록
            $transaction = Transaction::create([
                'user_id' => $user->id,
                'tx_hash' => $txHash,
                'from_address' => $wallet->address,
                'to_address' => $request->to_address,
                'amount' => $amountInWei,
                'type' => 'transfer',
                'status' => 'pending'
            ]);
            
            DB::commit();
            
            return response()->json([
                'success' => true,
                'data' => [
                    'transaction_id' => $transaction->id,
                    'tx_hash' => $txHash,
                    'status' => 'pending',
                    'message' => '전송이 시작되었습니다. 블록체인 확인까지 약간의 시간이 소요됩니다.'
                ]
            ]);
            
        } catch (\Exception $e) {
            DB::rollBack();
            
            return response()->json([
                'success' => false,
                'message' => '전송 실패: ' . $e->getMessage()
            ], 500);
        }
    }
    
    /**
     * 토큰 발행 (관리자 전용)
     */
    public function mint(Request $request)
    {
        // 관리자 권한 확인
        if (!$request->user()->is_admin) {
            return response()->json([
                'success' => false,
                'message' => '권한이 없습니다.'
            ], 403);
        }
        
        $validator = Validator::make($request->all(), [
            'to_address' => 'required|string|size:42',
            'amount' => 'required|numeric|min:1'
        ]);
        
        if ($validator->fails()) {
            return response()->json([
                'success' => false,
                'errors' => $validator->errors()
            ], 422);
        }
        
        try {
            $amountInWei = bcmul($request->amount, '1000000000000000000');
            
            $txHash = $this->blockchain->mint(
                $request->to_address,
                $amountInWei
            );
            
            Transaction::create([
                'user_id' => $request->user()->id,
                'tx_hash' => $txHash,
                'from_address' => '0x0000000000000000000000000000000000000000',
                'to_address' => $request->to_address,
                'amount' => $amountInWei,
                'type' => 'mint',
                'status' => 'pending'
            ]);
            
            return response()->json([
                'success' => true,
                'data' => [
                    'tx_hash' => $txHash,
                    'message' => '토큰 발행이 시작되었습니다.'
                ]
            ]);
            
        } catch (\Exception $e) {
            return response()->json([
                'success' => false,
                'message' => '발행 실패: ' . $e->getMessage()
            ], 500);
        }
    }
    
    /**
     * 토큰 소각
     */
    public function burn(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'amount' => 'required|numeric|min:0.0001'
        ]);
        
        if ($validator->fails()) {
            return response()->json([
                'success' => false,
                'errors' => $validator->errors()
            ], 422);
        }
        
        try {
            $user = $request->user();
            $wallet = $user->wallets()->where('is_primary', true)->first();
            
            $amountInWei = bcmul($request->amount, '1000000000000000000');
            
            $txHash = $this->blockchain->burn(
                $wallet->address,
                $amountInWei,
                decrypt($wallet->encrypted_private_key)
            );
            
            Transaction::create([
                'user_id' => $user->id,
                'tx_hash' => $txHash,
                'from_address' => $wallet->address,
                'to_address' => '0x0000000000000000000000000000000000000000',
                'amount' => $amountInWei,
                'type' => 'burn',
                'status' => 'pending'
            ]);
            
            return response()->json([
                'success' => true,
                'data' => [
                    'tx_hash' => $txHash,
                    'message' => '토큰 소각이 시작되었습니다.'
                ]
            ]);
            
        } catch (\Exception $e) {
            return response()->json([
                'success' => false,
                'message' => '소각 실패: ' . $e->getMessage()
            ], 500);
        }
    }
    
    /**
     * 트랜잭션 상태 조회
     */
    public function transactionStatus($txHash)
    {
        try {
            $transaction = Transaction::where('tx_hash', $txHash)->first();
            
            if (!$transaction) {
                return response()->json([
                    'success' => false,
                    'message' => '트랜잭션을 찾을 수 없습니다.'
                ], 404);
            }
            
            // 블록체인에서 최신 상태 확인
            $receipt = $this->blockchain->getTransactionReceipt($txHash);
            
            if ($receipt && $receipt->status) {
                $transaction->update([
                    'status' => 'confirmed',
                    'block_number' => hexdec($receipt->blockNumber)
                ]);
            }
            
            return response()->json([
                'success' => true,
                'data' => [
                    'tx_hash' => $transaction->tx_hash,
                    'status' => $transaction->status,
                    'block_number' => $transaction->block_number,
                    'from' => $transaction->from_address,
                    'to' => $transaction->to_address,
                    'amount' => number_format($transaction->amount / 1e18, 4),
                    'type' => $transaction->type,
                    'created_at' => $transaction->created_at
                ]
            ]);
            
        } catch (\Exception $e) {
            return response()->json([
                'success' => false,
                'message' => '조회 실패: ' . $e->getMessage()
            ], 500);
        }
    }
    
    /**
     * 사용자 트랜잭션 내역
     */
    public function history(Request $request)
    {
        $user = $request->user();
        
        $transactions = Transaction::where('user_id', $user->id)
            ->orderBy('created_at', 'desc')
            ->paginate(20);
        
        return response()->json([
            'success' => true,
            'data' => $transactions
        ]);
    }
    
    /**
     * 토큰 통계
     */
    public function statistics()
    {
        try {
            $totalSupply = $this->blockchain->totalSupply();
            
            $stats = [
                'total_supply' => number_format($totalSupply / 1e18, 2),
                'total_holders' => Wallet::distinct('address')->count(),
                'total_transactions' => Transaction::count(),
                'pending_transactions' => Transaction::pending()->count(),
                'confirmed_transactions' => Transaction::confirmed()->count()
            ];
            
            return response()->json([
                'success' => true,
                'data' => $stats
            ]);
            
        } catch (\Exception $e) {
            return response()->json([
                'success' => false,
                'message' => '통계 조회 실패: ' . $e->getMessage()
            ], 500);
        }
    }
}

🛣️ API 라우트 설정

routes/api.php에 라우트를 추가해:

<?php

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

Route::middleware('auth:sanctum')->group(function () {
    // 토큰 잔액 조회
    Route::get('/token/balance', [TokenController::class, 'balance']);
    
    // 토큰 전송
    Route::post('/token/transfer', [TokenController::class, 'transfer']);
    
    // 토큰 소각
    Route::post('/token/burn', [TokenController::class, 'burn']);
    
    // 트랜잭션 내역
    Route::get('/token/history', [TokenController::class, 'history']);
    
    // 트랜잭션 상태 조회
    Route::get('/token/transaction/{txHash}', [TokenController::class, 'transactionStatus']);
    
    // 토큰 통계
    Route::get('/token/statistics', [TokenController::class, 'statistics']);
    
    // 관리자 전용
    Route::middleware('admin')->group(function () {
        Route::post('/token/mint', [TokenController::class, 'mint']);
    });
});

📋 Job 클래스 생성

# Job 생성
php artisan make:job CheckTransactionStatus

app/Jobs/CheckTransactionStatus.php:

<?php

namespace App\Jobs;

use App\Models\Transaction;
use App\Services\BlockchainService;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;

class CheckTransactionStatus implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
    
    protected $transaction;
    public $tries = 10;  // 최대 재시도 횟수
    public $backoff = 30;  // 재시도 간격 (초)
    
    public function __construct(Transaction $transaction)
    {
        $this->transaction = $transaction;
    }
    
    public function handle(BlockchainService $blockchain)
    {
        try {
            // 이미 확인된 트랜잭션은 스킵
            if ($this->transaction->status !== 'pending') {
                return;
            }
            
            // 블록체인에서 영수증 조회
            $receipt = $blockchain->getTransactionReceipt($this->transaction->tx_hash);
            
            if ($receipt) {
                // 트랜잭션 성공
                if ($receipt->status === '0x1') {
                    $this->transaction->update([
                        'status' => 'confirmed',
                        'block_number' => hexdec($receipt->blockNumber)
                    ]);
                    
                    // 사용자에게 알림 전송 (옵션)
                    // event(new TransactionConfirmed($this->transaction));
                }
                // 트랜잭션 실패
                else {
                    $this->transaction->update([
                        'status' => 'failed',
                        'error_message' => 'Transaction reverted'
                    ]);
                }
            } else {
                // 아직 마이닝되지 않음 - 재시도
                $this->release(30);
            }
            
        } catch (\Exception $e) {
            // 에러 로깅
            \Log::error('Transaction status check failed: ' . $e->getMessage(), [
                'transaction_id' => $this->transaction->id,
                'tx_hash' => $this->transaction->tx_hash
            ]);
            
            // 재시도
            if ($this->attempts() < $this->tries) {
                $this->release(60);
            } else {
                // 최대 재시도 초과
                $this->transaction->update([
                    'status' => 'failed',
                    'error_message' => 'Max retry attempts exceeded'
                ]);
            }
        }
    }
}

⏰ 스케줄러 설정

주기적으로 pending 상태인 트랜잭션들을 체크하는 스케줄러를 만들어:

app/Console/Kernel.php:

<?php

namespace App\Console;

use Illuminate\Console\Scheduling\Schedule;
use Illuminate\Foundation\Console\Kernel as ConsoleKernel;
use App\Models\Transaction;
use App\Jobs\CheckTransactionStatus;

class Kernel extends ConsoleKernel
{
    protected function schedule(Schedule $schedule)
    {
        // 1분마다 pending 트랜잭션 체크
        $schedule->call(function () {
            $pendingTransactions = Transaction::where('status', 'pending')
                ->where('created_at', '>', now()->subHours(24))
                ->get();
            
            foreach ($pendingTransactions as $transaction) {
                CheckTransactionStatus::dispatch($transaction);
            }
        })->everyMinute();
        
        // 24시간 이상 pending인 트랜잭션은 실패 처리
        $schedule->call(function () {
            Transaction::where('status', 'pending')
                ->where('created_at', '<', now()->subHours(24))
                ->update([
                    'status' => 'failed',
                    'error_message' => 'Transaction timeout'
                ]);
        })->hourly();
    }
}

스케줄러를 실행하려면 cron에 등록해야 해:

# crontab -e
* * * * * cd /path-to-your-project && php artisan schedule:run >> /dev/null 2>&1

🚀 큐 워커 실행

큐를 사용하려면 워커를 실행해야 해:

# 개발 환경
php artisan queue:work

# 프로덕션 환경 (Supervisor 사용 권장)
php artisan queue:work --daemon --tries=3 --timeout=90

프로덕션에서는 Supervisor를 사용해서 워커를 관리하는 게 좋아:

# /etc/supervisor/conf.d/laravel-worker.conf
[program:laravel-worker]
process_name=%(program_name)s_%(process_num)02d
command=php /path-to-your-project/artisan queue:work --sleep=3 --tries=3
autostart=true
autorestart=true
user=www-data
numprocs=4
redirect_stderr=true
stdout_logfile=/path-to-your-project/storage/logs/worker.log

📦 Vue.js 설치

# Laravel Mix 사용
npm install vue@next vue-loader@next

# 또는 Vite 사용 (Laravel 9+)
npm install vue@next @vitejs/plugin-vue

💰 토큰 대시보드 컴포넌트

resources/js/components/TokenDashboard.vue:

<template>
  <div class="token-dashboard">
    <div class="dashboard-header">
      <h2>🪙 내 토큰 지갑</h2>
      <button @click="refreshBalance" class="refresh-btn">
        🔄 새로고침
      </button>
    </div>
    
    <div class="balance-card">
      <div class="balance-label">보유 토큰</div>
      <div class="balance-amount">
        {{ formattedBalance }} JNT
      </div>
      <div class="wallet-address">
        {{ shortenAddress(walletAddress) }}
      </div>
    </div>
    
    <div class="action-cards">
      <div class="action-card">
        <h3>💸 토큰 전송</h3>
        <form @submit.prevent="sendTokens">
          <input
            v-model="transferForm.toAddress"
            type="text"
            placeholder="받는 주소 (0x...)"
            required
          />
          <input
            v-model.number="transferForm.amount"
            type="number"
            step="0.0001"
            placeholder="수량"
            required
          />
          <button type="submit" :disabled="sending">
            {{ sending ? '전송 중...' : '전송하기' }}
          </button>
        </form>
      </div>
      
      <div class="action-card">
        <h3>🔥 토큰 소각</h3>
        <form @submit.prevent="burnTokens">
          <input
            v-model.number="burnAmount"
            type="number"
            step="0.0001"
            placeholder="소각할 수량"
            required
          />
          <button type="submit" :disabled="burning">
            {{ burning ? '소각 중...' : '소각하기' }}
          </button>
        </form>
      </div>
    </div>
    
    <div class="transaction-history">
      <h3>📜 거래 내역</h3>
      <div v-if="transactions.length === 0" class="no-transactions">
        아직 거래 내역이 없습니다.
      </div>
      <div v-else class="transaction-list">
        <div
          v-for="tx in transactions"
          :key="tx.id"
          class="transaction-item"
          :class="'status-' + tx.status"
        >
          <div class="tx-type">
            {{ getTypeEmoji(tx.type) }} {{ getTypeLabel(tx.type) }}
          </div>
          <div class="tx-details">
            <div>수량: {{ tx.amount }} JNT</div>
            <div>상태: {{ getStatusLabel(tx.status) }}</div>
            <div class="tx-hash">
              <a :href="getEtherscanUrl(tx.tx_hash)" target="_blank">
                {{ shortenHash(tx.tx_hash) }}
              </a>
            </div>
          </div>
          <div class="tx-time">
            {{ formatTime(tx.created_at) }}
          </div>
        </div>
      </div>
    </div>
  </div>
</template>

<script>
import axios from 'axios';

export default {
  name: 'TokenDashboard',
  
  data() {
    return {
      walletAddress: '',
      balance: '0',
      transactions: [],
      transferForm: {
        toAddress: '',
        amount: 0
      },
      burnAmount: 0,
      sending: false,
      burning: false
    };
  },
  
  computed: {
    formattedBalance() {
      return parseFloat(this.balance).toLocaleString('ko-KR', {
        minimumFractionDigits: 4,
        maximumFractionDigits: 4
      });
    }
  },
  
  mounted() {
    this.loadWalletInfo();
    this.loadTransactions();
    
    // 30초마다 자동 새로고침
    setInterval(() => {
      this.refreshBalance();
      this.loadTransactions();
    }, 30000);
  },
  
  methods: {
    async loadWalletInfo() {
      try {
        const response = await axios.get('/api/user/wallet');
        this.walletAddress = response.data.address;
        await this.refreshBalance();
      } catch (error) {
        console.error('지갑 정보 로드 실패:', error);
        this.$toast.error('지갑 정보를 불러올 수 없습니다.');
      }
    },
    
    async refreshBalance() {
      try {
        const response = await axios.get('/api/token/balance', {
          params: { address: this.walletAddress }
        });
        this.balance = response.data.data.formatted_balance;
      } catch (error) {
        console.error('잔액 조회 실패:', error);
      }
    },
    
    async loadTransactions() {
      try {
        const response = await axios.get('/api/token/history');
        this.transactions = response.data.data.data;
      } catch (error) {
        console.error('거래 내역 로드 실패:', error);
      }
    },
    
    async sendTokens() {
      if (!this.validateAddress(this.transferForm.toAddress)) {
        this.$toast.error('올바른 주소를 입력해주세요.');
        return;
      }
      
      this.sending = true;
      
      try {
        const response = await axios.post('/api/token/transfer', this.transferForm);
        
        this.$toast.success('전송이 시작되었습니다!');
        this.transferForm.toAddress = '';
        this.transferForm.amount = 0;
        
        // 트랜잭션 목록 새로고침
        setTimeout(() => {
          this.loadTransactions();
        }, 2000);
        
      } catch (error) {
        this.$toast.error(error.response?.data?.message || '전송 실패');
      } finally {
        this.sending = false;
      }
    },
    
    async burnTokens() {
      if (!confirm(`${this.burnAmount} JNT를 소각하시겠습니까? 이 작업은 되돌릴 수 없습니다.`)) {
        return;
      }
      
      this.burning = true;
      
      try {
        await axios.post('/api/token/burn', {
          amount: this.burnAmount
        });
        
        this.$toast.success('토큰 소각이 시작되었습니다!');
        this.burnAmount = 0;
        
        setTimeout(() => {
          this.loadTransactions();
          this.refreshBalance();
        }, 2000);
        
      } catch (error) {
        this.$toast.error(error.response?.data?.message || '소각 실패');
      } finally {
        this.burning = false;
      }
    },
    
    validateAddress(address) {
      return /^0x[a-fA-F0-9]{40}$/.test(address);
    },
    
    shortenAddress(address) {
      if (!address) return '';
      return `${address.slice(0, 6)}...${address.slice(-4)}`;
    },
    
    shortenHash(hash) {
      return `${hash.slice(0, 10)}...${hash.slice(-8)}`;
    },
    
    getTypeEmoji(type) {
      const emojis = {
        transfer: '💸',
        mint: '🎁',
        burn: '🔥'
      };
      return emojis[type] || '📝';
    },
    
    getTypeLabel(type) {
      const labels = {
        transfer: '전송',
        mint: '발행',
        burn: '소각'
      };
      return labels[type] || type;
    },
    
    getStatusLabel(status) {
      const labels = {
        pending: '⏳ 대기중',
        confirmed: '✅ 완료',
        failed: '❌ 실패'
      };
      return labels[status] || status;
    },
    
    getEtherscanUrl(txHash) {
      // 테스트넷이면 rinkeby, 메인넷이면 etherscan.io
      return `https://rinkeby.etherscan.io/tx/${txHash}`;
    },
    
    formatTime(timestamp) {
      const date = new Date(timestamp);
      const now = new Date();
      const diff = now - date;
      
      const minutes = Math.floor(diff / 60000);
      const hours = Math.floor(diff / 3600000);
      const days = Math.floor(diff / 86400000);
      
      if (minutes < 1) return '방금 전';
      if (minutes < 60) return `${minutes}분 전`;
      if (hours < 24) return `${hours}시간 전`;
      return `${days}일 전`;
    }
  }
};
</script>

<style scoped>
.token-dashboard {
  max-width: 1000px;
  margin: 0 auto;
  padding: 20px;
}

.dashboard-header {
  display: flex;
  justify-content: space-between;
  align-items: center;
  margin-bottom: 30px;
}

.refresh-btn {
  background: #667eea;
  color: white;
  border: none;
  padding: 10px 20px;
  border-radius: 8px;
  cursor: pointer;
  font-size: 14px;
}

.balance-card {
  background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
  color: white;
  padding: 30px;
  border-radius: 16px;
  text-align: center;
  margin-bottom: 30px;
  box-shadow: 0 8px 20px rgba(102, 126, 234, 0.3);
}

.balance-label {
  font-size: 16px;
  opacity: 0.9;
  margin-bottom: 10px;
}

.balance-amount {
  font-size: 48px;
  font-weight: bold;
  margin-bottom: 10px;
}

.wallet-address {
  font-size: 14px;
  opacity: 0.8;
  font-family: monospace;
}

.action-cards {
  display: grid;
  grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
  gap: 20px;
  margin-bottom: 30px;
}

.action-card {
  background: white;
  border: 2px solid #e0e0e0;
  border-radius: 12px;
  padding: 20px;
}

.action-card h3 {
  margin-top: 0;
  color: #2d3436;
}

.action-card input {
  width: 100%;
  padding: 12px;
  margin-bottom: 10px;
  border: 1px solid #ddd;
  border-radius: 8px;
  font-size: 14px;
}

.action-card button {
  width: 100%;
  padding: 12px;
  background: #667eea;
  color: white;
  border: none;
  border-radius: 8px;
  cursor: pointer;
  font-size: 16px;
  font-weight: 600;
}

.action-card button:disabled {
  background: #ccc;
  cursor: not-allowed;
}

.transaction-history {
  background: white;
  border-radius: 12px;
  padding: 20px;
}

.transaction-item {
  display: flex;
  justify-content: space-between;
  align-items: center;
  padding: 15px;
  border-bottom: 1px solid #f0f0f0;
}

.transaction-item:last-child {
  border-bottom: none;
}

.status-pending {
  background: #fff3e0;
}

.status-confirmed {
  background: #e8f5e9;
}

.status-failed {
  background: #ffebee;
}

.tx-hash a {
  color: #667eea;
  text-decoration: none;
  font-family: monospace;
  font-size: 12px;
}

.no-transactions {
  text-align: center;
  padding: 40px;
  color: #999;
}
</style>

와! 이제 완전히 작동하는 토큰 대시보드가 생겼어! 사용자는 이 인터페이스를 통해 토큰을 전송하고, 소각하고, 거래 내역을 확인할 수 있어. 🎉

🧪 단위 테스트 작성

스마트 컨트랙트 테스트 (test/MyToken.test.js):

const MyToken = artifacts.require("MyToken");

contract("MyToken", accounts => {
  let token;
  const owner = accounts[0];
  const user1 = accounts[1];
  const user2 = accounts[2];
  
  beforeEach(async () => {
    token = await MyToken.new(
      "Test Token",
      "TEST",
      18,
      1000000,
      10000000
    );
  });
  
  describe("배포 테스트", () => {
    it("올바른 이름과 심볼을 가져야 함", async () => {
      const name = await token.name();
      const symbol = await token.symbol();
      
      assert.equal(name, "Test Token");
      assert.equal(symbol, "TEST");
    });
    
    it("초기 공급량이 소유자에게 할당되어야 함", async () => {
      const balance = await token.balanceOf(owner);
      const expected = web3.utils.toBN("1000000000000000000000000"); // 1M tokens
      
      assert.equal(balance.toString(), expected.toString());
    });
  });
  
  describe("전송 테스트", () => {
    it("토큰을 전송할 수 있어야 함", async () => {
      const amount = web3.utils.toWei("100", "ether");
      
      await token.transfer(user1, amount, { from: owner });
      
      const balance = await token.balanceOf(user1);
      assert.equal(balance.toString(), amount);
    });
    
    it("잔액보다 많은 금액은 전송할 수 없어야 함", async () => {
      const amount = web3.utils.toWei("2000000", "ether");
      
      try {
        await token.transfer(user1, amount, { from: owner });
        assert.fail("예외가 발생해야 함");
      } catch (error) {
        assert.include(error.message, "revert");
      }
    });
  });
  
  describe("발행 테스트", () => {
    it("소유자는 토큰을 발행할 수 있어야 함", async () => {
      const amount = web3.utils.toWei("1000", "ether");
      
      await token.mint(user1, amount, { from: owner });
      
      const balance = await token.balanceOf(user1);
      assert.equal(balance.toString(), amount);
    });
    
    it("소유자가 아니면 발행할 수 없어야 함", async () => {
      const amount = web3.utils.toWei("1000", "ether");
      
      try {
        await token.mint(user2, amount, { from: user1 });
        assert.fail("예외가 발생해야 함");
      } catch (error) {
        assert.include(error.message, "Ownable");
      }
    });
    
    it("최대 발행량을 초과할 수 없어야 함", async () => {
      const amount = web3.utils.toWei("20000000", "ether");
      
      try {
        await token.mint(user1, amount, { from: owner });
        assert.fail("예외가 발생해야 함");
      } catch (error) {
        assert.include(error.message, "Cap exceeded");
      }
    });
  });
  
  describe("소각 테스트", () => {
    it("토큰을 소각할 수 있어야 함", async () => {
      const initialBalance = await token.balanceOf(owner);
      const burnAmount = web3.utils.toWei("1000", "ether");
      
      await token.burn(burnAmount, { from: owner });
      
      const newBalance = await token.balanceOf(owner);
      const expected = initialBalance.sub(web3.utils.toBN(burnAmount));
      
      assert.equal(newBalance.toString(), expected.toString());
    });
  });
});

테스트 실행:

# 모든 테스트 실행
truffle test

# 특정 파일만 테스트
truffle test test/MyToken.test.js

# 커버리지 확인
npm install --save-dev solidity-coverage
truffle run coverage

🌐 테스트넷 배포

Rinkeby 테스트넷에 배포해보자:

# HDWalletProvider 설치
npm install @truffle/hdwallet-provider

# .env 파일에 추가
MNEMONIC="your twelve word mnemonic here"
INFURA_KEY="your-infura-project-id"

truffle-config.js 수정:

require('dotenv').config();
const HDWalletProvider = require('@truffle/hdwallet-provider');

module.exports = {
  networks: {
    rinkeby: {
      provider: () => new HDWalletProvider(
        process.env.MNEMONIC,
        `https://rinkeby.infura.io/v3/${process.env.INFURA_KEY}`
      ),
      network_id: 4,
      gas: 5500000,
      confirmations: 2,
      timeoutBlocks: 200,
      skipDryRun: true
    }
  }
};

배포 실행:

# Rinkeby 테스트넷에 배포
truffle migrate --network rinkeby

# 배포 후 컨트랙트 주소를 .env에 저장
CONTRACT_ADDRESS=0x...

테스트 이더 받기:

• 🔗 Rinkeby Faucet: https://faucet.rinkeby.io/
• 🔗 Goerli Faucet: https://goerlifaucet.com/

🔐 보안 강화 코드

ReentrancyGuard 적용:

import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

contract MyToken is ERC20, Ownable, ReentrancyGuard {
    
    function transfer(address to, uint256 amount) 
        public 
        override 
        nonReentrant 
        returns (bool) 
    {
        return super.transfer(to, amount);
    }
}

Pausable 기능 추가 (긴급 중지):

import "@openzeppelin/contracts/security/Pausable.sol";

contract MyToken is ERC20, Ownable, Pausable {
    
    function pause() public onlyOwner {
        _pause();
    }
    
    function unpause() public onlyOwner {
        _unpause();
    }
    
    function transfer(address to, uint256 amount) 
        public 
        override 
        whenNotPaused 
        returns (bool) 
    {
        return super.transfer(to, amount);
    }
}

Rate Limiting (전송 제한):

contract MyToken is ERC20, Ownable {
    mapping(address => uint256) private _lastTransferTime;
    uint256 private constant TRANSFER_COOLDOWN = 1 minutes;
    
    function transfer(address to, uint256 amount) 
        public 
        override 
        returns (bool) 
    {
        require(
            block.timestamp >= _lastTransferTime[msg.sender] + TRANSFER_COOLDOWN,
            "Transfer cooldown not met"
        );
        
        _lastTransferTime[msg.sender] = block.timestamp;
        return super.transfer(to, amount);
    }
}

📉 대시보드 구현

관리자용 통계 API:

<?php

namespace App\Http\Controllers\Admin;

use App\Http\Controllers\Controller;
use App\Models\Transaction;
use App\Models\Wallet;
use App\Services\BlockchainService;
use Illuminate\Support\Facades\DB;

class AnalyticsController extends Controller
{
    public function dashboard(BlockchainService $blockchain)
    {
        $stats = [
            // 토큰 통계
            'total_supply' => $blockchain->totalSupply(),
            'total_holders' => Wallet::distinct('address')->count(),
            
            // 트랜잭션 통계
            'total_transactions' => Transaction::count(),
            'today_transactions' => Transaction::whereDate('created_at', today())->count(),
            'pending_transactions' => Transaction::pending()->count(),
            
            // 일별 거래량
            'daily_volume' => Transaction::where('created_at', '>=', now()->subDays(30))
                ->where('status', 'confirmed')
                ->groupBy(DB::raw('DATE(created_at)'))
                ->select(
                    DB::raw('DATE(created_at) as date'),
                    DB::raw('SUM(amount) as volume'),
                    DB::raw('COUNT(*) as count')
                )
                ->get(),
            
            // 상위 홀더
            'top_holders' => $this->getTopHolders($blockchain, 10),
            
            // 최근 거래
            'recent_transactions' => Transaction::with('user')
                ->orderBy('created_at', 'desc')
                ->limit(20)
                ->get()
        ];
        
        return response()->json([
            'success' => true,
            'data' => $stats
        ]);
    }
    
    private function getTopHolders(BlockchainService $blockchain, $limit)
    {
        $wallets = Wallet::all();
        $holders = [];
        
        foreach ($wallets as $wallet) {
            $balance = $blockchain->getBalance($wallet->address);
            $holders[] = [
                'address' => $wallet->address,
                'balance' => $balance,
                'user_id' => $wallet->user_id
            ];
        }
        
        usort($holders, function($a, $b) {
            return bccomp($b['balance'], $a['balance']);
        });
        
        return array_slice($holders, 0, $limit);
    }
}

🔔 알림 시스템

중요한 이벤트 발생 시 알림을 보내는 시스템:

<?php

namespace App\Listeners;

use App\Events\LargeTransactionDetected;
use App\Notifications\LargeTransactionAlert;
use Illuminate\Support\Facades\Notification;

class NotifyLargeTransaction
{
    public function handle(LargeTransactionDetected $event)
    {
        $transaction = $event->transaction;
        
        // 관리자에게 알림
        $admins = User::where('is_admin', true)->get();
        
        Notification::send($admins, new LargeTransactionAlert($transaction));
        
        // 슬랙 알림
        \Log::channel('slack')->warning('Large transaction detected', [
            'tx_hash' => $transaction->tx_hash,
            'amount' => $transaction->amount,
            'from' => $transaction->from_address,
            'to' => $transaction->to_address
        ]);
    }
}

🐛 디버깅 팁

1. 트랜잭션 실패 원인 파악

// 트랜잭션 영수증에서 에러 확인
const receipt = await web3.eth.getTransactionReceipt(txHash);
if (receipt.status === false) {
    // 실패한 트랜잭션
    // Etherscan에서 상세 에러 확인
}

2. 이벤트 로그 활용

// 스마트 컨트랙트에서 이벤트 발생
emit Transfer(from, to, amount);

// 라라벨에서 이벤트 리스닝
$events = $contract->getPastEvents('Transfer', [
    'fromBlock' => $fromBlock,
    'toBlock' => 'latest'
]);

3. 로컬 블록체인 상태 확인

# Ganache CLI로 계정 확인
ganache-cli --accounts 10 --defaultBalanceEther 100

# 블록 높이 확인
truffle console
> web3.eth.getBlockNumber()

📊 캐싱 구현

<?php

namespace App\Services;

use Illuminate\Support\Facades\Cache;

class CachedBlockchainService extends BlockchainService
{
    public function getBalance($address)
    {
        $cacheKey = "balance:{$address}";
        
        return Cache::remember($cacheKey, 60, function () use ($address) {
            return parent::getBalance($address);
        });
    }
    
    public function totalSupply()
    {
        return Cache::remember('total_supply', 300, function () {
            return parent::totalSupply();
        });
    }
    
    public function invalidateBalanceCache($address)
    {
        Cache::forget("balance:{$address}");
    }
}