useful_blockchain 2.1.1__py3-none-any.whl

useful_blockchain/__init__.py

@@ -0,0 +1,6 @@
+from useful_blockchain.blockchain import BlockChain
+from useful_blockchain.network.node import Node
+from useful_blockchain.signature import SignatureManager
+
+__version__ = "2.1.1"
+__all__ = ["BlockChain", "SignatureManager", "Node", "__version__"]

useful_blockchain/blockchain.py

@@ -0,0 +1,220 @@
+"""
+シンプルなブロックチェーンの実装
+
+このモジュールは基本的なブロックチェーンの機能を提供します。
+各ブロックは前のブロックのハッシュ値を含んでおり、チェーン状に連結されています。
+"""
+
+from __future__ import annotations
+
+import datetime as dt
+import hashlib
+import json
+from typing import Any
+
+from cryptography.hazmat.primitives.asymmetric.rsa import RSAPrivateKey, RSAPublicKey
+
+from useful_blockchain.chain_validator import verify_chain_integrity
+from useful_blockchain.consensus.base import ConsensusProtocol
+from useful_blockchain.hash_utils import calc_body_hash, calc_legacy_tran_hash
+from useful_blockchain.signature import SignatureManager
+from useful_blockchain.types import (
+    Block,
+    ChainVerificationResult,
+    DEFAULT_GENESIS_PREV_HASH,
+    TransactionBody,
+)
+
+
+class BlockChain:
+    """
+    ブロックチェーンクラス
+
+    ブロックを連結してチェーン状に管理するクラスです。
+    各ブロックには取引データ、タイムスタンプ、前のブロックへの参照が含まれます。
+    """
+
+    def __init__(
+        self,
+        enable_signature: bool = False,
+        consensus: ConsensusProtocol | None = None,
+        genesis_prev_hash: str = DEFAULT_GENESIS_PREV_HASH,
+    ) -> None:
+        self.chain: list[Block] = []
+        self.enable_signature = enable_signature
+        self.consensus = consensus
+        self.genesis_prev_hash = genesis_prev_hash
+        self.signature_manager = SignatureManager() if enable_signature else None
+
+    def add_new_block(self, input_data: Any, output_data: Any) -> Block:
+        new_transaction = self.__create_new_transaction(input_data, output_data)
+
+        if len(self.chain) > 0:
+            prev_hash = self.chain[-1]["block_header"]["tran_hash"]
+        else:
+            prev_hash = self.genesis_prev_hash
+
+        body_hash = calc_body_hash(new_transaction)
+        header: dict[str, Any] = {"prev_hash": prev_hash}
+
+        if self.consensus is not None:
+            header["consensus_type"] = self.consensus.consensus_type
+            header["tran_hash"] = ""
+        else:
+            header["tran_hash"] = calc_legacy_tran_hash(prev_hash, body_hash)
+
+        new_block: Block = {
+            "block_index": len(self.chain) + 1,
+            "block_item": dt.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            "block_header": header,  # type: ignore[typeddict-item]
+            "tran_counter": len(input_data) + len(output_data),
+            "tran_body": new_transaction,
+        }
+
+        if self.consensus is not None:
+            new_block = self.consensus.prepare_block(new_block, self.chain)
+        elif self.enable_signature and self.signature_manager:
+            if self.signature_manager.private_key is None:
+                raise ValueError(
+                    "秘密鍵が設定されていません。generate_key_pair()を先に実行してください。"
+                )
+            new_block = self.signature_manager.sign_block(new_block)  # type: ignore[assignment]
+
+        self.chain.append(new_block)
+        if self.consensus is not None:
+            self.consensus.on_block_added(new_block)
+        return new_block
+
+    def add_block(self, block: Block, validate: bool = True) -> bool:
+        """外部から受信したブロックを追加する。"""
+        if validate:
+            previous = self.chain[-1] if self.chain else None
+            if self.consensus is not None:
+                link = self.consensus.validate_chain_link(
+                    block, previous, self.genesis_prev_hash
+                )
+                if not link.valid:
+                    return False
+            elif previous is not None:
+                if block["block_header"]["prev_hash"] != previous["block_header"]["tran_hash"]:
+                    return False
+            if self.consensus is not None:
+                result = self.consensus.validate_block(block, self.chain)
+                if not result.valid:
+                    return False
+            verification = verify_chain_integrity(
+                self.chain + [block], self.consensus, self.genesis_prev_hash
+            )
+            if not verification.valid:
+                return False
+
+        self.chain.append(block)
+        if self.consensus is not None:
+            self.consensus.on_block_added(block)
+        return True
+
+    def replace_chain(
+        self,
+        new_chain: list[Block],
+        *,
+        genesis_stakes: dict[str, int] | None = None,
+    ) -> bool:
+        verification = verify_chain_integrity(
+            new_chain,
+            self.consensus,
+            self.genesis_prev_hash,
+            genesis_stakes=genesis_stakes,
+        )
+        if not verification.valid:
+            return False
+        self.chain = list(new_chain)
+        if self.consensus is not None and genesis_stakes is not None:
+            from useful_blockchain.consensus.pos import ProofOfStake
+
+            if isinstance(self.consensus, ProofOfStake):
+                self.consensus.sync_validators_from_chain(self.chain, genesis_stakes)
+        return True
+
+    def verify_chain(
+        self, *, genesis_stakes: dict[str, int] | None = None
+    ) -> ChainVerificationResult:
+        return verify_chain_integrity(
+            self.chain,
+            self.consensus,
+            self.genesis_prev_hash,
+            genesis_stakes=genesis_stakes,
+        )
+
+    def get_blocks_from(self, from_height: int, limit: int | None = None) -> list[Block]:
+        if from_height < 1:
+            blocks = list(self.chain)
+        else:
+            blocks = self.chain[from_height - 1 :]
+        if limit is not None:
+            return blocks[:limit]
+        return blocks
+
+    def __create_new_transaction(self, input_data: Any, output_data: Any) -> TransactionBody:
+        return {
+            "input_data": input_data,
+            "output_data": output_data,
+        }
+
+    def __calc_tran_hash(self, new_transaction: dict[str, Any]) -> str:
+        tran_string = json.dumps(new_transaction, sort_keys=True).encode()
+        return self.__hash(tran_string)
+
+    def __hash(self, str_seed: Any) -> str:
+        return hashlib.sha256(str(str_seed).encode()).hexdigest()
+
+    def dump(self, block_index: int = 0) -> None:
+        if block_index == 0:
+            print(json.dumps(self.chain, indent=2))
+        elif block_index < 1 or block_index > len(self.chain):
+            print("無効なブロックインデックスです。")
+        else:
+            print(json.dumps(self.chain[block_index - 1], indent=2))
+
+    def generate_key_pair(self) -> tuple[RSAPrivateKey, RSAPublicKey] | None:
+        if not self.enable_signature or not self.signature_manager:
+            print("署名機能が有効ではありません。")
+            return None
+        return self.signature_manager.generate_key_pair()
+
+    def verify_block_signature(self, block_index: int) -> bool:
+        if not self.enable_signature or not self.signature_manager:
+            print("署名機能が有効ではありません。")
+            return False
+        if block_index < 1 or block_index > len(self.chain):
+            print("無効なブロックインデックスです。")
+            return False
+        block = self.chain[block_index - 1]
+        if "signature" not in block:
+            print("このブロックには署名がありません。")
+            return False
+        return self.signature_manager.verify_block_signature(block)
+
+    def verify_all_signatures(self) -> dict[str, bool | None]:
+        if not self.enable_signature or not self.signature_manager:
+            print("署名機能が有効ではありません。")
+            return {}
+        results: dict[str, bool | None] = {}
+        for i, block in enumerate(self.chain, 1):
+            if "signature" in block:
+                results[f"block_{i}"] = self.signature_manager.verify_block_signature(block)
+            else:
+                results[f"block_{i}"] = None
+        return results
+
+    def export_public_key(self) -> bytes | None:
+        if not self.enable_signature or not self.signature_manager:
+            print("署名機能が有効ではありません。")
+            return None
+        return self.signature_manager.export_public_key()
+
+
+if __name__ == "__main__":
+    bc = BlockChain()
+    bc.add_new_block("test", "test1")
+    bc.add_new_block("test3", "test4")
+    print(bc.chain)

