005_多因素认证在Web3的应用：从传统2FA到去中心化身份的安全演进

Web3多因素认证架构图：

┌──────────────────────────────────────────────────────────────────┐
│                        用户认证请求                               │
└───────────────┬──────────────────────────────────────────────────┘
                │
┌───────────────▼──────────────────────────────────────────────────┐
│                        知识因素验证                               │
│                  (密码/PIN/助记词片段)                             │
└───────────────┬──────────────────────────────────────────────────┘
                │
┌───────────────▼──────────────────────────────────────────────────┐
│                      持有因素验证                                │
│            (硬件钱包/安全令牌/认证应用)                             │
└───────────────┬──────────────────────────────────────────────────┘
                │
┌───────────────▼──────────────────────────────────────────────────┐
│                      生物因素验证                                │
│            (指纹/面部/虹膜/声纹识别)                               │
└───────────────┬──────────────────────────────────────────────────┘
                │
┌───────────────▼──────────────────────────────────────────────────┐
│                       认证成功/失败                                │
└──────────────────────────────────────────────────────────────────┘

// 简化的多因素认证智能合约示例
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

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

contract Web3MFA is AccessControl {
    bytes32 public constant AUTHENTICATOR_ROLE = keccak256("AUTHENTICATOR_ROLE");
    bytes32 public constant OWNER_ROLE = keccak256("OWNER_ROLE");
    
    mapping(address => uint256) public nonces;
    mapping(address => bool) public isVerified;
    
    // 事件定义
    event UserVerified(address indexed user);
    event TransactionApproved(address indexed user, bytes32 indexed txHash);
    
    constructor() {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(OWNER_ROLE, msg.sender);
    }
    
    // 验证用户的多重签名
    function verifyUser(
        address user,
        bytes memory sig1,
        bytes memory sig2,
        uint256 nonce
    ) external onlyRole(AUTHENTICATOR_ROLE) {
        require(nonce == nonces[user] + 1, "Invalid nonce");
        
        bytes32 messageHash = keccak256(abi.encodePacked(user, nonce));
        bytes32 ethSignedMessageHash = ECDSA.toEthSignedMessageHash(messageHash);
        
        // 验证两个不同的签名
        address signer1 = ECDSA.recover(ethSignedMessageHash, sig1);
        address signer2 = ECDSA.recover(ethSignedMessageHash, sig2);
        
        require(signer1 != signer2, "Signers must be different");
        require(signer1 == user || hasRole(AUTHENTICATOR_ROLE, signer1), "Invalid signer1");
        require(signer2 == user || hasRole(AUTHENTICATOR_ROLE, signer2), "Invalid signer2");
        
        nonces[user] = nonce;
        isVerified[user] = true;
        
        emit UserVerified(user);
    }
    
    // 批准交易（需要已经验证）
    function approveTransaction(bytes32 txHash) external {
        require(isVerified[msg.sender], "User not verified");
        
        // 重置验证状态，需要重新验证
        isVerified[msg.sender] = false;
        
        emit TransactionApproved(msg.sender, txHash);
    }
    
    // 撤销用户验证状态
    function revokeVerification(address user) external onlyRole(OWNER_ROLE) {
        isVerified[user] = false;
    }
}

// Web3多因素认证客户端实现示例
const ethers = require('ethers');
const jsSHA = require('jssha');
const QRCode = require('qrcode');

class Web3MFA {
    constructor(wallet, authenticatorAddress) {
        this.wallet = wallet;
        this.authenticatorAddress = authenticatorAddress;
        this.totpSecret = null;
    }
    
    // 生成TOTP密钥并创建QR码
    async generateTOTPSecret() {
        // 生成随机密钥（64字节）
        const randomBytes = ethers.utils.randomBytes(64);
        this.totpSecret = ethers.utils.hexDataSlice(randomBytes, 0, 64);
        
        // 创建OTP URL格式
        const issuer = 'Web3SecureWallet';
        const account = this.wallet.address;
        const otpUrl = `otpauth://totp/${encodeURIComponent(issuer)}:${encodeURIComponent(account)}?secret=${this.totpSecret}&issuer=${encodeURIComponent(issuer)}`;
        
        // 生成QR码（实际应用中可以返回给前端显示）
        const qrCode = await QRCode.toDataURL(otpUrl);
        
        return {
            secret: this.totpSecret,
            otpUrl: otpUrl,
            qrCode: qrCode
        };
    }
    
    // 生成当前的TOTP码
    generateTOTP() {
        if (!this.totpSecret) {
            throw new Error('TOTP secret not initialized');
        }
        
        // 计算时间戳（30秒间隔）
        const timeCounter = Math.floor(Date.now() / 30000);
        const timeHex = timeCounter.toString(16).padStart(16, '0');
        const timeBytes = Buffer.from(timeHex, 'hex');
        
        // 使用HMAC-SHA1计算
        const shaObj = new jsSHA('SHA-1', 'ARRAYBUFFER');
        shaObj.setHMACKey(Buffer.from(this.totpSecret, 'hex'), 'ARRAYBUFFER');
        shaObj.update(timeBytes.buffer);
        const hmacResult = shaObj.getHMAC('ARRAYBUFFER');
        
        // 提取动态偏移量
        const hmacBytes = new Uint8Array(hmacResult);
        const offset = hmacBytes[19] & 0x0f;
        
        // 提取4字节并计算TOTP
        const code = ((hmacBytes[offset] & 0x7f) << 24) |
                    ((hmacBytes[offset + 1] & 0xff) << 16) |
                    ((hmacBytes[offset + 2] & 0xff) << 8) |
                    (hmacBytes[offset + 3] & 0xff);
        
        // 生成6位数字码
        const totpCode = (code % 1000000).toString().padStart(6, '0');
        return totpCode;
    }
    
    // 验证TOTP码
    verifyTOTP(inputCode) {
        const currentCode = this.generateTOTP();
        return inputCode === currentCode;
    }
    
    // 准备多重签名的交易数据
    async prepareMultisigTransaction(txData) {
        // 获取当前nonce（实际应该从合约读取）
        const nonce = Date.now();
        
        // 生成消息哈希
        const message = ethers.utils.solidityKeccak256(
            ['address', 'uint256', 'bytes'],
            [this.wallet.address, nonce, txData]
        );
        
        // 从用户钱包签名
        const signature = await this.wallet.signMessage(ethers.utils.arrayify(message));
        
        return {
            nonce: nonce,
            message: message,
            signature: signature,
            totpCode: this.generateTOTP()
        };
    }
}

