Elysia Tools

在一个清晰的工作台里浏览工具、案例、可视化和主题指南。

热门分类

专题

语言
ZHDERUPTENFRES

Elysia Tools

导航

区块链

Web3前端集成

高级Web3前端集成示例,包含Ethers.js/Web3.js、多链钱包支持、DeFi协议交互和NFT市场接口

案例

这个案例集合中的条目

代码typescript中等

Ethers.js高级集成

完整的Web3前端与Ethers.js集成,包含合约交互、事件监听、gas估算、交易监控和错误处理

难度

7/10

预计时间

40 min

标签

ethers, web3, frontend, dapp, blockchain

前置条件

JavaScript, React, Ethereum basics, Web3 concepts

typescript
// Advanced Ethers.js Frontend Integration
// Complete Web3 DApp with Ethers.js v6
// Dependencies: ethers@^6.0.0, @walletconnect/web3-provider@^2.0.0

import { ethers } from 'ethers';
import { providers } from '@walletconnect/web3-provider';
import { watchContractEvent } from '@ethersproject/contracts';
import { Writable } from '@ethersproject/contracts';

// Contract ABIs (normally imported from JSON files)
const ERC20_ABI = [
    // ... ERC-20 ABI
    "function name() view returns (string)",
    "function symbol() view returns (string)",
    "function decimals() view returns (uint8)",
    "function totalSupply() view returns (uint256)",
    "function balanceOf(address) view returns (uint256)",
    "function transfer(address, uint256) returns (bool)",
    "function allowance(address, address) view returns (uint256)",
    "function approve(address, uint256) returns (bool)",
    "function transferFrom(address, address, uint256) returns (bool)",
    "event Transfer(address indexed from, address indexed to, uint256 value)",
    "event Approval(address indexed owner, address indexed spender, uint256 value)"
];

const NFT_MARKETPLACE_ABI = [
    // NFT Marketplace ABI
    "function listNFT(uint256, uint256) external",
    "function buyNFT(uint256) external payable",
    "function cancelListing(uint256) external",
    "function updateListing(uint256, uint256) external",
    "event NFTListed(uint256 indexed tokenId, uint256 price, address indexed seller)",
    "event NFTSold(uint256 indexed tokenId, address indexed seller, address indexed buyer, uint256 price)",
    "event ListingCancelled(uint256 indexed tokenId)"
];

interface Web3Config {
    infuraProjectId?: string;
    alchemyApiKey?: string;
    defaultChainId: number;
    supportedNetworks: NetworkConfig[];
    rpcUrls: { [chainId: number]: string };
}

interface NetworkConfig {
    chainId: number;
    name: string;
    rpcUrl: string;
    blockExplorerUrl: string;
    nativeCurrency: {
        name: string;
        symbol: string;
        decimals: number;
    };
}

class Web3Manager {
    private provider: ethers.providers.Provider | null = null;
    private signer: ethers.Signer | null = null;
    private contracts: Map<string, ethers.Contract> = new Map();
    private eventListeners: Map<string, ethers.Listener[]> = new Map();
    private config: Web3Config;
    private network: NetworkConfig | null = null;
    private isWalletConnected: boolean = false;

    constructor(config: Web3Config) {
        this.config = config;
        this.initializeProvider();
    }

    private initializeProvider() {
        // Initialize with Infura fallback
        const infuraUrl = this.config.infuraProjectId
            ? `https://mainnet.infura.io/v3/${this.config.infuraProjectId}`
            : 'https://eth-mainnet.alchemyapi.io/v2/demo';

        this.provider = new ethers.providers.JsonRpcProvider(infuraUrl);
        console.log('🔗 Initialized with RPC provider');
    }

