1️⃣ 라라벨 설치 및 설정

라라벨은 Composer를 통해 설치할 수 있어. 최신 버전(Laravel 10 이상)을 사용하는 걸 추천해.

composer create-project laravel/laravel blockchain-payment
cd blockchain-payment
php artisan serve

이렇게 하면 기본 라라벨 프로젝트가 생성돼. http://localhost:8000에 접속하면 라라벨 웰컴 페이지가 보일 거야.

2️⃣ 필수 패키지 설치

블록체인과 통신하려면 Web3 관련 패키지가 필요해. PHP에서는 web3.php 라이브러리를 많이 써.

composer require sc0vu/web3.php
composer require guzzlehttp/guzzle
composer require predis/predis

web3.php: 이더리움 노드와 통신
guzzle: HTTP 클라이언트 (API 호출용)
predis: Redis 캐싱 (트랜잭션 상태 추적용)

3️⃣ 솔리디티 개발 환경

스마트 컨트랙트 개발을 위해서는 별도의 툴체인이 필요해. 요즘은 Hardhat이나 Foundry를 많이 쓰는데, 나는 Hardhat을 추천해. 초보자도 쓰기 쉽거든!

mkdir smart-contracts
cd smart-contracts
npm init -y
npm install --save-dev hardhat @nomicfoundation/hardhat-toolbox
npx hardhat init

Hardhat 초기화 시 "Create a JavaScript project"를 선택하면 돼. 그러면 기본 프로젝트 구조가 생성돼.

4️⃣ 테스트넷 설정

실제 이더리움 메인넷에서 테스트하면 진짜 돈이 들어가니까, 테스트넷을 사용해야 해. Sepolia나 Goerli 같은 테스트넷에서 개발하자!

Infura나 Alchemy에 가입하면 무료로 API 키를 받을 수 있어. 이걸 라라벨 .env 파일에 저장해두자.

ETHEREUM_NETWORK=sepolia
INFURA_API_KEY=your_infura_key_here
CONTRACT_ADDRESS=
WALLET_PRIVATE_KEY=your_test_wallet_private_key

🎨 기본 결제 컨트랙트 구조

먼저 간단한 결제 컨트랙트부터 시작해볼게. 이 컨트랙트는 ETH를 받고, 판매자에게 전달하고, 플랫폼 수수료를 떼는 기능을 가지고 있어.

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

contract PaymentContract {
    address public owner;
    uint256 public platformFeePercent = 3; // 3% 수수료
    
    struct Payment {
        address buyer;
        address seller;
        uint256 amount;
        uint256 timestamp;
        bool completed;
        bool refunded;
    }
    
    mapping(uint256 => Payment) public payments;
    uint256 public paymentCounter;
    
    event PaymentCreated(
        uint256 indexed paymentId,
        address indexed buyer,
        address indexed seller,
        uint256 amount
    );
    
    event PaymentCompleted(uint256 indexed paymentId);
    event PaymentRefunded(uint256 indexed paymentId);
    
    modifier onlyOwner() {
        require(msg.sender == owner, "Only owner can call this");
        _;
    }
    
    constructor() {
        owner = msg.sender;
    }
    
    function createPayment(address _seller) external payable returns (uint256) {
        require(msg.value > 0, "Payment amount must be greater than 0");
        require(_seller != address(0), "Invalid seller address");
        
        uint256 paymentId = paymentCounter++;
        
        payments[paymentId] = Payment({
            buyer: msg.sender,
            seller: _seller,
            amount: msg.value,
            timestamp: block.timestamp,
            completed: false,
            refunded: false
        });
        
        emit PaymentCreated(paymentId, msg.sender, _seller, msg.value);
        
        return paymentId;
    }
    
    function completePayment(uint256 _paymentId) external {
        Payment storage payment = payments[_paymentId];
        
        require(!payment.completed, "Payment already completed");
        require(!payment.refunded, "Payment was refunded");
        require(
            msg.sender == payment.seller || msg.sender == owner,
            "Only seller or owner can complete"
        );
        
        uint256 platformFee = (payment.amount * platformFeePercent) / 100;
        uint256 sellerAmount = payment.amount - platformFee;
        
        payment.completed = true;
        
        payable(payment.seller).transfer(sellerAmount);
        payable(owner).transfer(platformFee);
        
        emit PaymentCompleted(_paymentId);
    }
    
    function refundPayment(uint256 _paymentId) external onlyOwner {
        Payment storage payment = payments[_paymentId];
        
        require(!payment.completed, "Cannot refund completed payment");
        require(!payment.refunded, "Payment already refunded");
        
        payment.refunded = true;
        
        payable(payment.buyer).transfer(payment.amount);
        
        emit PaymentRefunded(_paymentId);
    }
    
    function updatePlatformFee(uint256 _newFee) external onlyOwner {
        require(_newFee <= 10, "Fee cannot exceed 10%");
        platformFeePercent = _newFee;
    }
    
    function getPayment(uint256 _paymentId) external view returns (
        address buyer,
        address seller,
        uint256 amount,
        uint256 timestamp,
        bool completed,
        bool refunded
    ) {
        Payment memory payment = payments[_paymentId];
        return (
            payment.buyer,
            payment.seller,
            payment.amount,
            payment.timestamp,
            payment.completed,
            payment.refunded
        );
    }
}

이 컨트랙트의 핵심 기능을 설명하면:

1. createPayment(): 구매자가 ETH를 보내면서 결제를 생성해. 이때 판매자 주소를 지정하고, 돈은 컨트랙트에 일단 보관돼. 에스크로 방식이지!

2. completePayment(): 거래가 완료되면 판매자나 플랫폼 관리자가 이 함수를 호출해. 그러면 수수료를 제외한 금액이 판매자에게 전송돼.

3. refundPayment(): 문제가 생기면 관리자가 환불을 처리할 수 있어. 구매자에게 전액 반환!

4. 이벤트(Event): 모든 중요한 액션마다 이벤트를 발생시켜. 라라벨에서 이걸 감지해서 DB에 기록할 거야.

🚀 ERC-20 토큰 결제 지원

ETH만 받는 게 아니라 USDT, USDC 같은 스테이블코인도 받고 싶다면? ERC-20 토큰을 지원하는 컨트랙트를 만들어야 해!

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

interface IERC20 {
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    function transfer(address recipient, uint256 amount) external returns (bool);
}

contract TokenPaymentContract {
    address public owner;
    uint256 public platformFeePercent = 3;
    
    struct TokenPayment {
        address buyer;
        address seller;
        address tokenAddress;
        uint256 amount;
        uint256 timestamp;
        bool completed;
        bool refunded;
    }
    
    mapping(uint256 => TokenPayment) public payments;
    uint256 public paymentCounter;
    
    event TokenPaymentCreated(
        uint256 indexed paymentId,
        address indexed buyer,
        address indexed seller,
        address tokenAddress,
        uint256 amount
    );
    
    event TokenPaymentCompleted(uint256 indexed paymentId);
    event TokenPaymentRefunded(uint256 indexed paymentId);
    
    modifier onlyOwner() {
        require(msg.sender == owner, "Only owner");
        _;
    }
    
    constructor() {
        owner = msg.sender;
    }
    
    function createTokenPayment(
        address _seller,
        address _tokenAddress,
        uint256 _amount
    ) external returns (uint256) {
        require(_amount > 0, "Amount must be greater than 0");
        require(_seller != address(0), "Invalid seller");
        require(_tokenAddress != address(0), "Invalid token");
        
        IERC20 token = IERC20(_tokenAddress);
        require(
            token.transferFrom(msg.sender, address(this), _amount),
            "Token transfer failed"
        );
        
        uint256 paymentId = paymentCounter++;
        
        payments[paymentId] = TokenPayment({
            buyer: msg.sender,
            seller: _seller,
            tokenAddress: _tokenAddress,
            amount: _amount,
            timestamp: block.timestamp,
            completed: false,
            refunded: false
        });
        
        emit TokenPaymentCreated(paymentId, msg.sender, _seller, _tokenAddress, _amount);
        
        return paymentId;
    }
    
    function completeTokenPayment(uint256 _paymentId) external {
        TokenPayment storage payment = payments[_paymentId];
        
        require(!payment.completed, "Already completed");
        require(!payment.refunded, "Was refunded");
        require(
            msg.sender == payment.seller || msg.sender == owner,
            "Unauthorized"
        );
        
        uint256 platformFee = (payment.amount * platformFeePercent) / 100;
        uint256 sellerAmount = payment.amount - platformFee;
        
        payment.completed = true;
        
        IERC20 token = IERC20(payment.tokenAddress);
        require(token.transfer(payment.seller, sellerAmount), "Transfer to seller failed");
        require(token.transfer(owner, platformFee), "Transfer fee failed");
        
        emit TokenPaymentCompleted(_paymentId);
    }
    
    function refundTokenPayment(uint256 _paymentId) external onlyOwner {
        TokenPayment storage payment = payments[_paymentId];
        
        require(!payment.completed, "Cannot refund completed");
        require(!payment.refunded, "Already refunded");
        
        payment.refunded = true;
        
        IERC20 token = IERC20(payment.tokenAddress);
        require(token.transfer(payment.buyer, payment.amount), "Refund failed");
        
        emit TokenPaymentRefunded(_paymentId);
    }
}

