┌─────────────────────────────────────┐
│   Business Layer (业务封装层)        │  ← 面向具体业务的方法
│   ContractCall                      │
├─────────────────────────────────────┤
│   Service Layer (服务抽象层)         │  ← 通用的读写方法
│   ContractService                   │
├─────────────────────────────────────┤
│   Provider Layer (连接管理层)        │  ← Provider/Signer 管理
│   ProviderManager                   │
├─────────────────────────────────────┤
│   Type Layer (类型定义层)            │  ← 接口和类型定义
│   Interfaces & Types                │
└─────────────────────────────────────┘

// src/contract/type.ts

/**
 * 合约配置接口
 */
export interface ContractConfig {
    address: string;      // 合约地址
    abi: any[];          // 合约 ABI
    bytecode?: string;   // 合约字节码（部署时需要）
}

/**
 * 交易选项
 */
export interface TransactionOptions {
    gasLimit?: string;
    gasPrice?: string;
    maxFeePerGas?: string;
    maxPriorityFeePerGas?: string;
    value?: string;
}

/**
 * 统一返回结果
 */
export interface ContractCallResult {
    success: boolean;           // 是否成功
    result?: any;              // 返回结果
    error?: string;            // 错误信息
    transactionHash?: string;  // 交易哈希
    gasUsed?: string;          // Gas 消耗
}

// src/contract/provider.ts

import { environment } from '../config/environment';
import { ethers } from 'ethers';

export class ProviderManager {
    // 使用 Map 缓存 Provider 和 Signer
    private providers: Map<string, ethers.JsonRpcProvider> = new Map();
    private signers: Map<string, ethers.Wallet> = new Map();

    private defaultTimeout = 30000;        // 30 秒
    private defaultPollingInterval = 4000; // 4 秒

    constructor(
        private privateKey?: string,
        private timeout: number = 30000,
        private pollingInterval: number = 4000
    ) {
        this.defaultTimeout = timeout;
        this.defaultPollingInterval = pollingInterval;
    }

    /**
     * 获取 Provider（带缓存）
     */
    getProvider(networkName: string): ethers.JsonRpcProvider {
        if (!this.providers.has(networkName)) {
            const network = environment.networks[networkName];
            if (!network) {
                throw new Error(`Network ${networkName} not found`);
            }

            // 方法1: 构造函数配置
            const provider = new ethers.JsonRpcProvider(
                network.rpc,
                undefined,
                {
                    staticNetwork: true,
                    pollingInterval: this.defaultPollingInterval,
                    cacheTimeout: this.defaultTimeout
                }
            );

            // 方法2: 全局超时配置
            provider._getConnection().timeout = this.defaultTimeout;

            // 方法3: 轮询间隔配置
            provider.pollingInterval = this.defaultPollingInterval;

            this.providers.set(networkName, provider);
        }

        return this.providers.get(networkName)!;
    }

    /**
     * 获取 Signer（带缓存）
     */
    getSigner(networkName: string): ethers.Wallet {
        if (!this.privateKey) {
            throw new Error('Private key not provided');
        }

        if (!this.signers.has(networkName)) {
            const provider = this.getProvider(networkName);
            const signer = new ethers.Wallet(this.privateKey, provider);
            this.signers.set(networkName, signer);
        }

        return this.signers.get(networkName)!;
    }

