《低俗小说》与跨链交易：非线性叙事作为区块链时间

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

import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

contract PulpFictionCrossChain is AccessControl, ReentrancyGuard {
    bytes32 public constant BRIDGE_OPERATOR_ROLE = keccak256("BRIDGE_OPERATOR_ROLE");
    bytes32 public constant VALIDATOR_ROLE = keccak256("VALIDATOR_ROLE");

    enum StoryLine {
        HONEY_BUNNY,      // 蜜兔和南瓜的早午餐抢劫
        VINCENT_VINCENT,  // 文森特和朱尔斯
        BUTCH_BOXER       // 布奇金表逃亡
    }

    enum TransactionStatus {
        PENDING,
        IN_TRANSIT,
        ATOMIC_LOCKED,
        COMPLETED,
        REVERTED,
        EXPIRED
    }

    enum NonLinearTimeType {
        FLASHBACK,
        FLASHFORWARD,
        CROSS_CUT,
        PARALLEL,
        CIRCULAR
    }

    struct CrossChainTransaction {
        uint256 txId;
        address initiator;
        uint256 sourceChainId;
        uint256 destinationChainId;
        bytes32 sourceTxHash;
        bytes32 destinationTxHash;
        bytes payload;
        uint256 amount;
        address tokenAddress;
        TransactionStatus status;
        uint256 createdAt;
        uint256 timeoutAt;
        bool isAtomic;
        bytes32 secretHash;
        bytes32 secret;
        uint256 blockNumber;
        StoryLine storyline;
    }

    struct NonLinearTimeEvent {
        uint256 eventId;
        uint256 txId;
        NonLinearTimeType timeType;
        uint256 referenceTime;
        string narrativeDescription;
        bool isResolved;
        uint256 resolutionTime;
    }

    struct AtomicSwap {
        uint256 swapId;
        address initiator;
        address counterparty;
        address initiatorToken;
        address counterpartyToken;
        uint256 initiatorAmount;
        uint256 counterpartyAmount;
        uint256 initiatorChainId;
        uint256 counterpartyChainId;
        bytes32 secretHash;
        bytes32 secret;
        bool isLocked;
        bool isClaimed;
        bool isRefunded;
        uint256 lockTime;
        uint256 expiryTime;
    }

    struct CircularTransaction {
        uint256 circularId;
        uint256[] txIds;
        string description;
        bool isComplete;
        uint256 startTime;
        uint256 endTime;
        address[] participants;
    }

    mapping(uint256 => CrossChainTransaction) public transactions;
    mapping(uint256 => NonLinearTimeEvent) public timeEvents;
    mapping(uint256 => AtomicSwap) public atomicSwaps;
    mapping(uint256 => CircularTransaction) public circularTxs;
    mapping(address => uint256[]) public userTransactions;
    mapping(bytes32 => bool) public usedSecrets;

    uint256 private _txCounter;
    uint256 private _eventCounter;
    uint256 private _swapCounter;
    uint256 private _circularCounter;
    uint256 public constant ATOMIC_LOCK_TIME = 3600; // 1 hour
    uint256 public constant MAX_TIMEOUT = 86400; // 24 hours

    event TransactionInitiated(
        uint256 indexed txId,
        address indexed initiator,
        uint256 sourceChainId,
        uint256 destinationChainId,
        StoryLine storyline,
        uint256 amount
    );

    event TransactionCompleted(
        uint256 indexed txId,
        bytes32 destinationTxHash,
        TransactionStatus status
    );

    event AtomicSwapLocked(
        uint256 indexed swapId,
        address indexed initiator,
        address indexed counterparty,
        uint256 amount
    );

    event AtomicSwapClaimed(
        uint256 indexed swapId,
        bytes32 secret
    );

    event NonLinearEventCreated(
        uint256 indexed eventId,
        NonLinearTimeType timeType,
        string description
    );

    event CircularTransactionCompleted(
        uint256 indexed circularId,
        uint256 endTime
    );

    constructor() {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(BRIDGE_OPERATOR_ROLE, msg.sender);
        _grantRole(VALIDATOR_ROLE, msg.sender);
    }

    function initiateTransaction(
        uint256 _destinationChainId,
        bytes calldata _payload,
        uint256 _amount,
        address _tokenAddress,
        StoryLine _storyline,
        bool _isAtomic,
        uint256 _timeout
    ) external payable returns (uint256) {
        _txCounter++;
        uint256 txId = _txCounter;

        bytes32 secretHash = bytes32(0);
        if (_isAtomic) {
            secretHash = keccak256(abi.encodePacked(block.timestamp, msg.sender, txId));
        }

        transactions[txId] = CrossChainTransaction({
            txId: txId,
            initiator: msg.sender,
            sourceChainId: block.chainid,
            destinationChainId: _destinationChainId,
            sourceTxHash: keccak256(abi.encodePacked(block.timestamp, msg.sender, txId, _amount)),
            destinationTxHash: bytes32(0),
            payload: _payload,
            amount: _amount,
            tokenAddress: _tokenAddress,
            status: TransactionStatus.PENDING,
            createdAt: block.timestamp,
            timeoutAt: block.timestamp + (_timeout > 0 ? _timeout : MAX_TIMEOUT),
            isAtomic: _isAtomic,
            secretHash: secretHash,
            secret: bytes32(0),
            blockNumber: block.number,
            storyline: _storyline
        });

        userTransactions[msg.sender].push(txId);

        // 创建非线性时间事件
        _createTimeEvent(txId, NonLinearTimeType.CROSS_CUT, "跨链交易启动");

        emit TransactionInitiated(txId, msg.sender, block.chainid, _destinationChainId, _storyline, _amount);
        return txId;
    }

    function lockAtomicSwap(
        address _counterparty,
        address _initiatorToken,
        address _counterpartyToken,
        uint256 _initiatorAmount,
        uint256 _counterpartyAmount,
        uint256 _counterpartyChainId,
        bytes32 _secretHash
    ) external returns (uint256) {
        require(!usedSecrets[_secretHash], "Secret hash already used");

        _swapCounter++;
        uint256 swapId = _swapCounter;

        atomicSwaps[swapId] = AtomicSwap({
            swapId: swapId,
            initiator: msg.sender,
            counterparty: _counterparty,
            initiatorToken: _initiatorToken,
            counterpartyToken: _counterpartyToken,
            initiatorAmount: _initiatorAmount,
            counterpartyAmount: _counterpartyAmount,
            initiatorChainId: block.chainid,
            counterpartyChainId: _counterpartyChainId,
            secretHash: _secretHash,
            secret: bytes32(0),
            isLocked: true,
            isClaimed: false,
            isRefunded: false,
            lockTime: block.timestamp,
            expiryTime: block.timestamp + ATOMIC_LOCK_TIME
        });

        emit AtomicSwapLocked(swapId, msg.sender, _counterparty, _initiatorAmount);
        return swapId;
    }

    function claimAtomicSwap(uint256 _swapId, bytes32 _secret) external {
        AtomicSwap storage swap = atomicSwaps[_swapId];
        require(swap.isLocked, "Swap not locked");
        require(!swap.isClaimed, "Already claimed");
        require(!swap.isRefunded, "Already refunded");
        require(block.timestamp < swap.expiryTime, "Swap expired");
        require(keccak256(abi.encodePacked(_secret)) == swap.secretHash, "Invalid secret");
        require(msg.sender == swap.counterparty, "Not counterparty");

        swap.isClaimed = true;
        swap.secret = _secret;
        usedSecrets[swap.secretHash] = true;

        emit AtomicSwapClaimed(_swapId, _secret);
    }

    function refundAtomicSwap(uint256 _swapId) external {
        AtomicSwap storage swap = atomicSwaps[_swapId];
        require(swap.isLocked, "Swap not locked");
        require(!swap.isClaimed, "Already claimed");
        require(!swap.isRefunded, "Already refunded");
        require(block.timestamp >= swap.expiryTime, "Not expired yet");
        require(msg.sender == swap.initiator, "Not initiator");

        swap.isRefunded = true;
    }

    function completeTransaction(
        uint256 _txId,
        bytes32 _destinationTxHash,
        bytes32 _secret
    ) external onlyRole(BRIDGE_OPERATOR_ROLE) {
        CrossChainTransaction storage tx_ = transactions[_txId];
        require(tx_.status == TransactionStatus.PENDING || tx_.status == TransactionStatus.IN_TRANSIT, "Invalid status");
        require(block.timestamp < tx_.timeoutAt, "Transaction expired");

        tx_.destinationTxHash = _destinationTxHash;
        tx_.status = TransactionStatus.COMPLETED;

        if (tx_.isAtomic) {
            tx_.secret = _secret;
        }

        _createTimeEvent(_txId, NonLinearTimeType.PARALLEL, "跨链交易完成");

        emit TransactionCompleted(_txId, _destinationTxHash, TransactionStatus.COMPLETED);
    }

    function revertTransaction(uint256 _txId) external onlyRole(BRIDGE_OPERATOR_ROLE) {
        CrossChainTransaction storage tx_ = transactions[_txId];
        require(tx_.status == TransactionStatus.PENDING || tx_.status == TransactionStatus.IN_TRANSIT, "Cannot revert");
        require(block.timestamp < tx_.timeoutAt, "Transaction expired");

        tx_.status = TransactionStatus.REVERTED;
    }

    function createCircularTransaction(
        uint256[] memory _txIds,
        string memory _description
    ) external returns (uint256) {
        _circularCounter++;
        uint256 circularId = _circularCounter;

        circularTxs[circularId] = CircularTransaction({
            circularId: circularId,
            txIds: _txIds,
            description: _description,
            isComplete: false,
            startTime: block.timestamp,
            endTime: 0,
            participants: new address[](0)
        });

        emit CircularTransactionCompleted(circularId, 0);
        return circularId;
    }

    function _createTimeEvent(
        uint256 _txId,
        NonLinearTimeType _timeType,
        string memory _description
    ) internal {
        _eventCounter++;
        uint256 eventId = _eventCounter;

        timeEvents[eventId] = NonLinearTimeEvent({
            eventId: eventId,
            txId: _txId,
            timeType: _timeType,
            referenceTime: block.timestamp,
            narrativeDescription: _description,
            isResolved: true,
            resolutionTime: block.timestamp
        });
    }

    function getTransactionStoryline(uint256 _txId) external view returns (StoryLine, TransactionStatus, bytes32) {
        CrossChainTransaction storage tx_ = transactions[_txId];
        return (tx_.storyline, tx_.status, tx_.destinationTxHash);
    }

    function getUserTransactions(address _user) external view returns (uint256[] memory) {
        return userTransactions[_user];
    }

    function getCircularTimeline(uint256 _circularId) external view returns (CircularTransaction memory) {
        return circularTxs[_circularId];
    }
}

