@hyperlane-xyz/sdk/dist/providers/MinimalProviderRegistry.js

The official SDK for the Hyperlane Network

import { ProtocolType, pick, rootLogger } from '@hyperlane-xyz/utils';
import { ChainMetadataManager } from '../metadata/ChainMetadataManager.js';
import { PROTOCOL_TO_DEFAULT_PROVIDER_TYPE, ProviderType, } from './ProviderType.js';
// Lightweight provider registry for metadata-backed reads. It owns typed
// provider instances/builders, but intentionally does not carry the legacy
// MultiProvider bridge behavior layered on top by derived classes.
export class MinimalProviderRegistry extends ChainMetadataManager {
    options;
    providers;
    providerBuilders;
    logger;
    constructor(chainMetadata, options = {}) {
        super(chainMetadata, options);
        this.options = options;
        const loggerModule = new.target?.name || 'MinimalProviderRegistry';
        this.logger =
            options.logger ||
                rootLogger.child({
                    module: loggerModule,
                });
        this.providers = options.providers ?? {};
        this.providerBuilders = options.providerBuilders ?? {};
    }
    extendChainMetadata(additionalMetadata) {
        const newMetadata = super.extendChainMetadata(additionalMetadata).metadata;
        return new MinimalProviderRegistry(newMetadata, {
            ...this.options,
            providers: this.providers,
            providerBuilders: this.providerBuilders,
        });
    }
    getProviderBuilder(_protocol, type) {
        return this.providerBuilders[type];
    }
    tryGetProvider(chainNameOrId, type) {
        const metadata = this.tryGetChainMetadata(chainNameOrId);
        if (!metadata)
            return null;
        const { protocol, name, chainId, rpcUrls } = metadata;
        if (protocol === ProtocolType.Unknown)
            return null;
        type = type || PROTOCOL_TO_DEFAULT_PROVIDER_TYPE[protocol];
        if (!type)
            return null;
        if (this.providers[name]?.[type])
            return this.providers[name][type];
        const builder = this.getProviderBuilder(protocol, type);
        if (!rpcUrls.length || !builder)
            return null;
        const provider = builder(rpcUrls, chainId);
        this.providers[name] ||= {};
        this.providers[name][type] = provider;
        return provider;
    }
    getProvider(chainNameOrId, type) {
        const provider = this.tryGetProvider(chainNameOrId, type);
        if (!provider)
            throw new Error(`No provider available for ${chainNameOrId}`);
        return provider;
    }
    getSpecificProvider(chainNameOrId, type) {
        const provider = this.getProvider(chainNameOrId, type);
        if (provider.type !== type)
            throw new Error(`Invalid provider type, expected ${type} but found ${provider.type}`);
        // CAST: provider.type is checked against `type` immediately above, so the
        // wrapped provider payload matches the requested generic T.
        return provider.provider;
    }
    getEthersV5Provider(chainNameOrId) {
        return this.getSpecificProvider(chainNameOrId, ProviderType.EthersV5);
    }
    getViemProvider(chainNameOrId) {
        return this.getSpecificProvider(chainNameOrId, ProviderType.Viem);
    }
    getSolanaWeb3Provider(chainNameOrId) {
        return this.getSpecificProvider(chainNameOrId, ProviderType.SolanaWeb3);
    }
    getCosmJsProvider(chainNameOrId) {
        return this.getSpecificProvider(chainNameOrId, ProviderType.CosmJs);
    }
    getCosmJsWasmProvider(chainNameOrId) {
        return this.getSpecificProvider(chainNameOrId, ProviderType.CosmJsWasm);
    }
    getCosmJsNativeProvider(chainNameOrId) {
        return this.getSpecificProvider(chainNameOrId, ProviderType.CosmJsNative);
    }
    getStarknetProvider(chainNameOrId) {
        return this.getSpecificProvider(chainNameOrId, ProviderType.Starknet);
    }
    getRadixProvider(chainNameOrId) {
        return this.getSpecificProvider(chainNameOrId, ProviderType.Radix);
    }
    getAleoProvider(chainNameOrId) {
        return this.getSpecificProvider(chainNameOrId, ProviderType.Aleo);
    }
    getTronProvider(chainNameOrId) {
        return this.getSpecificProvider(chainNameOrId, ProviderType.Tron);
    }
    setProvider(chainNameOrId, provider) {
        const chainName = this.getChainName(chainNameOrId);
        this.providers[chainName] ||= {};
        this.providers[chainName][provider.type] = provider;
        return provider;
    }
    setProviders(providers) {
        for (const chain of Object.keys(providers)) {
            this.setProvider(chain, providers[chain]);
        }
    }
    intersect(chains, throwIfNotSubset = false) {
        const { intersection, result } = super.intersect(chains, throwIfNotSubset);
        return {
            intersection,
            result: new MinimalProviderRegistry(result.metadata, {
                ...this.options,
                providers: pick(this.providers, intersection),
                providerBuilders: this.providerBuilders,
            }),
        };
    }
}
//# sourceMappingURL=MinimalProviderRegistry.js.map