# 라라벨 프로젝트 생성
composer create-project laravel/laravel blockchain-subscription

cd blockchain-subscription

# 필요한 패키지 설치
composer require web3p/web3.php
composer require simplito/elliptic-php
composer require kornrunner/keccak

# 프론트엔드 패키지
npm install ethers@5.7.2
npm install @metamask/detect-provider

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

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

contract SubscriptionService is ReentrancyGuard, Ownable {
    
    // 구독 플랜 구조체
    struct Plan {
        uint256 price;           // 월 구독료 (토큰 단위)
        uint256 duration;        // 구독 기간 (초 단위)
        bool active;             // 플랜 활성화 여부
        string name;             // 플랜 이름
    }
    
    // 사용자 구독 정보
    struct Subscription {
        uint256 planId;          // 구독 중인 플랜 ID
        uint256 startTime;       // 구독 시작 시간
        uint256 endTime;         // 구독 종료 시간
        bool autoRenew;          // 자동 갱신 여부
        bool active;             // 구독 활성화 여부
    }
    
    // 상태 변수
    IERC20 public paymentToken;                          // 결제 토큰 (USDT, USDC 등)
    mapping(uint256 => Plan) public plans;               // 플랜 ID => 플랜 정보
    mapping(address => Subscription) public subscriptions; // 사용자 주소 => 구독 정보
    uint256 public planCount;                            // 총 플랜 개수
    
    // 이벤트
    event PlanCreated(uint256 indexed planId, string name, uint256 price);
    event Subscribed(address indexed user, uint256 indexed planId, uint256 endTime);
    event Renewed(address indexed user, uint256 indexed planId, uint256 newEndTime);
    event Cancelled(address indexed user, uint256 indexed planId);
    event AutoRenewToggled(address indexed user, bool autoRenew);
    
    constructor(address _paymentToken) {
        paymentToken = IERC20(_paymentToken);
    }
    
    // 플랜 생성 (관리자만)
    function createPlan(
        string memory _name,
        uint256 _price,
        uint256 _duration
    ) external onlyOwner {
        planCount++;
        plans[planCount] = Plan({
            name: _name,
            price: _price,
            duration: _duration,
            active: true
        });
        
        emit PlanCreated(planCount, _name, _price);
    }
    
    // 구독 시작
    function subscribe(uint256 _planId) external nonReentrant {
        require(plans[_planId].active, "Plan not active");
        require(!subscriptions[msg.sender].active, "Already subscribed");
        
        Plan memory plan = plans[_planId];
        
        // 토큰 전송
        require(
            paymentToken.transferFrom(msg.sender, address(this), plan.price),
            "Payment failed"
        );
        
        // 구독 정보 저장
        uint256 endTime = block.timestamp + plan.duration;
        subscriptions[msg.sender] = Subscription({
            planId: _planId,
            startTime: block.timestamp,
            endTime: endTime,
            autoRenew: true,
            active: true
        });
        
        emit Subscribed(msg.sender, _planId, endTime);
    }
    
    // 구독 갱신
    function renew() external nonReentrant {
        Subscription storage sub = subscriptions[msg.sender];
        require(sub.active, "No active subscription");
        require(block.timestamp >= sub.endTime, "Subscription still valid");
        require(sub.autoRenew, "Auto-renew disabled");
        
        Plan memory plan = plans[sub.planId];
        require(plan.active, "Plan no longer active");
        
        // 토큰 전송
        require(
            paymentToken.transferFrom(msg.sender, address(this), plan.price),
            "Payment failed"
        );
        
        // 구독 기간 연장
        sub.endTime = block.timestamp + plan.duration;
        
        emit Renewed(msg.sender, sub.planId, sub.endTime);
    }
    
    // 구독 취소
    function cancel() external {
        Subscription storage sub = subscriptions[msg.sender];
        require(sub.active, "No active subscription");
        
        sub.active = false;
        sub.autoRenew = false;
        
        emit Cancelled(msg.sender, sub.planId);
    }
    
    // 자동 갱신 토글
    function toggleAutoRenew() external {
        Subscription storage sub = subscriptions[msg.sender];
        require(sub.active, "No active subscription");
        
        sub.autoRenew = !sub.autoRenew;
        
        emit AutoRenewToggled(msg.sender, sub.autoRenew);
    }
    
    // 구독 상태 확인
    function isSubscriptionValid(address _user) external view returns (bool) {
        Subscription memory sub = subscriptions[_user];
        return sub.active && block.timestamp < sub.endTime;
    }
    
    // 남은 구독 기간 조회
    function getRemainingTime(address _user) external view returns (uint256) {
        Subscription memory sub = subscriptions[_user];
        if (!sub.active || block.timestamp >= sub.endTime) {
            return 0;
        }
        return sub.endTime - block.timestamp;
    }
    
    // 수익 인출 (관리자만)
    function withdraw(uint256 _amount) external onlyOwner {
        require(
            paymentToken.transfer(owner(), _amount),
            "Withdrawal failed"
        );
    }
}

# Hardhat 프로젝트 초기화
npm install --save-dev hardhat
npx hardhat

# 필요한 플러그인 설치
npm install --save-dev @nomiclabs/hardhat-ethers ethers
npm install --save-dev @openzeppelin/contracts

const hre = require("hardhat");

async function main() {
    // USDT 토큰 주소 (테스트넷)
    const USDT_ADDRESS = "0x..."; // Goerli USDT 주소
    
    console.log("Deploying SubscriptionService...");
    
    const SubscriptionService = await hre.ethers.getContractFactory("SubscriptionService");
    const subscription = await SubscriptionService.deploy(USDT_ADDRESS);
    
    await subscription.deployed();
    
    console.log("SubscriptionService deployed to:", subscription.address);
    
    // 기본 플랜 생성
    console.log("Creating default plans...");
    
    // 베이직 플랜: 월 $9.99 (30일)
    await subscription.createPlan(
        "Basic Plan",
        hre.ethers.utils.parseUnits("9.99", 6), // USDT는 6 decimals
        30 * 24 * 60 * 60 // 30일
    );
    
    // 프로 플랜: 월 $29.99 (30일)
    await subscription.createPlan(
        "Pro Plan",
        hre.ethers.utils.parseUnits("29.99", 6),
        30 * 24 * 60 * 60
    );
    
    // 엔터프라이즈 플랜: 월 $99.99 (30일)
    await subscription.createPlan(
        "Enterprise Plan",
        hre.ethers.utils.parseUnits("99.99", 6),
        30 * 24 * 60 * 60
    );
    
    console.log("Plans created successfully!");
    
    // 컨트랙트 정보 저장
    const fs = require('fs');
    const contractInfo = {
        address: subscription.address,
        network: hre.network.name,
        deployedAt: new Date().toISOString()
    };
    
    fs.writeFileSync(
        './contract-info.json',
        JSON.stringify(contractInfo, null, 2)
    );
}

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