ERC-20 토큰 결제의 핵심은 transferFrom() 함수야. 사용자가 먼저 컨트랙트에 approve를 해줘야 하고, 그 다음에 컨트랙트가 사용자 지갑에서 토큰을 가져올 수 있어. 이 부분은 프론트엔드에서 처리해야 해!

🔨 컨트랙트 컴파일 및 배포

컨트랙트를 작성했으면 이제 컴파일하고 테스트넷에 배포해야 해.

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

module.exports = {
  solidity: "0.8.20",
  networks: {
    sepolia: {
      url: `https://sepolia.infura.io/v3/${process.env.INFURA_API_KEY}`,
      accounts: [process.env.PRIVATE_KEY]
    }
  },
  etherscan: {
    apiKey: process.env.ETHERSCAN_API_KEY
  }
};

// scripts/deploy.js
const hre = require("hardhat");

async function main() {
  const PaymentContract = await hre.ethers.getContractFactory("PaymentContract");
  const payment = await PaymentContract.deploy();
  
  await payment.waitForDeployment();
  
  const address = await payment.getAddress();
  console.log("PaymentContract deployed to:", address);
  
  // TokenPaymentContract도 배포
  const TokenPaymentContract = await hre.ethers.getContractFactory("TokenPaymentContract");
  const tokenPayment = await TokenPaymentContract.deploy();
  
  await tokenPayment.waitForDeployment();
  
  const tokenAddress = await tokenPayment.getAddress();
  console.log("TokenPaymentContract deployed to:", tokenAddress);
}

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

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

배포가 완료되면 컨트랙트 주소가 출력돼. 이 주소를 라라벨 .env 파일에 저장해둬야 해!

📦 Web3 서비스 클래스 만들기

먼저 블록체인과 통신하는 전용 서비스 클래스를 만들어야 해. 이렇게 하면 코드 재사용성이 높아지고 유지보수가 쉬워져.

<?php

namespace App\Services;

use Web3\Web3;
use Web3\Contract;
use Web3\Utils;
use Illuminate\Support\Facades\Log;

class Web3Service
{
    protected $web3;
    protected $contract;
    protected $contractAddress;
    protected $abi;
    
    public function __construct()
    {
        $providerUrl = 'https://sepolia.infura.io/v3/' . env('INFURA_API_KEY');
        $this->web3 = new Web3($providerUrl);
        $this->contractAddress = env('CONTRACT_ADDRESS');
        
        // ABI는 컴파일 후 생성된 JSON 파일에서 가져와야 해
        $this->abi = json_decode(file_get_contents(storage_path('contracts/PaymentContract.json')), true);
        
        $this->contract = new Contract($providerUrl, $this->abi);
    }
    
    public function createPayment($sellerAddress, $amount)
    {
        try {
            $amountInWei = Utils::toWei($amount, 'ether');
            
            // 트랜잭션 데이터 생성
            $data = $this->contract->at($this->contractAddress)->getData('createPayment', $sellerAddress);
            
            return [
                'to' => $this->contractAddress,
                'data' => $data,
                'value' => '0x' . dechex($amountInWei->toString())
            ];
            
        } catch (\Exception $e) {
            Log::error('Create payment error: ' . $e->getMessage());
            throw $e;
        }
    }
    
    public function getPaymentDetails($paymentId)
    {
        try {
            $payment = null;
            
            $this->contract->at($this->contractAddress)->call('getPayment', $paymentId, function ($err, $result) use (&$payment) {
                if ($err !== null) {
                    throw new \Exception($err->getMessage());
                }
                $payment = $result;
            });
            
            return [
                'buyer' => $payment[0],
                'seller' => $payment[1],
                'amount' => Utils::fromWei($payment[2], 'ether'),
                'timestamp' => $payment[3],
                'completed' => $payment[4],
                'refunded' => $payment[5]
            ];
            
        } catch (\Exception $e) {
            Log::error('Get payment details error: ' . $e->getMessage());
            throw $e;
        }
    }
    
    public function completePayment($paymentId, $privateKey)
    {
        try {
            // 실제로는 서버에서 직접 트랜잭션을 보내는 건 보안상 위험할 수 있어
            // 대신 서명된 트랜잭션을 프론트엔드에서 받아서 처리하는 게 나아
            
            $data = $this->contract->at($this->contractAddress)->getData('completePayment', $paymentId);
            
            return [
                'to' => $this->contractAddress,
                'data' => $data
            ];
            
        } catch (\Exception $e) {
            Log::error('Complete payment error: ' . $e->getMessage());
            throw $e;
        }
    }
    
    public function listenToPaymentEvents($fromBlock = 'latest')
    {
        try {
            $filter = [
                'fromBlock' => $fromBlock,
                'toBlock' => 'latest',
                'address' => $this->contractAddress,
                'topics' => []
            ];
            
            $this->web3->eth->getLogs($filter, function ($err, $logs) {
                if ($err !== null) {
                    Log::error('Event listening error: ' . $err->getMessage());
                    return;
                }
                
                foreach ($logs as $log) {
                    $this->processEvent($log);
                }
            });
            
        } catch (\Exception $e) {
            Log::error('Listen to events error: ' . $e->getMessage());
            throw $e;
        }
    }
    
    protected function processEvent($log)
    {
        // 이벤트 처리 로직
        // PaymentCreated, PaymentCompleted, PaymentRefunded 등
        Log::info('Blockchain event received', ['log' => $log]);
    }
    
    public function getTransactionReceipt($txHash)
    {
        try {
            $receipt = null;
            
            $this->web3->eth->getTransactionReceipt($txHash, function ($err, $result) use (&$receipt) {
                if ($err !== null) {
                    throw new \Exception($err->getMessage());
                }
                $receipt = $result;
            });
            
            return $receipt;
            
        } catch (\Exception $e) {
            Log::error('Get transaction receipt error: ' . $e->getMessage());
            throw $e;
        }
    }
    
    public function estimateGas($transactionData)
    {
        try {
            $gas = null;
            
            $this->web3->eth->estimateGas($transactionData, function ($err, $result) use (&$gas) {
                if ($err !== null) {
                    throw new \Exception($err->getMessage());
                }
                $gas = $result;
            });
            
            return $gas;
            
        } catch (\Exception $e) {
            Log::error('Estimate gas error: ' . $e->getMessage());
            throw $e;
        }
    }
}

이 서비스 클래스는 블록체인과의 모든 상호작용을 담당해. 주요 기능들을 살펴보면:

createPayment(): 결제 트랜잭션 데이터를 생성해. 실제 전송은 프론트엔드에서 MetaMask를 통해 해.

getPaymentDetails(): 특정 결제의 상세 정보를 블록체인에서 조회해.

listenToPaymentEvents(): 블록체인 이벤트를 감지해서 DB에 동기화할 수 있어.

getTransactionReceipt(): 트랜잭션이 성공했는지 확인해.

estimateGas(): 가스비를 미리 계산해서 사용자에게 보여줄 수 있어.

🗄️ 데이터베이스 모델 설계

블록체인 데이터를 라라벨 DB에도 저장해야 해. 왜냐하면 블록체인 조회는 느리고 비용이 들기 때문이야. 빠른 조회를 위해 DB에 캐싱하는 거지!

<?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('payments', function (Blueprint $table) {
            $table->id();
            $table->unsignedBigInteger('blockchain_payment_id')->nullable();
            $table->foreignId('user_id')->constrained()->onDelete('cascade');
            $table->foreignId('seller_id')->constrained('users')->onDelete('cascade');
            $table->string('buyer_address', 42);
            $table->string('seller_address', 42);
            $table->decimal('amount', 20, 8);
            $table->string('currency', 10)->default('ETH');
            $table->string('token_address', 42)->nullable();
            $table->string('transaction_hash', 66)->nullable();
            $table->enum('status', ['pending', 'processing', 'completed', 'refunded', 'failed'])->default('pending');
            $table->text('description')->nullable();
            $table->timestamp('completed_at')->nullable();
            $table->timestamp('refunded_at')->nullable();
            $table->timestamps();
            
            $table->index('blockchain_payment_id');
            $table->index('transaction_hash');
            $table->index('status');
        });
    }

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

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;

