import { type Address } from "viem";
import { type IEulerEarn } from "../../../../entities/EulerEarn.js";
import { type BuildQueryFn } from "../../../../utils/buildQuery.js";
import type { ServiceResult } from "../../../../utils/entityDiagnostics.js";
import type { DeploymentService } from "../../../deploymentService/index.js";
import type { EVCBatchItem } from "../../../executionService/executionServiceTypes.js";
import type { ProviderService } from "../../../providerService/index.js";
import type { IEulerEarnAdapter } from "../eulerEarnService.js";
export declare const getEulerEarnVaultInfoFullLensBatchItem: (lensAddress: Address, vault: Address, onBehalfOfAccount: Address) => EVCBatchItem;
export declare class EulerEarnOnchainAdapter implements IEulerEarnAdapter {
    private providerService;
    private deploymentService;
    constructor(providerService: ProviderService, deploymentService: DeploymentService, buildQuery?: BuildQueryFn);
    setProviderService(providerService: ProviderService): void;
    queryBlockNumber: (provider: ReturnType<ProviderService["getProvider"]>) => Promise<bigint>;
    setQueryBlockNumber(fn: typeof this.queryBlockNumber): void;
    queryBlock: (provider: ReturnType<ProviderService["getProvider"]>, blockNumber: bigint) => Promise<{
        number: bigint;
        size: bigint;
        nonce: `0x${string}`;
        timestamp: bigint;
        hash: `0x${string}`;
        gasUsed: bigint;
        logsBloom: `0x${string}`;
        baseFeePerGas: bigint | null;
        blobGasUsed: bigint;
        difficulty: bigint;
        excessBlobGas: bigint;
        extraData: import("viem").Hex;
        gasLimit: bigint;
        miner: Address;
        mixHash: import("viem").Hash;
        parentBeaconBlockRoot?: `0x${string}` | undefined;
        parentHash: import("viem").Hash;
        receiptsRoot: import("viem").Hex;
        sealFields: import("viem").Hex[];
        sha3Uncles: import("viem").Hash;
        stateRoot: import("viem").Hash;
        totalDifficulty: bigint | null;
        transactionsRoot: import("viem").Hash;
        uncles: import("viem").Hash[];
        withdrawals?: import("viem").Withdrawal[] | undefined | undefined;
        withdrawalsRoot?: `0x${string}` | undefined;
        transactions: `0x${string}`[];
    }>;
    setQueryBlock(fn: typeof this.queryBlock): void;
    queryEulerEarnVaultInfoFull: (provider: ReturnType<ProviderService["getProvider"]>, lensAddress: Address, vault: Address) => Promise<{
        timestamp: bigint;
        vault: `0x${string}`;
        vaultName: string;
        vaultSymbol: string;
        vaultDecimals: bigint;
        asset: `0x${string}`;
        assetName: string;
        assetSymbol: string;
        assetDecimals: bigint;
        totalShares: bigint;
        totalAssets: bigint;
        lostAssets: bigint;
        availableAssets: bigint;
        timelock: bigint;
        performanceFee: bigint;
        feeReceiver: `0x${string}`;
        owner: `0x${string}`;
        creator: `0x${string}`;
        curator: `0x${string}`;
        guardian: `0x${string}`;
        evc: `0x${string}`;
        permit2: `0x${string}`;
        pendingTimelock: bigint;
        pendingTimelockValidAt: bigint;
        pendingGuardian: `0x${string}`;
        pendingGuardianValidAt: bigint;
        supplyQueue: readonly `0x${string}`[];
        strategies: readonly {
            strategy: `0x${string}`;
            allocatedAssets: bigint;
            availableAssets: bigint;
            currentAllocationCap: bigint;
            pendingAllocationCap: bigint;
            pendingAllocationCapValidAt: bigint;
            removableAt: bigint;
            info: {
                timestamp: bigint;
                vault: `0x${string}`;
                vaultName: string;
                vaultSymbol: string;
                vaultDecimals: bigint;
                asset: `0x${string}`;
                assetName: string;
                assetSymbol: string;
                assetDecimals: bigint;
                totalShares: bigint;
                totalAssets: bigint;
                isEVault: boolean;
            };
        }[];
    }>;
    setQueryEulerEarnVaultInfoFull(fn: typeof this.queryEulerEarnVaultInfoFull): void;
    queryEulerEarnConvertToAssets: (provider: ReturnType<ProviderService["getProvider"]>, vault: Address, shares: bigint, blockNumber?: bigint) => Promise<bigint>;
    setQueryEulerEarnConvertToAssets(fn: typeof this.queryEulerEarnConvertToAssets): void;
    queryEulerEarnVerifiedArray: (provider: ReturnType<ProviderService["getProvider"]>, perspective: Address) => Promise<readonly `0x${string}`[]>;
    setQueryEulerEarnVerifiedArray(fn: typeof this.queryEulerEarnVerifiedArray): void;
    private getSupplyApyWindow;
    private findBlockAtOrBeforeTimestamp;
    private computeSupplyApy;
    fetchVaults(chainId: number, vaults: Address[]): Promise<ServiceResult<(IEulerEarn | undefined)[]>>;
    fetchVerifiedVaultsAddresses(chainId: number, perspectives: Address[]): Promise<Address[]>;
    fetchAllVaults(chainId: number): Promise<ServiceResult<(IEulerEarn | undefined)[]>>;
}
//# sourceMappingURL=eulerEarnOnchainAdapter.d.ts.map