require("@nomiclabs/hardhat-ethers");
require('dotenv').config();

module.exports = {
    solidity: {
        version: "0.8.19",
        settings: {
            optimizer: {
                enabled: true,
                runs: 200
            }
        }
    },
    networks: {
        goerli: {
            url: process.env.GOERLI_RPC_URL,
            accounts: [process.env.PRIVATE_KEY],
            chainId: 5
        },
        sepolia: {
            url: process.env.SEPOLIA_RPC_URL,
            accounts: [process.env.PRIVATE_KEY],
            chainId: 11155111
        },
        mainnet: {
            url: process.env.MAINNET_RPC_URL,
            accounts: [process.env.PRIVATE_KEY],
            chainId: 1
        }
    }
};

# 테스트넷 배포
npx hardhat run scripts/deploy.js --network goerli

# 메인넷 배포 (충분한 테스트 후!)
npx hardhat run scripts/deploy.js --network mainnet

// app/Services/Web3Service.php
<?php

namespace App\Services;

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

class Web3Service
{
    private $web3;
    private $contract;
    private $contractAddress;
    private $abi;
    
    public function __construct()
    {
        // Infura 또는 Alchemy RPC URL
        $rpcUrl = config('web3.rpc_url');
        $this->web3 = new Web3($rpcUrl);
        
        // 컨트랙트 주소와 ABI 로드
        $this->contractAddress = config('web3.contract_address');
        $this->abi = json_decode(file_get_contents(storage_path('app/contract-abi.json')), true);
        
        $this->contract = new Contract($rpcUrl, $this->abi);
    }
    
    /**
     * 사용자의 구독 상태 확인
     */
    public function checkSubscription(string $userAddress): array
    {
        $subscription = null;
        
        $this->contract->at($this->contractAddress)->call('subscriptions', $userAddress, function ($err, $result) use (&$subscription) {
            if ($err !== null) {
                throw new \Exception('Failed to fetch subscription: ' . $err->getMessage());
            }
            $subscription = $result;
        });
        
        return [
            'plan_id' => $subscription['planId']->toString(),
            'start_time' => $subscription['startTime']->toString(),
            'end_time' => $subscription['endTime']->toString(),
            'auto_renew' => $subscription['autoRenew'],
            'active' => $subscription['active']
        ];
    }
    
    /**
     * 구독 유효성 확인
     */
    public function isSubscriptionValid(string $userAddress): bool
    {
        $isValid = false;
        
        $this->contract->at($this->contractAddress)->call('isSubscriptionValid', $userAddress, function ($err, $result) use (&$isValid) {
            if ($err !== null) {
                throw new \Exception('Failed to check validity: ' . $err->getMessage());
            }
            $isValid = $result[0];
        });
        
        return $isValid;
    }
    
    /**
     * 남은 구독 기간 조회 (초 단위)
     */
    public function getRemainingTime(string $userAddress): int
    {
        $remainingTime = 0;
        
        $this->contract->at($this->contractAddress)->call('getRemainingTime', $userAddress, function ($err, $result) use (&$remainingTime) {
            if ($err !== null) {
                throw new \Exception('Failed to get remaining time: ' . $err->getMessage());
            }
            $remainingTime = (int) $result[0]->toString();
        });
        
        return $remainingTime;
    }
    
    /**
     * 플랜 정보 조회
     */
    public function getPlan(int $planId): array
    {
        $plan = null;
        
        $this->contract->at($this->contractAddress)->call('plans', $planId, function ($err, $result) use (&$plan) {
            if ($err !== null) {
                throw new \Exception('Failed to fetch plan: ' . $err->getMessage());
            }
            $plan = $result;
        });
        
        return [
            'price' => $plan['price']->toString(),
            'duration' => $plan['duration']->toString(),
            'active' => $plan['active'],
            'name' => $plan['name']
        ];
    }
    
    /**
     * 트랜잭션 확인
     */
    public function getTransactionReceipt(string $txHash): ?array
    {
        $receipt = null;
        
        $this->web3->eth->getTransactionReceipt($txHash, function ($err, $result) use (&$receipt) {
            if ($err !== null) {
                return null;
            }
            $receipt = $result;
        });
        
        return $receipt;
    }
    
    /**
     * 이벤트 로그 파싱
     */
    public function parseSubscribedEvent(array $log): array
    {
        // 이벤트 시그니처: Subscribed(address,uint256,uint256)
        $eventSignature = '0x' . hash('sha3-256', 'Subscribed(address,uint256,uint256)');
        
        if ($log['topics'][0] !== $eventSignature) {
            throw new \Exception('Invalid event signature');
        }
        
        return [
            'user' => '0x' . substr($log['topics'][1], 26),
            'plan_id' => hexdec($log['topics'][2]),
            'end_time' => hexdec($log['data'])
        ];
    }
}

<?php

return [
    'rpc_url' => env('WEB3_RPC_URL', 'https://goerli.infura.io/v3/YOUR_PROJECT_ID'),
    'contract_address' => env('WEB3_CONTRACT_ADDRESS'),
    'chain_id' => env('WEB3_CHAIN_ID', 5),
    'payment_token' => env('WEB3_PAYMENT_TOKEN'),
];

// database/migrations/2024_01_01_000001_create_subscriptions_table.php
<?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('subscriptions', function (Blueprint $table) {
            $table->id();
            $table->foreignId('user_id')->constrained()->onDelete('cascade');
            $table->string('wallet_address', 42)->index();
            $table->unsignedBigInteger('plan_id');
            $table->timestamp('start_time');
            $table->timestamp('end_time');
            $table->boolean('auto_renew')->default(true);
            $table->boolean('active')->default(true);
            $table->string('tx_hash', 66)->nullable();
            $table->timestamps();
            
            $table->index(['wallet_address', 'active']);
            $table->index('end_time');
        });
        
        Schema::create('subscription_transactions', function (Blueprint $table) {
            $table->id();
            $table->foreignId('subscription_id')->constrained()->onDelete('cascade');
            $table->string('tx_hash', 66)->unique();
            $table->string('type', 20); // subscribe, renew, cancel
            $table->string('amount', 78); // BigNumber string
            $table->unsignedBigInteger('block_number');
            $table->timestamp('block_timestamp');
            $table->string('status', 20)->default('pending'); // pending, confirmed, failed
            $table->timestamps();
            
            $table->index('tx_hash');
            $table->index(['subscription_id', 'type']);
        });
        
        Schema::create('subscription_plans', function (Blueprint $table) {
            $table->id();
            $table->unsignedBigInteger('chain_plan_id')->unique();
            $table->string('name');
            $table->string('price', 78);
            $table->unsignedInteger('duration'); // seconds
            $table->boolean('active')->default(true);
            $table->text('description')->nullable();
            $table->json('features')->nullable();
            $table->timestamps();
        });
    }
    
    public function down()
    {
        Schema::dropIfExists('subscription_transactions');
        Schema::dropIfExists('subscriptions');
        Schema::dropIfExists('subscription_plans');
    }
};

