以太坊ERC-4337账户抽象：智能合约钱包如何重塑数字身份

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

/// @title 基础账户抽象钱包
/// @notice 实现ERC-4337标准的智能合约钱包
/// @dev 支持社交恢复和Gas赞助
contract AccountAbstractionWallet {
    address public immutable entryPoint;
    address public owner;
    address[] public guardians;
    uint256 public recoveryThreshold;
    bool public paused;

    event WalletCreated(address indexed wallet, address indexed owner);
    event GuardianAdded(address indexed guardian);
    event RecoveryInitiated(address indexed newOwner, uint256 confirmations);
    event GasSponsored(address indexed sponsor, uint256 amount);

    modifier onlyEntryPoint() {
        require(msg.sender == entryPoint, "仅入口点可调用");
        _;
    }

    constructor(address _entryPoint, address _owner) {
        entryPoint = _entryPoint;
        owner = _owner;
        recoveryThreshold = 2;
        emit WalletCreated(address(this), _owner);
    }

    function validateUserOp(
        UserOperation calldata userOp,
        bytes32 userOpHash,
        uint256 missingAccountFunds
    ) external onlyEntryPoint returns (uint256 validationData) {
        address recovered = recoverSigner(userOpHash, userOp.signature);
        if (recovered != owner) return SIG_VALIDATION_FAILED;
        if (paused) return SIG_VALIDATION_FAILED;
        if (missingAccountFunds > 0) _payPrefund(missingAccountFunds);
        return 0;
    }

    function execute(address dest, uint256 value, bytes calldata func)
        external onlyEntryPoint
    {
        (bool success, bytes memory result) = dest.call{value: value}(func);
        require(success, string(result));
    }

    function addGuardian(address guardian) external {
        require(msg.sender == owner, "仅所有者可操作");
        guardians.push(guardian);
        emit GuardianAdded(guardian);
    }

    function initiateRecovery(address newOwner) external {
        require(!paused, "钱包已暂停");
        uint256 confirmations = 0;
        for (uint256 i = 0; i < guardians.length; i++) {
            if (msg.sender == guardians[i]) confirmations++;
        }
        require(confirmations >= recoveryThreshold, "守护者确认不足");
        owner = newOwner;
        emit RecoveryInitiated(newOwner, confirmations);
    }

    function recoverSigner(bytes32 hash, bytes memory sig)
        internal pure returns (address)
    {
        (uint8 v, bytes32 r, bytes32 s) = splitSignature(sig);
        return ecrecover(hash, v, r, s);
    }

    function splitSignature(bytes memory sig)
        internal pure returns (uint8 v, bytes32 r, bytes32 s)
    {
        require(sig.length == 65, "签名长度无效");
        assembly {
            r := mload(add(sig, 32))
            s := mload(add(sig, 64))
            v := byte(0, mload(add(sig, 96)))
        }
    }

    function _payPrefund(uint256 amount) internal {
        if (amount > 0) {
            (bool success,) = payable(msg.sender).call{value: amount}("");
            require(success, "预付Gas失败");
        }
    }
}

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

class RecoveryStatus(Enum):
    PENDING = "待确认"
    APPROVED = "已通过"
    REJECTED = "已拒绝"
    EXPIRED = "已过期"

@dataclass
class Guardian:
    address: str
    name: str
    weight: int = 1
    is_active: bool = True
    added_at: int = 0

@dataclass
class RecoveryRequest:
    new_owner: str
    initiator: str
    confirmations: List[str] = field(default_factory=list)
    created_at: int = 0
    status: RecoveryStatus = RecoveryStatus.PENDING
    expiry: int = 604800