    // Wallet Connection Methods
    async connectWallet(walletType: 'metamask' | 'walletconnect' = 'metamask') {
        try {
            let provider: ethers.providers.Web3Provider;

            switch (walletType) {
                case 'metamask':
                    provider = await this.connectMetaMask();
                    break;
                case 'walletconnect':
                    provider = await this.connectWalletConnect();
                    break;
                default:
                    throw new Error(`Unsupported wallet type: ${walletType}`);
            }

            this.provider = provider;
            this.signer = provider.getSigner();
            this.isWalletConnected = true;

            // Get current network
            const network = await provider.getNetwork();
            this.network = this.config.supportedNetworks.find(
                (config: NetworkConfig) => config.chainId === network.chainId
            );

            if (!this.network) {
                throw new Error(`Network ${network.chainId} not supported`);
            }

            console.log('✅ Wallet connected:', {
                network: network.name,
                chainId: network.chainId,
                account: await this.getConnectedAccount()
            });

            return true;

        } catch (error) {
            console.error('❌ Wallet connection failed:', error);
            throw error;
        }
    }

    private async connectMetaMask(): Promise<ethers.providers.Web3Provider> {
        if (typeof window.ethereum === 'undefined') {
            throw new Error('MetaMask is not installed');
        }

        // Request account access
        await window.ethereum.request({ method: 'eth_requestAccounts' });

        // Create provider
        const provider = new ethers.providers.Web3Provider(window.ethereum);

        // Listen for network changes
        window.ethereum.on('chainChanged', () => {
            this.handleNetworkChange();
        });

        // Listen for account changes
        window.ethereum.on('accountsChanged', () => {
            this.handleAccountChange();
        });

        return provider;
    }

    private async connectWalletConnect(): Promise<ethers.providers.Web3Provider> {
        const wcProvider = new providers.Web3Provider({
            infuraId: this.config.infuraProjectId
        });

        await wcProvider.enable();

        return wcProvider;
    }

    async disconnectWallet() {
        try {
            this.provider = null;
            this.signer = null;
            this.isWalletConnected = false;

            console.log('🔌 Wallet disconnected');
        } catch (error) {
            console.error('❌ Failed to disconnect wallet:', error);
        }
    }

    private handleNetworkChange() {
        console.log('⚡ Network changed, reloading...');
        window.location.reload();
    }

    private handleAccountChange() {
        console.log('👤 Account changed');
        this.emit('accountChanged');
    }

    // Utility Methods
    async getConnectedAccount(): Promise<string | null> {
        if (!this.signer) return null;
        return await this.signer.getAddress();
    }

    async getBalance(address?: string): Promise<string> {
        const account = address || await this.getConnectedAccount();
        if (!account) return '0';

        const balance = await this.provider!.getBalance(account);
        return ethers.utils.formatEther(balance);
    }

    async switchNetwork(chainId: number): Promise<void> {
        try {
            if (window.ethereum) {
                await window.ethereum.request({
                    method: 'wallet_switchEthereumChain',
                    params: [{ chainId: `0x${chainId.toString(16)}` }]
                });
            } else {
                throw new Error('Network switching not supported by current wallet');
            }
        } catch (error) {
            console.error('❌ Network switch failed:', error);
            throw error;
        }
    }

    async addNetwork(networkConfig: NetworkConfig): Promise<void> {
        try {
            if (window.ethereum) {
                await window.ethereum.request({
                    method: 'wallet_addEthereumChain',
                    params: [networkConfig]
                });
            } else {
                throw new Error('Network addition not supported by current wallet');
            }
        } catch (error) {
            console.error('❌ Failed to add network:', error);
            throw error;
        }
    }

    // Contract Interactions
    getContract(address: string, abi: any[]): ethers.Contract {
        const cacheKey = `${address}-${JSON.stringify(abi)}`;

        if (this.contracts.has(cacheKey)) {
            return this.contracts.get(cacheKey)!;
        }

        if (!this.signer) {
            throw new Error('Wallet not connected');
        }

        const contract = new ethers.Contract(address, abi, this.signer);
        this.contracts.set(cacheKey, contract);
        return contract;
    }

    // ERC-20 Token Methods
    async transferToken(tokenAddress: string, to: string, amount: string): Promise<ethers.TransactionResponse> {
        try {
            const contract = this.getContract(tokenAddress, ERC20_ABI);
            const decimals = await contract.decimals();
            const parsedAmount = ethers.utils.parseUnits(amount, decimals);

            const tx = await contract.transfer(to, parsedAmount);

            return await this.waitForTransaction(tx);
        } catch (error) {
            console.error('❌ Token transfer failed:', error);
            throw error;
        }
    }

