# docker-compose.yml

version: '3.8'

services:

# Laravel API 서버

laravel-api:

build: ./laravel

ports: ["8000:8000"]

environment:

- DB_HOST=mysql

- REDIS_HOST=redis

- PYTHON_SERVICE_URL=http://python-worker:5000

depends_on: [mysql, redis]



# Python Web3 Worker

python-worker:

build: ./python

ports: ["5000:5000"]

environment:

- WEB3_PROVIDER_URL=https://mainnet.infura.io/v3/YOUR_KEY

- REDIS_URL=redis://redis:6379

- CONTRACT_ADDRESS=0x...

depends_on: [redis]



# MySQL 데이터베이스

mysql:

image: mysql:8.0

volumes: ["mysql_data:/var/lib/mysql"]

environment:

MYSQL_DATABASE: dao_backend



# Redis (캐시 + 메시지 브로커)

redis:

image: redis:7-alpine

ports: ["6379:6379"]



# Nginx 리버스 프록시

nginx:

image: nginx:alpine

ports: ["80:80", "443:443"]

depends_on: [laravel-api, python-worker]

// database/migrations/create_proposals_table.php

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

$table->id();

$table->string('onchain_id')->nullable()->index(); // 온체인 프로포절 ID

$table->string('title');

$table->text('description'); // IPFS에 올리기 전 오프체인 저장

$table->string('ipfs_hash')->nullable(); // IPFS CID

$table->string('proposer_address', 42)->index(); // 이더리움 주소

$table->foreignId('proposer_id')->constrained('members');

$table->enum('status', [

'draft', 'pending', 'active', 'succeeded',

'defeated', 'queued', 'executed', 'cancelled'

])->default('draft');

$table->string('tx_hash')->nullable(); // 온체인 제출 트랜잭션

$table->bigInteger('for_votes')->default(0);

$table->bigInteger('against_votes')->default(0);

$table->bigInteger('abstain_votes')->default(0);

$table->integer('quorum_required');

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

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

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

$table->json('actions')->nullable(); // 실행할 컨트랙트 액션들

$table->timestamps();

});



// create_votes_table.php

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

$table->id();

$table->foreignId('proposal_id')->constrained();

$table->string('voter_address', 42)->index();

$table->enum('support', ['for', 'against', 'abstain']);

$table->decimal('voting_power', 36, 18); // 토큰 기반 투표력

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

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

$table->boolean('is_onchain_verified')->default(false);

$table->timestamps();

$table->unique(['proposal_id', 'voter_address']);

});



// create_members_table.php

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

$table->id();

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

$table->string('ens_name')->nullable(); // ENS 도메인

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

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

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

$table->decimal('token_balance', 36, 18)->default(0);

$table->decimal('delegated_votes', 36, 18)->default(0);

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

$table->integer('proposals_created')->default(0);

$table->integer('votes_cast')->default(0);

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

$table->timestamps();

});

// app/Http/Controllers/AuthController.php

class AuthController extends Controller

{

public function getNonce(Request $request): JsonResponse

{

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

$nonce = Str::random(32);



// Redis에 5분간 nonce 저장

Cache::put("siwe_nonce:{$address}", $nonce, 300);



return response()->json([

'nonce' => $nonce,

'message' => "DAO에 로그인합니다.\n\n주소: {$address}\nNonce: {$nonce}"

]);

}



public function verifySignature(Request $request): JsonResponse

{

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

$signature = $request->signature;

$message = $request->message;



// Redis에서 nonce 확인

$storedNonce = Cache::get("siwe_nonce:{$address}");

if (!$storedNonce || !str_contains($message, $storedNonce)) {

return response()->json(['error' => '유효하지 않은 nonce'], 401);

}



// Python 서비스에 서명 검증 위임

$verified = $this->pythonService->verifyEthSignature(

$address, $message, $signature

);



if (!$verified) {

return response()->json(['error' => '서명 검증 실패'], 401);

}



// 멤버 조회 또는 생성

$member = Member::firstOrCreate(

['wallet_address' => $address],

['display_name' => substr($address, 0, 6) . '...' . substr($address, -4)]

);



// Sanctum 토큰 발급

$token = $member->createToken('dao-session')->plainTextToken;

Cache::forget("siwe_nonce:{$address}");



return response()->json(['token' => $token, 'member' => $member]);

}

}