class Payment extends Model
{
    protected $fillable = [
        'blockchain_payment_id',
        'user_id',
        'seller_id',
        'buyer_address',
        'seller_address',
        'amount',
        'currency',
        'token_address',
        'transaction_hash',
        'status',
        'description',
        'completed_at',
        'refunded_at'
    ];
    
    protected $casts = [
        'amount' => 'decimal:8',
        'completed_at' => 'datetime',
        'refunded_at' => 'datetime'
    ];
    
    public function user(): BelongsTo
    {
        return $this->belongsTo(User::class);
    }
    
    public function seller(): BelongsTo
    {
        return $this->belongsTo(User::class, 'seller_id');
    }
    
    public function isPending(): bool
    {
        return $this->status === 'pending';
    }
    
    public function isCompleted(): bool
    {
        return $this->status === 'completed';
    }
    
    public function isRefunded(): bool
    {
        return $this->status === 'refunded';
    }
    
    public function markAsCompleted(): void
    {
        $this->update([
            'status' => 'completed',
            'completed_at' => now()
        ]);
    }
    
    public function markAsRefunded(): void
    {
        $this->update([
            'status' => 'refunded',
            'refunded_at' => now()
        ]);
    }
}

이렇게 하면 블록체인 데이터와 DB 데이터를 동기화할 수 있어. blockchain_payment_id가 블록체인의 결제 ID와 매핑되는 거지!

🎮 컨트롤러 구현

이제 실제 API 엔드포인트를 만들어보자. 프론트엔드에서 호출할 수 있는 REST API야.

<?php

namespace App\Http\Controllers;

use App\Models\Payment;
use App\Services\Web3Service;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;

class PaymentController extends Controller
{
    protected $web3Service;
    
    public function __construct(Web3Service $web3Service)
    {
        $this->web3Service = $web3Service;
    }
    
    public function createPayment(Request $request)
    {
        $validated = $request->validate([
            'seller_id' => 'required|exists:users,id',
            'seller_address' => 'required|string|size:42',
            'amount' => 'required|numeric|min:0.001',
            'currency' => 'required|in:ETH,USDT,USDC',
            'description' => 'nullable|string|max:500'
        ]);
        
        try {
            DB::beginTransaction();
            
            // DB에 결제 레코드 생성
            $payment = Payment::create([
                'user_id' => Auth::id(),
                'seller_id' => $validated['seller_id'],
                'buyer_address' => $request->user()->wallet_address,
                'seller_address' => $validated['seller_address'],
                'amount' => $validated['amount'],
                'currency' => $validated['currency'],
                'status' => 'pending',
                'description' => $validated['description'] ?? null
            ]);
            
            // 블록체인 트랜잭션 데이터 생성
            $txData = $this->web3Service->createPayment(
                $validated['seller_address'],
                $validated['amount']
            );
            
            DB::commit();
            
            return response()->json([
                'success' => true,
                'payment_id' => $payment->id,
                'transaction_data' => $txData,
                'message' => 'Payment created. Please sign the transaction in your wallet.'
            ]);
            
        } catch (\Exception $e) {
            DB::rollBack();
            Log::error('Payment creation failed: ' . $e->getMessage());
            
            return response()->json([
                'success' => false,
                'message' => 'Failed to create payment: ' . $e->getMessage()
            ], 500);
        }
    }
    
    public function confirmPayment(Request $request, $id)
    {
        $validated = $request->validate([
            'transaction_hash' => 'required|string|size:66',
            'blockchain_payment_id' => 'required|integer'
        ]);
        
        try {
            $payment = Payment::findOrFail($id);
            
            if ($payment->user_id !== Auth::id()) {
                return response()->json([
                    'success' => false,
                    'message' => 'Unauthorized'
                ], 403);
            }
            
            // 트랜잭션 영수증 확인
            $receipt = $this->web3Service->getTransactionReceipt($validated['transaction_hash']);
            
            if (!$receipt || !isset($receipt->status) || $receipt->status !== '0x1') {
                return response()->json([
                    'success' => false,
                    'message' => 'Transaction failed or not found'
                ], 400);
            }
            
            // DB 업데이트
            $payment->update([
                'blockchain_payment_id' => $validated['blockchain_payment_id'],
                'transaction_hash' => $validated['transaction_hash'],
                'status' => 'processing'
            ]);
            
            return response()->json([
                'success' => true,
                'message' => 'Payment confirmed successfully'
            ]);
            
        } catch (\Exception $e) {
            Log::error('Payment confirmation failed: ' . $e->getMessage());
            
            return response()->json([
                'success' => false,
                'message' => 'Failed to confirm payment: ' . $e->getMessage()
            ], 500);
        }
    }
    
    public function completePayment(Request $request, $id)
    {
        try {
            $payment = Payment::findOrFail($id);
            
            // 판매자나 관리자만 완료 가능
            if ($payment->seller_id !== Auth::id() && !Auth::user()->isAdmin()) {
                return response()->json([
                    'success' => false,
                    'message' => 'Unauthorized'
                ], 403);
            }
            
            if ($payment->status !== 'processing') {
                return response()->json([
                    'success' => false,
                    'message' => 'Payment is not in processing status'
                ], 400);
            }
            
            // 블록체인에서 완료 트랜잭션 데이터 생성
            $txData = $this->web3Service->completePayment($payment->blockchain_payment_id);
            
            return response()->json([
                'success' => true,
                'transaction_data' => $txData,
                'message' => 'Please sign the completion transaction'
            ]);
            
        } catch (\Exception $e) {
            Log::error('Payment completion failed: ' . $e->getMessage());
            
            return response()->json([
                'success' => false,
                'message' => 'Failed to complete payment: ' . $e->getMessage()
            ], 500);
        }
    }
    
    public function getPaymentDetails($id)
    {
        try {
            $payment = Payment::with(['user', 'seller'])->findOrFail($id);
            
            // 권한 체크
            if ($payment->user_id !== Auth::id() && $payment->seller_id !== Auth::id() && !Auth::user()->isAdmin()) {
                return response()->json([
                    'success' => false,
                    'message' => 'Unauthorized'
                ], 403);
            }
            
            // 블록체인에서 최신 정보 가져오기
            if ($payment->blockchain_payment_id) {
                $blockchainData = $this->web3Service->getPaymentDetails($payment->blockchain_payment_id);
                
                // DB와 블록체인 데이터 동기화
                if ($blockchainData['completed'] && !$payment->isCompleted()) {
                    $payment->markAsCompleted();
                } elseif ($blockchainData['refunded'] && !$payment->isRefunded()) {
                    $payment->markAsRefunded();
                }
            }
            
            return response()->json([
                'success' => true,
                'payment' => $payment
            ]);
            
        } catch (\Exception $e) {
            Log::error('Get payment details failed: ' . $e->getMessage());
            
            return response()->json([
                'success' => false,
                'message' => 'Failed to get payment details: ' . $e->getMessage()
            ], 500);
        }
    }
    
    public function listPayments(Request $request)
    {
        try {
            $query = Payment::with(['user', 'seller'])
                ->where(function($q) {
                    $q->where('user_id', Auth::id())
                      ->orWhere('seller_id', Auth::id());
                });
            
            if ($request->has('status')) {
                $query->where('status', $request->status);
            }
            
            if ($request->has('currency')) {
                $query->where('currency', $request->currency);
            }
            
            $payments = $query->orderBy('created_at', 'desc')
                             ->paginate(20);
            
            return response()->json([
                'success' => true,
                'payments' => $payments
            ]);
            
        } catch (\Exception $e) {
            Log::error('List payments failed: ' . $e->getMessage());
            
            return response()->json([
                'success' => false,
                'message' => 'Failed to list payments: ' . $e->getMessage()
            ], 500);
        }
    }
}

이 컨트롤러의 흐름을 정리하면:

1. createPayment(): DB에 결제 레코드를 만들고, 블록체인 트랜잭션 데이터를 생성해서 프론트엔드로 반환해.

2. confirmPayment(): 프론트엔드에서 트랜잭션을 전송한 후, 트랜잭션 해시를 받아서 영수증을 확인하고 DB를 업데이트해.

