오픈 미션: 프리코스 챌린지

---

선정 주제 : 블록체인 학습 및 구현

선정 이유

기존에 암호 화폐에 대한 관심으로 인해 블록 체인에 대해 학습해야겠다고 생각해왔는데, 마침 주제를 자유롭게 선정하고 도전할 수 있는 기회가 생겨 해당 주제를 선정하게 되었습니다.

미션 목표

블록 체인에 대한 이해, 구현, 확장 및 자바 프로그래밍 능력 향상

수행 방식

포괄적인 흐름으로 학습 → 구현 → 확장의 형태로 진행합니다. 프리코스 과정의 피드백을 바탕으로 자바를 통해 구현 및 확장 할 예정입니다.

블록체인에 대한 이해도가 없는 상태에서 세부적인 계획을 잡는 건 힘들다고 판단하여, 하나의 목표를 설정하고 목표 달성 시 다음 목표를 세우고 다시 진행하는 방식으로 수행 하겠습니다.

---

수행 과정

학습

1. 블록체인 개요
2. 트랜잭션
3. SHA256

자료 출처1 : bitcoin Devloper Guides

자료 출처2: https://kwjdnjs.tistory.com

설계 및 구현

학습 이후 블록체인에 대한 이해와, 이더리움의 스마트 컨트랙트와 같은 내용에서 인사이트를 얻어 다음과 같은 주제를 선정하였습니다.

---

블록체인 암호화 거래 시스템

개요

블록체인 네트워크 상에서 1:1 혹은 n:n 관계에서 계약이 이루어진다고 가정했을 때:

• 계약 내용과 계약 이행 시 받을 금액은 내부자들끼리만 알 수 있음
• 계약 이행 여부는 내부자들의 투표로 결정
• 투표로 승인된 경우 계약 금액에 해당하는 트랜잭션 실행

트랜잭션 구조

공개 정보

• txid: 트랜잭션 ID
• timestamp: 생성 시각
• 송금 금액

비공개 정보 (암호화)

• 계약 내용
• 송신자/수신자
  • 트랜잭션 마다 새로운 개인키를 통해 지갑 주소를 생성하고, 해당 output에 해당하는 내부자에게 트랜잭션 번호와, 개인키를 전달하는 방식
  • 거래를 여러 번 진행해도, 각각 다른 지갑 주소를 사용하기 때문에 기존 비트 코인 구조보다 거래자 특정이 어렵습니다.
• 내부자 명단

동작 방식

1. 투표를 통해 트랜잭션 실행 결정
2. 승인 시 내부자들에게 Private Key 제공
3. Private Key로 비공개 정보 복호화
4. 외부 노드는 조회 불가능
5. 전체 네트워크의 Mempool에 트랜잭션 추가
6. 기존 블록체인(비트코인) 방식으로 블록 생성 및 추가

위와 같이 공개와 비공개 정보를 나누어, 비공개 정보의 경우 투표를 통해 트랜잭션이 실행될 때 내부자들에게 private key를 제공하여 나중에 비공개 내용을 알 수 있게 하고 외부 노드들은 조회 불가능하게 한다.

전체 네트워크의 mempool에 해당 트랜잭션을 추가하고, 기존 블록체인 네트워크(비트코인)가 동작하는 방식으로 블록을 생성하고, 블록을 추가한다.

블록체인 네트워크 상에서 1:1 혹은 n:n 관계에서 계약이 이루어진다고 가정했을 때:

• 계약 내용과 계약 이행 시 받을 금액은 내부자들끼리만 알 수 있음
• 계약 이행 여부는 내부자들의 투표로 결정
• 투표로 승인된 경우 계약 금액에 해당하는 트랜잭션 실행

---

클래스 다이어그램

