@metamask-previews/earn-controller 12.2.6-preview-4f4c98e → 12.2.6-preview-eb263b0ee

package/dist/EarnController.cjs

@@ -0,0 +1,778 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _EarnController_instances, _EarnController_earnSDK, _EarnController_initPromise, _EarnController_lastRefreshedAddress, _EarnController_earnApiService, _EarnController_addTransactionFn, _EarnController_supportedPooledStakingChains, _EarnController_env, _EarnController_refreshEarnPortfolio, _EarnController_initializeSDK, _EarnController_getSelectedNetworkClientId, _EarnController_getSelectedEvmAccount, _EarnController_getSelectedEvmAccountAddress, _EarnController_refreshEarnPortfolioOnAccountReady;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EarnController = exports.getDefaultEarnControllerState = exports.DEFAULT_TRON_STAKING_STATE = exports.DEFAULT_POOLED_STAKING_CHAIN_STATE = exports.DEFAULT_POOLED_STAKING_VAULT_APY_AVERAGES = exports.DEFAULT_LENDING_POSITION = exports.DEFAULT_LENDING_MARKET = exports.controllerName = void 0;
+const providers_1 = require("@ethersproject/providers");
+const base_controller_1 = require("@metamask/base-controller");
+const controller_utils_1 = require("@metamask/controller-utils");
+const keyring_api_1 = require("@metamask/keyring-api");
+const stake_sdk_1 = require("@metamask/stake-sdk");
+const transaction_controller_1 = require("@metamask/transaction-controller");
+exports.controllerName = 'EarnController';
+const stakingTransactionTypes = new Set([
+    transaction_controller_1.TransactionType.stakingDeposit,
+    transaction_controller_1.TransactionType.stakingUnstake,
+    transaction_controller_1.TransactionType.stakingClaim,
+]);
+const lendingTransactionTypes = new Set([
+    transaction_controller_1.TransactionType.lendingDeposit,
+    transaction_controller_1.TransactionType.lendingWithdraw,
+]);
+/**
+ * Metadata for the EarnController.
+ */
+const earnControllerMetadata = {
+    pooled_staking: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    lending: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    tron_staking: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    lastUpdated: {
+        includeInStateLogs: true,
+        persist: false,
+        includeInDebugSnapshot: true,
+        usedInUi: false,
+    },
+};
+// === Default State ===
+exports.DEFAULT_LENDING_MARKET = {
+    id: '',
+    chainId: 0,
+    protocol: '',
+    name: '',
+    address: '',
+    tvlUnderlying: '0',
+    netSupplyRate: 0,
+    totalSupplyRate: 0,
+    underlying: {
+        address: '',
+        chainId: 0,
+    },
+    outputToken: {
+        address: '',
+        chainId: 0,
+    },
+    rewards: [
+        {
+            token: {
+                address: '',
+                chainId: 0,
+            },
+            rate: 0,
+        },
+    ],
+};
+exports.DEFAULT_LENDING_POSITION = {
+    id: '',
+    chainId: 0,
+    assets: '0',
+    marketId: '',
+    marketAddress: '',
+    protocol: '',
+};
+exports.DEFAULT_POOLED_STAKING_VAULT_APY_AVERAGES = {
+    oneDay: '0',
+    oneWeek: '0',
+    oneMonth: '0',
+    threeMonths: '0',
+    sixMonths: '0',
+    oneYear: '0',
+};
+exports.DEFAULT_POOLED_STAKING_CHAIN_STATE = {
+    pooledStakes: {
+        account: '',
+        lifetimeRewards: '0',
+        assets: '0',
+        exitRequests: [],
+    },
+    exchangeRate: '1',
+    vaultMetadata: {
+        apy: '0',
+        capacity: '0',
+        feePercent: 0,
+        totalAssets: '0',
+        vaultAddress: '0x0000000000000000000000000000000000000000',
+    },
+    vaultDailyApys: [],
+    vaultApyAverages: exports.DEFAULT_POOLED_STAKING_VAULT_APY_AVERAGES,
+};
+exports.DEFAULT_TRON_STAKING_STATE = null;
+/**
+ * Gets the default state for the EarnController.
+ *
+ * @returns The default EarnController state.
+ */
+function getDefaultEarnControllerState() {
+    return {
+        pooled_staking: {
+            isEligible: false,
+        },
+        lending: {
+            markets: [exports.DEFAULT_LENDING_MARKET],
+            positions: [exports.DEFAULT_LENDING_POSITION],
+            isEligible: false,
+        },
+        tron_staking: exports.DEFAULT_TRON_STAKING_STATE,
+        lastUpdated: 0,
+    };
+}
+exports.getDefaultEarnControllerState = getDefaultEarnControllerState;
+// === MESSENGER ===
+const MESSENGER_EXPOSED_METHODS = [
+    'refreshPooledStakes',
+    'refreshEarnEligibility',
+    'refreshPooledStakingVaultMetadata',
+    'refreshPooledStakingVaultDailyApys',
+    'refreshPooledStakingVaultApyAverages',
+    'refreshPooledStakingData',
+    'refreshLendingMarkets',
+    'refreshLendingPositions',
+    'refreshLendingData',
+    'refreshTronStakingApy',
+    'getTronStakingApy',
+    'getLendingPositionHistory',
+    'getLendingMarketDailyApysAndAverages',
+    'executeLendingDeposit',
+    'executeLendingWithdraw',
+    'executeLendingTokenApprove',
+    'getLendingTokenAllowance',
+    'getLendingTokenMaxWithdraw',
+    'getLendingTokenMaxDeposit',
+];
+// === CONTROLLER DEFINITION ===
+/**
+ * EarnController manages DeFi earning opportunities across different protocols and chains.
+ */
+class EarnController extends base_controller_1.BaseController {
+    constructor({ messenger, state = {}, addTransactionFn, env = stake_sdk_1.EarnEnvironments.PROD, }) {
+        super({
+            name: exports.controllerName,
+            metadata: earnControllerMetadata,
+            messenger,
+            state: {
+                ...getDefaultEarnControllerState(),
+                ...state,
+            },
+        });
+        _EarnController_instances.add(this);
+        _EarnController_earnSDK.set(this, null);
+        _EarnController_initPromise.set(this, null);
+        _EarnController_lastRefreshedAddress.set(this, void 0);
+        _EarnController_earnApiService.set(this, void 0);
+        _EarnController_addTransactionFn.set(this, void 0);
+        _EarnController_supportedPooledStakingChains.set(this, void 0);
+        _EarnController_env.set(this, void 0);
+        __classPrivateFieldSet(this, _EarnController_env, env, "f");
+        __classPrivateFieldSet(this, _EarnController_earnApiService, new stake_sdk_1.EarnApiService(__classPrivateFieldGet(this, _EarnController_env, "f")), "f");
+        // temporary array of supported chains
+        // TODO: remove this once we export a supported chains list from the sdk
+        // from sdk or api to get lending and pooled staking chains
+        //
+        // Only eagerly prefetch Ethereum on startup/network-change; Hoodi
+        // (testnet) is still fully supported on-demand via explicit chainId
+        // calls (e.g. refreshPooledStakes({ chainId: ChainId.HOODI })), we just
+        // don't unconditionally fetch it for every user on every unlock.
+        __classPrivateFieldSet(this, _EarnController_supportedPooledStakingChains, [stake_sdk_1.ChainId.ETHEREUM], "f");
+        __classPrivateFieldSet(this, _EarnController_addTransactionFn, addTransactionFn, "f");
+        // Listen for network changes
+        this.messenger.subscribe('NetworkController:networkDidChange', (networkControllerState) => {
+            __classPrivateFieldGet(this, _EarnController_instances, "m", _EarnController_initializeSDK).call(this, networkControllerState.selectedNetworkClientId).catch(console.error);
+            // refresh pooled staking data
+            this.refreshPooledStakingVaultMetadata().catch(console.error);
+            this.refreshPooledStakingVaultDailyApys().catch(console.error);
+            this.refreshPooledStakingVaultApyAverages().catch(console.error);
+            this.refreshPooledStakes().catch(console.error);
+            // refresh lending data for all chains
+            this.refreshLendingMarkets().catch(console.error);
+            this.refreshLendingPositions().catch(console.error);
+        });
+        this.messenger.registerMethodActionHandlers(this, MESSENGER_EXPOSED_METHODS);
+        // Listen for account group changes
+        this.messenger.subscribe('AccountTreeController:selectedAccountGroupChange', () => {
+            const address = __classPrivateFieldGet(this, _EarnController_instances, "m", _EarnController_getSelectedEvmAccountAddress).call(this);
+            // Skip if this account group change didn't actually change the
+            // resolved address (e.g. it can fire again right after init()
+            // during startup hydration) - nothing new to fetch.
+            if (!address || address === __classPrivateFieldGet(this, _EarnController_lastRefreshedAddress, "f")) {
+                return;
+            }
+            __classPrivateFieldSet(this, _EarnController_lastRefreshedAddress, address, "f");
+            // TODO: temp solution, this will refresh lending eligibility also
+            // we could have a more general check, as what is happening is a compliance address check
+            this.refreshEarnEligibility({ address }).catch(console.error);
+            this.refreshPooledStakes({ address }).catch(console.error);
+            this.refreshLendingPositions({ address }).catch(console.error);
+        });
+        // Listen for confirmed staking transactions
+        this.messenger.subscribe('TransactionController:transactionConfirmed', (transactionMeta) => {
+            /**
+             * When we speed up a transaction, we set the type as Retry and we lose
+             * information about type of transaction that is being set up, so we use
+             * original type to track that information.
+             */
+            const { type, originalType } = transactionMeta;
+            const isStakingTransaction = stakingTransactionTypes.has(type) ||
+                stakingTransactionTypes.has(originalType);
+            const isLendingTransaction = lendingTransactionTypes.has(type) ||
+                lendingTransactionTypes.has(originalType);
+            const sender = transactionMeta.txParams.from;
+            if (isStakingTransaction) {
+                this.refreshPooledStakes({ resetCache: true, address: sender }).catch(console.error);
+            }
+            if (isLendingTransaction) {
+                this.refreshLendingPositions({ address: sender }).catch(console.error);
+            }
+        });
+    }
+    async init() {
+        if (__classPrivateFieldGet(this, _EarnController_initPromise, "f")) {
+            return __classPrivateFieldGet(this, _EarnController_initPromise, "f");
+        }
+        __classPrivateFieldSet(this, _EarnController_initPromise, (async () => {
+            await __classPrivateFieldGet(this, _EarnController_instances, "m", _EarnController_initializeSDK).call(this, __classPrivateFieldGet(this, _EarnController_instances, "m", _EarnController_getSelectedNetworkClientId).call(this));
+            const address = __classPrivateFieldGet(this, _EarnController_instances, "m", _EarnController_getSelectedEvmAccountAddress).call(this);
+            if (address) {
+                __classPrivateFieldGet(this, _EarnController_instances, "m", _EarnController_refreshEarnPortfolio).call(this, address);
+            }
+            else {
+                // Account tree state is not yet available, so we defer the refresh to when it is.
+                __classPrivateFieldGet(this, _EarnController_instances, "m", _EarnController_refreshEarnPortfolioOnAccountReady).call(this);
+            }
+        })().catch((error) => {
+            __classPrivateFieldSet(this, _EarnController_initPromise, null, "f");
+            throw error;
+        }), "f");
+        return __classPrivateFieldGet(this, _EarnController_initPromise, "f");
+    }
+    /**
+     * Refreshes the pooled stakes data for the current account.
+     * Fetches updated stake information including lifetime rewards, assets, and exit requests
+     * from the staking API service and updates the state.
+     *
+     * @param options - Optional arguments
+     * @param [options.resetCache] - Control whether the BE cache should be invalidated (optional).
+     * @param [options.address] - The address to refresh pooled stakes for (optional).
+     * @param [options.chainId] - The chain id to refresh pooled stakes for (optional).
+     * @returns A promise that resolves when the stakes data has been updated
+     */
+    async refreshPooledStakes({ resetCache = false, address, chainId = stake_sdk_1.ChainId.ETHEREUM, } = {}) {
+        const addressToUse = address ?? __classPrivateFieldGet(this, _EarnController_instances, "m", _EarnController_getSelectedEvmAccountAddress).call(this);
+        if (!addressToUse) {
+            return;
+        }
+        const chainIdToUse = (0, stake_sdk_1.isSupportedPooledStakingChain)(chainId)
+            ? chainId
+            : stake_sdk_1.ChainId.ETHEREUM;
+        const { accounts, exchangeRate } = await __classPrivateFieldGet(this, _EarnController_earnApiService, "f").pooledStaking.getPooledStakes([addressToUse], chainIdToUse, resetCache);
+        this.update((state) => {
+            const chainState = state.pooled_staking[chainIdToUse] ??
+                exports.DEFAULT_POOLED_STAKING_CHAIN_STATE;
+            state.pooled_staking[chainIdToUse] = {
+                ...chainState,
+                pooledStakes: accounts[0],
+                exchangeRate,
+            };
+        });
+    }
+    /**
+     * Refreshes the earn eligibility status for the current account.
+     * Updates the eligibility status in the controller state based on the location and address blocklist for compliance.
+     *
+     * Note: Pooled-staking and Lending used the same result since there isn't a need to split these up right now.
+     *
+     * @param options - Optional arguments
+     * @param [options.address] - Address to refresh earn eligibility for (optional).
+     * @returns A promise that resolves when the eligibility status has been updated
+     */
+    async refreshEarnEligibility({ address, } = {}) {
+        const addressToCheck = address ?? __classPrivateFieldGet(this, _EarnController_instances, "m", _EarnController_getSelectedEvmAccountAddress).call(this);
+        if (!addressToCheck) {
+            return;
+        }
+        const { eligible: isEligible } = await __classPrivateFieldGet(this, _EarnController_earnApiService, "f").pooledStaking.getPooledStakingEligibility([
+            addressToCheck,
+        ]);
+        this.update((state) => {
+            state.pooled_staking.isEligible = isEligible;
+            state.lending.isEligible = isEligible;
+        });
+    }
+    /**
+     * Refreshes pooled staking vault metadata for the current chain.
+     * Updates the vault metadata in the controller state including APY, capacity,
+     * fee percentage, total assets, and vault address.
+     *
+     * @param [chainId] - The chain id to refresh pooled staking vault metadata for (optional).
+     * @returns A promise that resolves when the vault metadata has been updated
+     */
+    async refreshPooledStakingVaultMetadata(chainId = stake_sdk_1.ChainId.ETHEREUM) {
+        const chainIdToUse = (0, stake_sdk_1.isSupportedPooledStakingChain)(chainId)
+            ? chainId
+            : stake_sdk_1.ChainId.ETHEREUM;
+        const vaultMetadata = await __classPrivateFieldGet(this, _EarnController_earnApiService, "f").pooledStaking.getVaultData(chainIdToUse);
+        this.update((state) => {
+            const chainState = state.pooled_staking[chainIdToUse] ??
+                exports.DEFAULT_POOLED_STAKING_CHAIN_STATE;
+            state.pooled_staking[chainIdToUse] = {
+                ...chainState,
+                vaultMetadata,
+            };
+        });
+    }
+    /**
+     * Refreshes pooled staking vault daily apys for the current chain.
+     * Updates the pooled staking vault daily apys controller state.
+     *
+     * @param [options] - The options for refreshing pooled staking vault daily apys.
+     * @param [options.chainId] - The chain id to refresh pooled staking vault daily apys for (defaults to Ethereum).
+     * @param [options.days] - The number of days to fetch pooled staking vault daily apys for (defaults to 365).
+     * @param [options.order] - The order in which to fetch pooled staking vault daily apys. Descending order fetches the latest N days (latest working backwards). Ascending order fetches the oldest N days (oldest working forwards) (defaults to 'desc').
+     * @returns A promise that resolves when the pooled staking vault daily apys have been updated.
+     */
+    async refreshPooledStakingVaultDailyApys({ chainId = stake_sdk_1.ChainId.ETHEREUM, days = 365, order = 'desc', } = {}) {
+        const chainIdToUse = (0, stake_sdk_1.isSupportedPooledStakingChain)(chainId)
+            ? chainId
+            : stake_sdk_1.ChainId.ETHEREUM;
+        const vaultDailyApys = await __classPrivateFieldGet(this, _EarnController_earnApiService, "f").pooledStaking.getVaultDailyApys(chainIdToUse, days, order);
+        this.update((state) => {
+            const chainState = state.pooled_staking[chainIdToUse] ??
+                exports.DEFAULT_POOLED_STAKING_CHAIN_STATE;
+            state.pooled_staking[chainIdToUse] = {
+                ...chainState,
+                vaultDailyApys,
+            };
+        });
+    }
+    /**
+     * Refreshes pooled staking vault apy averages for the current chain.
+     * Updates the pooled staking vault apy averages controller state.
+     *
+     * @param [chainId] - The chain id to refresh pooled staking vault apy averages for (optional).
+     * @returns A promise that resolves when the pooled staking vault apy averages have been updated.
+     */
+    async refreshPooledStakingVaultApyAverages(chainId = stake_sdk_1.ChainId.ETHEREUM) {
+        const chainIdToUse = (0, stake_sdk_1.isSupportedPooledStakingChain)(chainId)
+            ? chainId
+            : stake_sdk_1.ChainId.ETHEREUM;
+        const vaultApyAverages = await __classPrivateFieldGet(this, _EarnController_earnApiService, "f").pooledStaking.getVaultApyAverages(chainIdToUse);
+        this.update((state) => {
+            const chainState = state.pooled_staking[chainIdToUse] ??
+                exports.DEFAULT_POOLED_STAKING_CHAIN_STATE;
+            state.pooled_staking[chainIdToUse] = {
+                ...chainState,
+                vaultApyAverages,
+            };
+        });
+    }
+    /**
+     * Refreshes all pooled staking related data including stakes, eligibility, and vault data.
+     * This method allows partial success, meaning some data may update while other requests fail.
+     * All errors are collected and thrown as a single error message.
+     *
+     * @param options - Optional arguments
+     * @param [options.resetCache] - Control whether the BE cache should be invalidated (optional).
+     * @param [options.address] - The address to refresh pooled stakes for (optional).
+     * @returns A promise that resolves when all possible data has been updated
+     * @throws {Error} If any of the refresh operations fail, with concatenated error messages
+     */
+    async refreshPooledStakingData({ resetCache, address, } = {}) {
+        const errors = [];
+        for (const chainId of __classPrivateFieldGet(this, _EarnController_supportedPooledStakingChains, "f")) {
+            await Promise.all([
+                this.refreshPooledStakes({ resetCache, address, chainId }).catch((error) => {
+                    errors.push(error);
+                }),
+                this.refreshPooledStakingVaultMetadata(chainId).catch((error) => {
+                    errors.push(error);
+                }),
+                this.refreshPooledStakingVaultDailyApys({ chainId }).catch((error) => {
+                    errors.push(error);
+                }),
+                this.refreshPooledStakingVaultApyAverages(chainId).catch((error) => {
+                    errors.push(error);
+                }),
+            ]);
+        }
+        if (errors.length > 0) {
+            throw new Error(`Failed to refresh some staking data: ${errors
+                .map((error) => error.message)
+                .join(', ')}`);
+        }
+    }
+    /**
+     * Refreshes the lending markets data for all chains.
+     * Updates the lending markets in the controller state.
+     *
+     * @returns A promise that resolves when the lending markets have been updated
+     */
+    async refreshLendingMarkets() {
+        const markets = await __classPrivateFieldGet(this, _EarnController_earnApiService, "f").lending.getMarkets();
+        this.update((state) => {
+            state.lending.markets = markets;
+        });
+    }
+    /**
+     * Refreshes the lending positions for the current account.
+     * Updates the lending positions in the controller state.
+     *
+     * @param options - Optional arguments
+     * @param [options.address] - The address to refresh lending positions for (optional).
+     * @returns A promise that resolves when the lending positions have been updated
+     */
+    async refreshLendingPositions({ address, } = {}) {
+        const addressToUse = address ?? __classPrivateFieldGet(this, _EarnController_instances, "m", _EarnController_getSelectedEvmAccountAddress).call(this);
+        if (!addressToUse) {
+            return;
+        }
+        // linter complaining about this not being a promise, but it is
+        // TODO: figure out why this is not seen as a promise
+        const positions = await Promise.resolve(__classPrivateFieldGet(this, _EarnController_earnApiService, "f").lending.getPositions(addressToUse));
+        this.update((state) => {
+            state.lending.positions = positions.map((position) => ({
+                ...position,
+                marketId: position.market.id,
+                marketAddress: position.market.address,
+                protocol: position.market.protocol,
+            }));
+        });
+    }
+    /**
+     * Refreshes all lending related data including markets, positions, and eligibility.
+     * This method allows partial success, meaning some data may update while other requests fail.
+     * All errors are collected and thrown as a single error message.
+     *
+     * @returns A promise that resolves when all possible data has been updated
+     * @throws {Error} If any of the refresh operations fail, with concatenated error messages
+     */
+    async refreshLendingData() {
+        const errors = [];
+        await Promise.all([
+            this.refreshLendingMarkets().catch((error) => {
+                errors.push(error);
+            }),
+            this.refreshLendingPositions().catch((error) => {
+                errors.push(error);
+            }),
+        ]);
+        if (errors.length > 0) {
+            throw new Error(`Failed to refresh some lending data: ${errors
+                .map((error) => error.message)
+                .join(', ')}`);
+        }
+    }
+    /**
+     * Refreshes the APY for TRON staking.
+     * The consumer provides a fetcher function that returns the APY for TRON.
+     *
+     * @param apyFetcher - An async function that fetches and returns the APY as a decimal string.
+     * @returns A promise that resolves when the APY has been updated.
+     */
+    async refreshTronStakingApy(apyFetcher) {
+        const apy = await apyFetcher();
+        this.update((state) => {
+            state.tron_staking = {
+                apy,
+                lastUpdated: Date.now(),
+            };
+        });
+    }
+    /**
+     * Gets the TRON staking APY.
+     *
+     * @returns The APY for TRON staking, or undefined if not available.
+     */
+    getTronStakingApy() {
+        return this.state.tron_staking?.apy;
+    }
+    /**
+     * Gets the lending position history for the current account.
+     *
+     * @param options - Optional arguments
+     * @param [options.address] - The address to get lending position history for (optional).
+     * @param options.chainId - The chain id to get lending position history for.
+     * @param [options.positionId] - The position id to get lending position history for.
+     * @param [options.marketId] - The market id to get lending position history for.
+     * @param [options.marketAddress] - The market address to get lending position history for.
+     * @param [options.protocol] - The protocol to get lending position history for.
+     * @param [options.days] - The number of days to get lending position history for (optional).
+     * @returns A promise that resolves when the lending position history has been updated
+     */
+    getLendingPositionHistory({ address, chainId, positionId, marketId, marketAddress, protocol, days = 730, }) {
+        const addressToUse = address ?? __classPrivateFieldGet(this, _EarnController_instances, "m", _EarnController_getSelectedEvmAccountAddress).call(this);
+        if (!addressToUse || !(0, stake_sdk_1.isSupportedLendingChain)(chainId)) {
+            return [];
+        }
+        return __classPrivateFieldGet(this, _EarnController_earnApiService, "f").lending.getPositionHistory(addressToUse, chainId, protocol, marketId, marketAddress, positionId, days);
+    }
+    /**
+     * Gets the lending market daily apys and averages for the current chain.
+     *
+     * @param options - Optional arguments
+     * @param options.chainId - The chain id to get lending market daily apys and averages for.
+     * @param [options.protocol] - The protocol to get lending market daily apys and averages for.
+     * @param [options.marketId] - The market id to get lending market daily apys and averages for.
+     * @param [options.days] - The number of days to get lending market daily apys and averages for (optional).
+     * @returns A promise that resolves when the lending market daily apys and averages have been updated
+     */
+    getLendingMarketDailyApysAndAverages({ chainId, protocol, marketId, days = 365, }) {
+        if (!(0, stake_sdk_1.isSupportedLendingChain)(chainId)) {
+            return undefined;
+        }
+        return __classPrivateFieldGet(this, _EarnController_earnApiService, "f").lending.getHistoricMarketApys(chainId, protocol, marketId, days);
+    }
+    /**
+     * Executes a lending deposit transaction.
+     *
+     * @param options - The options for the lending deposit transaction.
+     * @param options.amount - The amount to deposit.
+     * @param options.chainId - The chain ID for the lending deposit transaction.
+     * @param options.protocol - The protocol of the lending market.
+     * @param options.underlyingTokenAddress - The address of the underlying token.
+     * @param options.gasOptions - The gas options for the transaction.
+     * @param options.gasOptions.gasLimit - The gas limit for the transaction.
+     * @param options.gasOptions.gasBufferPct - The gas buffer percentage for the transaction.
+     * @param options.txOptions - The transaction options for the transaction.
+     * @returns A promise that resolves to the transaction hash.
+     */
+    async executeLendingDeposit({ amount, chainId, protocol, underlyingTokenAddress, gasOptions, txOptions, }) {
+        const address = __classPrivateFieldGet(this, _EarnController_instances, "m", _EarnController_getSelectedEvmAccountAddress).call(this);
+        if (!address) {
+            throw new Error('No EVM-compatible account address found');
+        }
+        const transactionData = await __classPrivateFieldGet(this, _EarnController_earnSDK, "f")?.contracts?.lending?.[protocol]?.[underlyingTokenAddress]?.encodeDepositTransactionData(amount, address, gasOptions);
+        if (!transactionData) {
+            throw new Error('Transaction data not found');
+        }
+        const selectedNetworkClientId = __classPrivateFieldGet(this, _EarnController_instances, "m", _EarnController_getSelectedNetworkClientId).call(this);
+        if (!selectedNetworkClientId) {
+            throw new Error('Selected network client id not found');
+        }
+        const gasLimit = !transactionData.gasLimit
+            ? undefined
+            : (0, controller_utils_1.toHex)(transactionData.gasLimit);
+        const txHash = await __classPrivateFieldGet(this, _EarnController_addTransactionFn, "f").call(this, {
+            ...transactionData,
+            value: transactionData.value.toString(),
+            chainId: (0, controller_utils_1.toHex)(chainId),
+            gasLimit,
+        }, {
+            ...txOptions,
+            networkClientId: selectedNetworkClientId,
+            isInternal: true,
+        });
+        return txHash;
+    }
+    /**
+     * Executes a lending withdraw transaction.
+     *
+     * @param options - The options for the lending withdraw transaction.
+     * @param options.amount - The amount to withdraw.
+     * @param options.chainId - The chain ID for the lending withdraw transaction.
+     * @param options.protocol - The protocol of the lending market.
+     * @param options.underlyingTokenAddress - The address of the underlying token.
+     * @param options.gasOptions - The gas options for the transaction.
+     * @param options.gasOptions.gasLimit - The gas limit for the transaction.
+     * @param options.gasOptions.gasBufferPct - The gas buffer percentage for the transaction.
+     * @param options.txOptions - The transaction options for the transaction.
+     * @returns A promise that resolves to the transaction hash.
+     */
+    async executeLendingWithdraw({ amount, chainId, protocol, underlyingTokenAddress, gasOptions, txOptions, }) {
+        const address = __classPrivateFieldGet(this, _EarnController_instances, "m", _EarnController_getSelectedEvmAccountAddress).call(this);
+        if (!address) {
+            throw new Error('No EVM-compatible account address found');
+        }
+        const transactionData = await __classPrivateFieldGet(this, _EarnController_earnSDK, "f")?.contracts?.lending?.[protocol]?.[underlyingTokenAddress]?.encodeWithdrawTransactionData(amount, address, gasOptions);
+        if (!transactionData) {
+            throw new Error('Transaction data not found');
+        }
+        const selectedNetworkClientId = __classPrivateFieldGet(this, _EarnController_instances, "m", _EarnController_getSelectedNetworkClientId).call(this);
+        if (!selectedNetworkClientId) {
+            throw new Error('Selected network client id not found');
+        }
+        const gasLimit = !transactionData.gasLimit
+            ? undefined
+            : (0, controller_utils_1.toHex)(transactionData.gasLimit);
+        const txHash = await __classPrivateFieldGet(this, _EarnController_addTransactionFn, "f").call(this, {
+            ...transactionData,
+            value: transactionData.value.toString(),
+            chainId: (0, controller_utils_1.toHex)(chainId),
+            gasLimit,
+        }, {
+            ...txOptions,
+            networkClientId: selectedNetworkClientId,
+            isInternal: true,
+        });
+        return txHash;
+    }
+    /**
+     * Executes a lending token approve transaction.
+     *
+     * @param options - The options for the lending token approve transaction.
+     * @param options.amount - The amount to approve.
+     * @param options.chainId - The chain ID for the lending token approve transaction.
+     * @param options.protocol - The protocol of the lending market.
+     * @param options.underlyingTokenAddress - The address of the underlying token.
+     * @param options.gasOptions - The gas options for the transaction.
+     * @param options.gasOptions.gasLimit - The gas limit for the transaction.
+     * @param options.gasOptions.gasBufferPct - The gas buffer percentage for the transaction.
+     * @param options.txOptions - The transaction options for the transaction.
+     * @returns A promise that resolves to the transaction hash.
+     */
+    async executeLendingTokenApprove({ protocol, amount, chainId, underlyingTokenAddress, gasOptions, txOptions, }) {
+        const address = __classPrivateFieldGet(this, _EarnController_instances, "m", _EarnController_getSelectedEvmAccountAddress).call(this);
+        if (!address) {
+            throw new Error('No EVM-compatible account address found');
+        }
+        const transactionData = await __classPrivateFieldGet(this, _EarnController_earnSDK, "f")?.contracts?.lending?.[protocol]?.[underlyingTokenAddress]?.encodeUnderlyingTokenApproveTransactionData(amount, address, gasOptions);
+        if (!transactionData) {
+            throw new Error('Transaction data not found');
+        }
+        const selectedNetworkClientId = __classPrivateFieldGet(this, _EarnController_instances, "m", _EarnController_getSelectedNetworkClientId).call(this);
+        if (!selectedNetworkClientId) {
+            throw new Error('Selected network client id not found');
+        }
+        const gasLimit = !transactionData.gasLimit
+            ? undefined
+            : (0, controller_utils_1.toHex)(transactionData.gasLimit);
+        const txHash = await __classPrivateFieldGet(this, _EarnController_addTransactionFn, "f").call(this, {
+            ...transactionData,
+            value: transactionData.value.toString(),
+            chainId: (0, controller_utils_1.toHex)(chainId),
+            gasLimit,
+        }, {
+            ...txOptions,
+            networkClientId: selectedNetworkClientId,
+            isInternal: true,
+        });
+        return txHash;
+    }
+    /**
+     * Gets the allowance for a lending token.
+     *
+     * @param protocol - The protocol of the lending market.
+     * @param underlyingTokenAddress - The address of the underlying token.
+     * @returns A promise that resolves to the allowance.
+     */
+    async getLendingTokenAllowance(protocol, underlyingTokenAddress) {
+        const address = __classPrivateFieldGet(this, _EarnController_instances, "m", _EarnController_getSelectedEvmAccountAddress).call(this);
+        if (!address) {
+            return undefined;
+        }
+        const allowance = await __classPrivateFieldGet(this, _EarnController_earnSDK, "f")?.contracts?.lending?.[protocol]?.[underlyingTokenAddress]?.underlyingTokenAllowance(address);
+        return allowance;
+    }
+    /**
+     * Gets the maximum withdraw amount for a lending token's output token or shares if no output token.
+     *
+     * @param protocol - The protocol of the lending market.
+     * @param underlyingTokenAddress - The address of the underlying token.
+     * @returns A promise that resolves to the maximum withdraw amount.
+     */
+    async getLendingTokenMaxWithdraw(protocol, underlyingTokenAddress) {
+        const address = __classPrivateFieldGet(this, _EarnController_instances, "m", _EarnController_getSelectedEvmAccountAddress).call(this);
+        if (!address) {
+            return undefined;
+        }
+        const maxWithdraw = await __classPrivateFieldGet(this, _EarnController_earnSDK, "f")?.contracts?.lending?.[protocol]?.[underlyingTokenAddress]?.maxWithdraw(address);
+        return maxWithdraw;
+    }
+    /**
+     * Gets the maximum deposit amount for a lending token.
+     *
+     * @param protocol - The protocol of the lending market.
+     * @param underlyingTokenAddress - The address of the underlying token.
+     * @returns A promise that resolves to the maximum deposit amount.
+     */
+    async getLendingTokenMaxDeposit(protocol, underlyingTokenAddress) {
+        const address = __classPrivateFieldGet(this, _EarnController_instances, "m", _EarnController_getSelectedEvmAccountAddress).call(this);
+        if (!address) {
+            return undefined;
+        }
+        const maxDeposit = await __classPrivateFieldGet(this, _EarnController_earnSDK, "f")?.contracts?.lending?.[protocol]?.[underlyingTokenAddress]?.maxDeposit(address);
+        return maxDeposit;
+    }
+}
+exports.EarnController = EarnController;
+_EarnController_earnSDK = new WeakMap(), _EarnController_initPromise = new WeakMap(), _EarnController_lastRefreshedAddress = new WeakMap(), _EarnController_earnApiService = new WeakMap(), _EarnController_addTransactionFn = new WeakMap(), _EarnController_supportedPooledStakingChains = new WeakMap(), _EarnController_env = new WeakMap(), _EarnController_instances = new WeakSet(), _EarnController_refreshEarnPortfolio = function _EarnController_refreshEarnPortfolio(address) {
+    __classPrivateFieldSet(this, _EarnController_lastRefreshedAddress, address, "f");
+    this.refreshEarnEligibility({ address }).catch(console.error);
+    this.refreshPooledStakingData({ address }).catch(console.error);
+    this.refreshLendingData().catch(console.error);
+}, _EarnController_initializeSDK = 
+/**
+ * Initializes the Earn SDK.
+ *
+ * @param networkClientId - The network client id to initialize the Earn SDK for.
+ */
+async function _EarnController_initializeSDK(networkClientId) {
+    const networkClient = this.messenger.call('NetworkController:getNetworkClientById', networkClientId);
+    if (!networkClient?.provider) {
+        __classPrivateFieldSet(this, _EarnController_earnSDK, null, "f");
+        return;
+    }
+    const provider = new providers_1.Web3Provider(networkClient.provider);
+    const { chainId } = networkClient.configuration;
+    // Initialize appropriate contracts based on chainId
+    const config = {
+        chainId: (0, controller_utils_1.convertHexToDecimal)(chainId),
+        env: __classPrivateFieldGet(this, _EarnController_env, "f"),
+    };
+    try {
+        __classPrivateFieldSet(this, _EarnController_earnSDK, await stake_sdk_1.EarnSdk.create(provider, config), "f");
+    }
+    catch (error) {
+        __classPrivateFieldSet(this, _EarnController_earnSDK, null, "f");
+        // Only log unexpected errors, not unsupported chain errors
+        if (!(error instanceof Error &&
+            error.message.includes('Unsupported chainId'))) {
+            console.error('Earn SDK initialization failed:', error);
+        }
+    }
+}, _EarnController_getSelectedNetworkClientId = function _EarnController_getSelectedNetworkClientId() {
+    return this.messenger.call('NetworkController:getState')
+        .selectedNetworkClientId;
+}, _EarnController_getSelectedEvmAccount = function _EarnController_getSelectedEvmAccount() {
+    return this.messenger
+        .call('AccountTreeController:getAccountsFromSelectedAccountGroup')
+        .find((account) => (0, keyring_api_1.isEvmAccountType)(account.type));
+}, _EarnController_getSelectedEvmAccountAddress = function _EarnController_getSelectedEvmAccountAddress() {
+    return __classPrivateFieldGet(this, _EarnController_instances, "m", _EarnController_getSelectedEvmAccount).call(this)?.address;
+}, _EarnController_refreshEarnPortfolioOnAccountReady = function _EarnController_refreshEarnPortfolioOnAccountReady() {
+    const handler = ({ selectedAccountGroup, }) => {
+        if (!selectedAccountGroup) {
+            return;
+        }
+        const address = __classPrivateFieldGet(this, _EarnController_instances, "m", _EarnController_getSelectedEvmAccountAddress).call(this);
+        if (!address) {
+            return;
+        }
+        this.messenger.unsubscribe('AccountTreeController:stateChange', handler);
+        __classPrivateFieldGet(this, _EarnController_instances, "m", _EarnController_refreshEarnPortfolio).call(this, address);
+    };
+    this.messenger.subscribe('AccountTreeController:stateChange', handler);
+};
+//# sourceMappingURL=EarnController.cjs.map