// 使用示例
async function example() {
    const provider = new ethers.providers.JsonRpcProvider('https://mainnet.infura.io/v3/YOUR_INFURA_KEY');
    const wallet = new ethers.Wallet('YOUR_PRIVATE_KEY', provider);
    
    const mfa = new Web3MFA(wallet, '0xAuthenticatorContractAddress');
    
    // 设置MFA
    const mfaSetup = await mfa.generateTOTPSecret();
    console.log('扫描此QR码设置认证器:', mfaSetup.qrCode);
    
    // 验证并准备交易
    const userInputCode = '123456'; // 用户输入的TOTP码
    if (mfa.verifyTOTP(userInputCode)) {
        const txData = ethers.utils.defaultAbiCoder.encode(['address', 'uint256'], ['0xRecipientAddress', ethers.utils.parseEther('1.0')]);
        const multisigData = await mfa.prepareMultisigTransaction(txData);
        console.log('多重签名交易数据:', multisigData);
    }
}

硬件安全密钥签名流程：

1. 用户发起交易请求
2. 钱包/应用发送交易数据到硬件密钥
3. 硬件密钥显示交易详情供用户确认
4. 用户物理确认（触控/按钮）
5. 硬件密钥在安全环境中生成签名
6. 签名数据返回给应用并广播到区块链

// MetaMask + YubiKey WebAuthn集成示例
const web3 = require('web3');
const crypto = require('crypto');

class Web3YubiKeyIntegration {
    constructor(provider) {
        this.provider = provider;
        this.web3 = new web3(provider);
    }
    
    // 生成挑战（用于WebAuthn注册）
    generateChallenge() {
        return crypto.randomBytes(32).toString('base64url');
    }
    
    // 注册YubiKey作为Web3身份验证器
    async registerYubiKey(userName, displayName) {
        try {
            const challenge = this.generateChallenge();
            
            // 创建WebAuthn注册选项
            const publicKey = {
                challenge: Uint8Array.from(Buffer.from(challenge, 'base64url')),
                rp: {
                    name: 'Web3SecureWallet',
                    id: window.location.hostname
                },
                user: {
                    id: Uint8Array.from(Buffer.from(userName, 'utf8')),
                    name: userName,
                    displayName: displayName
                },
                pubKeyCredParams: [{
                    type: 'public-key',
                    alg: -7 // ES256
                }],
                timeout: 60000,
                attestation: 'direct'
            };
            
            // 调用WebAuthn API注册凭证
            const credential = await navigator.credentials.create({ publicKey });
            
            // 存储凭证信息（通常会发送到服务器）
            const registrationData = {
                id: credential.id,
                rawId: Array.from(new Uint8Array(credential.rawId)),
                response: {
                    clientDataJSON: Array.from(new Uint8Array(credential.response.clientDataJSON)),
                    attestationObject: Array.from(new Uint8Array(credential.response.attestationObject))
                },
                type: credential.type
            };
            
            console.log('YubiKey注册成功:', registrationData);
            return registrationData;
        } catch (error) {
            console.error('YubiKey注册失败:', error);
            throw error;
        }
    }
    
    // 使用YubiKey验证Web3交易
    async verifyWithYubiKey(storedCredentialId, transactionData) {
        try {
            // 获取已存储的凭证
            const allowCredentials = [{
                id: Uint8Array.from(Buffer.from(storedCredentialId, 'base64url')),
                type: 'public-key',
                transports: ['usb', 'nfc', 'ble']
            }];
            
            // 生成交易挑战
            const challenge = this.generateChallenge();
            
            // 创建WebAuthn验证选项
            const publicKey = {
                challenge: Uint8Array.from(Buffer.from(challenge, 'base64url')),
                allowCredentials,
                timeout: 60000,
                rpId: window.location.hostname
            };
            
            // 调用WebAuthn API验证
            const assertion = await navigator.credentials.get({ publicKey });
            
            // 准备交易验证数据
            const verificationData = {
                id: assertion.id,
                rawId: Array.from(new Uint8Array(assertion.rawId)),
                response: {
                    authenticatorData: Array.from(new Uint8Array(assertion.response.authenticatorData)),
                    clientDataJSON: Array.from(new Uint8Array(assertion.response.clientDataJSON)),
                    signature: Array.from(new Uint8Array(assertion.response.signature)),
                    userHandle: assertion.response.userHandle ? 
                        Array.from(new Uint8Array(assertion.response.userHandle)) : null
                },
                type: assertion.type,
                transactionData: transactionData
            };
            
            // 这里可以添加与MetaMask交互的代码，使用验证结果签名交易
            // const signedTx = await this.signTransactionWithVerifiedIdentity(verificationData);
            
            console.log('YubiKey验证成功，准备交易签名');
            return verificationData;
        } catch (error) {
            console.error('YubiKey验证失败:', error);
            throw error;
        }
    }
    
    // 将YubiKey验证与以太坊交易签名结合
    async signTransactionWithYubiKey(transaction, yubiKeyCredentialId) {
        // 步骤1: 使用YubiKey验证用户身份
        const verificationData = await this.verifyWithYubiKey(yubiKeyCredentialId, transaction);
        
        // 步骤2: 验证成功后，使用MetaMask签名交易
        // 注意：在实际应用中，可能需要自定义签名逻辑或与硬件钱包直接集成
        const signedTransaction = await this.provider.request({
            method: 'eth_signTransaction',
            params: [transaction]
        });
        
        return signedTransaction;
    }
}

// 使用示例
async function example() {
    // 检查浏览器WebAuthn支持
    if (!window.PublicKeyCredential) {
        console.error('浏览器不支持WebAuthn');
        return;
    }
    
    // 初始化Web3和集成
    const provider = window.ethereum;
    const yubiKeyIntegration = new Web3YubiKeyIntegration(provider);
    
    // 用户注册YubiKey
    const userName = 'user@example.com';
    const displayName = 'Web3 User';
    const registrationData = await yubiKeyIntegration.registerYubiKey(userName, displayName);
    
    // 存储凭证ID（实际应用中应安全存储）
    const credentialId = registrationData.id;
    
    // 准备交易
    const transaction = {
        from: (await provider.request({ method: 'eth_accounts' }))[0],
        to: '0xRecipientAddress',
        value: '0x' + (web3.utils.toWei('0.1', 'ether')).toString(16),
        gas: '0x' + (21000).toString(16)
    };
    
    // 使用YubiKey验证并签名交易
    const signedTransaction = await yubiKeyIntegration.signTransactionWithYubiKey(transaction, credentialId);
    console.log('已签名交易:', signedTransaction);
    
    // 发送交易
    const txHash = await provider.request({
        method: 'eth_sendRawTransaction',
        params: [signedTransaction]
    });
    
    console.log('交易发送成功，哈希:', txHash);
}