// app/Services/ProposalService.php

class ProposalService

{

public function __construct(

private PythonServiceClient $pythonClient,

private IpfsService $ipfsService

) {}



public function createProposal(array $data, Member $proposer): Proposal

{

// 1. IPFS에 메타데이터 업로드

$metadata = [

'title' => $data['title'],

'description' => $data['description'],

'actions' => $data['actions'],

'proposer' => $proposer->wallet_address,

'created_at' => now()->toIso8601String(),

];



$ipfsHash = $this->ipfsService->uploadJson($metadata);



// 2. DB에 오프체인 데이터 저장

$proposal = Proposal::create([

'title' => $data['title'],

'description' => $data['description'],

'ipfs_hash' => $ipfsHash,

'proposer_address' => $proposer->wallet_address,

'proposer_id' => $proposer->id,

'status' => 'pending',

'actions' => $data['actions'],

'quorum_required' => config('dao.quorum_percentage'),

]);



// 3. Python 서비스에 온체인 제출 작업 큐잉

SubmitProposalJob::dispatch($proposal->id, $ipfsHash, $data['actions']);



return $proposal;

}



public function syncOnchainStatus(int $proposalId): void

{

// Python 서비스에서 온체인 상태 조회

$onchainData = $this->pythonClient->getProposalState($proposalId);



Proposal::where('id', $proposalId)->update([

'status' => $this->mapOnchainStatus($onchainData['state']),

'for_votes' => $onchainData['for_votes'],

'against_votes' => $onchainData['against_votes'],

'abstain_votes' => $onchainData['abstain_votes'],

]);



// Redis 캐시 갱신

Cache::put("proposal_status:{$proposalId}", $onchainData, 60);

}

}

// app/Services/PythonServiceClient.php

class PythonServiceClient

{

private string $baseUrl;



public function __construct()

{

$this->baseUrl = config('services.python.url', 'http://python-worker:5000');

}



// 동기 방식: 즉시 응답이 필요한 경우

public function verifyEthSignature(string $address, string $message, string $sig): bool

{

$response = Http::timeout(10)->post("{$this->baseUrl}/verify-signature", [

'address' => $address,

'message' => $message,

'signature' => $sig,

]);



return $response->successful() && $response->json('verified') === true;

}



// 동기 방식: 토큰 잔액 조회

public function getTokenBalance(string $address): string

{

$cacheKey = "token_balance:{$address}";



return Cache::remember($cacheKey, 30, function () use ($address) {

$response = Http::timeout(15)->get("{$this->baseUrl}/token-balance/{$address}");

return $response->json('balance', '0');

});

}



// 비동기 방식: Redis 큐를 통한 작업 위임

public function queueBlockchainJob(string $jobType, array $payload): string

{

$jobId = Str::uuid()->toString();



Redis::lpush('blockchain_jobs', json_encode([

'job_id' => $jobId,

'type' => $jobType,

'payload' => $payload,

'created_at' => now()->timestamp,

]));



return $jobId; // 클라이언트에 job_id 반환, 폴링으로 상태 확인

}



// 작업 상태 확인

public function getJobStatus(string $jobId): array

{

$result = Redis::get("job_result:{$jobId}");

return $result ? json_decode($result, true) : ['status' => 'pending'];

}

}

# python/main.py

from fastapi import FastAPI, HTTPException

from web3 import Web3

from eth_account.messages import encode_defunct

from eth_account import Account

import redis

import json

import os

from contextlib import asynccontextmanager



# Web3 연결 초기화

w3 = Web3(Web3.HTTPProvider(os.getenv('WEB3_PROVIDER_URL')))

redis_client = redis.from_url(os.getenv('REDIS_URL', 'redis://localhost:6379'))



@asynccontextmanager

async def lifespan(app: FastAPI):

# 시작 시 블록체인 연결 확인