classDiagram
direction BT
class AdminSetup {
  - String ADMIN_SEED
  - String ADMIN_STORAGE_PATH
}
class BalanceCommand
class Block {
  - long timestamp
  - byte[] version
  - int txNum
  - byte[] blockHash
  - byte[] prevHash
  - int size
  - byte[] nonce
  - byte[] merkleRoot
  - List~Transaction~ transactions
}
class BlockCommand
class BlockHeader {
  ~ byte[] merkleRoot
  ~ byte[] bit
  ~ byte[] prevHash
  ~ byte[] nounce
}
class Blockchain {
  - long GENESIS_REWARD
  - List~Block~ chain
}
class BlockchainStorage {
  - String META_CHAIN_HEIGHT
  - RocksDB txDB
  - RocksDB utxoDB
  - RocksDB blocksDB
  - String dbPath
  - RocksDB metaDB
  - String META_PRIVATE_KEY
  - String META_BEST_BLOCK_HASH
  - ObjectMapper objectMapper
}
class BytesUtil
class CLI {
  - CommandContext context
  - Scanner scanner
  - Map~String, Command~ commands
}
class CLIIntegrationTest {
  - CommandContext context1
  - Node node2
  - CommandContext context2
  - String STORAGE_PATH_1
  - String STORAGE_PATH_2
  - Node node3
  - PrintStream originalOut
  - CommandContext context3
  - Node node1
  - ByteArrayOutputStream outContent
  - String STORAGE_PATH_3
}
class Command {
<<Interface>>

}
class CommandContext {
  - Node node
  - Mempool mempool
  - boolean running
}
class ConnectCommand
class ContractTransaction
class EncryptedContract {
  - byte[] encryptedContent
  - Map~String, byte[]~ encryptedKeys
}
class EncryptionUtil {
  - String AES_ALGORITHM
  - int AES_KEY_SIZE
  - int GCM_NONCE_LENGTH
  - int GCM_TAG_LENGTH
}
class ExitCommand
class GenesisBlock {
  - String GENESIS_MINER
  - long GENESIS_REWARD
  - byte[] GENESIS_PREV_HASH
  - String GENESIS_MESSAGE
  - Block cachedGenesisBlock
  - byte[] GENESIS_VERSION
  - long GENESIS_TIMESTAMP
}
class Hash
class HelpCommand {
  - Map~String, Command~ commands
}
class JsonMessage {
  - MessageType type
  - long timestamp
  - ObjectMapper mapper
  - String senderId
  - String payloadJson
  - long serialVersionUID
}
class KeyGenerator {
  - BigInteger N
}
class ListCommand
class Main
class MainTest
class Mempool {
  - TransactionValidator validator
  - Map~String, Transaction~ transactions
  - long MIN_FEE_RATE
  - int MAX_POOL_SIZE
}
class MempoolCommand
class MerkleTree
class Message {
  - MessageType type
  - long serialVersionUID
  - Object payload
  - String senderId
  - long timestamp
}
class MineCommand
class Miner {
  - Node node
  - int currentDifficulty
  - byte[] BLOCK_VERSION
  - long BLOCK_REWARD
  - Mempool mempool
}
class Node {
  - int p2pPort
  - List~Block~ blockList
  - byte[] privateKey
  - BlockchainStorage storage
  - UTXOSet utxoSet
  - TransactionValidator validator
  - P2PNetwork p2pNetwork
}
class Operation {
  - byte[] messageHash
  ~ Stack~byte[]~ stack
  - byte[] sigScriptValue
}
class P2PNetwork {
  - P2PServer server
  - List~Peer~ peers
  - Node node
  - ConcurrentHashMap~String, Peer~ peerMap
  - String nodeId
}
class P2PServer {
  - ServerSocket serverSocket
  - boolean running
  - int port
  - P2PNetwork network
  - ExecutorService executorService
}
class Peer {
  - Socket socket
  - ObjectInputStream in
  - String address
  - int port
  - ObjectOutputStream out
  - boolean connected
}
class PeersCommand
class ProofOfWork {
  - int MAX_NONCE
  - int DIFFICULTY_ADJUSTMENT_INTERVAL
  - long TARGET_BLOCK_TIME
}
class Random
class Script
class SendCommand
class Signature
class Spender {
  - byte[] txid
  - int inputIndex
  - long serialVersionUID
}
class StartCommand
class StatusCommand
class SyncCommand
class TXBlockInfo {
  - long serialVersionUID
  - int height
  - byte[] blockHash
}
class Transaction {
  - byte[] txid
  - boolean deleted
  - DateTimeFormatter TIME_FORMATTER
  - long fee
  - String time
  - List~TransactionInput~ inputs
  - List~String~ voteList
  - List~TransactionOutput~ outputs
  - String contract
  - int size
  - TXBlockInfo block
}
class TransactionInput {
  ~ int outputIdx
  ~ List~byte[]~ sigScript
  ~ byte[] pkScript
  ~ byte[] prevTXID
  ~ long value
  - Boolean isCoinbase
  ~ String address
}
class TransactionOutput {
  - Spender spender
  - byte[] address
  - boolean spent
  - long value
  - byte[] pkscript
}
class TransactionValidator {
  - UTXOSet utxoSet
}
class UTXO {
  - TransactionOutput output
  - long blockHeight
  - byte[] txid
  - int outputIndex
}
class UTXOSet {
  - Map~String, UTXO~ utxos
}
class ValidationResult {
  - String message
  - boolean valid
}
class Vote {
  - String voterAddress
  - long timestamp
  - VoteType voteType
  - byte[] signature
}
class VoteResult {
  - long finalizedAt
  - int totalParticipants
  - boolean approved
  - int rejections
  - int abstentions
  - int approvals
}
class VoteStatus {
  - int voteCount
  - boolean finalized
  - int totalParticipants
  - int approvals
  - int rejections
  - long votingDeadline
  - int abstentions
}
class VotingContract {
  - Map~String, Vote~ votes
  - long votingDeadline
  - boolean finalized
  - EncryptedContract encryptedContract
  - List~String~ participants
  - VoteResult finalResult
  - int requiredApprovals
}
class Wallet {
  - Node node
}
class WalletManager {
  - Node node
  - Map~String, byte[]~ wallets
}
class build
class settings