多签+硬件密钥架构：

┌─────────────┐    ┌──────────────┐    ┌──────────────┐
│ 发起交易请求  │───▶│ Gnosis Safe合约│◀───│ YubiKey安全层 │
└─────────────┘    └───────┬───────┘    └──────────────┘
                          │
                    ┌─────▼─────┐    ┌──────────────┐
                    │  其他签名者  │◀───│  手机验证器   │
                    └───────────┘    └──────────────┘

生物识别认证流程：

1. 用户注册：采集生物特征并生成模板
2. 加密存储：生物特征模板使用设备安全区域加密存储
3. 验证请求：Web3应用发起身份验证请求
4. 本地验证：设备执行生物特征匹配（不传输原始数据）
5. 安全签名：验证成功后使用设备安全元素生成签名
6. 交易授权：将签名用于Web3交易或身份声明

import React, { useState, useEffect } from 'react';
import { View, Text, TouchableOpacity, Alert, Platform } from 'react-native';
import * as LocalAuthentication from 'expo-local-authentication';
import { ethers } from 'ethers';
import { createWalletClient, custom } from 'viem';
import { mainnet } from 'viem/chains';
import { SafeKeychain } from './SafeKeychain'; // 自定义密钥管理模块

const BioAuthWeb3Wallet = () => {
  const [isAuthenticated, setIsAuthenticated] = useState(false);
  const [walletAddress, setWalletAddress] = useState('');
  const [isHardwareSupported, setIsHardwareSupported] = useState(false);
  const [isEnrolled, setIsEnrolled] = useState(false);
  
  // 初始化检查生物识别硬件支持
  useEffect(() => {
    checkBiometricSupport();
  }, []);
  
  // 检查设备生物识别支持情况
  const checkBiometricSupport = async () => {
    try {
      // 检查设备是否支持生物识别
      const compatible = await LocalAuthentication.hasHardwareAsync();
      setIsHardwareSupported(compatible);
      
      // 检查用户是否已注册生物识别
      const enrolled = await LocalAuthentication.isEnrolledAsync();
      setIsEnrolled(enrolled);
      
      console.log(`设备支持生物识别: ${compatible}, 用户已注册生物识别: ${enrolled}`);
    } catch (error) {
      console.error('检查生物识别支持时出错:', error);
    }
  };
  
  // 使用生物识别解锁钱包
  const unlockWalletWithBiometrics = async () => {
    try {
      // 配置验证选项
      const options = {
        promptMessage: '请验证您的身份以访问Web3钱包',
        fallbackLabel: '使用密码',
        disableDeviceFallback: false,
      };
      
      // 执行生物识别验证
      const result = await LocalAuthentication.authenticateAsync(options);
      
      if (result.success) {
        // 验证成功，从安全存储中恢复钱包
        const wallet = await recoverWalletFromSecureStorage();
        
        if (wallet) {
          setWalletAddress(wallet.address);
          setIsAuthenticated(true);
          Alert.alert('成功', '钱包已解锁，可进行交易操作');
        } else {
          Alert.alert('错误', '无法从安全存储中恢复钱包');
        }
      } else {
        console.log('生物识别验证失败');
      }
    } catch (error) {
      console.error('生物识别验证出错:', error);
      Alert.alert('错误', '生物识别验证过程中发生错误');
    }
  };
  
  // 从安全存储恢复钱包（示例实现）
  const recoverWalletFromSecureStorage = async () => {
    try {
      // 实际实现应该使用设备安全API或安全库
      const keychain = new SafeKeychain();
      const encryptedWallet = await keychain.getEncryptedWallet();
      
      if (encryptedWallet) {
        // 这里应该使用安全机制解密钱包
        // 注意：实际应用中，解密密钥应该受到生物识别保护
        const walletData = await keychain.decryptWallet(encryptedWallet);
        
        // 使用viem创建钱包客户端
        const walletClient = createWalletClient({
          account: walletData.address,
          chain: mainnet,
          transport: custom(walletData.provider)
        });
        
        return {
          address: walletData.address,
          client: walletClient
        };
      }
      
      return null;
    } catch (error) {
      console.error('恢复钱包出错:', error);
      return null;
    }
  };
  
  // 使用生物识别签署交易
  const signTransactionWithBiometrics = async () => {
    if (!isAuthenticated) {
      Alert.alert('请先解锁钱包');
      return;
    }
    
    try {
      // 配置验证选项 - 交易签署需要更严格的验证
      const options = {
        promptMessage: '请验证身份以签署交易',
        cancelLabel: '取消交易',
        disableDeviceFallback: true, // 强制使用生物识别，不允许回退到密码
      };
      
      // 执行生物识别验证
      const result = await LocalAuthentication.authenticateAsync(options);
      
      if (result.success) {
        // 验证成功，准备并签署交易
        const tx = await prepareAndSignTransaction();
        
        if (tx) {
          Alert.alert('成功', `交易已签署：${tx.hash.substring(0, 10)}...`);
        }
      } else {
        console.log('交易签署验证失败');
        Alert.alert('交易已取消', '未完成身份验证，交易未签署');
      }
    } catch (error) {
      console.error('交易签署出错:', error);
      Alert.alert('错误', '交易签署过程中发生错误');
    }
  };
  
  // 准备并签署交易（示例实现）
  const prepareAndSignTransaction = async () => {
    try {
      // 实际应用中应该从安全存储恢复签名功能
      const wallet = await recoverWalletFromSecureStorage();
      
      if (!wallet || !wallet.client) {
        throw new Error('无法访问钱包客户端');
      }
      
      // 准备交易数据
      const transaction = {
        to: '0xRecipientAddress',
        value: ethers.utils.parseEther('0.01'),
        gasLimit: 21000,
        maxFeePerGas: ethers.utils.parseUnits('20', 'gwei'),
        maxPriorityFeePerGas: ethers.utils.parseUnits('2', 'gwei'),
        type: 2,
      };
      
      // 在实际应用中，这里应该使用设备安全元素进行签名
      // 为简化示例，此处仅模拟签名过程
      console.log('使用生物识别验证后签署交易:', transaction);
      
      // 返回模拟的交易哈希
      return {
        hash: '0x' + 'a'.repeat(64),
        status: 'pending'
      };
    } catch (error) {
      console.error('准备交易出错:', error);
      throw error;
    }
  };
  
  // 创建安全存储的钱包（仅首次使用时）
  const createSecureWallet = async () => {
    try {
      // 首先验证用户身份
      const authResult = await LocalAuthentication.authenticateAsync({
        promptMessage: '请验证身份以创建安全钱包',
        fallbackLabel: '使用密码'
      });
      
      if (authResult.success) {
        // 验证成功，生成新钱包
        const wallet = ethers.Wallet.createRandom();
        const keychain = new SafeKeychain();
        
        // 加密并安全存储钱包
        const encryptedWallet = await keychain.encryptAndStoreWallet({
          address: wallet.address,
          privateKey: wallet.privateKey,
          mnemonic: wallet.mnemonic.phrase
        });
        
        if (encryptedWallet) {
          setWalletAddress(wallet.address);
          setIsAuthenticated(true);
          Alert.alert(
            '钱包创建成功', 
            `地址: ${wallet.address.substring(0, 10)}...\n请妥善保存助记词作为备份`
          );
          
          // 在实际应用中，应该安全地显示助记词给用户备份
          console.log('钱包助记词:', wallet.mnemonic.phrase);
        }
      }
    } catch (error) {
      console.error('创建钱包出错:', error);
      Alert.alert('错误', '创建安全钱包过程中发生错误');
    }
  };
  
  return (
    <View style={{ padding: 20, alignItems: 'center' }}>
      <Text style={{ fontSize: 24, marginBottom: 20 }}>Web3生物识别钱包</Text>
      
      {!isHardwareSupported && (
        <Text style={{ color: 'red', marginBottom: 20 }}>
          您的设备不支持生物识别功能
        </Text>
      )}
      
      {isHardwareSupported && !isEnrolled && (
        <Text style={{ color: 'orange', marginBottom: 20 }}>
          请先在设备设置中注册生物识别信息
        </Text>
      )}
      
      {isAuthenticated ? (
        <>
          <Text style={{ marginBottom: 20 }}>钱包已解锁</Text>
          <Text style={{ marginBottom: 20, fontFamily: 'monospace' }}>
            {walletAddress}
          </Text>
          
          <TouchableOpacity 
            style={{ 
              backgroundColor: '#4CAF50', 
              padding: 15, 
              borderRadius: 5, 
              marginBottom: 10 
            }}
            onPress={signTransactionWithBiometrics}
          >
            <Text style={{ color: 'white' }}>使用生物识别签署交易</Text>
          </TouchableOpacity>
          
          <TouchableOpacity 
            style={{ 
              backgroundColor: '#F44336', 
              padding: 15, 
              borderRadius: 5 
            }}
            onPress={() => setIsAuthenticated(false)}
          >
            <Text style={{ color: 'white' }}>锁定钱包</Text>
          </TouchableOpacity>
        </>
      ) : (
        <>
          <TouchableOpacity 
            style={{ 
              backgroundColor: '#2196F3', 
              padding: 15, 
              borderRadius: 5, 
              marginBottom: 10 
            }}
            onPress={unlockWalletWithBiometrics}
            disabled={!isHardwareSupported || !isEnrolled}
          >
            <Text style={{ color: 'white' }}>使用生物识别解锁钱包</Text>
          </TouchableOpacity>
          
          <TouchableOpacity 
            style={{ 
              backgroundColor: '#FF9800', 
              padding: 15, 
              borderRadius: 5 
            }}
            onPress={createSecureWallet}
            disabled={!isHardwareSupported || !isEnrolled}
          >
            <Text style={{ color: 'white' }}>创建新钱包</Text>
          </TouchableOpacity>
        </>
      )}
    </View>
  );
};

