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

The official SDK for the Hyperlane Network

import { ProtocolType, pick } from '@hyperlane-xyz/utils';
import { multiProtocolTestChainMetadata } from '../consts/testChains.js';
import { createAdapterFromMultiProvider, MultiProviderAdapter, } from './MultiProviderAdapter.js';
import { ProviderType } from './ProviderType.js';
import { defaultTronEthersProviderBuilder } from './providerBuilders.js';
import { defaultProviderBuilderMap } from './defaultProviderBuilderMaps.js';
export class MultiProtocolProvider extends MultiProviderAdapter {
    static fromMultiProvider(mp, options = {}) {
        return createAdapterFromMultiProvider(MultiProtocolProvider, mp, options);
    }
    constructor(chainMetadata, options = {}) {
        super(chainMetadata, {
            ...options,
            providerBuilders: {
                ...defaultProviderBuilderMap,
                ...options.providerBuilders,
            },
        });
    }
    getProviderBuilder(protocol, type) {
        if (protocol === ProtocolType.Tron && type === ProviderType.EthersV5) {
            return (urls, network) => ({
                type: ProviderType.EthersV5,
                provider: defaultTronEthersProviderBuilder(urls, network),
            });
        }
        return this.providerBuilders[type];
    }
    extendChainMetadata(additionalMetadata) {
        const newMetadata = super.extendChainMetadata(additionalMetadata).metadata;
        return new MultiProtocolProvider(newMetadata, {
            ...this.options,
            providers: this.providers,
            providerBuilders: this.providerBuilders,
        });
    }
    intersect(chains, throwIfNotSubset = false) {
        const { intersection, result } = super.intersect(chains, throwIfNotSubset);
        return {
            intersection,
            result: new MultiProtocolProvider(result.metadata, {
                ...this.options,
                providers: pick(this.providers, intersection),
                providerBuilders: this.providerBuilders,
            }),
        };
    }
    static createTestMultiProtocolProvider(metadata = multiProtocolTestChainMetadata, providers = {}) {
        // CAST: the generic overload now requires callers to supply matching
        // metadata. The shared implementation still handles the non-generic
        // default-fixture overload through the same code path.
        const mp = new MultiProtocolProvider(metadata);
        const providerMap = {};
        for (const [protocol, provider] of Object.entries(providers)) {
            const chains = Object.values(metadata).filter((m) => m.protocol === protocol);
            chains.forEach((c) => (providerMap[c.name] = provider));
        }
        mp.setProviders(providerMap);
        return mp;
    }
}
//# sourceMappingURL=MultiProtocolProvider.js.map