    /**
     * 获取网络信息（带重试）
     */
    async getNetworkInfo(networkName: string, retries: number = 3): Promise<any> {
        const provider = this.getProvider(networkName);

        for (let attempt = 1; attempt <= retries; attempt++) {
            try {
                // 使用 Promise.race 实现超时控制
                const networkPromise = Promise.race([
                    provider.getNetwork(),
                    this.timeoutPromise(this.defaultTimeout, 'Network info request timed out')
                ]);

                const blockNumberPromise = Promise.race([
                    provider.getBlockNumber(),
                    this.timeoutPromise(this.defaultTimeout, 'Block number request timed out')
                ]);

                const gasPricePromise = Promise.race([
                    provider.getFeeData(),
                    this.timeoutPromise(this.defaultTimeout, 'Gas price request timed out')
                ]);

                // 并行请求，提高效率
                const [network, blockNumber, gasPrice] = await Promise.all([
                    networkPromise,
                    blockNumberPromise,
                    gasPricePromise
                ]);

                return {
                    name: network.name,
                    chainId: network.chainId,
                    blockNumber,
                    gasPrice: gasPrice.gasPrice?.toString(),
                    maxFeePerGas: gasPrice.maxFeePerGas?.toString(),
                    maxPriorityFeePerGas: gasPrice.maxPriorityFeePerGas?.toString()
                };
            } catch (error) {
                console.warn(`Attempt ${attempt} failed:`, error);

                if (attempt === retries) {
                    throw new Error(`Failed to get network info after ${retries} attempts: ${error}`);
                }

                // 指数退避：1s, 2s, 3s...
                await new Promise(resolve => setTimeout(resolve, attempt * 1000));
            }
        }
    }

    /**
     * 获取地址余额（带重试）
     */
    async getBalance(address: string, networkName: string, retries: number = 3): Promise<string> {
        const provider = this.getProvider(networkName);

        for (let attempt = 1; attempt <= retries; attempt++) {
            try {
                const balancePromise = Promise.race([
                    provider.getBalance(address),
                    this.timeoutPromise(this.defaultTimeout, 'Balance request timed out')
                ]);

                const balance = await balancePromise;
                return ethers.formatEther(balance);
            } catch (error) {
                console.warn(`Balance request attempt ${attempt} failed:`, error);

                if (attempt === retries) {
                    throw new Error(`Failed to get balance after ${retries} attempts: ${error}`);
                }

                await new Promise(resolve => setTimeout(resolve, attempt * 1000));
            }
        }

        throw new Error('This should never be reached');
    }

    /**
     * 超时 Promise 辅助方法
     */
    private timeoutPromise(ms: number, message: string): Promise<never> {
        return new Promise((_, reject) => {
            setTimeout(() => reject(new Error(message)), ms);
        });
    }
}

private providers: Map<string, ethers.JsonRpcProvider> = new Map();

// 检查缓存，避免重复创建
if (!this.providers.has(networkName)) {
    // 创建并缓存
    this.providers.set(networkName, provider);
}

// 方法1: 构造函数配置
const provider = new ethers.JsonRpcProvider(rpc, undefined, {
    cacheTimeout: 30000
});

// 方法2: 全局配置
provider._getConnection().timeout = 30000;

// 方法3: Promise.race 实现精确超时
Promise.race([
    provider.getNetwork(),
    this.timeoutPromise(30000, 'Timeout')
]);

for (let attempt = 1; attempt <= retries; attempt++) {
    try {
        return await operation();
    } catch (error) {
        if (attempt === retries) throw error;
        
        // 等待时间随重试次数增加：1s, 2s, 3s...
        await new Promise(resolve => setTimeout(resolve, attempt * 1000));
    }
}

// src/contract/service.ts

import { ethers } from 'ethers';
import { ProviderManager } from './provider';
import { ContractConfig, ContractCallResult, TransactionOptions } from './type';

export class ContractService {
    private contracts: Map<string, ethers.Contract> = new Map();
    
    constructor(private providerManager: ProviderManager) {}

    /**
     * 获取合约实例（带缓存）
     * @param withSigner - 是否需要 Signer（写入操作需要）
     */
    getContract(
        contractConfig: ContractConfig,
        networkName: string,
        withSigner: boolean = false
    ): ethers.Contract {
        // 使用组合键：地址_网络_是否签名
        const key = `${contractConfig.address}_${networkName}_${withSigner}`;
        
        if (!this.contracts.has(key)) {
            let providerOrSigner;

            if (withSigner) {
                providerOrSigner = this.providerManager.getSigner(networkName);
            } else {
                providerOrSigner = this.providerManager.getProvider(networkName);
            }

            const contract = new ethers.Contract(
                contractConfig.address,
                contractConfig.abi,
                providerOrSigner
            );

            this.contracts.set(key, contract);
        }

        return this.contracts.get(key)!;
    }