    async getTokenInfo(tokenAddress: string) {
        try {
            const contract = this.getContract(tokenAddress, ERC20_ABI);

            const [name, symbol, decimals, totalSupply] = await Promise.all([
                contract.name(),
                contract.symbol(),
                contract.decimals(),
                contract.totalSupply()
            ]);

            return {
                address: tokenAddress,
                name,
                symbol,
                decimals: Number(decimals),
                totalSupply: ethers.utils.formatEther(totalSupply)
            };
        } catch (error) {
            console.error('❌ Failed to get token info:', error);
            throw error;
        }
    }

    async getTokenBalance(tokenAddress: string, userAddress?: string): Promise<string> {
        try {
            const contract = this.getContract(tokenAddress, ERC20_ABI);
            const account = userAddress || await this.getConnectedAccount();

            if (!account) return '0';

            const balance = await contract.balanceOf(account);
            const decimals = await contract.decimals();

            return ethers.utils.formatUnits(balance, decimals);
        } catch (error) {
            console.error('❌ Failed to get token balance:', error);
            throw error;
        }
    }

    // NFT Marketplace Methods
    async listNFT(marketplaceAddress: string, tokenId: string, price: string) {
        try {
            const contract = this.getContract(marketplaceAddress, NFT_MARKETPLACE_ABI);
            const parsedPrice = ethers.utils.parseEther(price);

            const tx = await contract.listNFT(tokenId, parsedPrice);
            return await this.waitForTransaction(tx);
        } catch (error) {
            console.error('❌ NFT listing failed:', error);
            throw error;
        }
    }

    async buyNFT(marketplaceAddress: string, tokenId: string, maxPrice?: string) {
        try {
            const contract = this.getContract(marketplaceAddress, NFT_MARKETPLACE_ABI);

            let tx: ethers.ContractTransaction;
            if (maxPrice) {
                const maxPriceWei = ethers.utils.parseEther(maxPrice);
                tx = await contract.buyNFT(tokenId, {
                    value: maxPriceWei
                });
            } else {
                tx = await contract.buyNFT(tokenId);
            }

            return await this.waitForTransaction(tx);
        } catch (error) {
            console.error('❌ NFT purchase failed:', error);
            throw error;
        }
    }

    // Transaction Management
    async estimateGas(transaction: ethers.Transaction): Promise<string> {
        try {
            const gasEstimate = await this.provider!.estimateGas(transaction);
            return gasEstimate.toString();
        } catch (error) {
            console.error('❌ Gas estimation failed:', error);
            return '0';
        }
    }

    async getTransactionReceipt(txHash: string) {
        try {
            return await this.provider!.getTransactionReceipt(txHash);
        } catch (error) {
            console.error('❌ Failed to get transaction receipt:', error);
            throw error;
        }
    }

    async waitForTransaction(
        transaction: ethers.ContractTransaction,
        confirmations: number = 1,
        timeout: number = 30000
    ): Promise<ethers.TransactionResponse> {
        try {
            // Send transaction
            const tx = await transaction.send();

            // Wait for confirmation
            const receipt = await tx.wait(confirmations);

            // Emit transaction event
            this.emit('transactionComplete', {
                hash: receipt.hash,
                status: receipt.status === 1 ? 'success' : 'failed',
                gasUsed: receipt.gasUsed.toString(),
                blockNumber: receipt.blockNumber.toString(),
                timestamp: Date.now()
            });

            return receipt;

        } catch (error) {
            // Emit error event
            this.emit('transactionError', {
                error: error.message,
                timestamp: Date.now()
            });
            throw error;
        }
    }

    // Event Listening
    listenToContractEvents(
        contractAddress: string,
        eventName: string,
        callback: (event: any) => void
    ): () => void {
        try {
            const contract = this.getContract(contractAddress, []);

            // Clean up existing listeners
            this.removeAllListeners(contractAddress, eventName);

            // Add new listener
            const listener = (...args: any[]) => {
                const event = args[args.length - 1];
                callback(event);
            };

            contract.on(eventName, listener);

            // Store listener for cleanup
            const listeners = this.eventListeners.get(contractAddress) || [];
            listeners.push({ eventName, listener });
            this.eventListeners.set(contractAddress, listeners);

            return () => this.removeAllListeners(contractAddress, eventName);

        } catch (error) {
            console.error('❌ Failed to set up event listener:', error);
            throw error;
        }
    }

