加密支付卡交易量激增230%：创作者经济的链上收银台

pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";

contract CryptoPaymentProcessor is ReentrancyGuard, Ownable, Pausable {
    using SafeERC20 for IERC20;

    struct PaymentSession {
        address merchant;
        address token;
        uint256 amount;
        uint256 exchangeRate;
        uint256 timestamp;
        PaymentStatus status;
    }

    enum PaymentStatus { Pending, Completed, Refunded, Disputed }

    mapping(bytes32 => PaymentSession) public sessions;
    mapping(address => bool) public authorizedMerchants;
    mapping(address => uint256) public merchantBalances;

    uint256 public platformFeeBps;
    address public feeCollector;
    uint256 public totalProcessed;
    uint256 public sessionCounter;

    event PaymentInitiated(bytes32 indexed sessionId, address indexed buyer, address indexed merchant, address token, uint256 amount);
    event PaymentSettled(bytes32 indexed sessionId, address indexed merchant, uint256 netAmount);
    event PaymentRefunded(bytes32 indexed sessionId, address indexed buyer, uint256 amount);
    event MerchantRegistered(address indexed merchant, uint256 timestamp);
    event ExchangeRateUpdated(address indexed token, uint256 newRate);

    modifier onlyMerchant() {
        require(authorizedMerchants[msg.sender], "Not authorized merchant");
        _;
    }

    constructor(uint256 _feeBps, address _feeCollector) {
        require(_feeBps <= 500, "Fee too high");
        platformFeeBps = _feeBps;
        feeCollector = _feeCollector;
    }

    function registerMerchant(address _merchant) external onlyOwner {
        authorizedMerchants[_merchant] = true;
        emit MerchantRegistered(_merchant, block.timestamp);
    }

    function initiatePayment(
        address _merchant,
        address _token,
        uint256 _amount,
        uint256 _exchangeRate
    ) external whenNotPaused nonReentrant returns (bytes32) {
        require(authorizedMerchants[_merchant], "Merchant not registered");
        require(_amount > 0, "Invalid amount");

        sessionCounter++;
        bytes32 sessionId = keccak256(abi.encodePacked(msg.sender, _merchant, _amount, sessionCounter, block.timestamp));

        sessions[sessionId] = PaymentSession({
            merchant: _merchant,
            token: _token,
            amount: _amount,
            exchangeRate: _exchangeRate,
            timestamp: block.timestamp,
            status: PaymentStatus.Pending
        });

        IERC20(_token).safeTransferFrom(msg.sender, address(this), _amount);
        emit PaymentInitiated(sessionId, msg.sender, _merchant, _token, _amount);
        return sessionId;
    }

    function settlePayment(bytes32 _sessionId) external onlyMerchant nonReentrant {
        PaymentSession storage session = sessions[_sessionId];
        require(session.status == PaymentStatus.Pending, "Invalid status");
        require(block.timestamp <= session.timestamp + 3600, "Session expired");

        uint256 fee = (session.amount * platformFeeBps) / 10000;
        uint256 netAmount = session.amount - fee;

        session.status = PaymentStatus.Completed;
        totalProcessed += session.amount;

        if (fee > 0) {
            IERC20(session.token).safeTransfer(feeCollector, fee);
        }
        IERC20(session.token).safeTransfer(session.merchant, netAmount);

        emit PaymentSettled(_sessionId, session.merchant, netAmount);
    }

    function refundPayment(bytes32 _sessionId) external onlyOwner nonReentrant {
        PaymentSession storage session = sessions[_sessionId];
        require(session.status == PaymentStatus.Pending, "Invalid status");

        session.status = PaymentStatus.Refunded;
        IERC20(session.token).safeTransfer(msg.sender, session.amount);

        emit PaymentRefunded(_sessionId, msg.sender, session.amount);
    }

    function batchSettle(bytes32[] calldata _sessionIds) external nonReentrant {
        for (uint256 i = 0; i < _sessionIds.length; i++) {
            PaymentSession storage session = sessions[_sessionIds[i]];
            if (session.status == PaymentStatus.Pending && session.merchant == msg.sender) {
                uint256 fee = (session.amount * platformFeeBps) / 10000;
                uint256 netAmount = session.amount - fee;
                session.status = PaymentStatus.Completed;
                totalProcessed += session.amount;
                if (fee > 0) {
                    IERC20(session.token).safeTransfer(feeCollector, fee);
                }
                IERC20(session.token).safeTransfer(session.merchant, netAmount);
                emit PaymentSettled(_sessionIds[i], session.merchant, netAmount);
            }
        }
    }

    function updateFeeBps(uint256 _newBps) external onlyOwner {
        require(_newBps <= 500, "Fee too high");
        platformFeeBps = _newBps;
    }

    function pause() external onlyOwner { _pause(); }
    function unpause() external onlyOwner { _unpause(); }
}