    /**
     * 调用只读函数
     */
    async callReadFunction(
        contractConfig: ContractConfig,
        networkName: string,
        functionName: string,
        params: any[] = []
    ): Promise<ContractCallResult> {
        try {
            const contract = this.getContract(contractConfig, networkName, false);
            const result = await contract[functionName](...params);

            return {
                success: true,
                result: result
            };
        } catch (error) {
            return {
                success: false,
                error: error instanceof Error ? error.message : 'Unknown error'
            };
        }
    }

    /**
     * 调用写入函数
     */
    async callWriteFunction(
        contractConfig: ContractConfig,
        networkName: string,
        functionName: string,
        params: any[] = [],
        options: TransactionOptions = {}
    ): Promise<ContractCallResult> {
        try {
            const contract = this.getContract(contractConfig, networkName, true);

            // 构建交易选项
            const txOptions: any = {};
            if (options.gasLimit) txOptions.gasLimit = options.gasLimit;
            if (options.gasPrice) txOptions.gasPrice = options.gasPrice;
            if (options.maxFeePerGas) txOptions.maxFeePerGas = options.maxFeePerGas;
            if (options.maxPriorityFeePerGas) txOptions.maxPriorityFeePerGas = options.maxPriorityFeePerGas;
            if (options.value) txOptions.value = options.value;

            // 🔥 自动 Gas 估算（带降级）
            let estimatedGas: bigint;
            try {
                estimatedGas = await contract[functionName].estimateGas(...params, txOptions);
                console.log(`Estimated gas: ${estimatedGas.toString()}`);
            } catch (error) {
                // 估算失败，使用默认值
                estimatedGas = BigInt(500_000);
                console.warn('Gas estimation failed, using default:', estimatedGas);
            }

            // 发送交易
            const tx = await contract[functionName](...params, {
                ...txOptions,
                gasLimit: txOptions.gasLimit || estimatedGas
            });

            console.log(`Transaction sent: ${tx.hash}`);
            console.log(`Network: ${networkName}`);
            console.log(`Contract: ${contractConfig.address}`);

            // 等待确认
            const receipt = await tx.wait();
            console.log(`Confirmed in block: ${receipt.blockNumber}`);

            return {
                success: true,
                result: receipt,
                transactionHash: tx.hash,
                gasUsed: receipt.gasUsed.toString()
            };
        } catch (error) {
            return {
                success: false,
                error: error instanceof Error ? error.message : 'Unknown error'
            };
        }
    }

    /**
     * 查询区块时间戳
     */
    async getBlockTimestamp(
        networkName: string,
        blockNumber?: number | string
    ): Promise<ContractCallResult> {
        try {
            const provider = this.providerManager.getProvider(networkName);
            const blockTag = blockNumber || 0;
            const block = await provider.getBlock(blockTag);

            if (!block) {
                return {
                    success: false,
                    error: `Block ${blockTag} not found`
                };
            }

            const result = {
                blockNumber: block.number,
                timestamp: block.timestamp,
                hash: block.hash,
                date: new Date(block.timestamp * 1000).toISOString()
            };

            return {
                success: true,
                result: result
            };
        } catch (error) {
            return {
                success: false,
                error: error instanceof Error ? error.message : 'Unknown error'
            };
        }
    }
}

const key = `${contractConfig.address}_${networkName}_${withSigner}`;

try {
    estimatedGas = await contract.estimateGas(...params);
} catch (error) {
    // 降级方案：使用合理的默认值
    estimatedGas = BigInt(500_000);
}

console.log(`Transaction sent: ${tx.hash}`);
console.log(`Network: ${networkName}`);
console.log(`Contract: ${contractConfig.address}`);
console.log(`Confirmed in block: ${receipt.blockNumber}`);