3. completePayment(): 판매자가 서비스를 제공한 후 결제를 완료하는 트랜잭션을 생성해.

4. getPaymentDetails(): 블록체인과 DB 데이터를 동기화하면서 최신 정보를 반환해.

5. listPayments(): 사용자의 결제 내역을 조회해.

📨 Job 클래스 생성

트랜잭션 상태를 체크하고 DB를 업데이트하는 Job을 만들어보자.

<?php

namespace App\Jobs;

use App\Models\Payment;
use App\Services\Web3Service;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use Illuminate\Support\Facades\Log;

class CheckTransactionStatus implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
    
    protected $payment;
    public $tries = 5;
    public $backoff = [60, 120, 300, 600, 1200]; // 재시도 간격 (초)
    
    public function __construct(Payment $payment)
    {
        $this->payment = $payment;
    }
    
    public function handle(Web3Service $web3Service)
    {
        try {
            if (!$this->payment->transaction_hash) {
                Log::warning("Payment {$this->payment->id} has no transaction hash");
                return;
            }
            
            // 트랜잭션 영수증 조회
            $receipt = $web3Service->getTransactionReceipt($this->payment->transaction_hash);
            
            if (!$receipt) {
                // 아직 마이닝 안됨, 나중에 다시 시도
                $this->release(30);
                return;
            }
            
            // 트랜잭션 성공 여부 확인
            if ($receipt->status === '0x1') {
                // 성공
                if ($this->payment->status === 'pending') {
                    $this->payment->update(['status' => 'processing']);
                    Log::info("Payment {$this->payment->id} transaction confirmed");
                }
                
                // 블록체인에서 결제 정보 가져오기
                if ($this->payment->blockchain_payment_id) {
                    $blockchainData = $web3Service->getPaymentDetails($this->payment->blockchain_payment_id);
                    
                    // 완료 상태 동기화
                    if ($blockchainData['completed'] && !$this->payment->isCompleted()) {
                        $this->payment->markAsCompleted();
                        Log::info("Payment {$this->payment->id} marked as completed");
                        
                        // 완료 알림 발송
                        event(new \App\Events\PaymentCompleted($this->payment));
                    }
                    
                    // 환불 상태 동기화
                    if ($blockchainData['refunded'] && !$this->payment->isRefunded()) {
                        $this->payment->markAsRefunded();
                        Log::info("Payment {$this->payment->id} marked as refunded");
                        
                        // 환불 알림 발송
                        event(new \App\Events\PaymentRefunded($this->payment));
                    }
                }
            } else {
                // 실패
                $this->payment->update(['status' => 'failed']);
                Log::error("Payment {$this->payment->id} transaction failed");
                
                // 실패 알림 발송
                event(new \App\Events\PaymentFailed($this->payment));
            }
            
        } catch (\Exception $e) {
            Log::error("CheckTransactionStatus job failed for payment {$this->payment->id}: " . $e->getMessage());
            
            if ($this->attempts() >= $this->tries) {
                // 최대 재시도 횟수 초과
                $this->payment->update(['status' => 'failed']);
            } else {
                // 재시도
                $this->release($this->backoff[$this->attempts() - 1] ?? 600);
            }
        }
    }
}

이 Job은 트랜잭션 상태를 주기적으로 체크해서 DB를 업데이트해. 실패하면 자동으로 재시도하고, 최대 5번까지 시도해.

🎪 이벤트 및 리스너 생성

결제 완료나 환불 같은 중요한 이벤트가 발생하면 알림을 보내야 해. 라라벨의 이벤트 시스템을 활용하자!

<?php

namespace App\Events;

use App\Models\Payment;
use Illuminate\Broadcasting\Channel;
use Illuminate\Broadcasting\InteractsWithSockets;
use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
use Illuminate\Foundation\Events\Dispatchable;
use Illuminate\Queue\SerializesModels;

class PaymentCompleted implements ShouldBroadcast
{
    use Dispatchable, InteractsWithSockets, SerializesModels;
    
    public $payment;
    
    public function __construct(Payment $payment)
    {
        $this->payment = $payment;
    }
    
    public function broadcastOn()
    {
        return [
            new Channel('payment.' . $this->payment->id),
            new Channel('user.' . $this->payment->user_id),
            new Channel('user.' . $this->payment->seller_id)
        ];
    }
    
    public function broadcastAs()
    {
        return 'payment.completed';
    }
    
    public function broadcastWith()
    {
        return [
            'payment_id' => $this->payment->id,
            'amount' => $this->payment->amount,
            'currency' => $this->payment->currency,
            'completed_at' => $this->payment->completed_at
        ];
    }
}

<?php

namespace App\Listeners;

use App\Events\PaymentCompleted;
use App\Notifications\PaymentCompletedNotification;
use Illuminate\Support\Facades\Log;

class SendPaymentCompletedNotification
{
    public function handle(PaymentCompleted $event)
    {
        try {
            $payment = $event->payment;
            
            // 구매자에게 알림
            $payment->user->notify(new PaymentCompletedNotification($payment, 'buyer'));
            
            // 판매자에게 알림
            $payment->seller->notify(new PaymentCompletedNotification($payment, 'seller'));
            
            Log::info("Payment completed notifications sent for payment {$payment->id}");
            
        } catch (\Exception $e) {
            Log::error("Failed to send payment completed notification: " . $e->getMessage());
        }
    }
}

이벤트를 사용하면 결제 완료 시 자동으로 이메일, 푸시 알림, 웹소켓 브로드캐스트 등을 보낼 수 있어. 코드가 깔끔하게 분리되지!

⏰ 스케줄러 설정

주기적으로 블록체인 이벤트를 감지하고 처리하는 스케줄러를 설정하자.

<?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분마다 pending 상태인 결제들의 트랜잭션 상태 체크
        $schedule->call(function () {
            $payments = \App\Models\Payment::where('status', 'pending')
                ->whereNotNull('transaction_hash')
                ->where('created_at', '>', now()->subHours(24))
                ->get();
            
            foreach ($payments as $payment) {
                \App\Jobs\CheckTransactionStatus::dispatch($payment);
            }
        })->everyMinute();
        
        // 5분마다 processing 상태인 결제들 체크
        $schedule->call(function () {
            $payments = \App\Models\Payment::where('status', 'processing')
                ->where('created_at', '>', now()->subDays(7))
                ->get();
            
            foreach ($payments as $payment) {
                \App\Jobs\CheckTransactionStatus::dispatch($payment);
            }
        })->everyFiveMinutes();
        
        // 10분마다 블록체인 이벤트 리스닝
        $schedule->call(function () {
            $web3Service = app(\App\Services\Web3Service::class);
            $web3Service->listenToPaymentEvents();
        })->everyTenMinutes();
        
        // 매일 자정에 오래된 failed 결제 정리
        $schedule->call(function () {
            \App\Models\Payment::where('status', 'failed')
                ->where('created_at', '<', now()->subDays(30))
                ->delete();
        })->daily();
    }
}

스케줄러를 실행하려면 서버의 cron에 다음 명령어를 등록해야 해:

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

이렇게 하면 자동으로 트랜잭션 상태를 추적하고 DB를 동기화할 수 있어!

🦊 MetaMask 연결

먼저 사용자의 지갑을 연결하는 기능부터 구현해야 해.

import { ref, computed } from 'vue';
import { ethers } from 'ethers';

export function useWeb3() {
    const account = ref(null);
    const chainId = ref(null);
    const provider = ref(null);
    const signer = ref(null);
    
    const isConnected = computed(() => !!account.value);
    
    const connectWallet = async () => {
        try {
            if (!window.ethereum) {
                throw new Error('MetaMask is not installed');
            }
            
            // 계정 요청
            const accounts = await window.ethereum.request({
                method: 'eth_requestAccounts'
            });
            
            account.value = accounts[0];
            
            // Provider 및 Signer 설정
            provider.value = new ethers.BrowserProvider(window.ethereum);
            signer.value = await provider.value.getSigner();
            
            // 체인 ID 가져오기
            const network = await provider.value.getNetwork();
            chainId.value = network.chainId.toString();
            
            // 계정 변경 감지
            window.ethereum.on('accountsChanged', (accounts) => {
                if (accounts.length === 0) {
                    disconnectWallet();
                } else {
                    account.value = accounts[0];
                }
            });
            
            // 네트워크 변경 감지
            window.ethereum.on('chainChanged', () => {
                window.location.reload();
            });
            
            return account.value;
            
        } catch (error) {
            console.error('Failed to connect wallet:', error);
            throw error;
        }
    };
    
    const disconnectWallet = () => {
        account.value = null;
        chainId.value = null;
        provider.value = null;
        signer.value = null;
    };
    
    const switchNetwork = async (targetChainId) => {
        try {
            await window.ethereum.request({
                method: 'wallet_switchEthereumChain',
                params: [{ chainId: `0x${parseInt(targetChainId).toString(16)}` }]
            });
        } catch (error) {
            if (error.code === 4902) {
                // 네트워크가 추가되지 않은 경우
                throw new Error('Please add this network to MetaMask');
            }
            throw error;
        }
    };
    
    const getBalance = async (address) => {
        try {
            if (!provider.value) {
                throw new Error('Provider not initialized');
            }
            
            const balance = await provider.value.getBalance(address || account.value);
            return ethers.formatEther(balance);
            
        } catch (error) {
            console.error('Failed to get balance:', error);
            throw error;
        }
    };
    
    return {
        account,
        chainId,
        provider,
        signer,
        isConnected,
        connectWallet,
        disconnectWallet,
        switchNetwork,
        getBalance
    };
}