class CreatorPaymentWidget {
    constructor(containerId, config) {
        this.container = document.getElementById(containerId);
        this.config = {
            recipientAddress: config.recipientAddress,
            supportedTokens: config.supportedTokens || ['ETH', 'USDC', 'DAI'],
            defaultAmount: config.defaultAmount || 5,
            currency: config.currency || 'USD',
            ...config
        };
        this.selectedToken = this.config.supportedTokens[0];
        this.init();
    }

    init() {
        this.container.innerHTML = this.renderTemplate();
        this.attachEventListeners();
        this.loadExchangeRates();
    }

    renderTemplate() {
        return `
            <div class="creator-payment-widget">
                <style>
                    .creator-payment-widget {
                        font-family: 'Inter', sans-serif;
                        max-width: 380px;
                        background: #1a1a2e;
                        border-radius: 16px;
                        padding: 24px;
                        color: #e0e0e0;
                        box-shadow: 0 8px 32px rgba(0,0,0,0.3);
                    }
                    .widget-header { text-align: center; margin-bottom: 20px; }
                    .widget-header h3 { margin: 0; font-size: 18px; color: #fff; }
                    .amount-grid { display: grid; grid-template-columns: repeat(3, 1fr); gap: 8px; margin: 16px 0; }
                    .amount-btn {
                        padding: 12px; border: 1px solid #444; border-radius: 8px;
                        background: transparent; color: #e0e0e0; cursor: pointer;
                        font-size: 14px; transition: all 0.2s;
                    }
                    .amount-btn:hover, .amount-btn.active { background: #6c63ff; border-color: #6c63ff; color: #fff; }
                    .token-selector { display: flex; gap: 8px; margin: 16px 0; }
                    .token-btn {
                        flex: 1; padding: 10px; border: 1px solid #444; border-radius: 8px;
                        background: transparent; color: #e0e0e0; cursor: pointer;
                        font-size: 13px; text-align: center; transition: all 0.2s;
                    }
                    .token-btn:hover, .token-btn.active { background: #16213e; border-color: #6c63ff; }
                    .pay-button {
                        width: 100%; padding: 14px; background: linear-gradient(135deg, #6c63ff, #3b82f6);
                        border: none; border-radius: 8px; color: #fff; font-size: 16px;
                        font-weight: 600; cursor: pointer; margin-top: 16px; transition: opacity 0.2s;
                    }
                    .pay-button:hover { opacity: 0.9; }
                    .pay-button:disabled { opacity: 0.5; cursor: not-allowed; }
                    .wallet-info { font-size: 12px; color: #888; margin-top: 12px; text-align: center; }
                    .custom-amount {
                        width: 100%; padding: 12px; border: 1px solid #444; border-radius: 8px;
                        background: #0f0f23; color: #fff; font-size: 16px;
                        text-align: center; margin: 8px 0; box-sizing: border-box;
                    }
                </style>
                <div class="widget-header">
                    <h3>Support this Creator</h3>
                    <p style="font-size:13px;color:#888;">Choose amount and token</p>
                </div>
                <div class="amount-grid">
                    <button class="amount-btn" data-amount="5">$5</button>
                    <button class="amount-btn active" data-amount="10">$10</button>
                    <button class="amount-btn" data-amount="25">$25</button>
                    <button class="amount-btn" data-amount="50">$50</button>
                    <button class="amount-btn" data-amount="100">$100</button>
                    <button class="amount-btn" data-amount="custom">Custom</button>
                </div>
                <input type="number" class="custom-amount" placeholder="Enter amount (USD)" style="display:none;" />
                <div class="token-selector">
                    ${this.config.supportedTokens.map(t => `
                        <button class="token-btn ${t === this.selectedToken ? 'active' : ''}" data-token="${t}">${t}</button>
                    `).join('')}
                </div>
                <button class="pay-button connect-btn">Connect Wallet</button>
                <div class="wallet-info">Powered by Web3 Payment Gateway</div>
            </div>
        `;
    }