// app/Models/Subscription.php
<?php

namespace App\Models;

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

class Subscription extends Model
{
    protected $fillable = [
        'user_id',
        'wallet_address',
        'plan_id',
        'start_time',
        'end_time',
        'auto_renew',
        'active',
        'tx_hash'
    ];
    
    protected $casts = [
        'start_time' => 'datetime',
        'end_time' => 'datetime',
        'auto_renew' => 'boolean',
        'active' => 'boolean'
    ];
    
    public function user(): BelongsTo
    {
        return $this->belongsTo(User::class);
    }
    
    public function plan(): BelongsTo
    {
        return $this->belongsTo(SubscriptionPlan::class, 'plan_id', 'chain_plan_id');
    }
    
    public function transactions(): HasMany
    {
        return $this->hasMany(SubscriptionTransaction::class);
    }
    
    /**
     * 구독이 유효한지 확인
     */
    public function isValid(): bool
    {
        return $this->active && $this->end_time->isFuture();
    }
    
    /**
     * 남은 일수 계산
     */
    public function daysRemaining(): int
    {
        if (!$this->isValid()) {
            return 0;
        }
        
        return Carbon::now()->diffInDays($this->end_time, false);
    }
    
    /**
     * 만료 임박 여부 (3일 이내)
     */
    public function isExpiringSoon(): bool
    {
        $days = $this->daysRemaining();
        return $days > 0 && $days <= 3;
    }
    
    /**
     * 스코프: 활성 구독만
     */
    public function scopeActive($query)
    {
        return $query->where('active', true)
                    ->where('end_time', '>', now());
    }
    
    /**
     * 스코프: 만료된 구독
     */
    public function scopeExpired($query)
    {
        return $query->where('end_time', '<=', now());
    }
}

// resources/js/components/SubscriptionManager.vue
<template>
    <div class="subscription-manager">
        <div v-if="!walletConnected" class="connect-wallet">
            <h2>지갑 연결이 필요합니다</h2>
            <button @click="connectWallet" class="btn-primary">
                MetaMask 연결
            </button>
        </div>
        
        <div v-else>
            <div class="wallet-info">
                <p>연결된 지갑: {{ shortenAddress(account) }}</p>
                <p>잔액: {{ balance }} USDT</p>
            </div>
            
            <div v-if="!hasSubscription" class="plans">
                <h2>구독 플랜 선택</h2>
                <div class="plan-grid">
                    <div 
                        v-for="plan in plans" 
                        :key="plan.id"
                        class="plan-card"
                        :class="{ selected: selectedPlan === plan.id }"
                        @click="selectPlan(plan.id)"
                    >
                        <h3>{{ plan.name }}</h3>
                        <div class="price">${{ plan.price }}</div>
                        <div class="duration">{{ plan.durationDays }}일</div>
                        <ul class="features">
                            <li v-for="feature in plan.features" :key="feature">
                                ✓ {{ feature }}
                            </li>
                        </ul>
                    </div>
                </div>
                
                <button 
                    @click="subscribe"
                    :disabled="!selectedPlan || subscribing"
                    class="btn-subscribe"
                >
                    {{ subscribing ? '처리 중...' : '구독하기' }}
                </button>
            </div>
            
            <div v-else class="current-subscription">
                <h2>현재 구독 정보</h2>
                <div class="sub-info">
                    <p><strong>플랜:</strong> {{ currentSubscription.planName }}</p>
                    <p><strong>시작일:</strong> {{ formatDate(currentSubscription.startTime) }}</p>
                    <p><strong>종료일:</strong> {{ formatDate(currentSubscription.endTime) }}</p>
                    <p><strong>남은 기간:</strong> {{ daysRemaining }}일</p>
                    <p>
                        <strong>자동 갱신:</strong> 
                        <span :class="currentSubscription.autoRenew ? 'text-success' : 'text-danger'">
                            {{ currentSubscription.autoRenew ? '활성화' : '비활성화' }}
                        </span>
                    </p>
                </div>
                
                <div class="actions">
                    <button @click="toggleAutoRenew" class="btn-secondary">
                        자동 갱신 {{ currentSubscription.autoRenew ? '끄기' : '켜기' }}
                    </button>
                    <button @click="cancelSubscription" class="btn-danger">
                        구독 취소
                    </button>
                </div>
            </div>
        </div>
        
        <div v-if="txHash" class="transaction-status">
            <p>트랜잭션 해시: {{ txHash }}</p>
            <a :href="getEtherscanUrl(txHash)" target="_blank">
                Etherscan에서 확인
            </a>
        </div>
    </div>
</template>

<script>
import { ethers } from 'ethers';
import detectEthereumProvider from '@metamask/detect-provider';
import contractABI from '../contracts/SubscriptionService.json';