이 composable은 MetaMask 연결, 계정 관리, 네트워크 전환 등의 기능을 제공해. Vue 컴포넌트에서 쉽게 사용할 수 있어!

💳 결제 컴포넌트 구현

실제 결제를 처리하는 Vue 컴포넌트를 만들어보자.

<template>
  <div class="payment-form">
    <h2>블록체인 결제</h2>
    
    <div v-if="!isConnected" class="connect-wallet">
      <button @click="handleConnect" class="btn-primary">
        🦊 MetaMask 연결
      </button>
    </div>
    
    <div v-else class="payment-details">
      <div class="wallet-info">
        <p>연결된 지갑: {{ shortenAddress(account) }}</p>
        <p>잔액: {{ balance }} ETH</p>
      </div>
      
      <form @submit.prevent="handlePayment">
        <div class="form-group">
          <label>판매자 주소</label>
          <input 
            v-model="form.sellerAddress" 
            type="text" 
            placeholder="0x..."
            required
          />
        </div>
        
        <div class="form-group">
          <label>결제 금액 (ETH)</label>
          <input 
            v-model="form.amount" 
            type="number" 
            step="0.001"
            min="0.001"
            required
          />
        </div>
        
        <div class="form-group">
          <label>설명 (선택)</label>
          <textarea 
            v-model="form.description" 
            rows="3"
            placeholder="결제 내용을 입력하세요"
          ></textarea>
        </div>
        
        <div v-if="estimatedGas" class="gas-estimate">
          <p>예상 가스비: {{ estimatedGas }} ETH</p>
          <p>총 금액: {{ totalAmount }} ETH</p>
        </div>
        
        <button 
          type="submit" 
          class="btn-primary"
          :disabled="isProcessing"
        >
          {{ isProcessing ? '처리 중...' : '결제하기' }}
        </button>
      </form>
      
      <div v-if="transactionHash" class="transaction-info">
        <p>✅ 트랜잭션 전송 완료!</p>
        <a 
          :href="`https://sepolia.etherscan.io/tx/${transactionHash}`" 
          target="_blank"
        >
          Etherscan에서 확인
        </a>
      </div>
    </div>
  </div>
</template>

<script setup>
import { ref, computed, onMounted } from 'vue';
import { ethers } from 'ethers';
import { useWeb3 } from '../composables/useWeb3';
import axios from 'axios';

const { 
  account, 
  isConnected, 
  connectWallet, 
  signer,
  getBalance 
} = useWeb3();

const form = ref({
  sellerAddress: '',
  amount: '',
  description: ''
});

const balance = ref('0');
const estimatedGas = ref(null);
const isProcessing = ref(false);
const transactionHash = ref(null);

const CONTRACT_ADDRESS = import.meta.env.VITE_CONTRACT_ADDRESS;
const CONTRACT_ABI = [
  "function createPayment(address _seller) external payable returns (uint256)",
  "event PaymentCreated(uint256 indexed paymentId, address indexed buyer, address indexed seller, uint256 amount)"
];

const totalAmount = computed(() => {
  if (!form.value.amount || !estimatedGas.value) return '0';
  return (parseFloat(form.value.amount) + parseFloat(estimatedGas.value)).toFixed(6);
});

const handleConnect = async () => {
  try {
    await connectWallet();
    await updateBalance();
  } catch (error) {
    alert('지갑 연결 실패: ' + error.message);
  }
};

const updateBalance = async () => {
  try {
    balance.value = await getBalance();
  } catch (error) {
    console.error('Failed to get balance:', error);
  }
};

const estimateGas = async () => {
  try {
    if (!form.value.sellerAddress || !form.value.amount) return;
    
    const contract = new ethers.Contract(CONTRACT_ADDRESS, CONTRACT_ABI, signer.value);
    const amountInWei = ethers.parseEther(form.value.amount);
    
    const gasEstimate = await contract.createPayment.estimateGas(
      form.value.sellerAddress,
      { value: amountInWei }
    );
    
    const gasPrice = await signer.value.provider.getFeeData();
    const gasCost = gasEstimate * gasPrice.gasPrice;
    
    estimatedGas.value = ethers.formatEther(gasCost);
    
  } catch (error) {
    console.error('Failed to estimate gas:', error);
  }
};

const handlePayment = async () => {
  try {
    isProcessing.value = true;
    
    // 1. 백엔드에 결제 생성 요청
    const response = await axios.post('/api/payments', {
      seller_id: 1, // 실제로는 동적으로 받아야 함
      seller_address: form.value.sellerAddress,
      amount: form.value.amount,
      currency: 'ETH',
      description: form.value.description
    });
    
    const { payment_id, transaction_data } = response.data;
    
    // 2. 스마트 컨트랙트 호출
    const contract = new ethers.Contract(CONTRACT_ADDRESS, CONTRACT_ABI, signer.value);
    
    const tx = await contract.createPayment(
      form.value.sellerAddress,
      { 
        value: ethers.parseEther(form.value.amount),
        gasLimit: 300000
      }
    );
    
    transactionHash.value = tx.hash;
    
    // 3. 트랜잭션 대기
    const receipt = await tx.wait();
    
    // 4. 이벤트에서 paymentId 추출
    const event = receipt.logs.find(log => {
      try {
        const parsed = contract.interface.parseLog(log);
        return parsed.name === 'PaymentCreated';
      } catch {
        return false;
      }
    });
    
    let blockchainPaymentId = null;
    if (event) {
      const parsed = contract.interface.parseLog(event);
      blockchainPaymentId = parsed.args.paymentId.toString();
    }
    
    // 5. 백엔드에 트랜잭션 확인 요청
    await axios.post(`/api/payments/${payment_id}/confirm`, {
      transaction_hash: tx.hash,
      blockchain_payment_id: blockchainPaymentId
    });
    
    alert('결제가 성공적으로 완료되었습니다!');
    
    // 폼 초기화
    form.value = {
      sellerAddress: '',
      amount: '',
      description: ''
    };
    
    await updateBalance();
    
  } catch (error) {
    console.error('Payment failed:', error);
    alert('결제 실패: ' + error.message);
  } finally {
    isProcessing.value = false;
  }
};

const shortenAddress = (address) => {
  if (!address) return '';
  return `${address.slice(0, 6)}...${address.slice(-4)}`;
};

onMounted(async () => {
  if (isConnected.value) {
    await updateBalance();
  }
});
</script>

<style scoped>
.payment-form {
  max-width: 500px;
  margin: 0 auto;
  padding: 20px;
}

.wallet-info {
  background: #f0f0f0;
  padding: 15px;
  border-radius: 8px;
  margin-bottom: 20px;
}

.form-group {
  margin-bottom: 15px;
}

.form-group label {
  display: block;
  margin-bottom: 5px;
  font-weight: 600;
}

.form-group input,
.form-group textarea {
  width: 100%;
  padding: 10px;
  border: 1px solid #ddd;
  border-radius: 4px;
}

.gas-estimate {
  background: #fff3cd;
  padding: 10px;
  border-radius: 4px;
  margin-bottom: 15px;
}

.btn-primary {
  width: 100%;
  padding: 12px;
  background: #667eea;
  color: white;
  border: none;
  border-radius: 8px;
  font-size: 16px;
  cursor: pointer;
}

.btn-primary:hover {
  background: #5568d3;
}

.btn-primary:disabled {
  background: #ccc;
  cursor: not-allowed;
}

.transaction-info {
  margin-top: 20px;
  padding: 15px;
  background: #d4edda;
  border-radius: 8px;
}