    attachEventListeners() {
        const amounts = this.container.querySelectorAll('.amount-btn');
        amounts.forEach(btn => {
            btn.addEventListener('click', (e) => {
                amounts.forEach(b => b.classList.remove('active'));
                btn.classList.add('active');
                const val = btn.dataset.amount;
                const input = this.container.querySelector('.custom-amount');
                if (val === 'custom') {
                    input.style.display = 'block';
                    input.focus();
                } else {
                    input.style.display = 'none';
                    this.selectedAmount = parseFloat(val);
                }
            });
        });

        const tokens = this.container.querySelectorAll('.token-btn');
        tokens.forEach(btn => {
            btn.addEventListener('click', () => {
                tokens.forEach(b => b.classList.remove('active'));
                btn.classList.add('active');
                this.selectedToken = btn.dataset.token;
            });
        });

        const connectBtn = this.container.querySelector('.connect-btn');
        connectBtn.addEventListener('click', () => this.handleConnect());
    }

    async loadExchangeRates() {
        this.rates = { ETH: 0, USDC: 1, DAI: 1 };
        try {
            const resp = await fetch('https://api.coingecko.com/api/v3/simple/price?ids=ethereum&vs_currencies=usd');
            const data = await resp.json();
            this.rates.ETH = data.ethereum.usd;
        } catch (e) {
            this.rates.ETH = 3500;
        }
    }

    async handleConnect() {
        if (typeof window.ethereum === 'undefined') {
            alert('Please install MetaMask or a compatible wallet');
            return;
        }
        try {
            const accounts = await window.ethereum.request({ method: 'eth_requestAccounts' });
            this.userAddress = accounts[0];
            const btn = this.container.querySelector('.connect-btn');
            btn.textContent = 'Pay Now';
            btn.classList.remove('connect-btn');
            btn.addEventListener('click', () => this.processPayment());
            this.container.querySelector('.wallet-info').textContent = `${this.userAddress.slice(0, 6)}...${this.userAddress.slice(-4)}`;
        } catch (err) {
            console.error('Wallet connection failed:', err);
        }
    }

    async processPayment() {
        const input = this.container.querySelector('.custom-amount');
        const amount = input && input.style.display !== 'none' ? parseFloat(input.value) : this.selectedAmount;
        if (!amount || amount <= 0) {
            alert('Please enter a valid amount');
            return;
        }
        const tokenAmount = this.rates[this.selectedToken] > 0 ? amount / this.rates[this.selectedToken] : amount;
        const payBtn = this.container.querySelector('.pay-button');
        payBtn.disabled = true;
        payBtn.textContent = 'Processing...';

        try {
            const valueHex = '0x' + Math.floor(tokenAmount * Math.pow(10, 18)).toString(16);
            const txParams = {
                from: this.userAddress,
                to: this.config.recipientAddress,
                value: valueHex,
                gas: '0x5208',
            };
            if (this.selectedToken !== 'ETH') {
                const iface = new ethers.utils.Interface(['function transfer(address,uint256)']);
                txParams.to = this.getTokenAddress(this.selectedToken);
                txParams.data = iface.encodeFunctionData('transfer', [
                    this.config.recipientAddress,
                    ethers.utils.parseUnits(tokenAmount.toString(), this.selectedToken === 'USDC' ? 6 : 18)
                ]);
                delete txParams.value;
            }
            const txHash = await window.ethereum.request({ method: 'eth_sendTransaction', params: [txParams] });
            payBtn.textContent = 'Payment Sent!';
            this.showReceipt(txHash, amount, this.selectedToken);
        } catch (err) {
            payBtn.textContent = 'Pay Now';
            payBtn.disabled = false;
        }
    }

    getTokenAddress(symbol) {
        const addresses = {
            'USDC': '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
            'DAI': '0x6B175474E89094C44Da98b954EedeAC495271d0F'
        };
        return addresses[symbol];
    }