useful_blockchain/chain_validator.py

@@ -0,0 +1,116 @@
+"""チェーン整合性検証。"""
+
+from __future__ import annotations
+
+from useful_blockchain.consensus.base import ConsensusProtocol
+from useful_blockchain.hash_utils import calc_body_hash, calc_legacy_tran_hash
+from useful_blockchain.types import Block, ChainVerificationResult, DEFAULT_GENESIS_PREV_HASH
+
+
+def verify_chain_integrity(
+    chain: list[Block],
+    consensus: ConsensusProtocol | None = None,
+    genesis_prev_hash: str = DEFAULT_GENESIS_PREV_HASH,
+    *,
+    genesis_stakes: dict[str, int] | None = None,
+) -> ChainVerificationResult:
+    from useful_blockchain.consensus.pos import ProofOfStake
+
+    if isinstance(consensus, ProofOfStake) and genesis_stakes is not None:
+        for index, block in enumerate(chain):
+            previous = chain[index - 1] if index > 0 else None
+            if previous is not None:
+                link = consensus.validate_chain_link(block, previous, genesis_prev_hash)
+                if not link.valid:
+                    return ChainVerificationResult(
+                        valid=False,
+                        failed_at_index=index + 1,
+                        reason=link.reason,
+                    )
+            else:
+                if block["block_header"]["prev_hash"] != genesis_prev_hash:
+                    return ChainVerificationResult(
+                        valid=False,
+                        failed_at_index=index + 1,
+                        reason="genesis prev_hash mismatch",
+                    )
+                link = consensus.validate_chain_link(block, None, genesis_prev_hash)
+                if not link.valid:
+                    return ChainVerificationResult(
+                        valid=False,
+                        failed_at_index=index + 1,
+                        reason=link.reason,
+                    )
+
+            prefix_validators = ProofOfStake.compute_validators_from_chain(
+                chain[:index], genesis_stakes, consensus.settings
+            )
+            result = consensus.validate_block(
+                block,
+                chain[:index],
+                validators_at_state=prefix_validators,
+            )
+            if not result.valid:
+                return ChainVerificationResult(
+                    valid=False,
+                    failed_at_index=index + 1,
+                    reason=result.reason,
+                )
+        return ChainVerificationResult(valid=True)
+
+    for index, block in enumerate(chain):
+        previous = chain[index - 1] if index > 0 else None
+        if previous is not None:
+            if consensus is not None:
+                link = consensus.validate_chain_link(block, previous, genesis_prev_hash)
+            else:
+                prev_tran = previous["block_header"]["tran_hash"]
+                if block["block_header"]["prev_hash"] != prev_tran:
+                    return ChainVerificationResult(
+                        valid=False,
+                        failed_at_index=index + 1,
+                        reason="prev_hash mismatch",
+                    )
+                if block["block_index"] != previous["block_index"] + 1:
+                    return ChainVerificationResult(
+                        valid=False,
+                        failed_at_index=index + 1,
+                        reason="block_index mismatch",
+                    )
+        else:
+            if block["block_header"]["prev_hash"] != genesis_prev_hash:
+                return ChainVerificationResult(
+                    valid=False,
+                    failed_at_index=index + 1,
+                    reason="genesis prev_hash mismatch",
+                )
+            if consensus is not None:
+                link = consensus.validate_chain_link(block, None, genesis_prev_hash)
+                if not link.valid:
+                    return ChainVerificationResult(
+                        valid=False,
+                        failed_at_index=index + 1,
+                        reason=link.reason,
+                    )
+
+        header = block.get("block_header", {})
+        consensus_type = header.get("consensus_type")
+        if consensus is not None and consensus_type:
+            result = consensus.validate_block(block, chain[:index])
+            if not result.valid:
+                return ChainVerificationResult(
+                    valid=False,
+                    failed_at_index=index + 1,
+                    reason=result.reason,
+                )
+        elif consensus is None and not consensus_type:
+            body_hash = calc_body_hash(block["tran_body"])
+            expected = calc_legacy_tran_hash(header["prev_hash"], body_hash)
+            if header.get("tran_hash") != expected:
+                return ChainVerificationResult(
+                    valid=False,
+                    failed_at_index=index + 1,
+                    reason="legacy tran_hash mismatch",
+                )
+
+    return ChainVerificationResult(valid=True)

