# 라라벨 프로젝트 생성

composer create-project laravel/laravel blockchain-membership

cd blockchain-membership


# Web3 PHP 라이브러리 설치

composer require web3p/web3.php


# 지갑 서명 검증용

composer require kornrunner/keccak

composer require simplito/elliptic-php


# JWT 인증

composer require tymon/jwt-auth


# 환경변수 설정

cp .env.example .env

php artisan key:generate

# .env 파일에 추가

ETHEREUM_RPC_URL=https://mainnet.infura.io/v3/YOUR_PROJECT_ID

ETHEREUM_CHAIN_ID=1

CONTRACT_ADDRESS=0xYourNFTContractAddress

PRIVATE_KEY=your_backend_wallet_private_key


# 테스트넷 사용시 (Sepolia)

ETHEREUM_RPC_URL=https://sepolia.infura.io/v3/YOUR_PROJECT_ID

ETHEREUM_CHAIN_ID=11155111

<?php

// app/Http/Controllers/AuthController.php

namespace App\Http\Controllers;


use App\Models\User;

use Illuminate\Http\Request;

use Illuminate\Support\Str;


class AuthController extends Controller

{

// 지갑 주소로 Nonce 요청

public function getNonce(Request $request)

{

$request->validate([

'wallet_address' => 'required|string|size:42'

]);


$address = strtolower($request->wallet_address);

$nonce = Str::random(32);


$user = User::updateOrCreate(

['wallet_address' => $address],

['nonce' => $nonce]

);


return response()->json([

'nonce' => $nonce,

'message' => "멤버십 로그인 서명: {$nonce}"

]);

}

}

<?php

// app/Services/Web3AuthService.php

namespace App\Services;


use kornrunner\Keccak;

use Elliptic\EC;


class Web3AuthService

{

public function verifySignature(

string $address,

string $message,

string $signature

): bool {

// Ethereum 서명 메시지 포맷

$msgLen = strlen($message);

$hash = Keccak::hash(

"\x19Ethereum Signed Message:\n{$msgLen}{$message}",

256

);


// 서명에서 r, s, v 추출

$sign = [

"r" => substr($signature, 2, 64),

"s" => substr($signature, 66, 64),

];

$recid = ord(hex2bin(substr($signature, 130, 2))) - 27;


// 공개키 복원

$ec = new EC('secp256k1');

$pubkey = $ec->recoverPubKey($hash, $sign, $recid);


// 주소 생성 및 비교

$recoveredAddress = $this->pubKeyToAddress($pubkey);

return strtolower($recoveredAddress) === strtolower($address);

}


private function pubKeyToAddress($pubkey): string

{

$pubkeyHex = $pubkey->encode('hex');

$hash = Keccak::hash(hex2bin(substr($pubkeyHex, 2)), 256);

return '0x' . substr($hash, -40);

}

}

<?php

// app/Services/Web3Service.php

namespace App\Services;


use Web3\Web3;

use Web3\Contract;

use Web3\Providers\HttpProvider;

use Web3\RequestManagers\HttpRequestManager;


class Web3Service

{

protected Web3 $web3;

protected Contract $contract;

protected string $contractAddress;


// ERC-721 ABI (핵심 함수만)

protected array $abi = [

['name' => 'balanceOf', 'type' => 'function',

'inputs' => [['name' => 'owner', 'type' => 'address']],

'outputs' => [['name' => '', 'type' => 'uint256']],

'stateMutability' => 'view'],

['name' => 'tokenOfOwnerByIndex', 'type' => 'function',

'inputs' => [

['name' => 'owner', 'type' => 'address'],

['name' => 'index', 'type' => 'uint256']

],

'outputs' => [['name' => '', 'type' => 'uint256']],

'stateMutability' => 'view'],

];


public function __construct()

{

$rpcUrl = config('blockchain.rpc_url');

$this->contractAddress = config('blockchain.contract_address');


$this->web3 = new Web3(

new HttpProvider(

new HttpRequestManager($rpcUrl, 30)

)

);


$this->contract = new Contract(

$this->web3->provider,

json_encode($this->abi)

);

}


// NFT 보유 여부 확인

public function getNFTBalance(string $walletAddress): int

{

$balance = 0;

$this->contract->at($this->contractAddress)

->call('balanceOf', $walletAddress,

function ($err, $result) use (&$balance) {

if (!$err) {

$balance = (int) $result[0]->toString();

}

}

);

return $balance;

}


// 멤버십 등급 판별

public function getMembershipTier(string $walletAddress): string

{

$balance = $this->getNFTBalance($walletAddress);

if ($balance === 0) return 'none';


// 첫 번째 토큰 ID로 등급 판별

$tokenId = $this->getTokenIdByIndex($walletAddress, 0);


return match(true) {

$tokenId >= 5001 => 'diamond',

$tokenId >= 3001 => 'gold',

$tokenId >= 1001 => 'silver',

default => 'bronze'

};

}

}

