What is an Ethereum wallet? Please explain wallet types, private key management, and security best practices - 面试题

Ethereum wallets are main tools for users to interact with Ethereum network, used to manage private keys, send transactions, and store assets. Here's a comprehensive analysis of wallets:

Basic Concepts of Wallets

Ethereum wallets are software or hardware devices that manage Ethereum addresses and private keys. Wallets don't store assets themselves but store private keys used to sign transactions.

Wallet Types

1. Hot Wallets

Wallets connected to internet, convenient for daily use.

Features:

Convenient and fast
Support DApp interaction
Relatively lower security

Representative Projects:

MetaMask: Browser extension wallet
WalletConnect: Mobile wallet protocol
Coinbase Wallet: Centralized wallet

2. Cold Wallets

Offline storage of private keys, higher security.

Features:

High security
Not easily hacked
Relatively inconvenient to use

Representative Projects:

Ledger: Hardware wallet
Trezor: Hardware wallet
Paper Wallet: Paper wallet

Private Keys and Public Keys

1. Key Pair Generation

javascript
const { ethers } = require("ethers");

// Generate random wallet
const wallet = ethers.Wallet.createRandom();

console.log("Address:", wallet.address);
console.log("Private Key:", wallet.privateKey);
console.log("Mnemonic:", wallet.mnemonic.phrase);

2. Recover from Mnemonic

javascript
// Recover wallet from mnemonic
const mnemonic = "word1 word2 word3 ...";
const wallet = ethers.Wallet.fromPhrase(mnemonic);

console.log("Address:", wallet.address);
console.log("Private Key:", wallet.privateKey);

MetaMask Usage

1. Connect to DApp

javascript
// Detect MetaMask
if (typeof window.ethereum !== 'undefined') {
    console.log("MetaMask is installed!");
    
    // Request account access
    const accounts = await window.ethereum.request({
        method: 'eth_requestAccounts'
    });
    
    console.log("Connected account:", accounts[0]);
} else {
    console.log("Please install MetaMask!");
}

2. Send Transaction

javascript
// Send transaction using MetaMask
async function sendTransaction() {
    const accounts = await window.ethereum.request({
        method: 'eth_requestAccounts'
    });
    
    const transactionParameters = {
        to: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb',
        from: accounts[0],
        value: '0x29a2241af62c00000' // 0.1 ETH in hex
    };
    
    const txHash = await window.ethereum.request({
        method: 'eth_sendTransaction',
        params: [transactionParameters]
    });
    
    console.log("Transaction hash:", txHash);
}

3. Sign Message

javascript
// Sign message
async function signMessage() {
    const accounts = await window.ethereum.request({
        method: 'eth_requestAccounts'
    });
    
    const message = "Hello, Ethereum!";
    const signature = await window.ethereum.request({
        method: 'personal_sign',
        params: [message, accounts[0]]
    });
    
    console.log("Signature:", signature);
}

Hardware Wallets

1. Ledger Integration

javascript
const { LedgerSigner } = require("@ethersproject/hardware-wallets");

async function connectLedger() {
    const signer = await LedgerSigner.create();
    console.log("Address:", await signer.getAddress());
    
    // Send transaction
    const tx = await signer.sendTransaction({
        to: recipientAddress,
        value: ethers.utils.parseEther("1.0")
    });
    
    console.log("Transaction hash:", tx.hash);
}

2. Trezor Integration

javascript
const { TrezorSigner } = require("@ethersproject/hardware-wallets");

async function connectTrezor() {
    const signer = await TrezorSigner.create();
    console.log("Address:", await signer.getAddress());
}

Wallet Security

1. Private Key Protection

javascript
// Encrypt private key
const crypto = require('crypto');
const algorithm = 'aes-256-cbc';

function encryptPrivateKey(privateKey, password) {
    const key = crypto.scryptSync(password, 'salt', 32);
    const iv = crypto.randomBytes(16);
    const cipher = crypto.createCipheriv(algorithm, key, iv);
    
    let encrypted = cipher.update(privateKey, 'utf8', 'hex');
    encrypted += cipher.final('hex');
    
    return iv.toString('hex') + ':' + encrypted;
}

function decryptPrivateKey(encryptedData, password) {
    const key = crypto.scryptSync(password, 'salt', 32);
    const parts = encryptedData.split(':');
    const iv = Buffer.from(parts[0], 'hex');
    const decipher = crypto.createDecipheriv(algorithm, key, iv);
    
    let decrypted = decipher.update(parts[1], 'hex', 'utf8');
    decrypted += decipher.final('utf8');
    
    return decrypted;
}