// src/contract/index.ts

import { environment } from "../config/environment";
import { ProviderManager } from "./provider";
import { ContractService } from "./service";
import erc20Abi from "../abis/erc20.json";
import tokenSaleAbi from "../abis/tokenSale.json";
import { ContractCallResult } from "./type";

export class ContractManager {
    private contractService: ContractService;
    private providerManager: ProviderManager;

    constructor() {
        this.providerManager = new ProviderManager(environment.privateKey);
        this.contractService = new ContractService(this.providerManager);
    }

    /**
     * 查询 ERC20 代币余额
     */
    async getTokenBalance(
        networkName: string,
        tokenAddress: string,
        accountAddress: string
    ): Promise<ContractCallResult> {
        const contractConfig = {
            address: tokenAddress,
            abi: erc20Abi
        };

        return await this.contractService.callReadFunction(
            contractConfig,
            networkName,
            "balanceOf",
            [accountAddress]
        );
    }

    /**
     * 查询代币总供应量
     */
    async getTotalSupply(
        networkName: string,
        tokenAddress: string
    ): Promise<ContractCallResult> {
        const contractConfig = {
            address: tokenAddress,
            abi: erc20Abi
        };

        return await this.contractService.callReadFunction(
            contractConfig,
            networkName,
            "totalSupply"
        );
    }

    /**
     * 授权代币（复合调用示例）
     */
    async approveToken(
        networkName: string,
        tokenAddress: string,
        spenderAddress: string,
        amount: string
    ): Promise<ContractCallResult> {
        const contractConfig = {
            address: tokenAddress,
            abi: erc20Abi
        };

        // 步骤1: 检查当前授权额度
        const allowanceResult = await this.contractService.callReadFunction(
            contractConfig,
            networkName,
            "allowance",
            [environment.walletAddress, spenderAddress]
        );

        if (!allowanceResult.success) {
            return allowanceResult;
        }

        // 步骤2: 如果授权额度不足，进行授权
        if (BigInt(allowanceResult.result) < BigInt(amount)) {
            return await this.contractService.callWriteFunction(
                contractConfig,
                networkName,
                "approve",
                [spenderAddress, amount]
            );
        }

        return {
            success: true,
            result: "Already approved"
        };
    }

    /**
     * 转账代币
     */
    async transferToken(
        networkName: string,
        tokenAddress: string,
        toAddress: string,
        amount: string
    ): Promise<ContractCallResult> {
        const contractConfig = {
            address: tokenAddress,
            abi: erc20Abi
        };

        return await this.contractService.callWriteFunction(
            contractConfig,
            networkName,
            "transfer",
            [toAddress, amount]
        );
    }

    /**
     * 检查合约是否暂停
     */
    async isPaused(
        networkName: string,
        contractAddress: string,
        abi: any[]
    ): Promise<ContractCallResult> {
        const contractConfig = {
            address: contractAddress,
            abi: abi
        };

        return await this.contractService.callReadFunction(
            contractConfig,
            networkName,
            "paused"
        );
    }

    /**
     * 查询区块时间戳
     */
    async getBlockTimestamp(
        networkName: string,
        blockNumber: number
    ): Promise<number> {
        try {
            const res = await this.contractService.getBlockTimestamp(
                networkName,
                blockNumber
            );
            return res.result?.timestamp ?? 0;
        } catch (error) {
            console.error(`getBlockTimestamp error: ${error}`);
            return 0;
        }
    }
}

async approveToken(networkName, tokenAddress, spenderAddress, amount) {
    // 步骤1: 检查当前授权额度
    const allowanceResult = await this.callReadFunction(..., "allowance", [...]);
    
    // 步骤2: 如果授权额度不足，进行授权
    if (BigInt(allowanceResult.result) < BigInt(amount)) {
        return await this.callWriteFunction(..., "approve", [spenderAddress, amount]);
    }
    
    return { success: true, result: "Already approved" };
}

// ❌ 不好的命名
async call(contract, method) { ... }
async query(address, func) { ... }