<?php

// config/blockchain.php

return [

'rpc_url' => env('ETHEREUM_RPC_URL'),

'chain_id' => env('ETHEREUM_CHAIN_ID', 1),

'contract_address' => env('CONTRACT_ADDRESS'),

'private_key' => env('PRIVATE_KEY'),

'cache_ttl' => 300, // 5분 캐싱

];

<?php

// app/Http/Middleware/CheckMembership.php

namespace App\Http\Middleware;


use App\Services\Web3Service;

use Closure;

use Illuminate\Http\Request;

use Illuminate\Support\Facades\Cache;


class CheckMembership

{

protected array $tierHierarchy = [

'none' => 0,

'bronze' => 1,

'silver' => 2,

'gold' => 3,

'diamond' => 4,

];


public function handle(Request $request, Closure $next, string $requiredTier = 'bronze')

{

$user = $request->user();

$walletAddress = $user->wallet_address;


// 캐시로 블록체인 호출 최소화 (5분 캐싱)

$cacheKey = "membership_tier_{$walletAddress}";

$currentTier = Cache::remember($cacheKey, 300, function () use ($walletAddress) {

$web3Service = app(Web3Service::class);

return $web3Service->getMembershipTier($walletAddress);

});


// 등급 비교

$currentLevel = $this->tierHierarchy[$currentTier] ?? 0;

$requiredLevel = $this->tierHierarchy[$requiredTier] ?? 0;


if ($currentLevel < $requiredLevel) {

return response()->json([

'error' => '멤버십 등급이 부족합니다',

'required' => $requiredTier,

'current' => $currentTier,

], 403);

}


// 현재 등급 정보를 request에 추가

$request->merge(['membership_tier' => $currentTier]);

return $next($request);

}

}

<?php

// routes/api.php

use App\Http\Controllers\ContentController;

use App\Http\Controllers\AuthController;


// 인증 라우트

Route::post('/auth/nonce', [AuthController::class, 'getNonce']);

Route::post('/auth/verify', [AuthController::class, 'verifyAndLogin']);


// 멤버십 보호 라우트

Route::middleware(['auth:api'])->group(function () {


// 브론즈 이상

Route::middleware('membership:bronze')->group(function () {

Route::get('/content/basic', [ContentController::class, 'basic']);

Route::get('/community', [ContentController::class, 'community']);

});


// 실버 이상

Route::middleware('membership:silver')->group(function () {

Route::get('/content/premium', [ContentController::class, 'premium']);

Route::get('/analytics', [ContentController::class, 'analytics']);

});


// 골드 이상

Route::middleware('membership:gold')->group(function () {

Route::get('/governance/vote', [GovernanceController::class, 'vote']);

Route::get('/revenue/share', [RevenueController::class, 'share']);

});


// 다이아몬드 전용

Route::middleware('membership:diamond')->group(function () {

Route::post('/dao/propose', [DaoController::class, 'propose']);

});

});

<?php

// app/Console/Commands/ListenBlockchainEvents.php

namespace App\Console\Commands;


use App\Jobs\ProcessNFTTransfer;

use App\Services\Web3Service;

use Illuminate\Console\Command;

use Illuminate\Support\Facades\Cache;


class ListenBlockchainEvents extends Command