.transaction-info a {
  color: #155724;
  text-decoration: underline;
}
</style>

이 컴포넌트는 완전한 결제 플로우를 구현해:

1️⃣ MetaMask 연결
2️⃣ 잔액 확인
3️⃣ 가스비 예측
4️⃣ 백엔드에 결제 생성
5️⃣ 스마트 컨트랙트 호출
6️⃣ 트랜잭션 대기 및 확인
7️⃣ 백엔드에 결과 전송

🔨 스마트 컨트랙트 테스트

Hardhat으로 컨트랙트를 테스트해보자. JavaScript로 작성할 수 있어서 편해!

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

describe("PaymentContract", function () {
    let paymentContract;
    let owner, buyer, seller;
    
    beforeEach(async function () {
        [owner, buyer, seller] = await ethers.getSigners();
        
        const PaymentContract = await ethers.getContractFactory("PaymentContract");
        paymentContract = await PaymentContract.deploy();
        await paymentContract.waitForDeployment();
    });
    
    describe("createPayment", function () {
        it("should create a payment successfully", async function () {
            const amount = ethers.parseEther("1.0");
            
            const tx = await paymentContract.connect(buyer).createPayment(
                seller.address,
                { value: amount }
            );
            
            const receipt = await tx.wait();
            
            // 이벤트 확인
            const event = receipt.logs.find(log => {
                try {
                    const parsed = paymentContract.interface.parseLog(log);
                    return parsed.name === 'PaymentCreated';
                } catch {
                    return false;
                }
            });
            
            expect(event).to.not.be.undefined;
            
            const parsed = paymentContract.interface.parseLog(event);
            expect(parsed.args.buyer).to.equal(buyer.address);
            expect(parsed.args.seller).to.equal(seller.address);
            expect(parsed.args.amount).to.equal(amount);
        });
        
        it("should fail with zero amount", async function () {
            await expect(
                paymentContract.connect(buyer).createPayment(seller.address, { value: 0 })
            ).to.be.revertedWith("Payment amount must be greater than 0");
        });
        
        it("should fail with invalid seller address", async function () {
            const amount = ethers.parseEther("1.0");
            
            await expect(
                paymentContract.connect(buyer).createPayment(
                    ethers.ZeroAddress,
                    { value: amount }
                )
            ).to.be.revertedWith("Invalid seller address");
        });
    });
    
    describe("completePayment", function () {
        let paymentId;
        const amount = ethers.parseEther("1.0");
        
        beforeEach(async function () {
            const tx = await paymentContract.connect(buyer).createPayment(
                seller.address,
                { value: amount }
            );
            
            const receipt = await tx.wait();
            const event = receipt.logs.find(log => {
                try {
                    const parsed = paymentContract.interface.parseLog(log);
                    return parsed.name === 'PaymentCreated';
                } catch {
                    return false;
                }
            });
            
            const parsed = paymentContract.interface.parseLog(event);
            paymentId = parsed.args.paymentId;
        });
        
        it("should complete payment and transfer funds", async function () {
            const sellerBalanceBefore = await ethers.provider.getBalance(seller.address);
            const ownerBalanceBefore = await ethers.provider.getBalance(owner.address);
            
            await paymentContract.connect(seller).completePayment(paymentId);
            
            const sellerBalanceAfter = await ethers.provider.getBalance(seller.address);
            const ownerBalanceAfter = await ethers.provider.getBalance(owner.address);
            
            const platformFee = amount * 3n / 100n;
            const sellerAmount = amount - platformFee;
            
            // 가스비 때문에 정확한 비교는 어렵지만, 대략적으로 확인
            expect(sellerBalanceAfter).to.be.gt(sellerBalanceBefore);
            expect(ownerBalanceAfter).to.be.gt(ownerBalanceBefore);
        });
        
        it("should fail if already completed", async function () {
            await paymentContract.connect(seller).completePayment(paymentId);
            
            await expect(
                paymentContract.connect(seller).completePayment(paymentId)
            ).to.be.revertedWith("Payment already completed");
        });
        
        it("should fail if unauthorized", async function () {
            await expect(
                paymentContract.connect(buyer).completePayment(paymentId)
            ).to.be.revertedWith("Only seller or owner can complete");
        });
    });
    
    describe("refundPayment", function () {
        let paymentId;
        const amount = ethers.parseEther("1.0");
        
        beforeEach(async function () {
            const tx = await paymentContract.connect(buyer).createPayment(
                seller.address,
                { value: amount }
            );
            
            const receipt = await tx.wait();
            const event = receipt.logs.find(log => {
                try {
                    const parsed = paymentContract.interface.parseLog(log);
                    return parsed.name === 'PaymentCreated';
                } catch {
                    return false;
                }
            });
            
            const parsed = paymentContract.interface.parseLog(event);
            paymentId = parsed.args.paymentId;
        });
        
        it("should refund payment successfully", async function () {
            const buyerBalanceBefore = await ethers.provider.getBalance(buyer.address);
            
            await paymentContract.connect(owner).refundPayment(paymentId);
            
            const buyerBalanceAfter = await ethers.provider.getBalance(buyer.address);
            
            expect(buyerBalanceAfter).to.be.gt(buyerBalanceBefore);
        });
        
        it("should fail if not owner", async function () {
            await expect(
                paymentContract.connect(seller).refundPayment(paymentId)
            ).to.be.revertedWith("Only owner can call this");
        });
    });
});

테스트 실행:

npx hardhat test
npx hardhat coverage  # 코드 커버리지 확인

100% 커버리지를 목표로 하자! 특히 돈과 관련된 로직은 모든 경우의 수를 테스트해야 해.

🧪 라라벨 테스트

백엔드 API도 철저하게 테스트해야 해.

<?php

namespace Tests\Feature;

use App\Models\User;
use App\Models\Payment;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;

class PaymentTest extends TestCase
{
    use RefreshDatabase;
    
    protected $user;
    protected $seller;
    
    protected function setUp(): void
    {
        parent::setUp();
        
        $this->user = User::factory()->create([
            'wallet_address' => '0x1234567890123456789012345678901234567890'
        ]);
        
        $this->seller = User::factory()->create([
            'wallet_address' => '0x0987654321098765432109876543210987654321'
        ]);
    }
    
    public function test_create_payment_successfully()
    {
        $response = $this->actingAs($this->user)->postJson('/api/payments', [
            'seller_id' => $this->seller->id,
            'seller_address' => $this->seller->wallet_address,
            'amount' => 1.5,
            'currency' => 'ETH',
            'description' => 'Test payment'
        ]);
        
        $response->assertStatus(200)
                 ->assertJsonStructure([
                     'success',
                     'payment_id',
                     'transaction_data',
                     'message'
                 ]);
        
        $this->assertDatabaseHas('payments', [
            'user_id' => $this->user->id,
            'seller_id' => $this->seller->id,
            'amount' => 1.5,
            'status' => 'pending'
        ]);
    }
    
    public function test_create_payment_validation_fails()
    {
        $response = $this->actingAs($this->user)->postJson('/api/payments', [
            'seller_id' => $this->seller->id,
            'seller_address' => 'invalid_address',
            'amount' => -1,
            'currency' => 'INVALID'
        ]);
        
        $response->assertStatus(422)
                 ->assertJsonValidationErrors(['seller_address', 'amount', 'currency']);
    }
    
    public function test_confirm_payment_successfully()
    {
        $payment = Payment::factory()->create([
            'user_id' => $this->user->id,
            'seller_id' => $this->seller->id,
            'status' => 'pending'
        ]);
        
        $response = $this->actingAs($this->user)->postJson("/api/payments/{$payment->id}/confirm", [
            'transaction_hash' => '0x' . str_repeat('a', 64),
            'blockchain_payment_id' => 1
        ]);
        
        $response->assertStatus(200);
        
        $payment->refresh();
        $this->assertEquals('processing', $payment->status);
        $this->assertNotNull($payment->transaction_hash);
    }
    
    public function test_unauthorized_user_cannot_confirm_payment()
    {
        $payment = Payment::factory()->create([
            'user_id' => $this->seller->id,
            'seller_id' => $this->user->id
        ]);
        
        $response = $this->actingAs($this->user)->postJson("/api/payments/{$payment->id}/confirm", [
            'transaction_hash' => '0x' . str_repeat('a', 64),
            'blockchain_payment_id' => 1
        ]);
        
        $response->assertStatus(403);
    }
    