// ✅ 好的命名
async getTokenBalance() { ... }
async transferToken() { ... }
async isPaused() { ... }

try {
    const res = await this.contractService.getBlockTimestamp(...);
    return res.result?.timestamp ?? 0;
} catch (error) {
    console.error(`getBlockTimestamp error: ${error}`);
    return 0; // 返回默认值，保证程序继续运行
}

private providers: Map<string, ethers.JsonRpcProvider> = new Map();

getProvider(networkName: string): ethers.JsonRpcProvider {
    if (!this.providers.has(networkName)) {
        this.providers.set(networkName, new ethers.JsonRpcProvider(...));
    }
    return this.providers.get(networkName)!;
}

getContract(config: ContractConfig, network: string, withSigner: boolean): Contract {
    const key = `${config.address}_${network}_${withSigner}`;
    
    if (!this.contracts.has(key)) {
        const providerOrSigner = withSigner 
            ? this.providerManager.getSigner(network)
            : this.providerManager.getProvider(network);
        
        this.contracts.set(key, new ethers.Contract(
            config.address,
            config.abi,
            providerOrSigner
        ));
    }
    
    return this.contracts.get(key)!;
}

// 策略1: 只读操作（使用 Provider）
async callReadFunction(...) {
    const contract = this.getContract(config, network, false); // Provider
    return await contract[functionName](...params);
}

// 策略2: 写入操作（使用 Signer）
async callWriteFunction(...) {
    const contract = this.getContract(config, network, true); // Signer
    return await contract[functionName](...params);
}

export class ContractCall {
    // 隐藏复杂的底层调用
    async getLatestPricerInfo(networkName: string, contractAddress: string) {
        // 内部处理多步骤调用
        const priceIdRes = await this.getLatestPriceID(...);
        return await this.contractService.callReadFunction(...);
    }
}

// Provider 层
private providers: Map<string, ethers.JsonRpcProvider> = new Map();

// Service 层
private contracts: Map<string, ethers.Contract> = new Map();

interface ContractCallResult {
    success: boolean;
    result?: any;
    error?: string;
}

// 使用示例
const result = await contractCall.getVaultPrice(network, address);
if (result.success) {
    console.log('Price:', result.result);
} else {
    console.error('Error:', result.error);
}

try {
    estimatedGas = await contract.estimateGas(...);
} catch (error) {
    // 降级：使用默认值
    estimatedGas = BigInt(500_000);
}

const [network, blockNumber, gasPrice] = await Promise.all([
    provider.getNetwork(),
    provider.getBlockNumber(),
    provider.getFeeData()
]);

private providers: Map<string, Provider> = new Map();
private signers: Map<string, Signer> = new Map();
private contracts: Map<string, Contract> = new Map();

console.log(`Transaction sent: ${tx.hash}`);
console.log(`Confirmed in block: ${receipt.blockNumber}`);
console.error(`Error: ${error.message}`);

constructor(
    private privateKey?: string,
    private timeout: number = 30000,
    private pollingInterval: number = 4000
) { }

async callWriteFunction(
    contractConfig: ContractConfig,
    networkName: string,
    functionName: string,
    params: any[] = [],
    options: TransactionOptions = {}  // 可选配置
) { }

interface ContractConfig {
    address: string;
    abi: any[];
    bytecode?: string;
}

private providers: Map<string, ethers.JsonRpcProvider> = new Map();

import { ContractManager } from './contract';
import { ethers } from 'ethers';

class TokenTransfer {
    private contractManager: ContractManager;

    constructor() {
        this.contractManager = new ContractManager();
    }