2. Multi-Signature

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

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

contract MultiSigWallet is AccessControl {
    using ECDSA for bytes32;
    
    bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
    uint256 public threshold;
    mapping(bytes32 => bool) public executedTransactions;
    
    constructor(address[] memory _owners, uint256 _threshold) {
        for (uint256 i = 0; i < _owners.length; i++) {
            _grantRole(ADMIN_ROLE, _owners[i]);
        }
        threshold = _threshold;
    }
    
    function executeTransaction(
        address to,
        uint256 value,
        bytes memory data,
        bytes[] memory signatures
    ) public onlyRole(ADMIN_ROLE) {
        bytes32 txHash = keccak256(abi.encodePacked(to, value, data));
        
        uint256 validSignatures = 0;
        for (uint256 i = 0; i < signatures.length; i++) {
            address signer = txHash.toEthSignedMessageHash().recover(signatures[i]);
            if (hasRole(ADMIN_ROLE, signer)) {
                validSignatures++;
            }
        }
        
        require(validSignatures >= threshold, "Not enough signatures");
        require(!executedTransactions[txHash], "Already executed");
        
        executedTransactions[txHash] = true;
        (bool success, ) = to.call{value: value}(data);
        require(success, "Transaction failed");
    }
}

Wallet Development

1. Create Simple Wallet

javascript
const { ethers } = require("ethers");

class SimpleWallet {
    constructor(privateKey) {
        this.wallet = new ethers.Wallet(privateKey);
    }
    
    getAddress() {
        return this.wallet.address;
    }
    
    async sendTransaction(to, value, provider) {
        const tx = {
            to: to,
            value: ethers.utils.parseEther(value.toString())
        };
        
        const signedTx = await this.wallet.signTransaction(tx);
        const txResponse = await provider.sendTransaction(signedTx);
        
        return await txResponse.wait();
    }
    
    signMessage(message) {
        return this.wallet.signMessage(message);
    }
}

// Usage example
const wallet = new SimpleWallet(privateKey);
const provider = ethers.getDefaultProvider();
const receipt = await wallet.sendTransaction(
    "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb",
    0.1,
    provider
);
console.log("Transaction confirmed:", receipt.transactionHash);

2. HD Wallet (Hierarchical Deterministic Wallet)

javascript
// Generate multiple addresses from mnemonic
const mnemonic = "word1 word2 word3 ...";
const hdNode = ethers.utils.HDNode.fromMnemonic(mnemonic);

// Generate 5 addresses
for (let i = 0; i < 5; i++) {
    const wallet = hdNode.derivePath(`m/44'/60'/0'/0/${i}`);
    console.log(`Address ${i}:`, wallet.address);
}

Wallet Best Practices

1. Secure Storage

Use hardware wallets for large amounts
Offline backup of mnemonic phrases
Never share private keys or mnemonics
Password protect wallet files

2. Transaction Security

Verify recipient address
Check transaction details
Use reasonable Gas prices
Wait for transaction confirmation

3. DApp Interaction

Only connect to trusted DApps
Check transaction permission requests
Regularly check authorization amounts
Revoke unnecessary authorizations

Wallet Integration

1. WalletConnect

javascript
import WalletConnect from "@walletconnect/web3-provider";

const walletConnector = new WalletConnect({
    bridge: "https://bridge.walletconnect.org",
    qrcodeModal: QRCodeModal
});

// Connect wallet
await walletConnector.connect();

// Send transaction
const tx = await walletConnector.sendTransaction({
    from: walletConnector.accounts[0],
    to: recipientAddress,
    value: "0x29a2241af62c00000"
});

2. Web3Modal

javascript
import Web3Modal from "web3modal";

const web3Modal = new Web3Modal({
    network: "mainnet",
    cacheProvider: true,
    providerOptions: {
        walletconnect: {
            package: WalletConnectProvider,
            options: {
                infuraId: "YOUR_INFURA_ID"
            }
        }
    }
});

const provider = await web3Modal.connect();
const web3 = new Web3(provider);

Common Questions

Q: What should I do if I lose my private key?

A: If you lose your private key without a backup, your assets will be permanently lost. Always keep your mnemonic phrase safe.

Q: How to choose a wallet?

A: Choose based on needs:

Daily use: Hot wallets like MetaMask
Long-term storage: Hardware wallets like Ledger
Development testing: Test network wallets

Q: Are wallets secure?

A: Wallets themselves are secure, but user behavior can lead to security issues. Following security best practices is crucial.

Ethereum wallets are the gateway to blockchain world. Understanding how they work and security practices is crucial for protecting assets.