    public function test_list_payments_returns_user_payments_only()
    {
        Payment::factory()->count(5)->create(['user_id' => $this->user->id]);
        Payment::factory()->count(3)->create(['seller_id' => $this->user->id]);
        Payment::factory()->count(2)->create(); // 다른 사용자
        
        $response = $this->actingAs($this->user)->getJson('/api/payments');
        
        $response->assertStatus(200)
                 ->assertJsonCount(8, 'payments.data');
    }
}

테스트 실행:

php artisan test
php artisan test --coverage  # 커버리지 확인

📦 메인넷 배포 준비

테스트넷에서 충분히 테스트했다면 이제 메인넷에 배포할 차례야. 하지만 조심해야 해!

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

module.exports = {
  solidity: {
    version: "0.8.20",
    settings: {
      optimizer: {
        enabled: true,
        runs: 200
      }
    }
  },
  networks: {
    mainnet: {
      url: `https://mainnet.infura.io/v3/${process.env.INFURA_API_KEY}`,
      accounts: [process.env.MAINNET_PRIVATE_KEY],
      gasPrice: 'auto',
      gas: 'auto'
    }
  },
  etherscan: {
    apiKey: process.env.ETHERSCAN_API_KEY
  }
};

# 배포 전 시뮬레이션
npx hardhat run scripts/deploy.js --network mainnet --dry-run

# 실제 배포
npx hardhat run scripts/deploy.js --network mainnet

# Etherscan에 소스코드 검증
npx hardhat verify --network mainnet DEPLOYED_CONTRACT_ADDRESS

🖥️ 라라벨 프로덕션 배포

백엔드도 프로덕션 환경에 맞게 설정해야 해.

APP_ENV=production
APP_DEBUG=false
APP_URL=https://your-domain.com

DB_CONNECTION=mysql
DB_HOST=your-db-host
DB_DATABASE=your-database
DB_USERNAME=your-username
DB_PASSWORD=your-secure-password

CACHE_DRIVER=redis
QUEUE_CONNECTION=redis
SESSION_DRIVER=redis

REDIS_HOST=your-redis-host
REDIS_PASSWORD=your-redis-password

ETHEREUM_NETWORK=mainnet
INFURA_API_KEY=your-infura-key
CONTRACT_ADDRESS=your-deployed-contract-address

# 절대로 메인넷 프라이빗 키를 여기에 넣지 마!
# 서버 사이드 서명이 필요하면 AWS KMS 같은 보안 솔루션 사용

#!/bin/bash

# 저장소에서 최신 코드 가져오기
git pull origin main

# 의존성 설치
composer install --no-dev --optimize-autoloader

# 캐시 최적화
php artisan config:cache
php artisan route:cache
php artisan view:cache

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

# 큐 워커 재시작
php artisan queue:restart

# 스케줄러 확인
php artisan schedule:list

echo "Deployment completed!"

서버 설정:

• Nginx/Apache: 웹 서버 설정
• PHP-FPM: PHP 프로세스 관리
• Supervisor: 큐 워커 관리
• Redis: 캐싱 및 큐
• MySQL/PostgreSQL: 데이터베이스
• SSL 인증서: HTTPS 필수!

[program:laravel-worker]
process_name=%(program_name)s_%(process_num)02d
command=php /path/to/your/project/artisan queue:work redis --sleep=3 --tries=3 --max-time=3600
autostart=true
autorestart=true
stopasgroup=true
killasgroup=true
user=www-data
numprocs=8
redirect_stderr=true
stdout_logfile=/path/to/your/project/storage/logs/worker.log
stopwaitsecs=3600

📊 모니터링 및 로깅

프로덕션에서는 모니터링이 정말 중요해! 문제가 생기면 빠르게 대응해야 하거든.

composer require sentry/sentry-laravel

# config/sentry.php
return [
    'dsn' => env('SENTRY_LARAVEL_DSN'),
    'traces_sample_rate' => 1.0,
    'environment' => env('APP_ENV'),
];

<?php

use Illuminate\Support\Facades\Log;

// 결제 관련 중요 이벤트 로깅
Log::channel('payments')->info('Payment created', [
    'payment_id' => $payment->id,
    'user_id' => $payment->user_id,
    'amount' => $payment->amount,
    'currency' => $payment->currency
]);

// 블록체인 트랜잭션 로깅
Log::channel('blockchain')->info('Transaction sent', [
    'tx_hash' => $txHash,
    'from' => $fromAddress,
    'to' => $toAddress,
    'value' => $value
]);

// 에러 로깅
Log::channel('slack')->error('Payment processing failed', [
    'payment_id' => $payment->id,
    'error' => $exception->getMessage(),
    'trace' => $exception->getTraceAsString()
]);

🔄 백업 및 재해 복구

만약을 대비한 백업 전략도 필수야!

#!/bin/bash

DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_DIR="/backups"
DB_NAME="your_database"

# 데이터베이스 백업
mysqldump -u $DB_USER -p$DB_PASS $DB_NAME | gzip > $BACKUP_DIR/db_$DATE.sql.gz

# 파일 백업
tar -czf $BACKUP_DIR/files_$DATE.tar.gz /path/to/your/project/storage

# S3에 업로드
aws s3 cp $BACKUP_DIR/db_$DATE.sql.gz s3://your-bucket/backups/
aws s3 cp $BACKUP_DIR/files_$DATE.tar.gz s3://your-bucket/backups/

# 7일 이상 된 백업 삭제
find $BACKUP_DIR -name "*.gz" -mtime +7 -delete

echo "Backup completed: $DATE"

🖼️ NFT 결제 컨트랙트

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

import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract NFTMarketplace is ReentrancyGuard, Ownable {
    struct Listing {
        address seller;
        address nftContract;
        uint256 tokenId;
        uint256 price;
        bool active;
    }
    
    mapping(uint256 => Listing) public listings;
    uint256 public listingCounter;
    uint256 public platformFeePercent = 2; // 2%
    
    event NFTListed(
        uint256 indexed listingId,
        address indexed seller,
        address indexed nftContract,
        uint256 tokenId,
        uint256 price
    );
    
    event NFTSold(
        uint256 indexed listingId,
        address indexed buyer,
        address indexed seller,
        uint256 price
    );
    
    event ListingCancelled(uint256 indexed listingId);
    
    constructor() Ownable(msg.sender) {}
    
    function listNFT(
        address _nftContract,
        uint256 _tokenId,
        uint256 _price
    ) external returns (uint256) {
        require(_price > 0, "Price must be greater than 0");
        
        IERC721 nft = IERC721(_nftContract);
        require(nft.ownerOf(_tokenId) == msg.sender, "Not the owner");
        require(
            nft.isApprovedForAll(msg.sender, address(this)) ||
            nft.getApproved(_tokenId) == address(this),
            "Marketplace not approved"
        );
        
        uint256 listingId = listingCounter++;
        
        listings[listingId] = Listing({
            seller: msg.sender,
            nftContract: _nftContract,
            tokenId: _tokenId,
            price: _price,
            active: true
        });
        
        emit NFTListed(listingId, msg.sender, _nftContract, _tokenId, _price);
        
        return listingId;
    }
    
    function buyNFT(uint256 _listingId) external payable nonReentrant {
        Listing storage listing = listings[_listingId];
        
        require(listing.active, "Listing not active");
        require(msg.value >= listing.price, "Insufficient payment");
        
        listing.active = false;
        
        uint256 platformFee = (listing.price * platformFeePercent) / 100;
        uint256 sellerAmount = listing.price - platformFee;
        
        IERC721(listing.nftContract).safeTransferFrom(
            listing.seller,
            msg.sender,
            listing.tokenId
        );
        
        payable(listing.seller).transfer(sellerAmount);
        payable(owner()).transfer(platformFee);
        
        if (msg.value > listing.price) {
            payable(msg.sender).transfer(msg.value - listing.price);
        }
        
        emit NFTSold(_listingId, msg.sender, listing.seller, listing.price);
    }
    
    function cancelListing(uint256 _listingId) external {
        Listing storage listing = listings[_listingId];
        
        require(listing.active, "Listing not active");
        require(listing.seller == msg.sender, "Not the seller");
        
        listing.active = false;
        
        emit ListingCancelled(_listingId);
    }
    
    function updatePlatformFee(uint256 _newFee) external onlyOwner {
        require(_newFee <= 10, "Fee too high");
        platformFeePercent = _newFee;
    }
}

🔧 라라벨 통합

<?php

namespace App\Http\Controllers;

use App\Models\NFTListing;
use App\Services\Web3Service;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;

class NFTMarketplaceController extends Controller
{
    protected $web3Service;
    