    async batchTransfer(recipients: string[], amounts: string[]) {
        const network = 'mainnet';
        const tokenAddress = '0x...'; // 你的代币地址

        console.log('Starting batch transfer...');

        for (let i = 0; i < recipients.length; i++) {
            // 步骤1: 查询余额
            const balanceResult = await this.contractManager.getTokenBalance(
                network,
                tokenAddress,
                recipients[i]
            );

            console.log(`Recipient ${i + 1} balance:`, 
                ethers.formatEther(balanceResult.result || 0)
            );

            // 步骤2: 转账
            const transferResult = await this.contractManager.transferToken(
                network,
                tokenAddress,
                recipients[i],
                amounts[i]
            );

            if (transferResult.success) {
                console.log(`✅ Transfer ${i + 1} successful!`);
                console.log(`   TX: ${transferResult.transactionHash}`);
                console.log(`   Gas: ${transferResult.gasUsed}`);
            } else {
                console.error(`❌ Transfer ${i + 1} failed:`, transferResult.error);
            }

            // 等待1秒，避免 nonce 冲突
            await new Promise(resolve => setTimeout(resolve, 1000));
        }
    }
}

// 使用示例
const transfer = new TokenTransfer();
transfer.batchTransfer(
    ['0xRecipient1...', '0xRecipient2...'],
    [ethers.parseEther('10').toString(), ethers.parseEther('20').toString()]
);

async function checkMultiChainBalance(address: string) {
    const contractManager = new ContractManager();
    const tokenAddress = '0x...'; // USDT/USDC 等跨链代币地址

    const networks = ['mainnet', 'polygon', 'bsc', 'arbitrum'];

    // 并行查询所有链上的余额
    const results = await Promise.all(
        networks.map(network =>
            contractManager.getTokenBalance(network, tokenAddress, address)
        )
    );

    console.log('\n=== Multi-Chain Balance ===');
    
    let totalBalance = 0n;
    
    results.forEach((result, index) => {
        const network = networks[index];
        if (result.success) {
            const balance = result.result;
            totalBalance += BigInt(balance);
            console.log(`${network.padEnd(10)}: ${ethers.formatEther(balance)} tokens`);
        } else {
            console.log(`${network.padEnd(10)}: Failed - ${result.error}`);
        }
    });

    console.log(`${'TOTAL'.padEnd(10)}: ${ethers.formatEther(totalBalance)} tokens`);
    console.log('===========================\n');
}

// 使用示例
checkMultiChainBalance('0xYourAddress...');

import { ContractManager } from './contract';
import tokenSaleAbi from './abis/tokenSale.json';

class TokenSaleBot {
    private contractManager: ContractManager;
    private saleAddress: string;

    constructor(saleAddress: string) {
        this.contractManager = new ContractManager();
        this.saleAddress = saleAddress;
    }

    async participateInSale(tokenAddress: string, amount: string) {
        const network = 'mainnet';

        // 步骤1: 检查 Sale 是否暂停
        const pausedResult = await this.contractManager.isPaused(
            network,
            this.saleAddress,
            tokenSaleAbi
        );

        if (pausedResult.result) {
            console.log('❌ Token sale is paused');
            return;
        }

        // 步骤2: 授权代币
        console.log('📝 Approving tokens...');
        const approveResult = await this.contractManager.approveToken(
            network,
            tokenAddress,
            this.saleAddress,
            amount
        );

        if (!approveResult.success) {
            console.error('❌ Approval failed:', approveResult.error);
            return;
        }

        console.log('✅ Tokens approved');

        // 步骤3: 购买代币
        console.log('💰 Purchasing tokens...');
        const buyResult = await this.contractManager.contractService.callWriteFunction(
            { address: this.saleAddress, abi: tokenSaleAbi },
            network,
            'buyTokens',
            [amount]
        );

        if (buyResult.success) {
            console.log('✅ Purchase successful!');
            console.log(`   TX: ${buyResult.transactionHash}`);
            console.log(`   Gas: ${buyResult.gasUsed}`);
        } else {
            console.error('❌ Purchase failed:', buyResult.error);
        }
    }
}

// 使用示例
const bot = new TokenSaleBot('0xSaleContract...');
bot.participateInSale(
    '0xUSDTAddress...',
    ethers.parseUnits('1000', 6).toString() // 1000 USDT
);