import { Address } from '@hyperlane-xyz/utils';
import { MultiProtocolProvider } from '../providers/MultiProtocolProvider.js';
import { MultiProvider } from '../providers/MultiProvider.js';
import { ChainNameOrId } from '../types.js';
import { HyperlaneReader } from '../utils/HyperlaneReader.js';
import { RateLimitMidPoint, xERC20Limits } from './adapters/ITokenAdapter.js';
import { XERC20Type } from './types.js';
import { StandardXERC20Limits, VeloXERC20Limits, XERC20LimitsMap } from './xerc20-limits.js';
export type { StandardXERC20Limits, VeloXERC20Limits, XERC20Limits, XERC20LimitsMap, } from './xerc20-limits.js';
export { limitsAreZero, limitsMatch } from './xerc20-limits.js';
/**
 * Reader for on-chain XERC20 state.
 * Reads limits and bridge configurations from XERC20 contracts.
 */
export declare class EvmXERC20Reader extends HyperlaneReader {
    protected readonly multiProvider: MultiProvider;
    protected logger: import("pino").pino.Logger<never>;
    protected readonly multiProtocolProvider: MultiProtocolProvider;
    constructor(multiProvider: MultiProvider, chain: ChainNameOrId);
    deriveXERC20TokenType(xERC20Address: Address): Promise<XERC20Type>;
    /**
     * Read current limits for the specified bridges.
     */
    readLimits(xERC20Address: Address, bridges: Address[], type: XERC20Type): Promise<XERC20LimitsMap>;
    /**
     * Read all bridges configured on-chain for a Velodrome XERC20 by parsing ConfigurationChanged events.
     * The scan covers the token's whole history, from the block it was deployed in
     * to the chain head, over the block explorer where the chain has a usable one
     * and over the paginated RPC otherwise.
     *
     * Returns an empty array for Standard XERC20, whose bridges this does not
     * enumerate. They are enumerable: a Standard token announces them through
     * BridgeLimitsSet, which getExtraLockBoxConfigs reads. Callers relying on
     * this therefore fall back to the bridges their config names for a Standard
     * token, which is why bringing the two paths together is worth doing.
     */
    readOnChainBridges(xERC20Address: Address, type: XERC20Type): Promise<Address[]>;
    /**
     * Read the owner of the XERC20 token contract.
     * This owner controls limit/bridge management (setBufferCap, addBridge, etc.).
     * Returns undefined if the XERC20 does not expose `owner()` (e.g. a
     * third-party token using AccessControl instead of Ownable) so callers on the
     * warp read/apply path don't break on non-Ownable tokens.
     */
    readOwner(xERC20Address: Address): Promise<Address | undefined>;
    /**
     * Read the ProxyAdmin for the XERC20 proxy and its owner.
     * The ProxyAdmin owner controls upgrades. Returns undefined if the XERC20 is
     * not behind a transparent proxy.
     */
    readProxyAdmin(xERC20Address: Address): Promise<{
        address: Address;
        owner: Address;
    } | undefined>;
    protected toStandardLimits(limits: xERC20Limits): StandardXERC20Limits;
    protected toVeloLimits(rateLimits: RateLimitMidPoint): VeloXERC20Limits;
}
//# sourceMappingURL=EvmXERC20Reader.d.ts.map