export default BioAuthWeb3Wallet;

生物识别风险与缓解策略：

风险：
1. 生物特征不可更改性 - 一旦泄露无法更换
2. 欺骗攻击（照片、指纹模具等）
3. 设备被破解导致模板泄露
4. 跨应用指纹信息滥用

缓解策略：
1. 多因素组合 - 生物识别仅作为第二因素
2. 活体检测 - 要求用户进行随机动作确认
3. 安全区域隔离 - 使用TEE存储模板
4. 应用隔离 - 每个应用使用独立的生物凭证

DID架构组成：

┌────────────────┐      ┌────────────────┐      ┌────────────────┐
│ DID标识符      │──────▶│ DID文档        │──────▶│ 可验证凭证(VC)  │
└────────────────┘      └────────────────┘      └────────────────┘
        │                      │                      │
        ▼                      ▼                      ▼
┌────────────────┐      ┌────────────────┐      ┌────────────────┐
│ 解析器         │      │ 控制器密钥     │      │ 验证方         │
└────────────────┘      └────────────────┘      └────────────────┘

// 基于Polygon ID的去中心化多因素认证实现
import { DID, DIDDocument, PublicKey, VerificationMethod } from 'did-resolver';
import { PolygonIdSDK } from '@0xpolygonid/js-sdk';
import { ZKProof } from '@0xpolygonid/js-sdk/dist/sdk/proof';
import { CircuitId } from '@0xpolygonid/js-sdk/dist/sdk/circuits';

class DIDMFAIntegration {
    constructor() {
        // 初始化Polygon ID SDK
        this.polygonId = new PolygonIdSDK({
            network: 'polygon-mumbai', // 测试网
            web3Provider: window.ethereum
        });
        
        // 信任阈值配置
        this.trustThresholds = {
            lowRisk: 0.3,     // 小额交易
            mediumRisk: 0.6,  // 中额交易
            highRisk: 0.9     // 大额交易
        };
        
        // 因素权重配置
        this.factorWeights = {
            password: 0.2,
            totp: 0.3,
            biometric: 0.4,
            hardwareKey: 0.5,
            socialRecovery: 0.3
        };
    }
    
    // 创建DID身份
    async createDID() {
        try {
            // 使用SDK创建新的DID身份
            const identity = await this.polygonId.identities.createIdentity();
            
            // 获取DID标识符
            const did = identity.did;
            console.log('创建新DID:', did);
            
            return identity;
        } catch (error) {
            console.error('创建DID失败:', error);
            throw error;
        }
    }
    
    // 注册身份验证因素
    async registerAuthenticationFactor(identity, factorType, factorData) {
        try {
            // 根据因素类型创建可验证凭证
            let credential;
            
            switch (factorType) {
                case 'biometric':
                    // 注册生物识别凭证（注意：不存储原始生物数据，只存储验证结果）
                    credential = await this.createBiometricCredential(identity, factorData);
                    break;
                
                case 'hardwareKey':
                    // 注册硬件密钥凭证
                    credential = await this.createHardwareKeyCredential(identity, factorData);
                    break;
                
                case 'socialRecovery':
                    // 注册社交恢复凭证
                    credential = await this.createSocialRecoveryCredential(identity, factorData);
                    break;
                
                default:
                    throw new Error(`不支持的因素类型: ${factorType}`);
            }
            
            // 存储凭证
            await this.storeCredential(identity, credential);
            
            console.log(`成功注册${factorType}验证因素`);
            return credential;
        } catch (error) {
            console.error(`注册${factorType}验证因素失败:`, error);
            throw error;
        }
    }
    