if not w3.is_connected():

raise Exception("블록체인 연결 실패!")

print(f"✅ 블록체인 연결 성공 - 현재 블록: {w3.eth.block_number}")

yield

print("🔴 Python 서비스 종료")



app = FastAPI(title="DAO Python Service", lifespan=lifespan)



# 라우터 등록

from routers import signature, token, proposal, governance

app.include_router(signature.router, prefix="/api")

app.include_router(token.router, prefix="/api")

app.include_router(proposal.router, prefix="/api")

app.include_router(governance.router, prefix="/api")

# python/routers/signature.py

from fastapi import APIRouter, HTTPException

from pydantic import BaseModel

from eth_account.messages import encode_defunct

from eth_account import Account

from web3 import Web3



router = APIRouter()



class SignatureVerifyRequest(BaseModel):

address: str

message: str

signature: str



@router.post("/verify-signature")

async def verify_signature(req: SignatureVerifyRequest):

try:

# EIP-191 메시지 해시 생성

message_hash = encode_defunct(text=req.message)



# 서명에서 주소 복구

recovered_address = Account.recover_message(

message_hash,

signature=req.signature

)



# 주소 비교 (대소문자 무시)

verified = recovered_address.lower() == req.address.lower()



return {"verified": verified, "recovered_address": recovered_address}

except Exception as e:

raise HTTPException(status_code=400, detail=f"서명 검증 오류: {str(e)}")



@router.post("/verify-typed-data")

async def verify_typed_data(req: dict):

"""EIP-712 타입드 데이터 서명 검증 (메타트랜잭션용)"""

try:

from eth_account._utils.structured_data.hashing import hash_domain

# EIP-712 검증 로직

structured_data = req.get('structured_data')

signature = req.get('signature')



recovered = Account.recover_message(

encode_defunct(hexstr=Web3.keccak(text=str(structured_data)).hex()),

signature=signature

)

return {"verified": True, "signer": recovered}

except Exception as e:

raise HTTPException(status_code=400, detail=str(e))

# python/services/governor_service.py

from web3 import Web3

import json

import os



# Governor ABI (핵심 함수들만)

GOVERNOR_ABI = json.loads('''[

{"name":"propose","type":"function","inputs":[

{"name":"targets","type":"address[]"},

{"name":"values","type":"uint256[]"},

{"name":"calldatas","type":"bytes[]"},

{"name":"description","type":"string"}

],"outputs":[{"name":"","type":"uint256"}]},

{"name":"castVote","type":"function","inputs":[

{"name":"proposalId","type":"uint256"},

{"name":"support","type":"uint8"}

],"outputs":[{"name":"","type":"uint256"}]},

{"name":"state","type":"function","inputs":[

{"name":"proposalId","type":"uint256"}

],"outputs":[{"name":"","type":"uint8"}]},

{"name":"proposalVotes","type":"function","inputs":[

{"name":"proposalId","type":"uint256"}

],"outputs":[

{"name":"againstVotes","type":"uint256"},

{"name":"forVotes","type":"uint256"},

{"name":"abstainVotes","type":"uint256"}

]}

]''')



class GovernorService:

# 프로포절 상태 매핑

PROPOSAL_STATES = {

0: "pending", 1: "active", 2: "cancelled",

3: "defeated", 4: "succeeded", 5: "queued",

6: "expired", 7: "executed"

}



def __init__(self, w3: Web3):

self.w3 = w3

self.contract = w3.eth.contract(

address=Web3.to_checksum_address(os.getenv('GOVERNOR_ADDRESS')),

abi=GOVERNOR_ABI

)



def get_proposal_state(self, proposal_id: int) -> dict:

"""온체인 프로포절 상태 조회"""

state_code = self.contract.functions.state(proposal_id).call()

votes = self.contract.functions.proposalVotes(proposal_id).call()



return {

"state": self.PROPOSAL_STATES.get(state_code, "unknown"),

"state_code": state_code,

"against_votes": str(votes[0]),

"for_votes": str(votes[1]),

"abstain_votes": str(votes[2]),

}