    private removeAllListeners(contractAddress: string, eventName?: string) {
        const listeners = this.eventListeners.get(contractAddress);
        if (!listeners) return;

        const contract = this.contracts.get(`${contractAddress}-[]`);
        if (!contract) return;

        listeners.forEach(({ eventName: name, listener }) => {
            if (!eventName || name === eventName) {
                contract.off(name, listener);
            }
        });

        if (eventName) {
            const remaining = listeners.filter((item) => item.eventName !== eventName);
            if (remaining.length > 0) {
                this.eventListeners.set(contractAddress, remaining);
            } else {
                this.eventListeners.delete(contractAddress);
            }
        } else {
            this.eventListeners.delete(contractAddress);
        }
    }

    // Gas Optimization
    async optimizeTransaction(transaction: ethers.Transaction): Promise<ethers.Transaction> {
        try {
            // Set reasonable gas limit if not provided
            if (!transaction.gasLimit) {
                const gasEstimate = await this.estimateGas(transaction);
                transaction.gasLimit = Math.floor(Number(gasEstimate) * 1.2); // 20% buffer
            }

            // Set gas price if not provided
            if (!transaction.gasPrice && this.network) {
                const feeData = await this.provider!.getFeeData();
                transaction.gasPrice = feeData.gasPrice;
            }

            // Set nonce if not provided
            if (transaction.nonce === undefined) {
                const nonce = await this.signer!.getTransactionCount();
                transaction.nonce = nonce;
            }

            return transaction;
        } catch (error) {
            console.error('❌ Transaction optimization failed:', error);
            return transaction;
        }
    }

    // Batch Operations
    async batchTransactions(transactions: ethers.Transaction[]): Promise<ethers.TransactionResponse[]> {
        try {
            // Process transactions in parallel with delays to avoid nonce conflicts
            const results = await Promise.all(
                transactions.map(async (tx, index) => {
                    // Add small delay between transactions
                    await new Promise(resolve => setTimeout(resolve, 100 * index));

                    return this.waitForTransaction(tx);
                })
            );

            return results;
        } catch (error) {
            console.error('❌ Batch transactions failed:', error);
            throw error;
        }
    }

    // Event Emission
    private listeners: Map<string, ((event: any) => void)[]> = new Map();

    emit(eventName: string, data: any) {
        const listeners = this.listeners.get(eventName) || [];
        listeners.forEach(listener => listener(data));
    }

    on(eventName: string, listener: (event: any) => void) {
        if (!this.listeners.has(eventName)) {
            this.listeners.set(eventName, []);
        }
        this.listeners.get(eventName)!.push(listener);
    }

    off(eventName: string, listener: (event: any) => void) {
        const listeners = this.listeners.get(eventName) || [];
        const index = listeners.indexOf(listener);
        if (index > -1) {
            listeners.splice(index, 1);
        }
    }

    // Multi-chain Support
    async switchChain(newChainId: number) {
        const targetNetwork = this.config.supportedNetworks.find(
            (config: NetworkConfig) => config.chainId === newChainId
        );

        if (!targetNetwork) {
            throw new Error(`Chain ${newChainId} not supported`);
        }

        try {
            // Switch wallet to new chain
            await this.switchNetwork(newChainId);

            // Update provider
            this.provider = new ethers.providers.JsonRpcProvider(targetNetwork.rpcUrl);
            this.network = targetNetwork;

            this.emit('chainChanged', {
                chainId: newChainId,
                network: targetNetwork.name
            });

        } catch (error) {
            console.error('❌ Chain switch failed:', error);
            throw error;
        }
    }

    getCurrentNetwork(): NetworkConfig | null {
        return this.network;
    }

    getNetworks(): NetworkConfig[] {
        return this.config.supportedNetworks;
    }

    // Storage and Persistence
    saveState() {
        const state = {
            isWalletConnected: this.isWalletConnected,
            network: this.network,
            connectedAccount: this.signer ? null : undefined
        };

        localStorage.setItem('web3-state', JSON.stringify(state));
    }