BalanceCommand  ..>  Command 
Block "1" *--> "transactions *" Transaction 
BlockCommand  ..>  Command 
Blockchain "1" *--> "chain *" Block 
CLI  ..>  BalanceCommand : «create»
CLI  ..>  BlockCommand : «create»
CLI "1" *--> "commands *" Command 
CLI "1" *--> "context 1" CommandContext 
CLI  ..>  CommandContext : «create»
CLI  ..>  ConnectCommand : «create»
CLI  ..>  ExitCommand : «create»
CLI  ..>  HelpCommand : «create»
CLI  ..>  ListCommand : «create»
CLI  ..>  MempoolCommand : «create»
CLI  ..>  MineCommand : «create»
CLI  ..>  PeersCommand : «create»
CLI  ..>  SendCommand : «create»
CLI  ..>  StartCommand : «create»
CLI  ..>  StatusCommand : «create»
CLI  ..>  SyncCommand : «create»
CLIIntegrationTest "1" *--> "context1 1" CommandContext 
CLIIntegrationTest "1" *--> "node1 1" Node 
CommandContext "1" *--> "mempool 1" Mempool 
CommandContext "1" *--> "node 1" Node 
ConnectCommand  ..>  Command 
ExitCommand  ..>  Command 
GenesisBlock "1" *--> "cachedGenesisBlock 1" Block 
HelpCommand  ..>  Command 
HelpCommand "1" *--> "commands *" Command 
ListCommand  ..>  Command 
Mempool "1" *--> "transactions *" Transaction 
Mempool "1" *--> "validator 1" TransactionValidator 
MempoolCommand  ..>  Command 
MineCommand  ..>  Command 
MineCommand  ..>  Miner : «create»
Miner "1" *--> "mempool 1" Mempool 
Miner "1" *--> "node 1" Node 
Node "1" *--> "blockList *" Block 
Node "1" *--> "storage 1" BlockchainStorage 
Node "1" *--> "p2pNetwork 1" P2PNetwork 
Node "1" *--> "validator 1" TransactionValidator 
Node "1" *--> "utxoSet 1" UTXOSet 
P2PNetwork "1" *--> "node 1" Node 
P2PNetwork "1" *--> "server 1" P2PServer 
P2PNetwork "1" *--> "peers *" Peer 
P2PServer "1" *--> "network 1" P2PNetwork 
PeersCommand  ..>  Command 
SendCommand  ..>  Command 
StartCommand  ..>  Command 
StartCommand  ..>  Mempool : «create»
StartCommand  ..>  Node : «create»
StatusCommand  ..>  Command 
SyncCommand  ..>  Command 
Transaction "1" *--> "block 1" TXBlockInfo 
Transaction "1" *--> "inputs *" TransactionInput 
Transaction "1" *--> "outputs *" TransactionOutput 
TransactionOutput "1" *--> "spender 1" Spender 
TransactionValidator "1" *--> "utxoSet 1" UTXOSet 
UTXO "1" *--> "output 1" TransactionOutput 
UTXOSet "1" *--> "utxos *" UTXO 
VotingContract "1" *--> "encryptedContract 1" EncryptedContract 
VotingContract "1" *--> "votes *" Vote 
VotingContract "1" *--> "finalResult 1" VoteResult 
Wallet "1" *--> "node 1" Node 
WalletManager "1" *--> "node 1" Node 