def submit_proposal(

self,

targets: list,

values: list,

calldatas: list,

description: str,

private_key: str  # 실제로는 HSM이나 KMS 사용 권장!

) -> str:

"""온체인 프로포절 제출"""

account = self.w3.eth.account.from_key(private_key)



# 가스 추정

gas_estimate = self.contract.functions.propose(

targets, values, calldatas, description

).estimate_gas({'from': account.address})



# 트랜잭션 빌드

tx = self.contract.functions.propose(

targets, values, calldatas, description

).build_transaction({

'from': account.address,

'gas': int(gas_estimate * 1.2),  # 20% 버퍼

'gasPrice': self.w3.eth.gas_price,

'nonce': self.w3.eth.get_transaction_count(account.address),

})



# 서명 및 전송

signed_tx = self.w3.eth.account.sign_transaction(tx, private_key)

tx_hash = self.w3.eth.send_raw_transaction(signed_tx.rawTransaction)



# 영수증 대기

receipt = self.w3.eth.wait_for_transaction_receipt(tx_hash, timeout=120)



return tx_hash.hex()

# python/workers/event_listener.py

import asyncio

from web3 import Web3, AsyncWeb3

from web3.middleware import geth_poa_middleware

import httpx

import redis

import json

import logging



logger = logging.getLogger(__name__)



class DAOEventListener:

def __init__(self, w3: Web3, redis_client, laravel_url: str):

self.w3 = w3

self.redis = redis_client

self.laravel_url = laravel_url

self.governor_contract = self._load_governor_contract()

self.token_contract = self._load_token_contract()



async def listen_proposal_created(self):

"""ProposalCreated 이벤트 리스닝"""

event_filter = self.governor_contract.events.ProposalCreated.create_filter(

fromBlock='latest'

)



while True:

try:

events = event_filter.get_new_entries()

for event in events:

await self._handle_proposal_created(event)

await asyncio.sleep(12)  # 이더리움 블록 시간 ~12초

except Exception as e:

logger.error(f"이벤트 리스닝 오류: {e}")

await asyncio.sleep(30)



async def _handle_proposal_created(self, event):

"""ProposalCreated 이벤트 처리"""

args = event['args']

proposal_id = args['proposalId']

proposer = args['proposer']

description = args['description']

tx_hash = event['transactionHash'].hex()



logger.info(f"새 프로포절 감지: {proposal_id}")



# Laravel API에 상태 업데이트 요청

async with httpx.AsyncClient() as client:

await client.post(

f"{self.laravel_url}/internal/proposals/onchain-created",

json={

"onchain_id": str(proposal_id),

"proposer_address": proposer,

"tx_hash": tx_hash,

"start_block": args['startBlock'],

"end_block": args['endBlock'],

},

headers={"X-Internal-Secret": "your-secret-key"}

)



# Redis에 이벤트 발행 (실시간 알림용)

self.redis.publish('dao_events', json.dumps({

'type': 'PROPOSAL_CREATED',

'proposal_id': str(proposal_id),

'proposer': proposer,

}))



async def listen_vote_cast(self):

"""VoteCast 이벤트 리스닝"""

event_filter = self.governor_contract.events.VoteCast.create_filter(

fromBlock='latest'

)



while True:

try:

events = event_filter.get_new_entries()

for event in events:

args = event['args']

# Laravel에 투표 결과 동기화

async with httpx.AsyncClient() as client:

await client.post(

f"{self.laravel_url}/internal/votes/sync",

json={

"proposal_id": str(args['proposalId']),

"voter": args['voter'],

"support": args['support'],

"weight": str(args['weight']),

"reason": args.get('reason', ''),

},

headers={"X-Internal-Secret": "your-secret-key"}

)

await asyncio.sleep(12)

except Exception as e:

logger.error(f"VoteCast 리스닝 오류: {e}")

await asyncio.sleep(30)



async def run_all_listeners(self):

"""모든 이벤트 리스너 동시 실행"""

await asyncio.gather(

self.listen_proposal_created(),

self.listen_vote_cast(),

self.listen_transfer_events(),  # 토큰 이전 감지

self.listen_delegate_changed(), # 위임 변경 감지

)