    loadState() {
        try {
            const saved = localStorage.getItem('web3-state');
            if (saved) {
                const state = JSON.parse(saved);
                this.isWalletConnected = state.isWalletConnected || false;
                this.network = state.network || null;

                if (state.connectedAccount) {
                    this.reconnectAccount(state.connectedAccount);
                }
            }
        } catch (error) {
            console.warn('⚠️ Failed to load state:', error);
        }
    }

    private async reconnectAccount(account: string) {
        try {
            if (this.provider && this.isWalletConnected) {
                // Verify the account is still available
                const availableAccounts = await this.provider.send('eth_requestAccounts', []);
                if (availableAccounts.includes(account)) {
                    // Account is available, update signer
                    this.provider = new ethers.providers.Web3Provider(window.ethereum);
                    this.signer = this.provider.getSigner();
                } else {
                    // Account no longer available, clear connection
                    this.isWalletConnected = false;
                    this.signer = null;
                }
            }
        } catch (error) {
            console.warn('⚠️ Failed to reconnect account:', error);
        }
    }

    // DeFi Integration Examples
    async swapTokens(
        routerAddress: string,
        tokenA: string,
        tokenB: string,
        amountIn: string,
        amountOutMin: string,
        slippage: number = 0.5
    ): Promise<ethers.TransactionResponse> {
        try {
            // Simplified Uniswap V2 Router example
            const routerAbi = [
                "function WETH() external view returns (address)",
                "function swapExactTokensForTokens(uint256,uint256,address,bytes[])",
                "function getAmountsOut(uint256,address[]) view returns (uint256[])",
                "function swapExactETHForTokens(uint256,address[],uint256) external payable",
                "function swapExactTokensForETH(address[],uint256,uint256) external"
            ];

            const router = this.getContract(routerAddress, routerAbi);

            // Calculate minimum output
            const decimalsA = await this.getTokenDecimals(tokenA);
            const decimalsB = await this.getTokenDecimals(tokenB);
            const parsedAmountIn = ethers.utils.parseUnits(amountIn, decimalsA);

            // This is a simplified example - actual implementation would require
            // getting pool data and calculating proper amounts
            const amountOut = await router.getAmountsOut(parsedAmountIn, [tokenA, tokenB]);
            const minAmountOut = amountOut[1].mul(100 - slippage).div(100);

            const tx = await router.swapExactTokensForTokens(
                parsedAmountIn,
                minAmountOut,
                [tokenA, tokenB],
                this.signer?.address()
            );

            return await this.waitForTransaction(tx);

        } catch (error) {
            console.error('❌ Token swap failed:', error);
            throw error;
        }
    }

    private async getTokenDecimals(tokenAddress: string): Promise<number> {
        try {
            const contract = this.getContract(tokenAddress, ERC20_ABI);
            const decimals = await contract.decimals();
            return Number(decimals);
        } catch (error) {
            return 18; // Default to 18 decimals for most tokens
        }
    }

    // Liquidity Pool Management
    async addLiquidity(
        poolAddress: string,
        tokenA: string,
        tokenB: string,
        amountA: string,
        amountB: string,
        slippage: number = 0.5
    ): Promise<ethers.TransactionResponse> {
        try {
            // Simplified liquidity pool example
            const poolAbi = [
                "function addLiquidity(uint256,uint256,address,address)",
                "function removeLiquidity(uint256,uint256)",
                "function getReserves() view returns (uint256,uint256)",
                "event LiquidityAdded(address indexed provider, uint256 amountA, uint256 amountB)"
            ];

            const pool = this.getContract(poolAddress, poolAbi);
            const decimalsA = await this.getTokenDecimals(tokenA);
            const decimalsB = await this.getTokenDecimals(tokenB);

            const parsedAmountA = ethers.utils.parseUnits(amountA, decimalsA);
            const parsedAmountB = ethers.utils.parseUnits(amountB, decimalsB);

            const tx = await pool.addLiquidity(parsedAmountA, parsedAmountB, tokenA, tokenB);
            return await this.waitForTransaction(tx);

        } catch (error) {
            console.error('❌ Add liquidity failed:', error);
            throw error;
        }
    }