import hashlib
import json
import time
from dataclasses import dataclass
from typing import Dict, List, Optional, Tuple, Set
from enum import Enum

class StoryLine(Enum):
    HONEY_BUNNY = "honey_bunny_robbery"
    VINCENT_VINCENT = "vincent_jules_adventures"
    BUTCH_BOXER = "butch_gold_watch"

class TransactionStatus(Enum):
    PENDING = "pending"
    IN_TRANSIT = "in_transit"
    ATOMIC_LOCKED = "atomic_locked"
    COMPLETED = "completed"
    REVERTED = "reverted"
    EXPIRED = "expired"

class NonLinearTimeType(Enum):
    FLASHBACK = "flashback"
    FLASHFORWARD = "flashforward"
    CROSS_CUT = "cross_cut"
    PARALLEL = "parallel"
    CIRCULAR = "circular"

@dataclass
class CrossChainTx:
    tx_id: int
    initiator: str
    source_chain: str
    dest_chain: str
    amount: int
    token: str
    status: TransactionStatus
    storyline: StoryLine
    created_at: int
    timeout_at: int
    completed_at: int
    is_atomic: bool
    secret_hash: str

@dataclass
class AtomicSwap:
    swap_id: int
    chain_a: str
    chain_b: str
    party_a: str
    party_b: str
    amount_a: int
    amount_b: int
    token_a: str
    token_b: str
    secret_hash: str
    is_locked: bool
    is_claimed: bool
    is_refunded: bool
    lock_time: int
    expiry_time: int

