@intuweb3/sdk/utils/reliable-provider.js

INTU SDK - Modern blockchain interaction toolkit

import { ethers } from "ethers";
import { getProviderForChain, getRpcUrl } from "../tools/chainList.js";
class ReliableProviderManager {
    static instance;
    config = {};
    providerCache = new Map();
    constructor() { }
    static getInstance() {
        if (!ReliableProviderManager.instance) {
            ReliableProviderManager.instance = new ReliableProviderManager();
        }
        return ReliableProviderManager.instance;
    }
    configure(config) {
        this.config = { ...this.config, ...config };
    }
    async getReliableProvider(chainId, signer) {
        const chainIdStr = chainId.toString();
        const cacheKey = `${chainIdStr}_reliable`;
        if (this.providerCache.has(cacheKey)) {
            return this.providerCache.get(cacheKey);
        }
        let provider;
        try {
            if (this.config.preferCustomRpc !== false &&
                this.config.customRpcEndpoints?.[chainIdStr]) {
                provider = new ethers.providers.JsonRpcProvider(this.config.customRpcEndpoints[chainIdStr], {
                    name: this.getNetworkName(chainIdStr),
                    chainId: parseInt(chainIdStr),
                });
            }
            else {
                provider = getProviderForChain(chainId);
            }
            await provider.getNetwork();
            this.providerCache.set(cacheKey, provider);
            return provider;
        }
        catch (error) {
            if (this.config.allowMetaMaskFallback !== false && signer?.provider) {
                return signer.provider;
            }
            if (this.config.preferCustomRpc === false &&
                this.config.customRpcEndpoints?.[chainIdStr]) {
                try {
                    provider = new ethers.providers.JsonRpcProvider(this.config.customRpcEndpoints[chainIdStr]);
                    this.providerCache.set(cacheKey, provider);
                    return provider;
                }
                catch (fallbackError) {
                }
            }
            throw new Error(`Unable to get reliable provider for chain ${chainIdStr}`);
        }
    }
    async getProviderForChainWithCustomRpc(chainId, customRpcUrl, signer) {
        if (customRpcUrl) {
            try {
                const provider = new ethers.providers.JsonRpcProvider(customRpcUrl);
                await provider.getNetwork();
                return provider;
            }
            catch (error) {
            }
        }
        return this.getReliableProvider(chainId, signer);
    }
    getNetworkName(chainId) {
        const chainIdNum = parseInt(chainId);
        switch (chainIdNum) {
            case 1:
                return "homestead";
            case 3:
                return "ropsten";
            case 4:
                return "rinkeby";
            case 5:
                return "goerli";
            case 10:
                return "optimism";
            case 42:
                return "kovan";
            case 56:
                return "bsc";
            case 97:
                return "bsc-testnet";
            case 137:
                return "matic";
            case 250:
                return "fantom";
            case 42161:
                return "arbitrum";
            case 421614:
                return "arbitrum-sepolia";
            case 43114:
                return "avalanche";
            case 80001:
                return "matic-mumbai";
            default:
                return `chain-${chainId}`;
        }
    }
    isMetaMaskProvider(provider) {
        const providerStr = provider.connection?.url || "";
        if (providerStr.startsWith("https://")) {
            return false;
        }
        return true;
    }
    async getBestProvider(chainId, signer) {
        if (signer?.provider) {
            const signerProvider = signer.provider;
            if (this.isMetaMaskProvider(signerProvider)) {
                const reliableProvider = await this.getReliableProvider(chainId, signer);
                return reliableProvider;
            }
            else {
                const rpcUrl = signerProvider.connection?.url || "unknown";
                console.log(`🔗 [SDK] Using signer provider (non-MetaMask) for chain ${chainId}: ${rpcUrl}`);
                return signerProvider;
            }
        }
        const reliableProvider = await this.getReliableProvider(chainId, signer);
        const rpcUrl = reliableProvider.connection?.url || "unknown";
        console.log(`🔗 [SDK] Using reliable provider for chain ${chainId}: ${rpcUrl}`);
        return reliableProvider;
    }
    clearCache() {
        this.providerCache.clear();
    }
    getRpcUrl(chainId) {
        const chainIdStr = chainId.toString();
        if (this.config.customRpcEndpoints?.[chainIdStr]) {
            return this.config.customRpcEndpoints[chainIdStr];
        }
        return getRpcUrl(chainId);
    }
}
export const reliableProviderManager = ReliableProviderManager.getInstance();
export async function getReliableProvider(chainId, signer) {
    return reliableProviderManager.getReliableProvider(chainId, signer);
}
export async function getBestProvider(chainId, signer) {
    return reliableProviderManager.getBestProvider(chainId, signer);
}
export async function getProviderWithCustomRpc(chainId, customRpcUrl, signer) {
    return reliableProviderManager.getProviderForChainWithCustomRpc(chainId, customRpcUrl, signer);
}
export function configureProviderManager(config) {
    reliableProviderManager.configure(config);
}
export function getRpcUrlWithCustomSupport(chainId) {
    return reliableProviderManager.getRpcUrl(chainId);
}
//# sourceMappingURL=reliable-provider.js.map