    // Utility Methods
    formatEther(wei: string): string {
        try {
            return ethers.utils.formatEther(wei);
        } catch {
            return wei;
        }
    }

    parseEther(ether: string): ethers.BigNumber {
        try {
            return ethers.utils.parseEther(ether);
        } catch {
            return ethers.BigNumber(0);
        }
    }

    formatUnits(value: ethers.BigNumber, decimals: number): string {
        try {
            return ethers.utils.formatUnits(value, decimals);
        } catch {
            return value.toString();
        }
    }

    parseUnits(value: string, decimals: number): ethers.BigNumber {
        try {
            return ethers.utils.parseUnits(value, decimals);
        } catch {
            return ethers.BigNumber(0);
        }
    }

    isValidAddress(address: string): boolean {
        try {
            return ethers.utils.isAddress(address);
        } catch {
            return false;
        }
    }

    // Cleanup
    destroy() {
        // Remove all event listeners
        this.eventListeners.forEach((listeners, contractAddress) => {
            listeners.forEach(({ listener }) => {
                this.off('eventChanged', listener);
            });
        });

        // Clear references
        this.provider = null;
        this.signer = null;
        this.contracts.clear();
        this.eventListeners.clear();
    }
}

// React Hook for Web3 Integration
// web3Hook.ts
import { useState, useEffect, useCallback } from 'react';

export const useWeb3 = () => {
    const [web3Manager, setWeb3Manager] = useState<Web3Manager | null>(null);
    const [isConnected, setIsConnected] = useState(false);
    const [account, setAccount] = useState<string | null>(null);
    const [network, setNetwork] = useState<any>(null);
    const [balance, setBalance] = useState<string>('0');

    // Initialize Web3Manager
    useEffect(() => {
        const config = {
            infuraProjectId: process.env.NEXT_PUBLIC_INFURA_PROJECT_ID,
            defaultChainId: 1,
            supportedNetworks: [
                {
                    chainId: 1,
                    name: 'Ethereum Mainnet',
                    rpcUrl: 'https://mainnet.infura.io/v3/YOUR_PROJECT_ID',
                    blockExplorerUrl: 'https://etherscan.io',
                    nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 }
                },
                {
                    chainId: 137,
                    name: 'Polygon',
                    rpcUrl: 'https://polygon-rpc.com',
                    blockExplorerUrl: 'https://polygonscan.com',
                    nativeCurrency: { name: 'MATIC', symbol: 'MATIC', decimals: 18 }
                },
                {
                    chainId: 56,
                    name: 'BSC',
                    rpcUrl: 'https://bsc-dataseid1.noderealapi.com',
                    blockExplorerUrl: 'https://bscscan.com',
                    nativeCurrency: { name: 'BNB', symbol: 'BNB', decimals: 18 }
                }
            ]
        };

        const manager = new Web3Manager(config);
        manager.loadState();

        setWeb3Manager(manager);
        setIsConnected(manager.isWalletConnected);
        setNetwork(manager.getCurrentNetwork());
        manager.getConnectedAccount().then(setAccount);

        // Save state on changes
        manager.on('accountChanged', async () => {
            setAccount(await manager.getConnectedAccount());
        });

        manager.on('chainChanged', (data) => {
            setNetwork(data.network);
        });

        manager.on('balanceChanged', (data) => {
            setBalance(data.balance);
        });

        // Cleanup on unmount
        return () => {
            manager.destroy();
        };
    }, []);

    const connectWallet = useCallback(async (walletType: 'metamask' | 'walletconnect' = 'metamask') => {
        if (!web3Manager) return;

        try {
            await web3Manager.connectWallet(walletType);
            setIsConnected(true);
            setAccount(await web3Manager.getConnectedAccount());
        } catch (error) {
            console.error('Failed to connect wallet:', error);
            throw error;
        }
    }, [web3Manager]);

    const disconnectWallet = useCallback(async () => {
        if (!web3Manager) return;

        try {
            await web3Manager.disconnectWallet();
            setIsConnected(false);
            setAccount(null);
        } catch (error) {
            console.error('Failed to disconnect wallet:', error);
            throw error;
        }
    }, [web3Manager]);

    const switchNetwork = useCallback(async (chainId: number) => {
        if (!web3Manager) return;

        try {
            await web3Manager.switchChain(chainId);
            setNetwork(web3Manager.getCurrentNetwork());
        } catch (error) {
            console.error('Failed to switch network:', error);
            throw error;
        }
    }, [web3Manager]);

    const getContract = useCallback((address: string, abi: any[]) => {
        return web3Manager?.getContract(address, abi);
    }, [web3Manager]);

    const transferToken = useCallback(async (tokenAddress: string, to: string, amount: string) => {
        return web3Manager?.transferToken(tokenAddress, to, amount);
    }, [web3Manager]);

    const getTokenBalance = useCallback(async (tokenAddress: string) => {
        return web3Manager?.getTokenBalance(tokenAddress);
    }, [web3Manager]);

    const buyNFT = useCallback(async (marketplaceAddress: string, tokenId: string, maxPrice?: string) => {
        return web3Manager?.buyNFT(marketplaceAddress, tokenId, maxPrice);
    }, [web3Manager]);

    return {
        web3Manager,
        isConnected,
        account,
        network,
        balance,
        connectWallet,
        disconnectWallet,
        switchNetwork,
        getContract,
        transferToken,
        getTokenBalance,
        buyNFT
    };
};