class SocialRecoveryWallet:
    def __init__(self, owner: str, name: str = "未命名钱包", threshold: int = 2):
        self.owner = owner
        self.name = name
        self.guardians: Dict[str, Guardian] = {}
        self.recovery_threshold = threshold
        self.pending_requests: List[RecoveryRequest] = []
        self.recovery_history: List[Dict] = []
        self.nonce = 0
        self.paused = False
        print(f"[钱包创建] {name} | 所有者: {owner[:10]}... | 阈值: {threshold}/{threshold}")

    def add_guardian(self, address: str, name: str, weight: int = 1) -> Guardian:
        if address in self.guardians:
            raise ValueError(f"守护者 {name} 已存在")
        guardian = Guardian(address=address, name=name, weight=weight, added_at=int(time.time()))
        self.guardians[address] = guardian
        print(f"[添加守护者] {name} ({address[:10]}...) 权重={weight}")
        return guardian

    def remove_guardian(self, address: str) -> bool:
        if address not in self.guardians:
            return False
        guardian = self.guardians.pop(address)
        print(f"[移除守护者] {guardian.name}")
        return True

    def initiate_recovery(self, new_owner: str) -> RecoveryRequest:
        if self.paused:
            raise ValueError("钱包已暂停")
        request = RecoveryRequest(
            new_owner=new_owner,
            initiator=self.owner,
            created_at=int(time.time()),
            expiry=int(time.time()) + 604800
        )
        self.pending_requests.append(request)
        self.nonce += 1
        print(f"\n[恢复请求发起] 新所有者: {new_owner[:10]}... | 需要确认: {self.recovery_threshold}/{len(self.guardians)}")
        return request

    def confirm_recovery(self, guardian_address: str, request_index: int = 0) -> Tuple[bool, str]:
        if guardian_address not in self.guardians:
            return False, "未注册的守护者"
        if not self.guardians[guardian_address].is_active:
            return False, "守护者已停用"
        if request_index >= len(self.pending_requests):
            return False, "恢复请求不存在"
        request = self.pending_requests[request_index]
        if request.status != RecoveryStatus.PENDING:
            return False, f"请求状态为 {request.status.value}"
        if int(time.time()) > request.expiry:
            request.status = RecoveryStatus.EXPIRED
            return False, "请求已过期"
        if guardian_address in request.confirmations:
            return False, "该守护者已确认"
        guardian = self.guardians[guardian_address]
        request.confirmations.append(guardian_address)
        print(f"[确认] {guardian.name} 已确认 | {len(request.confirmations)}/{self.recovery_threshold}")
        if len(request.confirmations) >= self.recovery_threshold:
            request.status = RecoveryStatus.APPROVED
            old_owner = self.owner
            self.owner = request.new_owner
            self.recovery_history.append({
                "old_owner": old_owner,
                "new_owner": request.new_owner,
                "timestamp": int(time.time()),
                "confirmations": request.confirmations[:]
            })
            print(f"[恢复成功] 旧: {old_owner[:10]}... → 新: {request.new_owner[:10]}...")
            return True, "恢复成功"
        return True, "确认已记录"

    def get_recovery_status(self, request_index: int = 0) -> Optional[Dict]:
        if request_index >= len(self.pending_requests):
            return None
        request = self.pending_requests[request_index]
        confirmed_names = [self.guardians[a].name for a in request.confirmations if a in self.guardians]
        return {
            "new_owner": request.new_owner,
            "status": request.status.value,
            "confirmations_needed": self.recovery_threshold,
            "confirmations_received": len(request.confirmations),
            "confirmed_by": confirmed_names,
            "created_at": request.created_at,
            "expires_at": request.expiry,
            "is_expired": int(time.time()) > request.expiry
        }

def simulate_recovery_scenario():
    print("=" * 60)
    print("🎬 社交恢复流程模拟")
    print("=" * 60)
    wallet = SocialRecoveryWallet(
        owner="0x1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b",
        name="导演王森涛的钱包", threshold=3
    )
    wallet.add_guardian("0x9f8e7d6c5b4a3f2e1d0c9b8a7f6e5d4c3b2a1f0e", "制片人张磊")
    wallet.add_guardian("0x0a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b", "摄影师李明")
    wallet.add_guardian("0x8b7a6c5d4e3f2a1b0c9d8e7f6a5b4c3d2e1f0a9b", "剪辑师陈华")
    wallet.add_guardian("0x7c6b5a4d3e2f1a0b9c8d7e6f5a4b3c2d1e0f9a8b", "编剧赵雪")
    print("\n🔑 私钥丢失！发起恢复...")
    new_owner = "0x2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c"
    request = wallet.initiate_recovery(new_owner)
    for addr in ["0x9f8e7d6c5b4a3f2e1d0c9b8a7f6e5d4c3b2a1f0e",
                  "0x0a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b",
                  "0x8b7a6c5d4e3f2a1b0c9d8e7f6a5b4c3d2e1f0a9b"]:
        success, msg = wallet.confirm_recovery(addr, 0)
        print(f"  → {msg}")
    print("\n" + "=" * 60)
    print(f"当前所有者: {wallet.owner[:10]}...")
    print(f"恢复历史: {len(wallet.recovery_history)} 次")

if __name__ == "__main__":
    simulate_recovery_scenario()

const { ethers } = require('ethers');