    // 创建生物识别凭证
    async createBiometricCredential(identity, biometricHash) {
        // 在实际应用中，这里应该验证生物识别信息
        // 注意：我们永远不会在链上或凭证中存储原始生物数据
        
        const credential = {
            '@context': ['https://www.w3.org/2018/credentials/v1'],
            type: ['VerifiableCredential', 'BiometricVerificationCredential'],
            issuer: identity.did,
            issuanceDate: new Date().toISOString(),
            credentialSubject: {
                id: identity.did,
                hasVerifiedBiometric: true,
                // 只存储哈希值，不存储原始生物数据
                biometricHash: biometricHash,
                // 增加过期时间，要求定期重新验证
                expiryDate: new Date(Date.now() + 180 * 24 * 60 * 60 * 1000).toISOString()
            }
        };
        
        // 使用DID私钥签名凭证
        return await this.polygonId.credentials.signCredential(identity, credential);
    }
    
    // 创建硬件密钥凭证
    async createHardwareKeyCredential(identity, hardwareKeyInfo) {
        const credential = {
            '@context': ['https://www.w3.org/2018/credentials/v1'],
            type: ['VerifiableCredential', 'HardwareKeyCredential'],
            issuer: identity.did,
            issuanceDate: new Date().toISOString(),
            credentialSubject: {
                id: identity.did,
                hardwareKeyType: hardwareKeyInfo.type,
                keyIdentifier: hardwareKeyInfo.keyId,
                lastVerified: new Date().toISOString()
            }
        };
        
        return await this.polygonId.credentials.signCredential(identity, credential);
    }
    
    // 创建社交恢复凭证
    async createSocialRecoveryCredential(identity, recoveryGuardians) {
        const credential = {
            '@context': ['https://www.w3.org/2018/credentials/v1'],
            type: ['VerifiableCredential', 'SocialRecoveryCredential'],
            issuer: identity.did,
            issuanceDate: new Date().toISOString(),
            credentialSubject: {
                id: identity.did,
                guardians: recoveryGuardians.map(guardian => ({
                    did: guardian.did,
                    weight: guardian.weight,
                    contactInfo: guardian.contactInfo
                })),
                threshold: recoveryGuardians.reduce((sum, g) => sum + g.weight, 0) / 2
            }
        };
        
        return await this.polygonId.credentials.signCredential(identity, credential);
    }
    
    // 存储凭证
    async storeCredential(identity, credential) {
        // 在实际应用中，凭证应该存储在安全的地方
        // 可以是链上、链下数据库或用户设备本地
        console.log('存储凭证:', credential.id || '未命名凭证');
        
        // 示例：返回存储标识
        return { stored: true, referenceId: Date.now().toString() };
    }
    
    // 验证身份（执行MFA）
    async verifyIdentity(identity, challenge, usedFactors = []) {
        try {
            // 计算信任分数
            let trustScore = 0;
            const verifiedFactors = [];
            
            // 验证每个提供的因素
            for (const factor of usedFactors) {
                const verified = await this.verifyFactor(identity, factor);
                if (verified) {
                    trustScore += this.factorWeights[factor.type] || 0;
                    verifiedFactors.push(factor.type);
                }
            }
            
            console.log(`身份验证信任分数: ${trustScore}, 已验证因素: ${verifiedFactors.join(', ')}`);
            
            // 根据信任分数生成零知识证明
            const proof = await this.generateZKP(identity, challenge, verifiedFactors, trustScore);
            
            return {
                success: trustScore >= this.trustThresholds.mediumRisk, // 默认要求中等风险阈值
                trustScore,
                verifiedFactors,
                proof
            };
        } catch (error) {
            console.error('身份验证失败:', error);
            throw error;
        }
    }
    
    // 验证单个因素
    async verifyFactor(identity, factor) {
        // 这里应该有实际的验证逻辑
        // 为简化示例，我们假设验证总是成功
        console.log(`验证因素: ${factor.type}`);
        
        // 在实际应用中，这里应该有真实的验证逻辑
        // 例如，对于TOTP，验证用户提供的代码
        // 对于生物识别，调用设备API进行验证
        return true;
    }
    
    // 生成零知识证明
    async generateZKP(identity, challenge, verifiedFactors, trustScore) {
        try {
            // 使用Polygon ID SDK生成零知识证明
            // 这允许证明某些属性而不泄露具体细节
            const proof = await this.polygonId.proofs.generateProof({
                identity,
                circuitId: CircuitId.AtomicQuerySigV2,
                inputs: {
                    challenge: challenge,
                    trustScore: Math.floor(trustScore * 100), // 转换为整数
                    factorCount: verifiedFactors.length
                }
            });
            
            return proof;
        } catch (error) {
            console.error('生成零知识证明失败:', error);
            throw error;
        }
    }
    
    // 验证交易（根据风险级别应用不同MFA要求）
    async verifyTransaction(identity, transaction, usedFactors = []) {
        try {
            // 评估交易风险级别
            const riskLevel = this.assessTransactionRisk(transaction);
            const requiredThreshold = this.trustThresholds[riskLevel];
            
            console.log(`交易风险级别: ${riskLevel}, 要求信任阈值: ${requiredThreshold}`);
            
            // 执行MFA验证
            const verificationResult = await this.verifyIdentity(identity, 
                                                              transaction.hash || Date.now().toString(), 
                                                              usedFactors);
            
            // 检查是否达到所需的信任阈值
            const transactionVerified = verificationResult.trustScore >= requiredThreshold;
            
            return {
                ...verificationResult,
                transactionVerified,
                requiredThreshold,
                riskLevel
            };
        } catch (error) {
            console.error('交易验证失败:', error);
            throw error;
        }
    }
    
    // 评估交易风险级别
    assessTransactionRisk(transaction) {
        // 根据交易金额和其他因素评估风险
        const value = transaction.value ? parseFloat(transaction.value) : 0;
        
        if (value > 10) { // 假设10 ETH为高风险阈值
            return 'highRisk';
        } else if (value > 1) { // 假设1 ETH为中等风险阈值
            return 'mediumRisk';
        } else {
            return 'lowRisk';
        }
    }
    