export default {
    name: 'SubscriptionManager',
    
    data() {
        return {
            provider: null,
            signer: null,
            contract: null,
            account: null,
            balance: '0',
            walletConnected: false,
            plans: [],
            selectedPlan: null,
            subscribing: false,
            hasSubscription: false,
            currentSubscription: null,
            txHash: null,
            contractAddress: process.env.MIX_CONTRACT_ADDRESS,
            usdtAddress: process.env.MIX_USDT_ADDRESS
        };
    },
    
    computed: {
        daysRemaining() {
            if (!this.currentSubscription) return 0;
            const now = Math.floor(Date.now() / 1000);
            const remaining = this.currentSubscription.endTime - now;
            return Math.floor(remaining / 86400);
        }
    },
    
    async mounted() {
        await this.initWeb3();
        await this.loadPlans();
    },
    
    methods: {
        async initWeb3() {
            const ethereumProvider = await detectEthereumProvider();
            
            if (!ethereumProvider) {
                alert('MetaMask를 설치해주세요!');
                return;
            }
            
            this.provider = new ethers.providers.Web3Provider(window.ethereum);
        },
        
        async connectWallet() {
            try {
                const accounts = await this.provider.send('eth_requestAccounts', []);
                this.account = accounts[0];
                this.signer = this.provider.getSigner();
                this.walletConnected = true;
                
                // 컨트랙트 인스턴스 생성
                this.contract = new ethers.Contract(
                    this.contractAddress,
                    contractABI.abi,
                    this.signer
                );
                
                await this.loadBalance();
                await this.checkSubscription();
                
                // 계정 변경 감지
                window.ethereum.on('accountsChanged', (accounts) => {
                    this.account = accounts[0];
                    this.checkSubscription();
                });
                
            } catch (error) {
                console.error('지갑 연결 실패:', error);
                alert('지갑 연결에 실패했습니다.');
            }
        },
        
        async loadBalance() {
            const usdtContract = new ethers.Contract(
                this.usdtAddress,
                ['function balanceOf(address) view returns (uint256)'],
                this.provider
            );
            
            const balance = await usdtContract.balanceOf(this.account);
            this.balance = ethers.utils.formatUnits(balance, 6); // USDT는 6 decimals
        },
        
        async loadPlans() {
            try {
                const response = await axios.get('/api/subscription/plans');
                this.plans = response.data;
            } catch (error) {
                console.error('플랜 로드 실패:', error);
            }
        },
        
        async checkSubscription() {
            try {
                const sub = await this.contract.subscriptions(this.account);
                
                if (sub.active) {
                    this.hasSubscription = true;
                    this.currentSubscription = {
                        planId: sub.planId.toNumber(),
                        planName: await this.getPlanName(sub.planId.toNumber()),
                        startTime: sub.startTime.toNumber(),
                        endTime: sub.endTime.toNumber(),
                        autoRenew: sub.autoRenew,
                        active: sub.active
                    };
                }
            } catch (error) {
                console.error('구독 정보 조회 실패:', error);
            }
        },
        
        async getPlanName(planId) {
            const plan = await this.contract.plans(planId);
            return plan.name;
        },
        
        selectPlan(planId) {
            this.selectedPlan = planId;
        },
        
        async subscribe() {
            if (!this.selectedPlan) return;
            
            this.subscribing = true;
            
            try {
                // 1. USDT approve
                const plan = this.plans.find(p => p.id === this.selectedPlan);
                const amount = ethers.utils.parseUnits(plan.price.toString(), 6);
                
                const usdtContract = new ethers.Contract(
                    this.usdtAddress,
                    [
                        'function approve(address spender, uint256 amount) returns (bool)',
                        'function allowance(address owner, address spender) view returns (uint256)'
                    ],
                    this.signer
                );
                
                // 현재 allowance 확인
                const currentAllowance = await usdtContract.allowance(
                    this.account,
                    this.contractAddress
                );
                
                if (currentAllowance.lt(amount)) {
                    console.log('USDT approve 진행 중...');
                    const approveTx = await usdtContract.approve(
                        this.contractAddress,
                        amount
                    );
                    await approveTx.wait();
                    console.log('USDT approve 완료');
                }
                
                // 2. 구독 실행
                console.log('구독 진행 중...');
                const tx = await this.contract.subscribe(this.selectedPlan);
                this.txHash = tx.hash;
                
                // 트랜잭션 대기
                const receipt = await tx.wait();
                console.log('구독 완료:', receipt);
                
                // 서버에 동기화
                await axios.post('/api/subscription/sync', {
                    tx_hash: tx.hash,
                    wallet_address: this.account
                });
                
                // 구독 정보 새로고침
                await this.checkSubscription();
                
                alert('구독이 완료되었습니다!');
                
            } catch (error) {
                console.error('구독 실패:', error);
                alert('구독에 실패했습니다: ' + error.message);
            } finally {
                this.subscribing = false;
            }
        },
        
        async toggleAutoRenew() {
            try {
                const tx = await this.contract.toggleAutoRenew();
                await tx.wait();
                
                await this.checkSubscription();
                alert('자동 갱신 설정이 변경되었습니다.');
                
            } catch (error) {
                console.error('설정 변경 실패:', error);
                alert('설정 변경에 실패했습니다.');
            }
        },
        
        async cancelSubscription() {
            if (!confirm('정말 구독을 취소하시겠습니까?')) return;
            
            try {
                const tx = await this.contract.cancel();
                await tx.wait();
                
                this.hasSubscription = false;
                this.currentSubscription = null;
                
                alert('구독이 취소되었습니다.');
                
            } catch (error) {
                console.error('구독 취소 실패:', error);
                alert('구독 취소에 실패했습니다.');
            }
        },
        
        shortenAddress(address) {
            if (!address) return '';
            return `${address.slice(0, 6)}...${address.slice(-4)}`;
        },
        
        formatDate(timestamp) {
            return new Date(timestamp * 1000).toLocaleDateString('ko-KR');
        },
        
        getEtherscanUrl(txHash) {
            const network = process.env.MIX_NETWORK === 'mainnet' ? '' : 'goerli.';
            return `https://${network}etherscan.io/tx/${txHash}`;
        }
    }
};
</script>