    showReceipt(txHash, amount, token) {
        const receiptHtml = `
            <div style="text-align:center;margin-top:16px;padding:16px;background:#0f0f23;border-radius:8px;">
                <p style="color:#4ade80;font-weight:600;">Payment Successful</p>
                <p style="font-size:24px;margin:8px 0;">$${amount} (${token})</p>
                <a href="https://etherscan.io/tx/${txHash}" target="_blank" style="color:#6c63ff;font-size:13px;">View on Etherscan</a>
            </div>
        `;
        this.container.querySelector('.wallet-info').insertAdjacentHTML('afterend', receiptHtml);
    }
}

const widget = new CreatorPaymentWidget('payment-widget', {
    recipientAddress: '0x742d35Cc6634C0532925a3b844Bc9e7595f2bD18',
    supportedTokens: ['ETH', 'USDC', 'DAI'],
    defaultAmount: 10
});

import json
import time
from datetime import datetime, timedelta
from collections import defaultdict
from web3 import Web3

class CryptoCardAnalytics:
    def __init__(self, rpc_url, contract_address, abi_path):
        self.w3 = Web3(Web3.HTTPProvider(rpc_url))
        with open(abi_path, 'r') as f:
            self.contract = self.w3.eth.contract(
                address=Web3.to_checksum_address(contract_address),
                abi=json.load(f)
            )
        self.transactions = []
        self.cardholders = {}
        self.merchants = {}

    def fetch_transactions(self, from_block, to_block):
        event_filter = self.contract.events.PaymentSettled.create_filter(
            fromBlock=from_block,
            toBlock=to_block
        )
        events = event_filter.get_all_entries()
        for event in events:
            tx = {
                'session_id': event['args']['sessionId'].hex(),
                'merchant': event['args']['merchant'],
                'token': event['args'].get('token', 'ETH'),
                'amount_wei': event['args']['netAmount'],
                'amount_usd': float(Web3.from_wei(event['args']['netAmount'], 'ether')) * self._get_token_price(event['args'].get('token', 'ETH')),
                'block_number': event['blockNumber'],
                'timestamp': self.w3.eth.get_block(event['blockNumber'])['timestamp'],
                'tx_hash': event['transactionHash'].hex()
            }
            self.transactions.append(tx)
        return len(self.transactions)

    def spending_by_category(self, start_date=None, end_date=None):
        category_map = self._load_merchant_categories()
        results = defaultdict(lambda: {'count': 0, 'total_usd': 0.0, 'avg_usd': 0.0})
        for tx in self.transactions:
            merchant = tx['merchant']
            category = category_map.get(merchant, 'Other')
            if merchant not in self.merchants:
                self.merchants[merchant] = {'category': category, 'tx_count': 0, 'total': 0}
            self.merchants[merchant]['tx_count'] += 1
            self.merchants[merchant]['total'] += tx['amount_usd']
            results[category]['count'] += 1
            results[category]['total_usd'] += tx['amount_usd']
        for cat in results:
            if results[cat]['count'] > 0:
                results[cat]['avg_usd'] = results[cat]['total_usd'] / results[cat]['count']
        sorted_cats = sorted(results.items(), key=lambda x: x[1]['total_usd'], reverse=True)
        return dict(sorted_cats)

    def user_demographics(self):
        age_brackets = {'Gen Z (18-25)': 0, 'Millennials (26-40)': 0, 'Gen X (41-55)': 0, 'Boomers (56+)': 0}
        gen_spending = defaultdict(float)
        for holder_id, data in self.cardholders.items():
            age = data.get('age')
            if age and 18 <= age <= 25:
                age_brackets['Gen Z (18-25)'] += 1
                gen_spending['Gen Z'] += data.get('total_spent', 0)
            elif age and 26 <= age <= 40:
                age_brackets['Millennials (26-40)'] += 1
                gen_spending['Millennials'] += data.get('total_spent', 0)
            elif age and 41 <= age <= 55:
                age_brackets['Gen X (41-55)'] += 1
                gen_spending['Gen X'] += data.get('total_spent', 0)
            elif age and age > 55:
                age_brackets['Boomers (56+)'] += 1
                gen_spending['Boomers'] += data.get('total_spent', 0)
        total_young = age_brackets['Gen Z (18-25)'] + age_brackets['Millennials (26-40)']
        total_all = sum(age_brackets.values())
        young_pct = (total_young / total_all * 100) if total_all > 0 else 0
        return {
            'age_distribution': age_brackets,
            'young_holder_pct': round(young_pct, 1),
            'avg_spend_by_generation': {k: round(v / max(age_brackets.get(k.split(' ')[0], 1), 1), 2) for k, v in gen_spending.items()}
        }

    def monthly_trends(self, num_months=12):
        monthly = defaultdict(lambda: {'volume': 0.0, 'count': 0, 'unique_users': set()})
        for tx in self.transactions:
            month_key = datetime.fromtimestamp(tx['timestamp']).strftime('%Y-%m')
            monthly[month_key]['volume'] += tx['amount_usd']
            monthly[month_key]['count'] += 1
        sorted_months = sorted(monthly.items(), key=lambda x: x[0])
        for i in range(1, len(sorted_months)):
            prev_vol = sorted_months[i - 1][1]['volume']
            curr_vol = sorted_months[i][1]['volume']
            growth = ((curr_vol - prev_vol) / prev_vol * 100) if prev_vol > 0 else 0
            sorted_months[i][1]['mom_growth'] = round(growth, 1)
        latest = sorted_months[-1] if sorted_months else None
        yoy_growth = 0
        if len(sorted_months) >= 13:
            current_vol = sorted_months[-1][1]['volume']
            year_ago_vol = sorted_months[-13][1]['volume']
            yoy_growth = ((current_vol - year_ago_vol) / year_ago_vol * 100) if year_ago_vol > 0 else 0
        return {
            'monthly_data': {k: {'volume': v['volume'], 'count': v['count'], 'mom_growth': v.get('mom_growth', 0)} for k, v in sorted_months},
            'yoy_growth': round(yoy_growth, 1),
            'latest_month': latest[0] if latest else None
        }

    def anomaly_detection(self, threshold=3.0):
        anomalies = []
        amounts = [tx['amount_usd'] for tx in self.transactions if tx['amount_usd'] > 0]
        if not amounts:
            return anomalies
        mean_val = sum(amounts) / len(amounts)
        variance = sum((x - mean_val) ** 2 for x in amounts) / len(amounts)
        std_dev = variance ** 0.5
        for tx in self.transactions:
            z_score = (tx['amount_usd'] - mean_val) / std_dev if std_dev > 0 else 0
            if abs(z_score) > threshold:
                anomalies.append({'tx_hash': tx['tx_hash'], 'amount': tx['amount_usd'], 'z_score': round(z_score, 2)})
        return anomalies

    def generate_report(self):
        categories = self.spending_by_category()
        demographics = self.user_demographics()
        trends = self.monthly_trends()
        anomalies = self.anomaly_detection()
        total_volume = sum(tx['amount_usd'] for tx in self.transactions)
        active_users = len(self.cardholders)
        active_merchants = len(self.merchants)
        avg_tx = total_volume / len(self.transactions) if self.transactions else 0
        report = {
            'generated_at': datetime.now().isoformat(),
            'overview': {
                'total_transactions': len(self.transactions),
                'total_volume_usd': round(total_volume, 2),
                'active_cardholders': active_users,
                'active_merchants': active_merchants,
                'avg_transaction_usd': round(avg_tx, 2),
                'yoy_growth_pct': trends['yoy_growth']
            },
            'top_categories': dict(list(categories.items())[:5]),
            'demographics': demographics,
            'monthly_trends': trends['monthly_data'],
            'anomalies_detected': len(anomalies),
            'top_spending_merchants': sorted(self.merchants.items(), key=lambda x: x[1]['total'], reverse=True)[:10]
        }
        return report

    def _get_token_price(self, token_symbol):
        prices = {'ETH': 3450, 'BTC': 68000, 'USDC': 1.0, 'USDT': 1.0, 'DAI': 1.0, 'BNB': 580}
        return prices.get(token_symbol, 1.0)

    def _load_merchant_categories(self):
        return {}

analytics = CryptoCardAnalytics(
    rpc_url='https://ethereum-rpc.publicnode.com',
    contract_address='0x1234567890abcdef1234567890abcdef12345678',
    abi_path='./payment_processor_abi.json'
)
report = analytics.generate_report()
print(json.dumps(report, indent=2, default=str))