import { type TokenInfo } from "alex-sdk";
import { type Network } from "../config/index.js";
import { type Account, type TransferResult } from "../transactions/builder.js";
export interface SwapQuote {
    tokenIn: string;
    tokenOut: string;
    amountIn: string;
    amountOut: string;
    priceImpact?: string;
    route: string[];
}
export interface PoolInfo {
    poolId: string;
    tokenX: string;
    tokenY: string;
    reserveX: string;
    reserveY: string;
    totalShares?: string;
}
export interface PoolListing {
    id: number;
    tokenX: string;
    tokenY: string;
    tokenXSymbol: string;
    tokenYSymbol: string;
    factor: string;
}
export interface ZestMarketInfo {
    asset: string;
    totalSupply: string;
    totalBorrow: string;
    supplyRate: string;
    borrowRate: string;
    utilizationRate: string;
}
export interface ZestUserPosition {
    asset: string;
    suppliedShares: string;
    borrowed: string;
    healthFactor?: string;
}
export interface ZestAsset {
    contractId: string;
    symbol: string;
    name: string;
    decimals?: number;
}
export declare class AlexDexService {
    private network;
    private sdk;
    private hiro;
    private contracts;
    private tokenInfoCache;
    constructor(network: Network);
    private ensureMainnet;
    /**
     * Get all swappable token info from SDK (cached)
     */
    private getTokenInfos;
    /**
     * Convert a token identifier (contract ID or symbol) to an ALEX SDK Currency
     */
    private resolveCurrency;
    /**
     * Get a swap quote for token X to token Y using ALEX SDK
     */
    getSwapQuote(tokenX: string, tokenY: string, amountIn: bigint, _senderAddress: string): Promise<SwapQuote>;
    /**
     * Execute a swap using ALEX SDK
     * The SDK handles STX wrapping internally
     */
    swap(account: Account, tokenX: string, tokenY: string, amountIn: bigint, minAmountOut: bigint): Promise<TransferResult>;
    /**
     * Get pool information
     */
    getPoolInfo(tokenX: string, tokenY: string, senderAddress: string): Promise<PoolInfo | null>;
    /**
     * List all available pools on ALEX DEX
     * Uses SDK to fetch swappable currencies
     */
    listPools(limit?: number): Promise<PoolListing[]>;
    /**
     * Get all swappable currencies from ALEX SDK
     */
    getSwappableCurrencies(): Promise<TokenInfo[]>;
    /**
     * Get latest prices from ALEX SDK
     */
    getLatestPrices(): Promise<Record<string, number>>;
}
export declare class ZestProtocolService {
    private network;
    private hiro;
    private contracts;
    constructor(network: Network);
    private ensureMainnet;
    /**
     * Get asset configuration from ZEST_ASSETS by symbol or contract ID
     */
    private getAssetConfig;
    /**
     * Get all supported assets from Zest Protocol v2
     */
    getAssets(): Promise<ZestAsset[]>;
    /**
     * Resolve an asset symbol or contract ID to a full contract ID
     */
    resolveAsset(assetOrSymbol: string): Promise<string>;
    /**
     * Get user's full position on Zest v2 via the data helper contract.
     * Returns collateral, debt, health factor, and LTV data in a single call.
     */
    getUserPosition(asset: string, userAddress: string): Promise<ZestUserPosition | null>;
    /**
     * Get detailed per-asset supply balances via the data helper.
     * Returns vault share balances, underlying equivalents, and market collateral.
     */
    getUserSupplies(userAddress: string): Promise<Record<string, unknown> | null>;
    /**
     * Build post-conditions for a principal sending tokens.
     * Handles wSTX (native STX transfers) vs FT transfers.
     */
    private buildSendPC;
    /**
     * Query the vault's convert-to-assets to predict underlying amount for a given share amount.
     * Used to set accurate post-conditions for withdraw operations (shares appreciate over time).
     */
    private getExpectedUnderlying;
    /**
     * Query the vault's convert-to-shares to predict zToken amount for a given underlying amount.
     * Used to set accurate post-conditions for supply operations.
     */
    private getExpectedShares;
    /**
     * Supply assets to Zest v2 via market's supply-collateral-add.
     * Atomically deposits into vault and adds zTokens as collateral.
     * This earns yield AND provides borrowing power.
     *
     * Token flow (3 ft-transfers):
     * 1. user → market (underlying)
     * 2. market → vault (underlying)
     * 3. user → market-vault (zTokens, minted to user then transferred)
     *
     * Contract: v0-4-market.supply-collateral-add(ft, amount, min-shares, price-feeds)
     */
    supply(account: Account, asset: string, amount: bigint): Promise<TransferResult>;
    /**
     * Add existing zTokens as collateral on Zest v2.
     * Use this when you deposited directly to a vault (via depositToVault)
     * and need to register those zTokens as collateral for borrowing.
     *
     * Note: supply() already calls supply-collateral-add which handles this
     * atomically. This method is only needed for the deposit → collateral flow.
     *
     * Token flow (1 ft-transfer):
     * 1. user → market-vault (zTokens registered as collateral)
     *
     * Contract: v0-4-market.collateral-add(ft, amount, price-feeds)
     */
    enableCollateral(account: Account, asset: string, amount: bigint): Promise<TransferResult>;
    /**
     * Withdraw assets from Zest v2 via market's collateral-remove-redeem.
     * Atomically removes zToken collateral and redeems for underlying.
     *
     * Token flow (3 ft-transfers):
     * 1. market-vault → market (zTokens released from collateral)
     * 2. market → vault (zTokens for redemption/burn)
     * 3. vault → user (underlying redeemed)
     *
     * Contract: v0-4-market.collateral-remove-redeem(ft, amount, min-underlying, receiver, price-feeds)
     *
     * @param amount - Amount in zToken shares to withdraw
     */
    withdraw(account: Account, asset: string, amount: bigint): Promise<TransferResult>;
    /**
     * Borrow assets from Zest v2 via market's borrow function.
     * Requires sufficient collateral to maintain healthy LTV.
     *
     * Token flow (1 ft-transfer):
     * 1. vault → user (borrowed underlying)
     *
     * Contract: v0-4-market.borrow(ft, amount, receiver, price-feeds)
     */
    borrow(account: Account, asset: string, amount: bigint): Promise<TransferResult>;
    /**
     * Repay borrowed assets on Zest v2.
     *
     * Token flow (1 ft-transfer):
     * 1. user → vault (repayment, amount may be capped to actual debt on-chain)
     *
     * Contract: v0-4-market.repay(ft, amount, on-behalf-of)
     */
    repay(account: Account, asset: string, amount: bigint, onBehalfOf?: string): Promise<TransferResult>;
    /**
     * Deposit directly into a Zest v2 vault for yield without collateral.
     * Mints zTokens that earn supply yield. Simpler than supply-collateral-add
     * but the zTokens won't be usable as collateral for borrowing.
     *
     * Token flow (1 ft-transfer):
     * 1. user → vault (underlying)
     * Note: zTokens minted to recipient (ft-mint, no PC needed)
     *
     * Contract: vault.deposit(amount, min-out, recipient)
     */
    depositToVault(account: Account, asset: string, amount: bigint): Promise<TransferResult>;
    /**
     * Redeem zTokens from a Zest v2 vault for underlying assets.
     *
     * Token flow:
     * 1. user sends zTokens → vault (ft-burn, but transfer happens first)
     * 2. vault sends underlying → recipient
     *
     * Contract: vault.redeem(amount, min-out, recipient)
     *
     * @param amount - Amount of zTokens to redeem
     */
    redeemFromVault(account: Account, asset: string, amount: bigint): Promise<TransferResult>;
}
export declare function getAlexDexService(network: Network): AlexDexService;
export declare function getZestProtocolService(network: Network): ZestProtocolService;
//# sourceMappingURL=defi.service.d.ts.map