    // 防范SIM卡交换攻击的DID绑定方法
    async bindPhoneNumberSecurely(identity, phoneNumber, hardwareVerified = false) {
        try {
            // 只有通过硬件验证的情况下才绑定电话号码
            if (!hardwareVerified) {
                throw new Error('必须通过硬件密钥验证才能绑定电话号码');
            }
            
            // 创建带有保护机制的电话号码凭证
            const credential = {
                '@context': ['https://www.w3.org/2018/credentials/v1'],
                type: ['VerifiableCredential', 'ProtectedPhoneCredential'],
                issuer: identity.did,
                issuanceDate: new Date().toISOString(),
                credentialSubject: {
                    id: identity.did,
                    phoneNumber: phoneNumber,
                    hardwareVerified: true,
                    recoveryMechanism: 'hardware_key_required',
                    // 添加有效期和定期重新验证要求
                    expiryDate: new Date(Date.now() + 90 * 24 * 60 * 60 * 1000).toISOString()
                }
            };
            
            // 使用DID私钥签名凭证
            const signedCredential = await this.polygonId.credentials.signCredential(identity, credential);
            
            // 存储凭证
            await this.storeCredential(identity, signedCredential);
            
            console.log('安全绑定电话号码成功，已添加防SIM交换保护');
            return signedCredential;
        } catch (error) {
            console.error('安全绑定电话号码失败:', error);
            throw error;
        }
    }
}

// 使用示例
async function example() {
    // 创建DID-MFA集成实例
    const didMFA = new DIDMFAIntegration();
    
    // 创建DID身份
    const identity = await didMFA.createDID();
    
    // 注册多种验证因素
    await didMFA.registerAuthenticationFactor(identity, 'biometric', 'biometric-hash-example');
    await didMFA.registerAuthenticationFactor(identity, 'hardwareKey', { type: 'YubiKey', keyId: 'yk-example-123' });
    
    // 安全绑定电话号码（防范SIM卡交换）
    await didMFA.bindPhoneNumberSecurely(identity, '+1234567890', true); // 假设已经通过硬件验证
    
    // 准备交易
    const transaction = {
        to: '0xRecipientAddress',
        value: '5', // 5 ETH，中等风险
        hash: '0x' + 'b'.repeat(64)
    };
    
    // 执行交易验证
    const verificationResult = await didMFA.verifyTransaction(identity, transaction, [
        { type: 'biometric', data: 'verification-data' },
        { type: 'hardwareKey', data: 'key-verification-data' }
    ]);
    
    console.log('交易验证结果:', {
        verified: verificationResult.transactionVerified,
        trustScore: verificationResult.trustScore,
        riskLevel: verificationResult.riskLevel,
        verifiedFactors: verificationResult.verifiedFactors
    });
}

智能合约恢复流程：

1. 用户发起恢复请求（或守护者发起）
2. 启动时间锁定期（48-72小时）
3. 通知所有相关方（用户、守护者）
4. 守护者投票同意（达到阈值）
5. 完成身份恢复，更新DID文档
6. 触发安全警报和审计日志

OpenSea安全架构：

用户身份 ──────────▶ 主MFA层 (硬件密钥/生物识别)
   │                      │
   │                      ▼
   │              辅助认证层 (TOTP/邮件验证)
   │                      │
   │                      ▼
   └───────────▶ 社交恢复网络 (Guardian节点)
                          │
                          ▼
                    资产保护层 (冷存储/时间锁)

// Web3钱包MFA与私钥保护协同实现
class Web3SecureWalletManager {
    constructor(walletProvider, mfaProvider) {
        this.walletProvider = walletProvider;
        this.mfaProvider = mfaProvider;
        this.riskAssessmentEngine = new RiskAssessmentEngine();
        
        // 资产阈值配置
        this.thresholds = {
            lowRisk: ethers.utils.parseEther("0.1"),    // 0.1 ETH
            mediumRisk: ethers.utils.parseEther("1"),  // 1 ETH
            highRisk: ethers.utils.parseEther("10")    // 10 ETH
        };
        
        // 操作类型风险级别
        this.operationRisks = {
            VIEW: "lowRisk",
            SWAP: "mediumRisk",
            SEND: "mediumRisk",
            STAKE: "mediumRisk",
            SIGN_CONTRACT: "highRisk",
            CHANGE_RECOVERY: "highRisk",
            EXPORT_KEYS: "highRisk"
        };
    }
    
    // 执行安全交易
    async executeSecureTransaction(operation, transaction) {
        try {
            // 步骤1: 评估交易风险
            const riskLevel = await this.assessTransactionRisk(operation, transaction);
            console.log(`交易风险级别: ${riskLevel}`);
            
            // 步骤2: 根据风险级别要求MFA验证
            const mfaResult = await this.requireMFAForRiskLevel(riskLevel);
            if (!mfaResult.success) {
                throw new Error("多因素认证失败，交易已取消");
            }
            
            // 步骤3: 对于高风险交易，应用额外保护
            if (riskLevel === "highRisk") {
                await this.applyEnhancedProtection(transaction);
            }
            
            // 步骤4: 执行交易
            const txResult = await this.walletProvider.executeTransaction(transaction);
            
            // 步骤5: 记录安全事件
            await this.logSecurityEvent(operation, transaction, riskLevel, mfaResult);
            
            return txResult;
        } catch (error) {
            console.error("安全交易执行失败:", error);
            throw error;
        }
    }
    
    // 评估交易风险
    async assessTransactionRisk(operation, transaction) {
        // 获取基础风险级别
        let baseRiskLevel = this.operationRisks[operation] || "mediumRisk";
        
        // 如果是发送或交换操作，根据金额调整风险级别
        if (operation === "SEND" || operation === "SWAP") {
            const value = transaction.value ? ethers.BigNumber.from(transaction.value) : ethers.BigNumber.from(0);
            
            if (value.gt(this.thresholds.highRisk)) {
                baseRiskLevel = "highRisk";
            } else if (value.gt(this.thresholds.mediumRisk)) {
                baseRiskLevel = "mediumRisk";
            } else {
                baseRiskLevel = "lowRisk";
            }
        }
        
        // 使用风险评估引擎进行更复杂的评估
        return await this.riskAssessmentEngine.evaluate(
            operation,
            transaction,
            baseRiskLevel,
            this.walletProvider.getCurrentUser()
        );
    }
    
    // 根据风险级别要求MFA
    async requireMFAForRiskLevel(riskLevel) {
        switch (riskLevel) {
            case "lowRisk":
                // 低风险操作可能只需要单因素或轻量级验证
                return await this.mfaProvider.verifyWithSingleFactor();
                
            case "mediumRisk":
                // 中等风险需要双因素验证
                return await this.mfaProvider.verifyWithTwoFactors();
                
            case "highRisk":
                // 高风险需要三因素或更多验证
                return await this.mfaProvider.verifyWithThreeFactors();
                
            default:
                // 默认使用中等风险要求
                return await this.mfaProvider.verifyWithTwoFactors();
        }
    }
    
