@moonwell-fi/moonwell-sdk/_esm/environments/types/config.js

TypeScript Interface for Moonwell

import { createPublicClient, getContract, } from "viem";
import { ChainLinkOracleAbi, ComptrollerTokenAbi, CoreRouterAbi, CoreViewsAbi, GovernanceTokenAbi, GovernorAbi, MarketTokenAbi, MaximillionAbi, MorphoBlueAbi, MorphoBundlerAbi, MorphoPublicAllocatorAbi, MorphoVaultAbi, MorphoViewsAbi, MultiRewardDistributorAbi, MultichainGovernorAbi, StakingTokenAbi, TemporalGovernorAbi, TokenAbi, VoteCollectorAbi, WrappedNativeTokenAbi, } from "../abis/index.js";
export const createTokenConfig = (tokens) => tokens;
export const createVaultConfig = (config) => config.vaults;
export const createMarketConfig = (config) => config.markets;
export const createMorphoMarketConfig = (config) => config.markets;
export const createContractsConfig = (config) => {
    return config.contracts;
};
export const createCustomConfig = (custom) => {
    return custom;
};
export const createEnvironmentConfig = (config) => {
    const publicClient = createPublicClient({
        chain: config.chain,
        batch: {
            multicall: {
                wait: 100,
            },
        },
        cacheTime: 5_000,
        transport: config.transport,
    });
    const createContract = (address, abi) => {
        return getContract({
            address,
            abi,
            client: publicClient,
        });
    };
    const getTokenContract = (key, abi) => {
        if (key) {
            const token = config.tokens[key];
            return getContract({
                address: token.address,
                abi,
                client: publicClient,
            });
        }
        else {
            return undefined;
        }
    };
    const tokenContracts = Object.keys(config.tokens).reduce((prev, curr) => {
        return {
            ...prev,
            [curr]: getTokenContract(curr, TokenAbi),
        };
    }, {});
    const marketContracts = Object.keys(config.markets).reduce((prev, curr) => {
        const market = config.markets[curr];
        return {
            ...prev,
            [curr]: getTokenContract(market.marketToken, MarketTokenAbi),
        };
    }, {});
    const vaultsContracts = Object.keys(config.vaults || {}).reduce((prev, curr) => {
        return {
            ...prev,
            [curr]: getTokenContract(curr, MorphoVaultAbi),
        };
    }, {});
    const contracts = Object.keys(config.contracts).reduce((prev, curr) => {
        const key = curr;
        let contractAddress = config.contracts[key];
        let abi = TokenAbi;
        switch (key) {
            case "comptroller":
                abi = ComptrollerTokenAbi;
                break;
            case "maximillion":
                abi = MaximillionAbi;
                break;
            case "views":
                abi = CoreViewsAbi;
                break;
            case "morphoViews":
                abi = MorphoViewsAbi;
                break;
            case "multiRewardDistributor":
                abi = MultiRewardDistributorAbi;
                break;
            case "temporalGovernor":
                abi = TemporalGovernorAbi;
                break;
            case "voteCollector":
                abi = VoteCollectorAbi;
                break;
            case "governor":
                abi = GovernorAbi;
                break;
            case "multichainGovernor":
                abi = MultichainGovernorAbi;
                break;
            case "oracle":
                abi = ChainLinkOracleAbi;
                break;
            case "router":
                abi = CoreRouterAbi;
                break;
            case "morphoBlue":
                abi = MorphoBlueAbi;
                break;
            case "morphoBundler":
                abi = MorphoBundlerAbi;
                break;
            case "morphoPublicAllocator":
                abi = MorphoPublicAllocatorAbi;
                break;
            case "stakingToken":
                contractAddress = config.tokens[contractAddress].address;
                abi = StakingTokenAbi;
                break;
            case "governanceToken":
                contractAddress = config.tokens[contractAddress].address;
                abi = GovernanceTokenAbi;
                break;
            case "wrappedNativeToken":
                contractAddress = config.tokens[contractAddress].address;
                abi = WrappedNativeTokenAbi;
                break;
        }
        return {
            ...prev,
            [curr]: createContract(contractAddress, abi),
        };
    }, {});
    return {
        key: config.key,
        name: config.name,
        chainId: config.chain.id,
        chain: config.chain,
        indexerUrl: config.indexerUrl,
        governanceIndexerUrl: config.governanceIndexerUrl,
        tokens: tokenContracts,
        markets: marketContracts,
        vaults: vaultsContracts,
        contracts: contracts,
        custom: config.custom,
        config: {
            tokens: config.tokens,
            vaults: config.vaults,
            markets: config.markets,
            morphoMarkets: config.morphoMarkets,
            contracts: config.contracts,
        },
        publicClient,
    };
};
//# sourceMappingURL=config.js.map