useful_blockchain/cli.py

@@ -0,0 +1,86 @@
+"""easyblockchain ノード CLI エントリポイント。"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import logging
+import sys
+
+from useful_blockchain.network.node import Node
+from useful_blockchain.observability.logging_config import configure_logging
+from useful_blockchain.settings import resolve_log_level
+
+logger = logging.getLogger(__name__)
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Run an easyblockchain P2P node")
+    parser.add_argument("--config", help="Path to config YAML", default=None)
+    parser.add_argument("--consensus", choices=["pow", "pos"], help="Consensus type override")
+    parser.add_argument("--port", type=int, help="Network port override")
+    parser.add_argument("--bootstrap", nargs="*", default=[], help="Bootstrap peer URLs")
+    parser.add_argument(
+        "--log-level",
+        choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+        help="Log level override",
+    )
+    parser.add_argument(
+        "--add-block",
+        nargs=2,
+        metavar=("INPUT", "OUTPUT"),
+        help="Add one block on start",
+    )
+    return parser
+
+
+def _build_overrides(args: argparse.Namespace) -> dict:
+    overrides: dict = {}
+    if args.consensus:
+        overrides.setdefault("consensus", {})["type"] = args.consensus
+    if args.port:
+        overrides.setdefault("network", {})["port"] = args.port
+    if args.bootstrap:
+        overrides.setdefault("network", {})["bootstrap_peers"] = args.bootstrap
+    if args.log_level:
+        overrides.setdefault("node", {})["log_level"] = args.log_level
+    return overrides
+
+
+async def run(args: argparse.Namespace | None = None) -> int:
+    parsed = args or _build_parser().parse_args()
+    overrides = _build_overrides(parsed)
+
+    node = Node(config_path=parsed.config, overrides=overrides or None)
+    configure_logging(
+        resolve_log_level(node.settings.node.log_level),
+        log_format=node.settings.observability.log_format,
+        node_id=node.node_id,
+    )
+    await node.start()
+    logger.info(
+        "Node %s listening on %s (%s)",
+        node.node_id,
+        node.p2p.local_url,
+        node.settings.consensus.type,
+    )
+
+    if parsed.add_block:
+        block = await node.add_block(parsed.add_block[0], parsed.add_block[1])
+        logger.info("Added block #%s", block["block_index"])
+
+    try:
+        while True:
+            await asyncio.sleep(3600)
+    except KeyboardInterrupt:
+        logger.info("Shutting down...")
+        await node.stop()
+    return 0
+
+
+def main() -> None:
+    sys.exit(asyncio.run(run()))
+
+
+if __name__ == "__main__":
+    main()

useful_blockchain/consensus/__init__.py

@@ -0,0 +1,11 @@
+from useful_blockchain.consensus.base import ConsensusProtocol
+from useful_blockchain.consensus.factory import create_consensus
+from useful_blockchain.consensus.pos import ProofOfStake
+from useful_blockchain.consensus.pow import ProofOfWork
+
+__all__ = [
+    "ConsensusProtocol",
+    "ProofOfWork",
+    "ProofOfStake",
+    "create_consensus",
+]

useful_blockchain/consensus/base.py

@@ -0,0 +1,58 @@
+"""合意プロトコルの抽象基底クラス。"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+from useful_blockchain.types import Block, DEFAULT_GENESIS_PREV_HASH, ValidationResult
+
+
+class ConsensusProtocol(ABC):
+    genesis_prev_hash: str = DEFAULT_GENESIS_PREV_HASH
+
+    @property
+    @abstractmethod
+    def consensus_type(self) -> str:
+        ...
+
+    @abstractmethod
+    def prepare_block(self, block: Block, chain: list[Block]) -> Block:
+        """ブロックに合意要件（マイニング・提案者署名等）を適用する。"""
+
+    @abstractmethod
+    def validate_block(self, block: Block, chain: list[Block]) -> ValidationResult:
+        """単一ブロックが合意ルールを満たすか検証する。"""
+
+    @abstractmethod
+    def select_canonical_chain(
+        self,
+        chains: list[list[Block]],
+        *,
+        genesis_stakes: dict[str, int] | None = None,
+    ) -> list[Block]:
+        """複数チェーンから正規チェーンを選択する。"""
+
+    def on_block_added(self, block: Block) -> None:
+        """ブロック追加後のフック（PoS 報酬等）。"""
+
+    def validate_chain_link(
+        self,
+        block: Block,
+        previous_block: Block | None,
+        genesis_prev_hash: str | None = None,
+    ) -> ValidationResult:
+        expected_genesis = genesis_prev_hash or self.genesis_prev_hash
+        if previous_block is None:
+            if block["block_header"]["prev_hash"] != expected_genesis:
+                return ValidationResult(valid=False, reason="genesis prev_hash mismatch")
+            return ValidationResult(valid=True)
+        prev_tran = previous_block["block_header"]["tran_hash"]
+        if block["block_header"]["prev_hash"] != prev_tran:
+            return ValidationResult(valid=False, reason="prev_hash mismatch")
+        if block["block_index"] != previous_block["block_index"] + 1:
+            return ValidationResult(valid=False, reason="block_index mismatch")
+        return ValidationResult(valid=True)
+
+    def score_chain(self, chain: list[Block]) -> tuple[int, int]:
+        """フォーク選択用スコア: (長さ, 重み)。"""
+        return len(chain), 0