    // 应用增强保护措施
    async applyEnhancedProtection(transaction) {
        // 1. 检查目标地址的安全性
        const addressSafety = await this.checkAddressSafety(transaction.to);
        if (addressSafety.risk > 0.7) {
            throw new Error(`目标地址存在高风险: ${addressSafety.reason}`);
        }
        
        // 2. 对于超过特定阈值的交易，实施确认对话框
        await this.showEnhancedConfirmation(transaction);
        
        // 3. 对于极高风险交易，考虑应用时间锁
        if (this.shouldApplyTimelock(transaction)) {
            return await this.applyTimelock(transaction);
        }
        
        return transaction;
    }
    
    // 检查地址安全性
    async checkAddressSafety(address) {
        // 在实际应用中，这里应该调用安全服务检查地址
        // 例如，检查是否为已知的恶意地址，是否有异常交易历史等
        
        // 模拟安全检查
        return {
            risk: 0.1, // 风险分数 (0-1)
            reason: "地址看起来安全",
            confidence: 0.95
        };
    }
    
    // 显示增强确认
    async showEnhancedConfirmation(transaction) {
        // 在实际应用中，这里应该显示详细的确认对话框
        // 包括交易详情、风险警告等
        
        console.log("显示增强确认对话框", transaction);
        // 模拟用户确认
        return true;
    }
    
    // 判断是否应该应用时间锁
    shouldApplyTimelock(transaction) {
        const value = transaction.value ? ethers.BigNumber.from(transaction.value) : ethers.BigNumber.from(0);
        return value.gt(ethers.utils.parseEther("50")); // 50 ETH以上的交易应用时间锁
    }
    
    // 应用时间锁
    async applyTimelock(transaction) {
        // 在实际应用中，这里应该创建一个时间锁定交易
        // 并通知用户交易将在指定时间后执行
        
        console.log("应用24小时时间锁到交易");
        return {
            ...transaction,
            timelockApplied: true,
            executionTime: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString()
        };
    }
    
    // 记录安全事件
    async logSecurityEvent(operation, transaction, riskLevel, mfaResult) {
        // 在实际应用中，这里应该将安全事件记录到安全日志系统
        console.log("记录安全事件:", {
            timestamp: new Date().toISOString(),
            operation,
            transactionHash: transaction.hash,
            riskLevel,
            mfaFactorsUsed: mfaResult.factorsUsed,
            userId: this.walletProvider.getCurrentUser().id
        });
    }
    
    // 紧急锁定钱包
    async emergencyLockWallet(reason) {
        // 立即锁定钱包，禁止所有交易
        await this.walletProvider.lockAllOperations();
        
        // 发送安全警报
        await this.sendSecurityAlert({
            type: "EMERGENCY_LOCK",
            reason,
            timestamp: new Date().toISOString()
        });
        
        return { success: true, message: "钱包已紧急锁定" };
    }
    
    // 发送安全警报
    async sendSecurityAlert(alert) {
        // 在实际应用中，这里应该通过多种渠道发送安全警报
        // 例如，邮件、短信、应用通知等
        console.log("发送安全警报:", alert);
    }
    
    // 恢复锁定的钱包
    async recoverLockedWallet(recoveryMethod) {
        // 要求最高级别的MFA验证
        const mfaResult = await this.mfaProvider.verifyWithThreeFactors();
        if (!mfaResult.success) {
            throw new Error("恢复验证失败，钱包保持锁定状态");
        }
        
        // 根据恢复方法执行恢复
        switch (recoveryMethod) {
            case "ownerVerification":
                return await this.walletProvider.unlockWithOwnerVerification();
                
            case "guardianApproval":
                return await this.walletProvider.unlockWithGuardianApproval();
                
            default:
                throw new Error("不支持的恢复方法");
        }
    }
}

// 使用示例
async function secureWalletExample() {
    // 创建钱包管理器实例
    const walletManager = new Web3SecureWalletManager(
        new EthereumWalletProvider(),
        new MultiFactorAuthProvider()
    );
    
    // 执行中等风险交易
    const mediumRiskTx = {
        to: "0xRecipientAddress",
        value: ethers.utils.parseEther("2"), // 2 ETH
        gasLimit: 21000
    };
    
    try {
        const result = await walletManager.executeSecureTransaction("SEND", mediumRiskTx);
        console.log("交易执行成功:", result);
    } catch (error) {
        console.error("交易执行失败:", error);
    }
    
    // 执行高风险交易
    const highRiskTx = {
        to: "0xContractAddress",
        data: "0xFunctionCallData", // 合约调用数据
        value: ethers.utils.parseEther("0")
    };
    
    try {
        const result = await walletManager.executeSecureTransaction("SIGN_CONTRACT", highRiskTx);
        console.log("合约调用成功:", result);
    } catch (error) {
        console.error("合约调用失败:", error);
    }
}

// 使用EIP-712防范重放攻击的签名实现
class SecureEIP712Signer {
    constructor(web3Provider, appName = "Web3SecureApp", version = "1") {
        this.web3Provider = web3Provider;
        this.appName = appName;
        this.version = version;
        
        // 初始化域名数据，用于EIP-712签名
        this.domain = {
            name: this.appName,
            version: this.version,
            chainId: null, // 将在初始化时设置
            verifyingContract: null // 可选，合约地址
        };
        
        // 已签名消息缓存，防止相同消息被重复使用
        this.signedMessageCache = new Set();
    }
    
    // 初始化，设置链ID
    async initialize() {
        // 获取当前链ID
        const chainId = await this.web3Provider.eth.getChainId();
        this.domain.chainId = chainId;
        
        console.log(`EIP-712签名器初始化完成，链ID: ${chainId}`);
        return this;
    }
    
    // 设置验证合约地址
    setVerifyingContract(contractAddress) {
        this.domain.verifyingContract = contractAddress;
        return this;
    }
    
    // 创建类型定义
    createTypeDefinition(primaryType, types) {
        return {
            primaryType,
            types: {
                ...types,
                EIP712Domain: [
                    { name: "name", type: "string" },
                    { name: "version", type: "string" },
                    { name: "chainId", type: "uint256" },
                    { name: "verifyingContract", type: "address" }
                ]
            }
        };
    }
    