// Laravel → Python 동기 호출 예시

// app/Http/Controllers/MemberController.php



public function getTokenBalance(Request $request): JsonResponse

{

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



try {

// Python 서비스에서 실시간 잔액 조회

$balance = $this->pythonClient->getTokenBalance($address);



// DB 업데이트 (비동기로 처리)

UpdateMemberBalanceJob::dispatch($address, $balance);



return response()->json([

'address' => $address,

'balance' => $balance,

'formatted' => number_format($balance / 1e18, 4) . ' GOV',

]);

} catch (ConnectionException $e) {

// Python 서비스 다운 시 캐시 폴백

$cachedBalance = Cache::get("token_balance:{$address}", '0');

return response()->json([

'balance' => $cachedBalance,

'source' => 'cache', // 캐시에서 가져왔음을 명시

]);

}

}

# Python 쪽 Redis 큐 워커

# python/workers/job_processor.py



import redis

import json

import asyncio

from services.governor_service import GovernorService



class BlockchainJobProcessor:

def __init__(self, redis_client, governor_service: GovernorService):

self.redis = redis_client

self.governor = governor_service



async def process_jobs(self):

"""Redis 큐에서 작업 꺼내서 처리"""

while True:

try:

# 블로킹 팝 (작업이 올 때까지 대기)

job_data = self.redis.brpop('blockchain_jobs', timeout=30)



if job_data:

_, job_json = job_data

job = json.loads(job_json)



await self._process_single_job(job)



except Exception as e:

print(f"작업 처리 오류: {e}")
await asyncio.sleep(5)



async def _process_single_job(self, job: dict):

job_id = job['job_id']

job_type = job['type']

payload = job['payload']



try:

result = None



if job_type == 'SUBMIT_PROPOSAL':

result = self.governor.submit_proposal(

targets=payload['targets'],

values=payload['values'],

calldatas=payload['calldatas'],

description=payload['description'],

private_key=payload['private_key']

)

elif job_type == 'CAST_VOTE':

result = await self._cast_vote(payload)

elif job_type == 'QUEUE_PROPOSAL':

result = await self._queue_proposal(payload)

elif job_type == 'EXECUTE_PROPOSAL':

result = await self._execute_proposal(payload)



# 결과를 Redis에 저장 (Laravel이 폴링으로 확인)

self.redis.setex(

f"job_result:{job_id}",

3600,  # 1시간 보관

json.dumps({

'status': 'completed',

'result': result,

'completed_at': asyncio.get_event_loop().time()

})

)



except Exception as e:

self.redis.setex(

f"job_result:{job_id}",

3600,

json.dumps({'status': 'failed', 'error': str(e)})

)

// Laravel Broadcasting 설정

// app/Events/ProposalStatusUpdated.php



class ProposalStatusUpdated implements ShouldBroadcast

{

use Dispatchable, InteractsWithSockets, SerializesModels;



public function __construct(

public Proposal $proposal

) {}



public function broadcastOn(): array

{

return [

new Channel('proposals'),

new PrivateChannel("proposal.{$this->proposal->id}"),

];

}



public function broadcastWith(): array

{

return [

'id' => $this->proposal->id,

'status' => $this->proposal->status,

'for_votes' => $this->proposal->for_votes,

'against_votes' => $this->proposal->against_votes,

'updated_at' => $this->proposal->updated_at,

];

}

}



// Python에서 Redis Pub/Sub으로 Laravel에 이벤트 전달

# python/workers/event_broadcaster.py



class EventBroadcaster:

def __init__(self, redis_client):

self.redis = redis_client

self.pubsub = redis_client.pubsub()



def broadcast_proposal_update(self, proposal_id: int, status: str):

"""Laravel Broadcasting 채널에 이벤트 발행"""

# Laravel Echo 서버가 구독하는 채널에 발행

channel_data = {

'event': 'ProposalStatusUpdated',

'data': {

'proposal_id': proposal_id,

'status': status,

}

}

self.redis.publish(

f'laravel_database_proposals',

json.dumps(channel_data)

)