@dataclass
class NarrativeEvent:
    event_id: int
    tx_id: int
    time_type: NonLinearTimeType
    description: str
    timestamp: int
    chain: str


class NonLinearCrossChain:
    """
    非线性跨链交易系统：模拟《低俗小说》的叙事结构
    """

    def __init__(self):
        self.transactions: Dict[int, CrossChainTx] = {}
        self.swaps: Dict[int, AtomicSwap] = {}
        self.events: List[NarrativeEvent] = []
        self.tx_counter = 0
        self.swap_counter = 0
        self.event_counter = 0
        self.used_secrets: Set[str] = set()

    def _hash(self, *args) -> str:
        data = ":".join(str(a) for a in args)
        return hashlib.sha256(data.encode()).hexdigest()

    def create_narrative_event(
        self,
        tx_id: int,
        time_type: NonLinearTimeType,
        description: str,
        chain: str
    ) -> int:
        self.event_counter += 1
        event_id = self.event_counter

        event = NarrativeEvent(
            event_id=event_id,
            tx_id=tx_id,
            time_type=time_type,
            description=description,
            timestamp=int(time.time()),
            chain=chain
        )

        self.events.append(event)
        return event_id

    def initiate_tx(
        self,
        initiator: str,
        source_chain: str,
        dest_chain: str,
        amount: int,
        token: str,
        storyline: StoryLine,
        is_atomic: bool = False,
        timeout: int = 86400
    ) -> int:
        self.tx_counter += 1
        tx_id = self.tx_counter

        secret_hash = ""
        if is_atomic:
            secret = self._hash(str(time.time()), initiator, str(tx_id))
            secret_hash = self._hash(secret)

        tx = CrossChainTx(
            tx_id=tx_id,
            initiator=initiator,
            source_chain=source_chain,
            dest_chain=dest_chain,
            amount=amount,
            token=token,
            status=TransactionStatus.PENDING,
            storyline=storyline,
            created_at=int(time.time()),
            timeout_at=int(time.time()) + timeout,
            completed_at=0,
            is_atomic=is_atomic,
            secret_hash=secret_hash
        )

        self.transactions[tx_id] = tx
        self.create_narrative_event(tx_id, NonLinearTimeType.CROSS_CUT,
            f"交易 #{tx_id}: {initiator[:8]} 从 {source_chain} 发送 {amount} {token} 到 {dest_chain}",
            source_chain)

        print(f"[交易发起] #{tx_id}: {storyline.value}")
        print(f"  {initiator[:8]} → {dest_chain}: {amount} {token}")
        print(f"  原子性: {is_atomic}, 超时: {timeout}s")

        return tx_id

    def lock_atomic_swap(
        self,
        chain_a: str,
        chain_b: str,
        party_a: str,
        party_b: str,
        amount_a: int,
        amount_b: int,
        token_a: str,
        token_b: str,
        secret_hash: str
    ) -> int:
        if secret_hash in self.used_secrets:
            raise ValueError("Secret哈希已使用")

        self.swap_counter += 1
        swap_id = self.swap_counter

        swap = AtomicSwap(
            swap_id=swap_id,
            chain_a=chain_a,
            chain_b=chain_b,
            party_a=party_a,
            party_b=party_b,
            amount_a=amount_a,
            amount_b=amount_b,
            token_a=token_a,
            token_b=token_b,
            secret_hash=secret_hash,
            is_locked=True,
            is_claimed=False,
            is_refunded=False,
            lock_time=int(time.time()),
            expiry_time=int(time.time()) + 3600
        )

        self.swaps[swap_id] = swap

        print(f"[原子交换] #{swap_id}: {chain_a} ↔ {chain_b}")
        print(f"  {party_a[:8]}: {amount_a} {token_a}")
        print(f"  {party_b[:8]}: {amount_b} {token_b}")

        return swap_id

    def claim_swap(self, swap_id: int, secret: str, claimant: str) -> bool:
        if swap_id not in self.swaps:
            raise ValueError(f"交换 #{swap_id} 不存在")

        swap = self.swaps[swap_id]
        if not swap.is_locked:
            raise ValueError("交换未锁定")
        if swap.is_claimed:
            raise ValueError("已领取")
        if swap.is_refunded:
            raise ValueError("已退款")
        if int(time.time()) >= swap.expiry_time:
            raise ValueError("已过期")

        computed_hash = self._hash(secret)
        if computed_hash != swap.secret_hash:
            raise ValueError("Secret不匹配")

        if claimant != swap.party_b:
            raise ValueError("只有对方可以领取")

        swap.is_claimed = True
        self.used_secrets.add(swap.secret_hash)

        print(f"[原子交换] #{swap_id}: 已领取")
        return True

    def refund_swap(self, swap_id: int, claimant: str) -> bool:
        if swap_id not in self.swaps:
            raise ValueError(f"交换 #{swap_id} 不存在")

        swap = self.swaps[swap_id]
        if not swap.is_locked:
            raise ValueError("交换未锁定")
        if swap.is_claimed:
            raise ValueError("已领取，无法退款")
        if swap.is_refunded:
            raise ValueError("已退款")

        if int(time.time()) < swap.expiry_time:
            remaining = swap.expiry_time - int(time.time())
            raise ValueError(f"未到期，剩余 {remaining}s")

        if claimant != swap.party_a:
            raise ValueError("只有发起方可以退款")

        swap.is_refunded = True

        print(f"[原子交换] #{swap_id}: 已退款")
        return True

    def complete_tx(self, tx_id: int) -> bool:
        if tx_id not in self.transactions:
            raise ValueError(f"交易 #{tx_id} 不存在")

        tx = self.transactions[tx_id]
        if tx.status != TransactionStatus.PENDING:
            raise ValueError(f"交易 #{tx_id} 状态不是 PENDING")
        if int(time.time()) >= tx.timeout_at:
            raise ValueError("交易已过期")

        tx.status = TransactionStatus.COMPLETED
        tx.completed_at = int(time.time())

        self.create_narrative_event(tx_id, NonLinearTimeType.PARALLEL,
            f"交易 #{tx_id}: 在 {tx.dest_chain} 完成", tx.dest_chain)

        print(f"[交易完成] #{tx_id}: {tx.status.value}")
        return True

    def revert_tx(self, tx_id: int) -> bool:
        if tx_id not in self.transactions:
            raise ValueError(f"交易 #{tx_id} 不存在")

        tx = self.transactions[tx_id]
        if tx.status in [TransactionStatus.COMPLETED, TransactionStatus.REVERTED]:
            raise ValueError(f"交易 #{tx_id} 已结束")

        tx.status = TransactionStatus.REVERTED

        self.create_narrative_event(tx_id, NonLinearTimeType.FLASHBACK,
            f"交易 #{tx_id}: 回滚到 {tx.source_chain}", tx.source_chain)

        print(f"[交易回滚] #{tx_id}: 已回滚")
        return True

    def get_event_timeline(self) -> List[Dict]:
        """获取叙事时间线，按时间顺序排列"""
        timeline = []
        for event in sorted(self.events, key=lambda e: e.timestamp):
            timeline.append({
                "event_id": event.event_id,
                "tx_id": event.tx_id,
                "time_type": event.time_type.value,
                "description": event.description,
                "timestamp": event.timestamp,
                "chain": event.chain,
                "human_time": time.strftime("%H:%M:%S", time.gmtime(event.timestamp))
            })
        return timeline

    def get_narrative_structure(self) -> Dict:
        """获取叙事结构分析"""
        storylines = {}
        for tx in self.transactions.values():
            sl = tx.storyline.value
            if sl not in storylines:
                storylines[sl] = []
            storylines[sl].append(tx.tx_id)

        # 分析非线性特征
        completed_txs = [t for t in self.transactions.values() if t.status == TransactionStatus.COMPLETED]
        reverted_txs = [t for t in self.transactions.values() if t.status == TransactionStatus.REVERTED]

        circular_patterns = []
        for tx in self.transactions.values():
            if tx.is_atomic:
                circular_patterns.append({
                    "tx_id": tx.tx_id,
                    "type": "atomic_swap_circular",
                    "chains": f"{tx.source_chain} ↔ {tx.dest_chain}"
                })

        return {
            "total_transactions": len(self.transactions),
            "completed": len(completed_txs),
            "reverted": len(reverted_txs),
            "storylines": storylines,
            "circular_patterns": circular_patterns,
            "total_events": len(self.events),
            "narrative_type": "non_linear_pulp_fiction"
        }

    def simulate_pulp_fiction_crosschain(self) -> Dict:
        """
        模拟《低俗小说》风格的跨链交易
        """
        print(f"\n{'='*60}")
        print(f"  《低俗小说》× 跨链交易模拟")
        print(f"  非线性叙事作为区块链时间")
        print(f"{'='*60}\n")

        # 场景1: 蜜兔和南瓜的"早午餐抢劫" → 跨链原子交换
        print(">>> 场景1: 蜜兔和南瓜的早午餐抢劫（原子交换）\n")

        honey_bunny_swap = self.lock_atomic_swap(
            chain_a="ethereum_breakfast_chain",
            chain_b="solana_restaurant_chain",
            party_a="Honey_Bunny_Robber",
            party_b="Pumpkin_Robber",
            amount_a=50000,
            amount_b=30000,
            token_a="USDC_BREAKFAST",
            token_b="USDC_RESTAURANT",
            secret_hash=self._hash("breakfast_robbery_secret")
        )

        # 场景2: 文森特和朱尔斯的"哲学讨论" → 跨链消息
        print("\n>>> 场景2: 文森特和朱尔斯的哲学讨论（跨链消息）\n")

        vincent_tx = self.initiate_tx(
            initiator="Vincent_Vega",
            source_chain="ethereum_chain",
            dest_chain="polygon_chain",
            amount=1000,
            token="EUR_WALLET",
            storyline=StoryLine.VINCENT_VINCENT,
            is_atomic=False
        )

        jules_tx = self.initiate_tx(
            initiator="Jules_Winnfield",
            source_chain="ethereum_chain",
            dest_chain="polygon_chain",
            amount=1500,
            token="EUR_WALLET",
            storyline=StoryLine.VINCENT_VINCENT,
            is_atomic=False
        )

        # 场景3: 布奇的"金表逃亡" → 跨链资产转移
        print("\n>>> 场景3: 布奇的金表逃亡（跨链资产转移）\n")

        butch_tx = self.initiate_tx(
            initiator="Butch_Coolidge",
            source_chain="ethereum_chain",
            dest_chain="avalanche_chain",
            amount=50000,
            token="GOLD_WATCH_NFT",
            storyline=StoryLine.BUTCH_BOXER,
            is_atomic=True,
            timeout=7200
        )

        fabienne_tx = self.initiate_tx(
            initiator="Fabienne",
            source_chain="ethereum_chain",
            dest_chain="avalanche_chain",
            amount=20000,
            token="USDC",
            storyline=StoryLine.BUTCH_BOXER,
            is_atomic=True
        )

        # 原子交换完成
        print("\n>>> 原子交换完成\n")
        self.claim_swap(honey_bunny_swap, "breakfast_robbery_secret", "Pumpkin_Robber")

        # 完成交易（非线性顺序）
        print("\n>>> 叙事时间线（非线性顺序）\n")
        # 先完成"Butch"的交易（在电影中，布奇的故事是"最后"被讲述的，但在"时间线"上，它发生在文森特的故事之后）
        # 这模拟了非线性叙事的"时间错位"
        self.complete_tx(butch_tx)
        self.complete_tx(fabienne_tx)
        self.complete_tx(vincent_tx)
        self.complete_tx(jules_tx)

        # 分析叙事结构
        print("\n>>> 叙事结构分析\n")
        structure = self.get_narrative_structure()
        print(f"总交易数: {structure['total_transactions']}")
        print(f"完成: {structure['completed']}, 回滚: {structure['reverted']}")
        print(f"故事线: {json.dumps(structure['storylines'], indent=2, ensure_ascii=False)}")

        print(f"\n>>> 完整事件时间线\n")
        timeline = self.get_event_timeline()
        for event in timeline:
            print(f"  [{event['human_time']}] {event['time_type']}: {event['description']}")

        print(f"\n{'='*60}")
        print(f"  模拟完成")
        print(f"{'='*60}")

        return {
            "total_transactions": structure["total_transactions"],
            "completed": structure["completed"],
            "storylines": structure["storylines"],
            "events_count": structure["total_events"],
            "narrative_type": structure["narrative_type"]
        }


def main():
    nlc = NonLinearCrossChain()
    result = nlc.simulate_pulp_fiction_crosschain()

    print(f"\n=== 模拟结果 ===")
    print(f"交易总数: {result['total_transactions']}")
    print(f"完成: {result['completed']}")
    print(f"叙事类型: {result['narrative_type']}")
    print(f"事件数: {result['events_count']}")


if __name__ == "__main__":
    main()