    // 为交易创建EIP-712签名
    async signTransaction(userAddress, transaction) {
        // 生成唯一消息ID，防止重放
        const messageId = this.generateUniqueMessageId();
        
        // 创建交易类型定义
        const transactionTypes = this.createTypeDefinition("TransactionRequest", {
            TransactionRequest: [
                { name: "to", type: "address" },
                { name: "value", type: "uint256" },
                { name: "gasLimit", type: "uint256" },
                { name: "nonce", type: "uint256" },
                { name: "chainId", type: "uint256" },
                { name: "messageId", type: "string" },
                { name: "timestamp", type: "uint256" },
                { name: "expirationTime", type: "uint256" }
            ]
        });
        
        // 获取当前nonce
        const nonce = await this.web3Provider.eth.getTransactionCount(userAddress, "pending");
        
        // 设置过期时间（例如，签名1小时内有效）
        const now = Math.floor(Date.now() / 1000);
        const expirationTime = now + 3600; // 1小时后过期
        
        // 创建消息内容
        const message = {
            to: transaction.to,
            value: transaction.value || "0",
            gasLimit: transaction.gasLimit || "21000",
            nonce: nonce,
            chainId: this.domain.chainId,
            messageId: messageId,
            timestamp: now,
            expirationTime: expirationTime
        };
        
        // 构建EIP-712结构化数据
        const data = {
            types: transactionTypes.types,
            domain: this.domain,
            primaryType: transactionTypes.primaryType,
            message: message
        };
        
        // 转换为JSON字符串
        const dataString = JSON.stringify(data);
        
        // 检查消息是否已被签名过
        if (this.signedMessageCache.has(dataString)) {
            throw new Error("该消息已被签名，防止重放攻击");
        }
        
        try {
            // 请求用户签名
            // 在MetaMask等钱包中，会显示结构化的交易信息供用户审核
            const signature = await this.web3Provider.request({
                method: "eth_signTypedData_v4",
                params: [userAddress, dataString]
            });
            
            // 将签名消息添加到缓存
            this.signedMessageCache.add(dataString);
            
            // 可选：限制缓存大小
            if (this.signedMessageCache.size > 100) {
                this.cleanupCache();
            }
            
            return {
                signature,
                message,
                data
            };
        } catch (error) {
            console.error("EIP-712签名失败:", error);
            throw error;
        }
    }
    
    // 验证EIP-712签名
    async verifySignature(signature, message, typeDefinition) {
        try {
            // 构建完整的EIP-712数据
            const data = {
                types: typeDefinition.types,
                domain: this.domain,
                primaryType: typeDefinition.primaryType,
                message: message
            };
            
            // 使用web3验证签名
            // 注意：不同的web3库可能有不同的验证方法
            // 这里使用通用的签名验证逻辑
            
            // 1. 计算消息的哈希值
            const messageHash = await this.web3Provider.utils.keccak256(
                this.encodeStructuredData(typeDefinition, this.domain, message)
            );
            
            // 2. 从签名中恢复公钥
            const recoveredAddress = await this.web3Provider.eth.accounts.recover(messageHash, signature);
            
            // 3. 验证签名未过期
            const now = Math.floor(Date.now() / 1000);
            if (message.expirationTime && now > message.expirationTime) {
                throw new Error("签名已过期");
            }
            
            // 4. 验证链ID是否匹配
            if (message.chainId && message.chainId !== this.domain.chainId) {
                throw new Error("链ID不匹配，可能是跨链重放攻击");
            }
            
            return {
                isValid: true,
                recoveredAddress,
                messageHash
            };
        } catch (error) {
            console.error("EIP-712签名验证失败:", error);
            return {
                isValid: false,
                error: error.message
            };
        }
    }
    
    // 生成唯一消息ID
    generateUniqueMessageId() {
        // 生成基于时间和随机数的唯一ID
        return `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
    }
    
    // 清理缓存
    cleanupCache() {
        // 简单实现：清除最早的一半缓存项
        const cacheArray = Array.from(this.signedMessageCache);
        const itemsToRemove = cacheArray.slice(0, Math.floor(cacheArray.length / 2));
        
        for (const item of itemsToRemove) {
            this.signedMessageCache.delete(item);
        }
    }
    
    // 编码结构化数据（简化版，实际实现需要遵循EIP-712规范）
    encodeStructuredData(typeDefinition, domain, message) {
        // 这是一个简化的实现
        // 在实际应用中，应该使用完整的EIP-712编码算法
        return JSON.stringify({
            domain,
            message
        });
    }
}

// 使用示例
async function eip712Example() {
    // 创建签名器实例
    const signer = new SecureEIP712Signer(window.ethereum, "MySecureWeb3App", "1.0");
    
    // 初始化
    await signer.initialize();
    
    // 设置验证合约地址（可选）
    signer.setVerifyingContract("0xContractAddress");
    
    // 获取用户地址
    const accounts = await window.ethereum.request({ method: "eth_requestAccounts" });
    const userAddress = accounts[0];
    
    // 准备交易
    const transaction = {
        to: "0xRecipientAddress",
        value: window.web3.utils.toWei("1", "ether"),
        gasLimit: "21000"
    };
    
    try {
        // 签名交易
        const signedData = await signer.signTransaction(userAddress, transaction);
        console.log("交易签名成功:", signedData.signature);
        
        // 可以将签名数据发送到后端进行验证和处理
        // ...
    } catch (error) {
        console.error("签名过程中出错:", error);
    }
}

Web3安全身份体系框架：

┌─────────────────────────────────────────────────────┐
│                  应用层安全                          │
│  ┌────────────┐  ┌────────────┐  ┌─────────────┐    │
│  │ 智能合约安全│  │  API安全   │  │ 前端防护    │    │
│  └────────────┘  └────────────┘  └─────────────┘    │
├─────────────────────────────────────────────────────┤
│                  身份验证层                          │
│  ┌────────────┐  ┌────────────┐  ┌─────────────┐    │
│  │ 多因素认证  │  │ 生物识别    │  │ 硬件密钥    │    │
│  └────────────┘  └────────────┘  └─────────────┘    │
├─────────────────────────────────────────────────────┤
│                  身份管理层                          │
│  ┌────────────┐  ┌────────────┐  ┌─────────────┐    │
│  │ DID身份     │  │ 可验证凭证  │  │ 社交恢复    │    │
│  └────────────┘  └────────────┘  └─────────────┘    │
├─────────────────────────────────────────────────────┤
│                  基础安全层                          │
│  ┌────────────┐  ┌────────────┐  ┌─────────────┐    │
│  │ 私钥管理    │  │ 密码策略    │  │ 设备安全    │    │
│  └────────────┘  └────────────┘  └─────────────┘    │
└─────────────────────────────────────────────────────┘