class ContentPlatformPaymaster {
  constructor(platformName, budget) {
    this.platformName = platformName;
    this.budget = budget;
    this.spent = ethers.parseEther('0');
    this.creators = new Map();
    this.transactions = [];
    this.rules = {
      maxGasPerTx: ethers.parseEther('0.01'),
      maxTxPerDay: 10,
      whitelistOnly: true,
    };
  }

  async sponsorWalletCreation(creatorAddress, creatorName) {
    console.log(`\n[注册创作者] ${creatorName} (${creatorAddress.slice(0, 10)}...)`);
    if (this.spent + ethers.parseEther('0.005') > this.budget) {
      throw new Error('赞助预算不足');
    }
    const creator = {
      address: creatorAddress, name: creatorName,
      registeredAt: Date.now(), txCount: 0,
      totalSponsored: ethers.parseEther('0'), isWhitelisted: true,
      dailyTxCount: 0, lastTxDate: null
    };
    this.creators.set(creatorAddress, creator);
    const cost = ethers.parseEther('0.005');
    this.spent += cost;
    creator.totalSponsored += cost;
    this.transactions.push({ type: 'wallet_creation', creator: creatorAddress, cost, timestamp: Date.now() });
    console.log(`  ✅ 钱包创建赞助: 0.005 ETH | 已用: ${ethers.formatEther(this.spent)}/${ethers.formatEther(this.budget)} ETH`);
    return creator;
  }

  async sponsorTransaction(creatorAddress, operation, data) {
    const creator = this.creators.get(creatorAddress);
    if (!creator) throw new Error('创作者未注册');
    if (this.rules.whitelistOnly && !creator.isWhitelisted) throw new Error('不在白名单中');
    const today = new Date().toDateString();
    if (creator.lastTxDate !== today) { creator.dailyTxCount = 0; creator.lastTxDate = today; }
    if (creator.dailyTxCount >= this.rules.maxTxPerDay) {
      throw new Error(`每日限额已到 (${this.rules.maxTxPerDay}笔)`);
    }
    const gasMap = { publish_content: '0.008', mint_nft: '0.01', tip_creator: '0.004', update_profile: '0.002' };
    const gasEstimate = ethers.parseEther(gasMap[operation] || '0.003');
    if (this.spent + gasEstimate > this.budget) throw new Error('预算不足');
    if (gasEstimate > this.rules.maxGasPerTx) throw new Error('超过单笔限额');
    this.spent += gasEstimate;
    creator.totalSponsored += gasEstimate;
    creator.txCount++;
    creator.dailyTxCount++;
    this.transactions.push({ type: operation, creator: creatorAddress, cost: gasEstimate, timestamp: Date.now(), data });
    console.log(`  ✅ ${operation} 赞助: ${ethers.formatEther(gasEstimate)} ETH | 创作者: ${creator.name} | 当日: ${creator.dailyTxCount}/${this.rules.maxTxPerDay}`);
    return { txId: `tx-${this.transactions.length}`, sponsoredAmount: gasEstimate, remainingBudget: this.budget - this.spent };
  }

  async simulatePublishing() {
    console.log('\n' + '='.repeat(60));
    console.log('🎬 内容平台Gas赞助模拟');
    console.log(`   平台: ${this.platformName}`);
    console.log('='.repeat(60));
    const addr = '0x3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c8d9e0f1a2b';
    await this.sponsorWalletCreation(addr, '独立纪录片导演');
    await this.sponsorTransaction(addr, 'publish_content', { title: '链上记忆', duration: '45:00' });
    await this.sponsorTransaction(addr, 'mint_nft', { nftName: '链上记忆海报', edition: '1/100' });
    await this.sponsorTransaction(addr, 'tip_creator', { from: '0x观众', amount: '0.05 ETH', message: '很棒！' });
    console.log('\n' + '='.repeat(60));
    console.log('📊 赞助报告');
    console.log('='.repeat(60));
    console.log(`  总预算: ${ethers.formatEther(this.budget)} ETH | 已用: ${ethers.formatEther(this.spent)} ETH`);
    console.log(`  交易数: ${this.transactions.length}`);
    const c = this.creators.get(addr);
    if (c) console.log(`  创作者: ${c.name} | 交易: ${c.txCount} | 总赞助: ${ethers.formatEther(c.totalSponsored)} ETH`);
  }
}

async function main() {
  const platform = new ContentPlatformPaymaster('森涛链上制片厂', ethers.parseEther('10'));
  await platform.simulatePublishing();
}
main().catch(console.error);