useful_blockchain/consensus/factory.py

@@ -0,0 +1,36 @@
+"""合意プロトコルファクトリ。"""
+
+from __future__ import annotations
+
+from useful_blockchain.consensus.base import ConsensusProtocol
+from useful_blockchain.consensus.pos import ProofOfStake
+from useful_blockchain.consensus.pow import ProofOfWork
+from useful_blockchain.signature import SignatureManager
+from useful_blockchain.types import AppSettings, ConsensusType
+
+
+def create_consensus(
+    settings: AppSettings,
+    node_validator_id: str | None = None,
+    signature_manager: SignatureManager | None = None,
+    genesis_stakes: dict[str, int] | None = None,
+) -> ConsensusProtocol:
+    consensus_type: ConsensusType = settings.consensus.type
+    if consensus_type == "pow":
+        consensus: ConsensusProtocol = ProofOfWork(settings.consensus.pow)
+    elif consensus_type == "pos":
+        pos = ProofOfStake(
+            settings.consensus.pos,
+            node_validator_id=node_validator_id,
+            signature_manager=signature_manager,
+        )
+        stakes = genesis_stakes or {}
+        if node_validator_id and node_validator_id not in stakes:
+            stakes[node_validator_id] = settings.consensus.pos.min_stake
+        for validator_id, stake in stakes.items():
+            pos.register_validator(validator_id, stake)
+        consensus = pos
+    else:
+        raise ValueError(f"Unsupported consensus type: {consensus_type}")
+    consensus.genesis_prev_hash = settings.genesis.prev_hash
+    return consensus