{

protected $signature = 'blockchain:listen';

protected $description = 'NFT Transfer 이벤트 리스닝';


public function handle(Web3Service $web3Service)

{

$this->info('블록체인 이벤트 리스닝 시작...');


// 마지막으로 처리한 블록 번호

$lastBlock = Cache::get('last_processed_block', 'latest');


while (true) {

$events = $web3Service->getTransferEvents($lastBlock);


foreach ($events as $event) {

// 큐에 작업 추가

ProcessNFTTransfer::dispatch(

$event['from'],

$event['to'],

$event['tokenId']

);

$lastBlock = $event['blockNumber'];

}


Cache::put('last_processed_block', $lastBlock, 86400);

sleep(15); // 15초마다 폴링

}

}

}

<?php

// app/Jobs/ProcessNFTTransfer.php

namespace App\Jobs;


use App\Models\User;

use App\Models\MembershipLog;

use Illuminate\Bus\Queueable;

use Illuminate\Contracts\Queue\ShouldQueue;

use Illuminate\Foundation\Bus\Dispatchable;

use Illuminate\Support\Facades\Cache;


class ProcessNFTTransfer implements ShouldQueue

{

use Dispatchable, Queueable;


public function __construct(

public string $fromAddress,

public string $toAddress,

public int $tokenId

) {}


public function handle()

{

// 보낸 사람 캐시 무효화

if ($this->fromAddress !== '0x0000000000000000000000000000000000000000') {

Cache::forget("membership_tier_{$this->fromAddress}");

$this->updateUserMembership($this->fromAddress);

}


// 받은 사람 캐시 무효화

Cache::forget("membership_tier_{$this->toAddress}");

$this->updateUserMembership($this->toAddress);


// 전송 로그 기록

MembershipLog::create([

'from_address' => $this->fromAddress,

'to_address' => $this->toAddress,

'token_id' => $this->tokenId,

'event_type' => 'transfer',

'processed_at' => now(),

]);

}


private function updateUserMembership(string $address): void

{

$web3Service = app(Web3Service::class);

$tier = $web3Service->getMembershipTier($address);


User::where('wallet_address', $address)

->update(['membership_tier' => $tier]);

}

}

<?php

// database/migrations/create_users_table.php

Schema::create('users', function (Blueprint $table) {

$table->id();

$table->string('wallet_address', 42)->unique();

$table->string('nonce', 64)->nullable();

$table->enum('membership_tier', ['none','bronze','silver','gold','diamond'])

->default('none');

$table->string('username')->nullable();

$table->string('email')->nullable();

$table->timestamp('last_blockchain_sync')->nullable();

$table->timestamps();

$table->index('wallet_address');

$table->index('membership_tier');

});


// membership_logs 테이블

Schema::create('membership_logs', function (Blueprint $table) {

$table->id();

$table->string('from_address', 42)->nullable();

$table->string('to_address', 42);

$table->unsignedBigInteger('token_id');

$table->string('event_type', 20); // mint, transfer, burn

$table->string('tx_hash', 66)->nullable();

$table->unsignedBigInteger('block_number')->nullable();

$table->timestamp('processed_at');

$table->timestamps();

$table->index(['to_address', 'token_id']);

});

; /etc/supervisor/conf.d/laravel-blockchain.conf

[program:laravel-blockchain-worker]

process_name=%(program_name)s_%(process_num)02d

command=php /var/www/html/artisan queue:work redis

--queue=blockchain,default

--sleep=3

--tries=3

--max-time=3600

autostart=true

autorestart=true

stopasgroup=true

killasgroup=true

user=www-data

numprocs=2

redirect_stderr=true

stdout_logfile=/var/log/blockchain-worker.log


[program:laravel-blockchain-listener]

command=php /var/www/html/artisan blockchain:listen

autostart=true

autorestart=true

user=www-data

numprocs=1

stdout_logfile=/var/log/blockchain-listener.log

# Laravel Horizon 설치 (큐 모니터링 대시보드)

composer require laravel/horizon

php artisan horizon:install

php artisan migrate


# Horizon 실행

php artisan horizon


# 대시보드 접근: /horizon