// Multi-chain Provider Manager
class MultiChainManager {
    private providers: Map<number, ethers.providers.JsonRpcProvider> = new Map();
    private wallets: Map<number, ethers.Wallet> = new Map();
    private currentChainId: number = 1;

    constructor(config: { [chainId: number]: string }) {
        // Initialize providers for all supported chains
        Object.entries(config).forEach(([chainId, rpcUrl]) => {
            this.providers.set(Number(chainId), new ethers.providers.JsonRpcProvider(rpcUrl));
        });
    }

    getProvider(chainId?: number): ethers.providers.JsonRpcProvider {
        return this.providers.get(chainId || this.currentChainId);
    }

    switchChain(chainId: number): void {
        this.currentChainId = chainId;
    }

    getCurrentChainId(): number {
        return this.currentChainId;
    }

    async executeOnChain<T>(
        chainId: number,
        operation: (provider: ethers.providers.JsonRpcProvider) => Promise<T>
    ): Promise<T> {
        const provider = this.getProvider(chainId);
        return await operation(provider);
    }

    async executeOnAllChains<T>(
        operation: (provider: ethers.providers.JsonRpcProvider, chainId: number) => Promise<T>
    ): Promise<Map<number, T>> {
        const results = new Map<number, T>();

        for (const [chainId, provider] of this.providers) {
            try {
                const result = await operation(provider, chainId);
                results.set(chainId, result);
            } catch (error) {
                console.error(`Error on chain ${chainId}:`, error);
                results.set(chainId, error);
            }
        }

        return results;
    }
}

export {
    Web3Manager,
    MultiChainManager,
    useWeb3
};