<style>.tx-header{background:linear-gradient(135deg,#667eea 0%,#764ba2 100%);
color:#fff;
padding:40px 30px;
border-radius:16px;
text-align:center;
margin-bottom:40px;
box-shadow:0 8px 24px rgba(102,126,234,0.25);}
.tx-intro-box{background:#f8f9fa;
border-left:5px solid #667eea;
padding:20px;
margin:30px 0;
border-radius:8px;}
.tx-section{margin:50px 0;}
.tx-highlight{background:linear-gradient(120deg,#fef3c7 0%,#fde68a 100%);
padding:3px 8px;
border-radius:4px;
font-weight:600;}
.tx-tip-box{background:#ecfdf5;
border:2px solid #10b981;
padding:18px;
border-radius:12px;
margin:25px 0;}
.tx-warning-box{background:#fef2f2;
border:2px solid #ef4444;
padding:18px;
border-radius:12px;
margin:25px 0;}
.tx-info-box{background:#eff6ff;
border:2px solid #3b82f6;
padding:18px;
border-radius:12px;
margin:25px 0;}
.tx-step-box{background:#fff;
border:2px solid #e5e7eb;
padding:20px;
border-radius:12px;
margin:20px 0;
box-shadow:0 2px 8px rgba(0,0,0,0.05);}
.tx-table-wrap{overflow-x:auto;
margin:25px 0;}
.tx-table{width:100%;
border-collapse:collapse;
background:#fff;
border-radius:8px;
overflow:hidden;
box-shadow:0 2px 8px rgba(0,0,0,0.05);}
.tx-table th{background:#667eea;
color:#fff;
padding:12px;
text-align:left;
font-weight:600;}
.tx-table td{padding:12px;
border-bottom:1px solid #e5e7eb;}
.tx-table tr:last-child td{border-bottom:none;}
.tx-subtitle{color:#667eea;
font-weight:700;
font-size:1.3em;
margin:35px 0 20px 0;
padding-bottom:10px;
border-bottom:3px solid #667eea;}
.tx-point{color:#764ba2;
font-weight:600;}
.tx-emoji{font-size:1.3em;
margin:0 5px;}</style>

// app/Jobs/SyncBlockchainEvents.php
<?php

namespace App\Jobs;

use App\Models\Subscription;
use App\Models\SubscriptionTransaction;
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 SyncBlockchainEvents implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
    
    private $web3Service;
    
    public function __construct()
    {
        $this->web3Service = new Web3Service();
    }
    
    public function handle()
    {
        try {
            // 마지막 동기화된 블록 번호 가져오기
            $lastBlock = cache('last_synced_block', 0);
            $currentBlock = $this->web3Service->getCurrentBlockNumber();
            
            Log::info("Syncing blocks from {$lastBlock} to {$currentBlock}");
            
            // 이벤트 로그 가져오기
            $events = $this->web3Service->getContractEvents($lastBlock + 1, $currentBlock);
            
            foreach ($events as $event) {
                $this->processEvent($event);
            }
            
            // 마지막 블록 번호 캐시 업데이트
            cache(['last_synced_block' => $currentBlock], now()->addDays(7));
            
            Log::info("Sync completed. Processed " . count($events) . " events");
            
        } catch (\Exception $e) {
            Log::error("Blockchain sync failed: " . $e->getMessage());
            throw $e;
        }
    }
    
    private function processEvent(array $event)
    {
        $eventName = $event['event'];
        
        switch ($eventName) {
            case 'Subscribed':
                $this->handleSubscribed($event);
                break;
                
            case 'Renewed':
                $this->handleRenewed($event);
                break;
                
            case 'Cancelled':
                $this->handleCancelled($event);
                break;
                
            case 'AutoRenewToggled':
                $this->handleAutoRenewToggled($event);
                break;
        }
    }
    
    private function handleSubscribed(array $event)
    {
        $userAddress = $event['args']['user'];
        $planId = $event['args']['planId'];
        $endTime = $event['args']['endTime'];
        
        // 사용자 찾기 또는 생성
        $user = User::firstOrCreate(
            ['wallet_address' => strtolower($userAddress)],
            ['name' => 'User ' . substr($userAddress, 0, 8)]
        );
        
        // 구독 생성
        $subscription = Subscription::create([
            'user_id' => $user->id,
            'wallet_address' => strtolower($userAddress),
            'plan_id' => $planId,
            'start_time' => now(),
            'end_time' => \Carbon\Carbon::createFromTimestamp($endTime),
            'auto_renew' => true,
            'active' => true,
            'tx_hash' => $event['transactionHash']
        ]);
        
        // 트랜잭션 기록
        SubscriptionTransaction::create([
            'subscription_id' => $subscription->id,
            'tx_hash' => $event['transactionHash'],
            'type' => 'subscribe',
            'amount' => $this->getPlanPrice($planId),
            'block_number' => $event['blockNumber'],
            'block_timestamp' => now(),
            'status' => 'confirmed'
        ]);
        
        Log::info("New subscription created for {$userAddress}");
    }
    
    private function handleRenewed(array $event)
    {
        $userAddress = $event['args']['user'];
        $planId = $event['args']['planId'];
        $newEndTime = $event['args']['newEndTime'];
        
        $subscription = Subscription::where('wallet_address', strtolower($userAddress))
            ->where('active', true)
            ->first();
        
        if ($subscription) {
            $subscription->update([
                'end_time' => \Carbon\Carbon::createFromTimestamp($newEndTime)
            ]);
            
            SubscriptionTransaction::create([
                'subscription_id' => $subscription->id,
                'tx_hash' => $event['transactionHash'],
                'type' => 'renew',
                'amount' => $this->getPlanPrice($planId),
                'block_number' => $event['blockNumber'],
                'block_timestamp' => now(),
                'status' => 'confirmed'
            ]);
            
            Log::info("Subscription renewed for {$userAddress}");
        }
    }
    
    private function handleCancelled(array $event)
    {
        $userAddress = $event['args']['user'];
        
        $subscription = Subscription::where('wallet_address', strtolower($userAddress))
            ->where('active', true)
            ->first();
        
        if ($subscription) {
            $subscription->update([
                'active' => false,
                'auto_renew' => false
            ]);
            
            SubscriptionTransaction::create([
                'subscription_id' => $subscription->id,
                'tx_hash' => $event['transactionHash'],
                'type' => 'cancel',
                'amount' => '0',
                'block_number' => $event['blockNumber'],
                'block_timestamp' => now(),
                'status' => 'confirmed'
            ]);
            
            Log::info("Subscription cancelled for {$userAddress}");
        }
    }
    
    private function handleAutoRenewToggled(array $event)
    {
        $userAddress = $event['args']['user'];
        $autoRenew = $event['args']['autoRenew'];
        
        $subscription = Subscription::where('wallet_address', strtolower($userAddress))
            ->where('active', true)
            ->first();
        
        if ($subscription) {
            $subscription->update(['auto_renew' => $autoRenew]);
            Log::info("Auto-renew toggled for {$userAddress}: " . ($autoRenew ? 'ON' : 'OFF'));
        }
    }
    
    private function getPlanPrice(int $planId): string
    {
        $plan = $this->web3Service->getPlan($planId);
        return $plan['price'];
    }
}

// app/Console/Kernel.php
protected function schedule(Schedule $schedule)
{
    // 5분마다 블록체인 이벤트 동기화
    $schedule->job(new SyncBlockchainEvents())
             ->everyFiveMinutes()
             ->withoutOverlapping();
    
    // 매일 자정에 만료된 구독 정리
    $schedule->call(function () {
        Subscription::expired()
                   ->where('active', true)
                   ->update(['active' => false]);
    })->daily();
    
    // 만료 3일 전 알림
    $schedule->call(function () {
        $expiringSoon = Subscription::active()
            ->whereBetween('end_time', [now(), now()->addDays(3)])
            ->get();
        
        foreach ($expiringSoon as $subscription) {
            // 이메일 또는 푸시 알림 발송
            Mail::to($subscription->user->email)
                ->send(new SubscriptionExpiringNotification($subscription));
        }
    })->daily();
}

// app/Http/Middleware/VerifyWalletSignature.php
<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Elliptic\EC;
use kornrunner\Keccak;

class VerifyWalletSignature
{
    public function handle(Request $request, Closure $next)
    {
        $signature = $request->header('X-Wallet-Signature');
        $message = $request->header('X-Wallet-Message');
        $address = $request->header('X-Wallet-Address');
        
        if (!$signature || !$message || !$address) {
            return response()->json(['error' => 'Missing signature headers'], 401);
        }
        
        // 서명 검증
        if (!$this->verifySignature($message, $signature, $address)) {
            return response()->json(['error' => 'Invalid signature'], 401);
        }
        
        // 타임스탬프 검증 (재생 공격 방지)
        $timestamp = json_decode($message, true)['timestamp'] ?? 0;
        if (abs(time() - $timestamp) > 300) { // 5분 이내
            return response()->json(['error' => 'Signature expired'], 401);
        }
        
        // 요청에 지갑 주소 추가
        $request->merge(['verified_wallet' => strtolower($address)]);
        
        return $next($request);
    }
    
    private function verifySignature(string $message, string $signature, string $address): bool
    {
        // 이더리움 서명 메시지 형식
        $hash = Keccak::hash("\x19Ethereum Signed Message:\n" . strlen($message) . $message, 256);
        
        // 서명에서 r, s, v 추출
        $r = substr($signature, 2, 64);
        $s = substr($signature, 66, 64);
        $v = hexdec(substr($signature, 130, 2));
        
        if ($v < 27) {
            $v += 27;
        }
        
        $ec = new EC('secp256k1');
        $pubkey = $ec->recoverPubKey($hash, [
            'r' => $r,
            's' => $s
        ], $v - 27);
        
        $recoveredAddress = '0x' . substr(Keccak::hash(substr(hex2bin($pubkey->encode('hex')), 1), 256), 24);
        
        return strtolower($recoveredAddress) === strtolower($address);
    }
}

// app/Http/Controllers/DashboardController.php
<?php

namespace App\Http\Controllers;

use App\Models\Subscription;
use App\Models\SubscriptionTransaction;
use App\Models\SubscriptionPlan;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Carbon\Carbon;

class DashboardController extends Controller
{
    /**
     * 관리자 대시보드
     */
    public function admin()
    {
        $stats = [
            'total_subscriptions' => Subscription::count(),
            'active_subscriptions' => Subscription::active()->count(),
            'total_revenue' => $this->calculateTotalRevenue(),
            'monthly_revenue' => $this->calculateMonthlyRevenue(),
            'churn_rate' => $this->calculateChurnRate(),
            'mrr' => $this->calculateMRR(), // Monthly Recurring Revenue
            'arr' => $this->calculateARR(), // Annual Recurring Revenue
        ];
        
        // 플랜별 구독 분포
        $planDistribution = Subscription::active()
            ->select('plan_id', DB::raw('count(*) as count'))
            ->groupBy('plan_id')
            ->with('plan')
            ->get();
        
        // 월별 신규 구독 추이
        $monthlyGrowth = Subscription::select(
                DB::raw('DATE_FORMAT(created_at, "%Y-%m") as month'),
                DB::raw('count(*) as count')
            )
            ->where('created_at', '>=', now()->subMonths(12))
            ->groupBy('month')
            ->orderBy('month')
            ->get();
        
        // 최근 트랜잭션
        $recentTransactions = SubscriptionTransaction::with(['subscription.user', 'subscription.plan'])
            ->orderBy('created_at', 'desc')
            ->limit(10)
            ->get();
        
        return view('dashboard.admin', compact(
            'stats',
            'planDistribution',
            'monthlyGrowth',
            'recentTransactions'
        ));
    }
    
    /**
     * 사용자 대시보드
     */
    public function user(Request $request)
    {
        $user = $request->user();
        
        $subscription = Subscription::where('user_id', $user->id)
            ->where('active', true)
            ->with('plan')
            ->first();
        
        if (!$subscription) {
            return view('dashboard.user', [
                'has_subscription' => false
            ]);
        }
        
        $transactions = SubscriptionTransaction::where('subscription_id', $subscription->id)
            ->orderBy('created_at', 'desc')
            ->get();
        
        $stats = [
            'days_remaining' => $subscription->daysRemaining(),
            'total_spent' => $transactions->where('type', '!=', 'cancel')->sum('amount'),
            'renewal_count' => $transactions->where('type', 'renew')->count(),
            'is_expiring_soon' => $subscription->isExpiringSoon(),
        ];
        
        return view('dashboard.user', compact(
            'subscription',
            'transactions',
            'stats'
        ));
    }
    
    /**
     * 총 수익 계산
     */
    private function calculateTotalRevenue(): float
    {
        return SubscriptionTransaction::where('status', 'confirmed')
            ->where('type', '!=', 'cancel')
            ->sum(DB::raw('CAST(amount AS DECIMAL(20,6))'));
    }
    
    /**
     * 월간 수익 계산
     */
    private function calculateMonthlyRevenue(): float
    {
        return SubscriptionTransaction::where('status', 'confirmed')
            ->where('type', '!=', 'cancel')
            ->whereMonth('created_at', now()->month)
            ->whereYear('created_at', now()->year)
            ->sum(DB::raw('CAST(amount AS DECIMAL(20,6))'));
    }
    
    /**
     * 이탈률 계산
     */
    private function calculateChurnRate(): float
    {
        $startOfMonth = now()->startOfMonth();
        $endOfMonth = now()->endOfMonth();
        
        $activeAtStart = Subscription::where('active', true)
            ->where('created_at', '<', $startOfMonth)
            ->count();
        
        if ($activeAtStart === 0) {
            return 0;
        }
        
        $cancelled = Subscription::where('active', false)
            ->whereBetween('updated_at', [$startOfMonth, $endOfMonth])
            ->count();
        
        return ($cancelled / $activeAtStart) * 100;
    }
    
    /**
     * MRR (Monthly Recurring Revenue) 계산
     */
    private function calculateMRR(): float
    {
        $activeSubscriptions = Subscription::active()->with('plan')->get();
        
        $mrr = 0;
        foreach ($activeSubscriptions as $sub) {
            $plan = $sub->plan;
            if ($plan) {
                // 플랜 가격을 월 단위로 정규화
                $monthlyPrice = $plan->price * (30 * 24 * 60 * 60 / $plan->duration);
                $mrr += $monthlyPrice;
            }
        }
        
        return $mrr;
    }
    
    /**
     * ARR (Annual Recurring Revenue) 계산
     */
    private function calculateARR(): float
    {
        return $this->calculateMRR() * 12;
    }
    
    /**
     * API: 구독 통계
     */
    public function stats(Request $request)
    {
        $period = $request->input('period', '30d'); // 30d, 90d, 1y
        
        $startDate = match($period) {
            '30d' => now()->subDays(30),
            '90d' => now()->subDays(90),
            '1y' => now()->subYear(),
            default => now()->subDays(30)
        };
        
        $data = [
            'new_subscriptions' => Subscription::where('created_at', '>=', $startDate)->count(),
            'renewals' => SubscriptionTransaction::where('type', 'renew')
                ->where('created_at', '>=', $startDate)
                ->count(),
            'cancellations' => SubscriptionTransaction::where('type', 'cancel')
                ->where('created_at', '>=', $startDate)
                ->count(),
            'revenue' => SubscriptionTransaction::where('status', 'confirmed')
                ->where('type', '!=', 'cancel')
                ->where('created_at', '>=', $startDate)
                ->sum(DB::raw('CAST(amount AS DECIMAL(20,6))')),
        ];
        
        return response()->json($data);
    }
}

// app/Jobs/ProcessAutoRenewals.php
<?php

namespace App\Jobs;

use App\Models\Subscription;
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;
use Web3\Contract;

class ProcessAutoRenewals implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
    
    public $timeout = 300; // 5분
    
    public function handle()
    {
        // 24시간 이내 만료 예정이고 자동 갱신이 켜진 구독 찾기
        $expiringSubscriptions = Subscription::active()
            ->where('auto_renew', true)
            ->whereBetween('end_time', [now(), now()->addDay()])
            ->get();
        
        Log::info("Found {$expiringSubscriptions->count()} subscriptions to renew");
        
        foreach ($expiringSubscriptions as $subscription) {
            try {
                $this->renewSubscription($subscription);
            } catch (\Exception $e) {
                Log::error("Failed to renew subscription {$subscription->id}: " . $e->getMessage());
                
                // 실패 알림 발송
                $this->notifyRenewalFailure($subscription, $e->getMessage());
            }
        }
    }
    
    private function renewSubscription(Subscription $subscription)
    {
        $web3Service = new Web3Service();
        
        // 1. 사용자의 토큰 allowance 확인
        $allowance = $web3Service->checkAllowance(
            $subscription->wallet_address,
            config('web3.contract_address')
        );
        
        $planPrice = $web3Service->getPlan($subscription->plan_id)['price'];
        
        if (bccomp($allowance, $planPrice) < 0) {
            throw new \Exception("Insufficient allowance. User needs to approve more tokens.");
        }
        
        // 2. 서버 지갑으로 renew 트랜잭션 전송
        $txHash = $web3Service->renewSubscriptionForUser($subscription->wallet_address);
        
        Log::info("Renewal transaction sent: {$txHash}");
        
        // 3. 트랜잭션 기록
        SubscriptionTransaction::create([
            'subscription_id' => $subscription->id,
            'tx_hash' => $txHash,
            'type' => 'renew',
            'amount' => $planPrice,
            'block_number' => 0, // 나중에 업데이트
            'block_timestamp' => now(),
            'status' => 'pending'
        ]);
        
        // 4. 트랜잭션 확인 Job 큐에 추가
        ConfirmTransaction::dispatch($txHash, $subscription->id)
            ->delay(now()->addMinutes(2));
    }
    
    private function notifyRenewalFailure(Subscription $subscription, string $reason)
    {
        // 사용자에게 이메일 발송
        Mail::to($subscription->user->email)
            ->send(new RenewalFailedNotification($subscription, $reason));
        
        // 자동 갱신 비활성화
        $subscription->update(['auto_renew' => false]);
    }
}

// app/Services/Web3Service.php 에 추가

use Web3\Personal;

/**
 * 서버 지갑으로 사용자 구독 갱신
 */
public function renewSubscriptionForUser(string $userAddress): string
{
    $serverAddress = config('web3.server_wallet_address');
    $privateKey = config('web3.server_private_key');
    
    // 트랜잭션 데이터 생성
    $contract = new Contract($this->web3->provider, $this->abi);
    $contract->at($this->contractAddress);
    
    // renew() 함수 인코딩
    $data = $contract->getData('renew');
    
    // 가스 추정
    $gasEstimate = null;
    $this->web3->eth->estimateGas([
        'from' => $serverAddress,
        'to' => $this->contractAddress,
        'data' => $data
    ], function ($err, $gas) use (&$gasEstimate) {
        if ($err !== null) {
            throw new \Exception('Gas estimation failed: ' . $err->getMessage());
        }
        $gasEstimate = $gas;
    });
    
    // Nonce 가져오기
    $nonce = null;
    $this->web3->eth->getTransactionCount($serverAddress, 'pending', function ($err, $count) use (&$nonce) {
        if ($err !== null) {
            throw new \Exception('Failed to get nonce: ' . $err->getMessage());
        }
        $nonce = $count;
    });
    
    // 트랜잭션 서명 및 전송
    $transaction = [
        'from' => $serverAddress,
        'to' => $this->contractAddress,
        'gas' => '0x' . dechex($gasEstimate->toHex()),
        'gasPrice' => '0x' . dechex(20000000000), // 20 Gwei
        'nonce' => '0x' . dechex($nonce->toHex()),
        'data' => $data,
        'chainId' => config('web3.chain_id')
    ];
    
    // 서명
    $signedTx = $this->signTransaction($transaction, $privateKey);
    
    // 전송
    $txHash = null;
    $this->web3->eth->sendRawTransaction('0x' . $signedTx, function ($err, $hash) use (&$txHash) {
        if ($err !== null) {
            throw new \Exception('Transaction failed: ' . $err->getMessage());
        }
        $txHash = $hash;
    });
    
    return $txHash;
}

/**
 * 트랜잭션 서명
 */
private function signTransaction(array $transaction, string $privateKey): string
{
    // Ethereum 트랜잭션 서명 로직
    // elliptic-php 라이브러리 사용
    
    $ec = new \Elliptic\EC('secp256k1');
    $key = $ec->keyFromPrivate($privateKey);
    
    // RLP 인코딩 및 서명
    // ... (복잡한 서명 로직)
    
    return $signedTransaction;
}

// config/chains.php
<?php

return [
    'ethereum' => [
        'chain_id' => 1,
        'name' => 'Ethereum Mainnet',
        'rpc_url' => env('ETHEREUM_RPC_URL'),
        'explorer' => 'https://etherscan.io',
        'contract_address' => env('ETHEREUM_CONTRACT_ADDRESS'),
        'usdt_address' => '0xdAC17F958D2ee523a2206206994597C13D831ec7',
    ],
    
    'polygon' => [
        'chain_id' => 137,
        'name' => 'Polygon',
        'rpc_url' => env('POLYGON_RPC_URL'),
        'explorer' => 'https://polygonscan.com',
        'contract_address' => env('POLYGON_CONTRACT_ADDRESS'),
        'usdt_address' => '0xc2132D05D31c914a87C6611C10748AEb04B58e8F',
    ],
    
    'bsc' => [
        'chain_id' => 56,
        'name' => 'BNB Smart Chain',
        'rpc_url' => env('BSC_RPC_URL'),
        'explorer' => 'https://bscscan.com',
        'contract_address' => env('BSC_CONTRACT_ADDRESS'),
        'usdt_address' => '0x55d398326f99059fF775485246999027B3197955',
    ],
    
    'arbitrum' => [
        'chain_id' => 42161,
        'name' => 'Arbitrum One',
        'rpc_url' => env('ARBITRUM_RPC_URL'),
        'explorer' => 'https://arbiscan.io',
        'contract_address' => env('ARBITRUM_CONTRACT_ADDRESS'),
        'usdt_address' => '0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9',
    ],
];

// app/Services/Web3ServiceFactory.php
<?php

namespace App\Services;

class Web3ServiceFactory
{
    public static function create(string $chain): Web3Service
    {
        $config = config("chains.{$chain}");
        
        if (!$config) {
            throw new \InvalidArgumentException("Unsupported chain: {$chain}");
        }
        
        return new Web3Service(
            $config['rpc_url'],
            $config['contract_address'],
            $config['chain_id']
        );
    }
    
    public static function getSupportedChains(): array
    {
        return array_keys(config('chains'));
    }
}

// tests/Feature/SubscriptionTest.php
<?php

namespace Tests\Feature;

use Tests\TestCase;
use App\Models\User;
use App\Models\Subscription;
use App\Models\SubscriptionPlan;
use App\Services\Web3Service;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Mockery;

class SubscriptionTest extends TestCase
{
    use RefreshDatabase;
    
    protected function setUp(): void
    {
        parent::setUp();
        
        // 테스트 플랜 생성
        SubscriptionPlan::create([
            'chain_plan_id' => 1,
            'name' => 'Basic Plan',
            'price' => '9990000', // 9.99 USDT (6 decimals)
            'duration' => 2592000, // 30 days
            'active' => true,
            'features' => json_encode(['Feature 1', 'Feature 2'])
        ]);
    }
    
    /** @test */
    public function user_can_subscribe_to_plan()
    {
        $user = User::factory()->create([
            'wallet_address' => '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb'
        ]);
        
        // Web3Service 모킹
        $web3Mock = Mockery::mock(Web3Service::class);
        $web3Mock->shouldReceive('checkSubscription')
            ->andReturn([
                'plan_id' => '1',
                'start_time' => time(),
                'end_time' => time() + 2592000,
                'auto_renew' => true,
                'active' => true
            ]);
        
        $this->app->instance(Web3Service::class, $web3Mock);
        
        // API 호출
        $response = $this->actingAs($user)
            ->postJson('/api/subscription/sync', [
                'tx_hash' => '0xabc123...',
                'wallet_address' => $user->wallet_address
            ]);
        
        $response->assertStatus(200);
        
        // DB 확인
        $this->assertDatabaseHas('subscriptions', [
            'user_id' => $user->id,
            'wallet_address' => strtolower($user->wallet_address),
            'plan_id' => 1,
            'active' => true
        ]);
    }
    
    /** @test */
    public function subscription_expires_after_end_time()
    {
        $user = User::factory()->create();
        
        $subscription = Subscription::create([
            'user_id' => $user->id,
            'wallet_address' => '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb',
            'plan_id' => 1,
            'start_time' => now()->subDays(31),
            'end_time' => now()->subDay(),
            'auto_renew' => false,
            'active' => true
        ]);
        
        $this->assertFalse($subscription->isValid());
        $this->assertEquals(0, $subscription->daysRemaining());
    }
    
    /** @test */
    public function auto_renewal_processes_expiring_subscriptions()
    {
        $subscription = Subscription::create([
            'user_id' => User::factory()->create()->id,
            'wallet_address' => '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb',
            'plan_id' => 1,
            'start_time' => now()->subDays(29),
            'end_time' => now()->addHours(12), // 12시간 후 만료
            'auto_renew' => true,
            'active' => true
        ]);
        
        // Web3Service 모킹
        $web3Mock = Mockery::mock(Web3Service::class);
        $web3Mock->shouldReceive('checkAllowance')
            ->andReturn('100000000'); // 충분한 allowance
        $web3Mock->shouldReceive('renewSubscriptionForUser')
            ->andReturn('0xtxhash123');
        
        $this->app->instance(Web3Service::class, $web3Mock);
        
        // Job 실행
        $job = new \App\Jobs\ProcessAutoRenewals();
        $job->handle();
        
        // 트랜잭션 기록 확인
        $this->assertDatabaseHas('subscription_transactions', [
            'subscription_id' => $subscription->id,
            'type' => 'renew',
            'status' => 'pending'
        ]);
    }
    
    /** @test */
    public function dashboard_shows_correct_statistics()
    {
        $admin = User::factory()->create(['is_admin' => true]);
        
        // 테스트 데이터 생성
        Subscription::factory()->count(10)->create(['active' => true]);
        Subscription::factory()->count(3)->create(['active' => false]);
        
        $response = $this->actingAs($admin)
            ->get('/dashboard/admin');
        
        $response->assertStatus(200);
        $response->assertViewHas('stats');
        
        $stats = $response->viewData('stats');
        $this->assertEquals(13, $stats['total_subscriptions']);
        $this->assertEquals(10, $stats['active_subscriptions']);
    }
}

# /etc/supervisor/conf.d/laravel-worker.conf

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

server {
    listen 80;
    listen [::]:80;
    server_name your-domain.com;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    server_name your-domain.com;
    root /var/www/html/public;

    ssl_certificate /etc/letsencrypt/live/your-domain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/your-domain.com/privkey.pem;

    add_header X-Frame-Options "SAMEORIGIN";
    add_header X-Content-Type-Options "nosniff";

    index index.php;

    charset utf-8;

    location / {
        try_files $uri $uri/ /index.php?$query_string;
    }

    location = /favicon.ico { access_log off; log_not_found off; }
    location = /robots.txt  { access_log off; log_not_found off; }

    error_page 404 /index.php;

    location ~ \.php$ {
        fastcgi_pass unix:/var/run/php/php8.1-fpm.sock;
        fastcgi_param SCRIPT_FILENAME $realpath_root$fastcgi_script_name;
        include fastcgi_params;
    }

    location ~ /\.(?!well-known).* {
        deny all;
    }
}