《唐人街》与链上调查：水门事件作为链上取证

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

contract ChainInvestigation {
    struct Investigation {
        bytes32 caseId;
        address investigator;
        address targetAddress;
        uint256 startBlock;
        uint256 endBlock;
        string description;
        bool completed;
        uint256 suspiciousTransactions;
    }

    struct TransactionEvidence {
        bytes32 txHash;
        address from;
        address to;
        uint256 value;
        uint256 timestamp;
        bool flagged;
        string reason;
    }

    mapping(bytes32 => Investigation) public investigations;
    mapping(bytes32 => TransactionEvidence[]) public evidence;
    bytes32[] public caseIds;

    event InvestigationOpened(bytes32 caseId, address investigator, address target);
    event TransactionFlagged(bytes32 caseId, bytes32 txHash, string reason);

    function openInvestigation(address targetAddress, string calldata description) 
        external returns (bytes32) {
        bytes32 caseId = keccak256(abi.encodePacked(msg.sender, targetAddress, block.timestamp));
        investigations[caseId] = Investigation({
            caseId: caseId,
            investigator: msg.sender,
            targetAddress: targetAddress,
            startBlock: block.number,
            endBlock: 0,
            description: description,
            completed: false,
            suspiciousTransactions: 0
        });
        caseIds.push(caseId);
        emit InvestigationOpened(caseId, msg.sender, targetAddress);
        return caseId;
    }

    function flagTransaction(bytes32 caseId, bytes32 txHash, address from, 
                             address to, uint256 value, string calldata reason) external {
        Investigation storage inv = investigations[caseId];
        require(inv.investigator == msg.sender, "Not investigator");

        evidence[caseId].push(TransactionEvidence({
            txHash: txHash,
            from: from,
            to: to,
            value: value,
            timestamp: block.timestamp,
            flagged: true,
            reason: reason
        }));
        inv.suspiciousTransactions++;
        emit TransactionFlagged(caseId, txHash, reason);
    }
}

import json
import random
from typing import Dict, List
from collections import defaultdict

class ChainAnalyzer:
    def analyze_transaction_pattern(self, txs: List[Dict]) -> Dict:
        addresses = set()
        total_value = 0
        for tx in txs:
            addresses.add(tx['from'])
            addresses.add(tx['to'])
            total_value += tx['value']
        return {
            'unique_addresses': len(addresses),
            'total_value': total_value,
            'tx_count': len(txs),
            'suspicious_patterns': total_value > 1000000 and len(addresses) < 5
        }

    def trace_money_flow(self, start_address: str, depth: int = 3) -> Dict:
        flow = {'start': start_address, 'hops': []}
        current = start_address
        for _ in range(depth):
            next_addr = f"0x{random.randint(0, 1000):040x}"
            flow['hops'].append({'from': current, 'to': next_addr, 'value': random.uniform(1, 100)})
            current = next_addr
        return flow


analyzer = ChainAnalyzer()
txs = [{'from': '0xAlice', 'to': '0xBob', 'value': random.uniform(1, 100)} for _ in range(10)]
result = analyzer.analyze_transaction_pattern(txs)
flow = analyzer.trace_money_flow('0xAlice')
print(json.dumps({'analysis': result, 'flow': flow}, indent=2))

const express = require('express');
const { ethers } = require('ethers');
const app = express();
app.use(express.json());

const INVESTIGATION_ABI = [
    "function openInvestigation(address targetAddress, string description) external returns (bytes32)",
    "function flagTransaction(bytes32 caseId, bytes32 txHash, address from, address to, uint256 value, string reason) external",
    "event InvestigationOpened(bytes32 caseId, address investigator, address target)"
];

class InvestigationPlatform {
    constructor(providerUrl, contractAddress) {
        this.provider = new ethers.providers.JsonRpcProvider(providerUrl);
        this.contract = new ethers.Contract(contractAddress, INVESTIGATION_ABI, this.provider);
    }

    async openInvestigation(privateKey, targetAddress, description) {
        const wallet = new ethers.Wallet(privateKey, this.provider);
        const contract = this.contract.connect(wallet);
        const tx = await contract.openInvestigation(targetAddress, description);
        return await tx.wait();
    }
}

app.post('/api/investigation/open', async (req, res) => {
    const { privateKey, targetAddress, description } = req.body;
    const platform = new InvestigationPlatform(process.env.RPC_URL, process.env.INVESTIGATION_ADDRESS);
    const receipt = await platform.openInvestigation(privateKey, targetAddress, description);
    res.json(receipt);
});

app.listen(3020, () => {
    console.log('Chain Investigation API running on port 3020');
});