// Usage example
// main.ts
async function main() {
    console.log('🚀 Web3 Frontend Integration Demo');

    // Initialize Web3 manager
    const web3Manager = new Web3Manager({
        infuraProjectId: process.env.INFURA_PROJECT_ID,
        defaultChainId: 1,
        supportedNetworks: [
            {
                chainId: 1,
                name: 'Ethereum Mainnet',
                rpcUrl: 'https://mainnet.infura.io/v3/YOUR_PROJECT_ID',
                blockExplorerUrl: 'https://etherscan.io',
                nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 }
            },
            {
                chainId: 137,
                name: 'Polygon',
                rpcUrl: 'https://polygon-rpc.com',
                blockExplorerUrl: 'https://polygonscan.com',
                nativeCurrency: { name: 'MATIC', symbol: 'MATIC', decimals: 18 }
            }
        ]
    });

    try {
        // Initialize and connect wallet
        await web3Manager.initialize();
        await web3Manager.connectWallet('metamask');

        // Get wallet balance
        const balance = await web3Manager.getBalance();
        console.log(`💰 Wallet balance: ${balance} ETH`);

        // Get token info
        const tokenAddress = '0xA0b86a33E6D13A1F297Cd2B55E1A7B80A5C2C6EBD24A1C2A;
        const tokenInfo = await web3Manager.getTokenInfo(tokenAddress);
        console.log('📊 Token Info:', tokenInfo);

        // Transfer tokens
        if (parseFloat(balance) > 0.1) {
            const recipient = '0x742d35Cc6634C0532925a3b8D4C9db96C4b4d8b6';
            const amount = '0.01';

            console.log(`💸 Transferring ${amount} tokens to ${recipient}...`);
            const receipt = await web3Manager.transferToken(tokenAddress, recipient, amount);
            console.log(`✅ Transfer complete: ${receipt.hash}`);
        }

        // Listen to contract events
        const marketplaceAddress = '0x1234567890123456789012345678901234567890';
        const stopListening = web3Manager.listenToContractEvents(
            marketplaceAddress,
            'NFTSold',
            (event) => {
                console.log(`🎨 NFT Sold! TokenId: ${event.tokenId}, Buyer: ${event.buyer}, Price: ${web3Manager.formatEther(event.price.toString())} ETH`);
            }
        );

        // Listen for transaction events
        web3Manager.on('transactionComplete', (event) => {
            console.log(`✅ Transaction ${event.hash} ${event.status}`);
        });

        // Wait for some events
        await new Promise(resolve => setTimeout(resolve, 10000));

        stopListening();

    } catch (error) {
        console.error('❌ Demo failed:', error);
    }
}

if (require.main === module) {
    main();
}

工具

经常与该案例搭配使用的工具

相关内容

相关案例集合

相关内容

相关专题

专题

SVG 图标集打包与前端集成验收

清理已批准的 SVG 图标,选择内联或外部引用模式,在真实页面核对标识符、几何和着色,并导出单图标位图回退。

专题

播客单集发布前音频与 RSS 一致性检查

将已完成的播客单集与 RSS 条目对照,核验最终文件字节数、类型及声明时长,再单独实测公开媒体地址与播放器表现。

专题

结构与逻辑图生成器

从文本、JSON、集合定义或日志生成流程图、思维导图、组织架构图、树状图、韦恩图、ASCII 目录树与时序图。

专题

模板化文档生成工作流

从结构化数据生成表单、证书、成绩单、发票、收据、故事板、DOCX 合并 PDF 和 XLSX 模板输出。

首页
工具3212
案例593
可视化471
文件查看器103
专题239
标签333
图像、音频与视频657

图像、音频、视频处理、转换与优化工具

数学、日期与金融647

计算器、数值计算、日期逻辑、统计与金融工具

设计与颜色298

颜色、版式、图形、视觉样式与设计辅助工具

文本与写作209

写作、清洗、格式化、提取与文本分析工具

开发与 Web193

开发者工具、网络处理、Web 调试与自动化辅助工具

转换与编码175

格式、文件、压缩包、单位与编码转换工具

潜客测验发布与联系人交接
讣告、悼词与纪念卡的家属复核及交付
本地习惯记录的备份、恢复演练与分享前检查
长文改编 X 串文与 LinkedIn 帖子的事实复核与交付
Markdown 互动课件审校、离线演示与交付

© 2026 Elysia Tools. 保留所有权利。

文档价格关于我们服务条款隐私政策Cookie 政策联系我们
区块链

Ethers.js 以太坊库

Ethers.js 示例,包括提供者、钱包、合约、交易、事件、签名、实用程序和区块链交互模式

区块链

Web3.py Python 库

Web3.py Python 库示例,包括区块链交互、智能合约、钱包管理、交易和去中心化应用开发

区块链

以太坊智能合约和Solidity开发

全面的以太坊智能合约开发示例,包括ERC-20、ERC-721、DeFi协议和硬件钱包集成

区块链

Solana 开发示例

全面的 Solana 区块链开发示例,包括 Rust 智能合约开发、高性能程序、NFT 开发和程序部署

区块链

Hardhat 开发框架示例

Hardhat 以太坊开发环境示例,包括智能合约、测试、部署、脚本、插件和开发工作流

区块链

Truffle 开发套件示例

Truffle 以太坊开发框架示例,包括智能合约、测试、部署、迁移、调试和开发工作流