    public function __construct(Web3Service $web3Service)
    {
        $this->web3Service = $web3Service;
    }
    
    public function listNFT(Request $request)
    {
        $validated = $request->validate([
            'nft_contract' => 'required|string|size:42',
            'token_id' => 'required|integer',
            'price' => 'required|numeric|min:0.001',
            'title' => 'required|string|max:200',
            'description' => 'nullable|string|max:1000',
            'image_url' => 'required|url'
        ]);
        
        try {
            // DB에 리스팅 생성
            $listing = NFTListing::create([
                'user_id' => Auth::id(),
                'nft_contract' => $validated['nft_contract'],
                'token_id' => $validated['token_id'],
                'price' => $validated['price'],
                'title' => $validated['title'],
                'description' => $validated['description'] ?? null,
                'image_url' => $validated['image_url'],
                'status' => 'pending'
            ]);
            
            // 블록체인 트랜잭션 데이터 생성
            $txData = $this->web3Service->createNFTListing(
                $validated['nft_contract'],
                $validated['token_id'],
                $validated['price']
            );
            
            return response()->json([
                'success' => true,
                'listing_id' => $listing->id,
                'transaction_data' => $txData
            ]);
            
        } catch (\Exception $e) {
            return response()->json([
                'success' => false,
                'message' => $e->getMessage()
            ], 500);
        }
    }
    
    public function getListings(Request $request)
    {
        $query = NFTListing::where('status', 'active');
        
        if ($request->has('min_price')) {
            $query->where('price', '>=', $request->min_price);
        }
        
        if ($request->has('max_price')) {
            $query->where('price', '<=', $request->max_price);
        }
        
        if ($request->has('search')) {
            $query->where(function($q) use ($request) {
                $q->where('title', 'like', "%{$request->search}%")
                  ->orWhere('description', 'like', "%{$request->search}%");
            });
        }
        
        $listings = $query->orderBy('created_at', 'desc')
                         ->paginate(20);
        
        return response()->json([
            'success' => true,
            'listings' => $listings
        ]);
    }
    
    public function buyNFT(Request $request, $id)
    {
        try {
            $listing = NFTListing::findOrFail($id);
            
            if ($listing->status !== 'active') {
                return response()->json([
                    'success' => false,
                    'message' => 'Listing is not active'
                ], 400);
            }
            
            // 블록체인 구매 트랜잭션 데이터 생성
            $txData = $this->web3Service->buyNFT(
                $listing->blockchain_listing_id,
                $listing->price
            );
            
            return response()->json([
                'success' => true,
                'transaction_data' => $txData
            ]);
            
        } catch (\Exception $e) {
            return response()->json([
                'success' => false,
                'message' => $e->getMessage()
            ], 500);
        }
    }
}

🎨 프론트엔드 NFT 갤러리

<template>
  <div class="nft-gallery">
    <div class="filters">
      <input 
        v-model="filters.search" 
        type="text" 
        placeholder="검색..."
        @input="searchNFTs"
      />
      
      <div class="price-range">
        <input 
          v-model="filters.minPrice" 
          type="number" 
          placeholder="최소 가격"
        />
        <input 
          v-model="filters.maxPrice" 
          type="number" 
          placeholder="최대 가격"
        />
        <button @click="applyFilters">적용</button>
      </div>
    </div>
    
    <div class="nft-grid">
      <div 
        v-for="nft in nfts" 
        :key="nft.id" 
        class="nft-card"
      >
        <img :src="nft.image_url" :alt="nft.title" />
        
        <div class="nft-info">
          <h3>{{ nft.title }}</h3>
          <p class="description">{{ nft.description }}</p>
          
          <div class="price-section">
            <span class="price">{{ nft.price }} ETH</span>
            <button 
              @click="buyNFT(nft)" 
              class="btn-buy"
              :disabled="!isConnected"
            >
              구매하기
            </button>
          </div>
        </div>
      </div>
    </div>
    
    <div v-if="loading" class="loading">
      로딩 중...
    </div>
  </div>
</template>

<script setup>
import { ref, onMounted } from 'vue';
import { useWeb3 } from '../composables/useWeb3';
import axios from 'axios';
import { ethers } from 'ethers';

const { isConnected, signer } = useWeb3();

const nfts = ref([]);
const loading = ref(false);
const filters = ref({
  search: '',
  minPrice: null,
  maxPrice: null
});

const MARKETPLACE_ADDRESS = import.meta.env.VITE_MARKETPLACE_ADDRESS;
const MARKETPLACE_ABI = [
  "function buyNFT(uint256 _listingId) external payable"
];

const loadNFTs = async () => {
  try {
    loading.value = true;
    
    const params = new URLSearchParams();
    if (filters.value.search) params.append('search', filters.value.search);
    if (filters.value.minPrice) params.append('min_price', filters.value.minPrice);
    if (filters.value.maxPrice) params.append('max_price', filters.value.maxPrice);
    
    const response = await axios.get(`/api/nft-listings?${params}`);
    nfts.value = response.data.listings.data;
    
  } catch (error) {
    console.error('Failed to load NFTs:', error);
    alert('NFT 목록을 불러오는데 실패했습니다.');
  } finally {
    loading.value = false;
  }
};

const buyNFT = async (nft) => {
  try {
    if (!isConnected.value) {
      alert('먼저 지갑을 연결해주세요.');
      return;
    }
    
    // 백엔드에서 트랜잭션 데이터 가져오기
    const response = await axios.post(`/api/nft-listings/${nft.id}/buy`);
    const { transaction_data } = response.data;
    
    // 스마트 컨트랙트 호출
    const contract = new ethers.Contract(
      MARKETPLACE_ADDRESS,
      MARKETPLACE_ABI,
      signer.value
    );
    
    const tx = await contract.buyNFT(
      nft.blockchain_listing_id,
      {
        value: ethers.parseEther(nft.price.toString()),
        gasLimit: 300000
      }
    );
    
    alert('트랜잭션이 전송되었습니다. 잠시만 기다려주세요...');
    
    await tx.wait();
    
    alert('NFT 구매가 완료되었습니다!');
    
    // 목록 새로고침
    await loadNFTs();
    
  } catch (error) {
    console.error('Failed to buy NFT:', error);
    alert('NFT 구매에 실패했습니다: ' + error.message);
  }
};

const searchNFTs = debounce(() => {
  loadNFTs();
}, 500);

const applyFilters = () => {
  loadNFTs();
};

function debounce(func, wait) {
  let timeout;
  return function executedFunction(...args) {
    const later = () => {
      clearTimeout(timeout);
      func(...args);
    };
    clearTimeout(timeout);
    timeout = setTimeout(later, wait);
  };
}

onMounted(() => {
  loadNFTs();
});
</script>

<style scoped>
.nft-gallery {
  max-width: 1200px;
  margin: 0 auto;
  padding: 20px;
}

.filters {
  margin-bottom: 30px;
  display: flex;
  gap: 15px;
  flex-wrap: wrap;
}

.filters input {
  padding: 10px;
  border: 1px solid #ddd;
  border-radius: 8px;
  flex: 1;
  min-width: 200px;
}

.price-range {
  display: flex;
  gap: 10px;
}

.nft-grid {
  display: grid;
  grid-template-columns: repeat(auto-fill, minmax(280px, 1fr));
  gap: 25px;
}

.nft-card {
  border: 1px solid #e0e0e0;
  border-radius: 12px;
  overflow: hidden;
  transition: transform 0.2s, box-shadow 0.2s;
}

.nft-card:hover {
  transform: translateY(-5px);
  box-shadow: 0 8px 20px rgba(0,0,0,0.1);
}

.nft-card img {
  width: 100%;
  height: 280px;
  object-fit: cover;
}

.nft-info {
  padding: 15px;
}

.nft-info h3 {
  margin: 0 0 10px 0;
  font-size: 18px;
}

.description {
  color: #666;
  font-size: 14px;
  margin-bottom: 15px;
  height: 40px;
  overflow: hidden;
  text-overflow: ellipsis;
}

.price-section {
  display: flex;
  justify-content: space-between;
  align-items: center;
}

.price {
  font-size: 20px;
  font-weight: bold;
  color: #667eea;
}

.btn-buy {
  padding: 8px 20px;
  background: #667eea;
  color: white;
  border: none;
  border-radius: 8px;
  cursor: pointer;
}

.btn-buy:hover {
  background: #5568d3;
}

.btn-buy:disabled {
  background: #ccc;
  cursor: not-allowed;
}

.loading {
  text-align: center;
  padding: 40px;
  font-size: 18px;
  color: #666;
}
</style>