Loading

구현 상세

1. UTXO 모델: 비트코인과 동일한 미사용 출력 기반 트랜잭션
2. Proof of Work: SHA-256 기반 작업 증명
3. P2P 네트워크: TCP 소켓 기반 노드 간 통신
4. 암호화 투표: 참여자만 계약 내용 확인 가능
5. RocksDB 영속성: Key-Value 기반 고성능 저장
6. CLI 인터페이스: Command 패턴 기반 명령어 처리
7. 머클 트리: 트랜잭션 무결성 검증
8. 디지털 서명: ECDSA 기반 인증

위 기능들을 CLI를 통해 사용할 수 있게 구현하였습니다.

╔════════════════════════════════════════════════════╗
║          BLOCKCHAIN CLI - HELP                     ║
╚════════════════════════════════════════════════════╝

  Available Commands:

  mine            mine [difficulty] - Mine a new block (default difficulty: 3)
  mempool         mempool - Display pending transactions
  start           start <port> [storage_path] - Start a blockchain node
  peers           peers - Display connected peers
  list            list [start] [count] - List blocks (recent 10 by default)
  sync            sync - Request blockchain synchronization from peers
  help            help - Display this help message
  exit            exit - Shutdown node and exit
  balance         balance [address] - Check balance (yours or specific address)
  block           block <height> - Display detailed block information
  send            send <to_address> <amount> - Send coins to an address
  connect         connect <host> <port> - Connect to a peer node
  status          status - Display node status

---

후기

1. 예상보다 복잡한 구현

도전: 블록체인의 기본 개념은 단순해 보였지만, 실제 구현은 훨씬 복잡했습니다. 특히 UTXO 관리, P2P 동기화, 암호화 시스템이 유기적으로 연결되어야 했습니다.

해결: 큰 목표를 작은 단계로 나누어 진행했습니다. 먼저 단일 노드에서 블록 생성을 구현하고, 이후 P2P 네트워크를 추가하는 방식으로 점진적으로 확장했습니다.

2. 분산 시스템의 어려움

도전: 여러 노드가 동시에 블록을 생성하거나 실시간으로 통신하는 환경에서, 구현과 동시에 테스트를 진행하는 것이 쉽지 않았습니다. 특히 네트워크 지연이나 동기화 이슈를 재현하고 디버깅하는 과정이 까다로웠습니다.

해결: 로컬 환경에서 여러 포트로 다중 노드를 실행하며 시나리오별로 테스트했습니다. Longest Chain Rule을 적용해 분기(Fork) 문제를 해결했고, 각 노드의 상태를 로그로 추적하며 문제를 파악했습니다.

3. 암호화 투표 시스템의 복잡성

도전: 처음 계획했던 암호화 투표 시스템은 구현 난이도가 높아 완벽히 구현하지 못했습니다.

대응: 기본 블록체인 기능을 먼저 완성하고, 투표 시스템의 기반 구조(VotingContract, EncryptedContract)만 구현했습니다. 이는 향후 확장을 위한 토대가 되었습니다.

4. 프리코스 피드백 적용

프리코스에서 배운 원칙들을 실제 프로젝트에 적용하려 노력했습니다

적용 사항:

Command 패턴: CLI 명령어를 독립적인 클래스로 분리하여 확장 가능한 구조 구축

일급 컬렉션: Mempool, UTXOSet, Blockchain 클래스로 컬렉션을 캡슐화하여 비즈니스 로직 응집

Enum 활용: MessageType으로 타입 안전성 확보 및 매직 스트링 제거

단일 책임 원칙: 각 클래스가 하나의 책임만 가지도록 설계하여 유지보수성 향상

하지만 블록·트랜잭션·노드처럼 복잡하게 얽힌 도메인에서는 단일 책임을 명확히 분리하거나 결합도를 최소화하는 것이 쉽지 않았습니다. 이론에서 배운 추상화와 책임 분리가 실제 시스템에서는 여러 제약과 현실적인 선택을 동반한다는 점을 깨달았습니다.