@peridot-agent/agent-kit 0.2.0

package/dist/index.d.cts

@@ -0,0 +1,880 @@
+import { T as ToolDefinition, P as PeridotConfig, L as LiquidatablePositions, C as ComposeRequest, B as BiconomyResponse, a as TransactionStatus, M as MarketSummary, b as LeaderboardEntry, c as MarketRates, U as UserPosition, S as SimulateBorrowResult, A as AccountLiquidity, H as HubTransactionIntent, d as CrossChainIntent } from './types-Cg95um6s.cjs';
+export { e as ComposeFlow, f as ToolCategory, g as TransactionCall, h as TransactionIntent } from './types-Cg95um6s.cjs';
+import { Address } from 'viem';
+import { z } from 'zod';
+
+/**
+ * Lending feature tool registry.
+ *
+ * Adding a new tool:
+ * 1. Implement the function in the appropriate read/ or intents/ subdirectory
+ * 2. Add an entry to the `lendingTools` array below
+ * 3. It will automatically appear in the MCP server and all framework adapters
+ *
+ * Adding a new feature (e.g. margin):
+ * Create src/features/margin/tools.ts with the same pattern, then add it to
+ * src/adapters/mcp/server.ts's `allTools` array.
+ */
+
+declare const lendingTools: ToolDefinition<any, any>[];
+
+interface RawMarketMetric {
+    utilizationPct: number;
+    tvlUsd: number;
+    liquidityUnderlying: number;
+    liquidityUsd: number;
+    priceUsd: number;
+    collateral_factor_pct: number;
+    updatedAt: string;
+    chainId: number;
+}
+/** Shape of one entry from `/api/apy` (from `apy_latest_mainnet` table). */
+interface RawMarketApy {
+    supplyApy: number;
+    borrowApy: number;
+    peridotSupplyApy: number;
+    peridotBorrowApy: number;
+    boostSourceSupplyApy: number;
+    boostRewardsSupplyApy: number;
+    totalSupplyApy: number;
+    netBorrowApy: number;
+    timestamp: string;
+}
+/**
+ * Full response from `/api/apy`.
+ * Keys are lowercase asset IDs (e.g. "usdc"), values are a map of chainId → APY data.
+ */
+type RawApyResponse = Record<string, Record<number, RawMarketApy>>;
+/** Shape of one leaderboard entry from `/api/leaderboard`. */
+interface RawTransaction {
+    txHash: string;
+    chainId: number;
+    blockNumber: number;
+    actionType: string;
+    tokenSymbol: string | null;
+    amount: number;
+    usdValue: number;
+    pointsAwarded: number;
+    verifiedAt: string;
+    contractAddress: string;
+}
+interface RawTransactionsResponse {
+    transactions: RawTransaction[];
+    total: number;
+}
+interface RawLeaderboardEntry {
+    rank: number;
+    address: string;
+    totalPoints: number;
+    supplyCount: number;
+    borrowCount: number;
+    repayCount: number;
+    redeemCount: number;
+    updatedAt: string;
+}
+interface RawLeaderboardResponse {
+    entries: RawLeaderboardEntry[];
+    total: number;
+}
+interface RawUserPortfolio {
+    portfolio: {
+        currentValue: number;
+        totalSupplied: number;
+        totalBorrowed: number;
+        netApy: number;
+        /** Note: simplified ratio (totalSupplied / totalBorrowed), not liquidation HF */
+        healthFactor: number;
+    };
+    assets: Array<{
+        assetId: string;
+        supplied: number;
+        borrowed: number;
+        net: number;
+        percentage: number;
+    }>;
+    transactions: {
+        totalCount: number;
+        supplyCount: number;
+        borrowCount: number;
+        repayCount: number;
+        redeemCount: number;
+    };
+    earnings: {
+        effectiveApy: number;
+        totalLifetimeEarnings: number;
+    };
+}
+declare class PeridotApiClient {
+    private readonly baseUrl;
+    private readonly biconomyApiKey;
+    constructor(config: PeridotConfig);
+    /**
+     * Fetches all market metrics. Returns a record keyed by `${ASSET}:${chainId}`.
+     * Example key: `USDC:56`
+     */
+    getMarketMetrics(): Promise<Record<string, RawMarketMetric>>;
+    /**
+     * Fetches the portfolio overview for a wallet address.
+     * Uses the platform's portfolio-data endpoint which aggregates DB snapshots.
+     */
+    getUserPortfolio(address: string): Promise<RawUserPortfolio>;
+    /**
+     * Fetches the latest APY snapshot for all markets (or a specific chain).
+     * Calls `/api/apy` — backed by the `apy_latest_mainnet` DB table.
+     *
+     * Returns a record keyed by lowercase asset ID, then by chainId.
+     * Example: `data["usdc"][56].totalSupplyApy`
+     */
+    getMarketApy(chainId?: number): Promise<RawApyResponse>;
+    /**
+     * Fetches the Peridot leaderboard (top users by points).
+     * Optionally filters by chainId and limits the result set.
+     */
+    getLeaderboard(options?: {
+        limit?: number;
+        chainId?: number;
+    }): Promise<RawLeaderboardResponse>;
+    /**
+     * Fetches accounts that are currently underwater (shortfall_usd > 0) and
+     * eligible for liquidation. Data is sourced from the account health scanner.
+     */
+    getLiquidatablePositions(options?: {
+        chainId?: number;
+        minShortfall?: number;
+        limit?: number;
+    }): Promise<LiquidatablePositions>;
+    /**
+     * Fetches verified transaction history for a wallet address.
+     * Optionally filters by chainId and/or actionType.
+     */
+    getUserTransactions(address: string, options?: {
+        limit?: number;
+        chainId?: number;
+        actionType?: 'supply' | 'borrow' | 'repay' | 'redeem';
+    }): Promise<RawTransactionsResponse>;
+    /**
+     * Calls Biconomy MEE /compose to build a cross-chain transaction payload.
+     * Does NOT execute — the returned instructions must be signed by the user.
+     */
+    biconomyCompose(request: ComposeRequest): Promise<BiconomyResponse>;
+    /** Polls Biconomy for the status of a submitted super-transaction. */
+    biconomyGetStatus(superTxHash: string): Promise<TransactionStatus>;
+}
+
+declare const BSC_MAINNET_CHAIN_ID = 56;
+declare const BSC_TESTNET_CHAIN_ID = 97;
+declare const MONAD_MAINNET_CHAIN_ID = 143;
+declare const SOMNIA_MAINNET_CHAIN_ID = 1868;
+/** Spoke chains — users bridge to the hub to interact with the protocol. */
+declare const ARBITRUM_CHAIN_ID = 42161;
+declare const BASE_CHAIN_ID = 8453;
+declare const ETHEREUM_CHAIN_ID = 1;
+declare function isHubChain(chainId: number): boolean;
+/** For spoke chains, returns the hub chain that hosts the markets. */
+declare function resolveHubChainId(chainId: number, network?: 'mainnet' | 'testnet'): number;
+declare const PERIDOT_CONTROLLER: Partial<Record<number, Address>>;
+/** pToken market addresses per hub chain, keyed by asset symbol (uppercase). */
+declare const PERIDOT_MARKETS: Partial<Record<number, Partial<Record<string, Address>>>>;
+/** Underlying ERC-20 token addresses on BSC Mainnet. */
+declare const BSC_UNDERLYING_TOKENS: Partial<Record<string, Address>>;
+/** Token addresses on spoke chains, keyed by chainId then asset symbol. */
+declare const SPOKE_TOKENS: Partial<Record<number, Partial<Record<string, Address>>>>;
+/** ERC-20 decimal places by asset symbol. */
+declare const ASSET_DECIMALS: Record<string, number>;
+declare function getPTokenAddress(chainId: number, asset: string): Address;
+declare function getUnderlyingTokenAddress(chainId: number, asset: string): Address;
+declare function getControllerAddress(chainId: number): Address;
+declare function getAssetDecimals(asset: string): number;
+
+/**
+ * Minimal ABI for pToken (Compound V2-style cToken) markets.
+ * Only includes functions used by the agent-kit.
+ */
+declare const PTOKEN_ABI: readonly [{
+    readonly name: "mint";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "mintAmount";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "redeem";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "redeemTokens";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "redeemUnderlying";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "redeemAmount";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "borrow";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "borrowAmount";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "repayBorrow";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "repayAmount";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "repayBorrowBehalf";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "borrower";
+    }, {
+        readonly type: "uint256";
+        readonly name: "repayAmount";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "liquidateBorrow";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "borrower";
+    }, {
+        readonly type: "uint256";
+        readonly name: "repayAmount";
+    }, {
+        readonly type: "address";
+        readonly name: "pTokenCollateral";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "balanceOf";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "owner";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "borrowBalanceStored";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "account";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "supplyRatePerBlock";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "borrowRatePerBlock";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "exchangeRateStored";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "underlying";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}];
+/**
+ * Minimal ABI for the Peridottroller (Compound V2-style Comptroller).
+ */
+declare const COMPTROLLER_ABI: readonly [{
+    readonly name: "enterMarkets";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address[]";
+        readonly name: "pTokens";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256[]";
+    }];
+}, {
+    readonly name: "exitMarket";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "pTokenAddress";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "getAccountLiquidity";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "account";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "errorCode";
+    }, {
+        readonly type: "uint256";
+        readonly name: "liquidity";
+    }, {
+        readonly type: "uint256";
+        readonly name: "shortfall";
+    }];
+}, {
+    readonly name: "getAllMarkets";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address[]";
+    }];
+}, {
+    readonly name: "markets";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "pToken";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+        readonly name: "isListed";
+    }, {
+        readonly type: "uint256";
+        readonly name: "collateralFactorMantissa";
+    }, {
+        readonly type: "bool";
+        readonly name: "isComped";
+    }];
+}, {
+    readonly name: "checkMembership";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "account";
+    }, {
+        readonly type: "address";
+        readonly name: "pToken";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}];
+/**
+ * Standard ERC-20 ABI subset used for approvals and balance checks.
+ */
+declare const ERC20_ABI: readonly [{
+    readonly name: "approve";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "spender";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly name: "allowance";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "owner";
+    }, {
+        readonly type: "address";
+        readonly name: "spender";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "balanceOf";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "owner";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "transfer";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "to";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}];
+
+declare const listMarketsSchema: z.ZodObject<{
+    chainId: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    chainId?: number | undefined;
+}, {
+    chainId?: number | undefined;
+}>;
+type ListMarketsInput = z.infer<typeof listMarketsSchema>;
+declare function listMarkets(input: ListMarketsInput, config: PeridotConfig): Promise<{
+    markets: MarketSummary[];
+    count: number;
+}>;
+
+declare const getLeaderboardSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    chainId: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    limit?: number | undefined;
+    chainId?: number | undefined;
+}, {
+    limit?: number | undefined;
+    chainId?: number | undefined;
+}>;
+type GetLeaderboardInput = z.infer<typeof getLeaderboardSchema>;
+declare function getLeaderboard(input: GetLeaderboardInput, config: PeridotConfig): Promise<{
+    entries: LeaderboardEntry[];
+    total: number;
+}>;
+
+declare const getMarketRatesSchema: z.ZodObject<{
+    asset: z.ZodString;
+    chainId: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    chainId: number;
+    asset: string;
+}, {
+    asset: string;
+    chainId?: number | undefined;
+}>;
+type GetMarketRatesInput = z.infer<typeof getMarketRatesSchema>;
+declare function getMarketRates(input: GetMarketRatesInput, config: PeridotConfig): Promise<MarketRates>;
+
+declare const getUserPositionSchema: z.ZodObject<{
+    address: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    address: string;
+}, {
+    address: string;
+}>;
+type GetUserPositionInput = z.infer<typeof getUserPositionSchema>;
+declare function getUserPosition(input: GetUserPositionInput, config: PeridotConfig): Promise<UserPosition>;
+
+declare const simulateBorrowSchema: z.ZodObject<{
+    address: z.ZodString;
+    asset: z.ZodString;
+    amount: z.ZodString;
+    chainId: z.ZodEffects<z.ZodDefault<z.ZodNumber>, number, number | undefined>;
+}, "strip", z.ZodTypeAny, {
+    chainId: number;
+    address: string;
+    asset: string;
+    amount: string;
+}, {
+    address: string;
+    asset: string;
+    amount: string;
+    chainId?: number | undefined;
+}>;
+type SimulateBorrowInput = z.infer<typeof simulateBorrowSchema>;
+declare function simulateBorrow(input: SimulateBorrowInput, config: PeridotConfig): Promise<SimulateBorrowResult>;
+
+declare const getAccountLiquiditySchema: z.ZodObject<{
+    address: z.ZodString;
+    chainId: z.ZodEffects<z.ZodDefault<z.ZodNumber>, number, number | undefined>;
+}, "strip", z.ZodTypeAny, {
+    chainId: number;
+    address: string;
+}, {
+    address: string;
+    chainId?: number | undefined;
+}>;
+type GetAccountLiquidityInput = z.infer<typeof getAccountLiquiditySchema>;
+/**
+ * Reads account liquidity directly from the Peridottroller contract.
+ * Returns the precise USD liquidity (excess borrowing power) and shortfall.
+ *
+ * This is the authoritative source for liquidation risk — more accurate than
+ * the portfolio-data API which uses a simplified health factor.
+ *
+ * Requires an RPC URL for the hub chain (uses public fallback if not configured).
+ */
+declare function getAccountLiquidity(input: GetAccountLiquidityInput, config: PeridotConfig): Promise<AccountLiquidity>;
+
+declare const hubSupplySchema: z.ZodObject<{
+    userAddress: z.ZodString;
+    asset: z.ZodString;
+    amount: z.ZodString;
+    chainId: z.ZodEffects<z.ZodDefault<z.ZodNumber>, number, number | undefined>;
+    enableAsCollateral: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    chainId: number;
+    asset: string;
+    amount: string;
+    userAddress: string;
+    enableAsCollateral: boolean;
+}, {
+    asset: string;
+    amount: string;
+    userAddress: string;
+    chainId?: number | undefined;
+    enableAsCollateral?: boolean | undefined;
+}>;
+type HubSupplyInput = z.input<typeof hubSupplySchema>;
+/**
+ * Builds the transaction calls to supply an asset to a Peridot hub-chain market.
+ *
+ * Call sequence:
+ * 1. approve(pToken, amount)   — allow pToken to spend your underlying
+ * 2. mint(amount)              — supply underlying, receive pTokens
+ * 3. enterMarkets([pToken])    — (optional) enable as collateral
+ */
+declare function buildHubSupplyIntent(input: HubSupplyInput, _config: PeridotConfig): HubTransactionIntent;
+
+declare const hubBorrowSchema: z.ZodObject<{
+    userAddress: z.ZodString;
+    borrowAsset: z.ZodString;
+    borrowAmount: z.ZodString;
+    collateralAssets: z.ZodArray<z.ZodString, "many">;
+    chainId: z.ZodEffects<z.ZodDefault<z.ZodNumber>, number, number | undefined>;
+}, "strip", z.ZodTypeAny, {
+    chainId: number;
+    borrowAmount: string;
+    userAddress: string;
+    borrowAsset: string;
+    collateralAssets: string[];
+}, {
+    borrowAmount: string;
+    userAddress: string;
+    borrowAsset: string;
+    collateralAssets: string[];
+    chainId?: number | undefined;
+}>;
+type HubBorrowInput = z.infer<typeof hubBorrowSchema>;
+/**
+ * Builds the transaction calls to borrow from a Peridot hub-chain market.
+ *
+ * Call sequence:
+ * 1. enterMarkets(collateralPTokens) — ensure collateral is active
+ * 2. borrow(amount)                   — borrow from the market
+ *
+ * Prerequisites:
+ * - Collateral must already be supplied (use build_hub_supply_intent first)
+ * - Borrow amount must not exceed borrowing capacity (use simulate_borrow first)
+ */
+declare function buildHubBorrowIntent(input: HubBorrowInput, _config: PeridotConfig): HubTransactionIntent;
+
+declare const hubRepaySchema: z.ZodObject<{
+    userAddress: z.ZodString;
+    asset: z.ZodString;
+    amount: z.ZodEffects<z.ZodString, string, string>;
+    chainId: z.ZodEffects<z.ZodDefault<z.ZodNumber>, number, number | undefined>;
+}, "strip", z.ZodTypeAny, {
+    chainId: number;
+    asset: string;
+    amount: string;
+    userAddress: string;
+}, {
+    asset: string;
+    amount: string;
+    userAddress: string;
+    chainId?: number | undefined;
+}>;
+type HubRepayInput = z.infer<typeof hubRepaySchema>;
+/**
+ * Builds the transaction calls to repay a borrow on a Peridot hub-chain market.
+ *
+ * Call sequence:
+ * 1. approve(pToken, amount)  — allow pToken to pull repayment tokens
+ * 2. repayBorrow(amount)       — repay outstanding debt
+ *
+ * Use amount = "max" to repay the full debt (passes uint256 max to the contract,
+ * which the pToken interprets as "repay all").
+ */
+declare function buildHubRepayIntent(input: HubRepayInput, _config: PeridotConfig): HubTransactionIntent;
+
+declare const hubWithdrawSchema: z.ZodObject<{
+    userAddress: z.ZodString;
+    asset: z.ZodString;
+    amount: z.ZodString;
+    chainId: z.ZodEffects<z.ZodDefault<z.ZodNumber>, number, number | undefined>;
+}, "strip", z.ZodTypeAny, {
+    chainId: number;
+    asset: string;
+    amount: string;
+    userAddress: string;
+}, {
+    asset: string;
+    amount: string;
+    userAddress: string;
+    chainId?: number | undefined;
+}>;
+type HubWithdrawInput = z.infer<typeof hubWithdrawSchema>;
+/**
+ * Builds the transaction call to withdraw (redeem) a supplied asset.
+ * Uses redeemUnderlying so the user specifies the exact underlying amount to receive.
+ *
+ * Will revert on-chain if the withdrawal would cause the user's health factor
+ * to drop below the liquidation threshold (i.e., they still have open borrows).
+ */
+declare function buildHubWithdrawIntent(input: HubWithdrawInput, _config: PeridotConfig): HubTransactionIntent;
+
+declare const hubEnableCollateralSchema: z.ZodObject<{
+    userAddress: z.ZodString;
+    assets: z.ZodArray<z.ZodString, "many">;
+    chainId: z.ZodEffects<z.ZodDefault<z.ZodNumber>, number, number | undefined>;
+}, "strip", z.ZodTypeAny, {
+    chainId: number;
+    assets: string[];
+    userAddress: string;
+}, {
+    assets: string[];
+    userAddress: string;
+    chainId?: number | undefined;
+}>;
+type HubEnableCollateralInput = z.infer<typeof hubEnableCollateralSchema>;
+/**
+ * Builds the enterMarkets call to enable one or more supplied assets as collateral.
+ * Must be called after supplying assets if they were not enabled during supply.
+ * Enabling collateral is required before borrowing against that asset.
+ */
+declare function buildHubEnableCollateralIntent(input: HubEnableCollateralInput, _config: PeridotConfig): HubTransactionIntent;
+
+declare const hubDisableCollateralSchema: z.ZodObject<{
+    userAddress: z.ZodString;
+    asset: z.ZodString;
+    chainId: z.ZodEffects<z.ZodDefault<z.ZodNumber>, number, number | undefined>;
+}, "strip", z.ZodTypeAny, {
+    chainId: number;
+    asset: string;
+    userAddress: string;
+}, {
+    asset: string;
+    userAddress: string;
+    chainId?: number | undefined;
+}>;
+type HubDisableCollateralInput = z.infer<typeof hubDisableCollateralSchema>;
+/**
+ * Builds the exitMarket call to disable a supplied asset as collateral.
+ *
+ * Will revert on-chain if disabling this collateral would make existing borrows
+ * undercollateralized. Repay borrows or add more collateral first.
+ */
+declare function buildHubDisableCollateralIntent(input: HubDisableCollateralInput, _config: PeridotConfig): HubTransactionIntent;
+
+declare const crossChainSupplySchema: z.ZodObject<{
+    userAddress: z.ZodString;
+    sourceChainId: z.ZodEffects<z.ZodDefault<z.ZodNumber>, number, number | undefined>;
+    asset: z.ZodString;
+    amount: z.ZodString;
+    enableAsCollateral: z.ZodDefault<z.ZodBoolean>;
+    slippage: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    asset: string;
+    amount: string;
+    userAddress: string;
+    enableAsCollateral: boolean;
+    sourceChainId: number;
+    slippage: number;
+}, {
+    asset: string;
+    amount: string;
+    userAddress: string;
+    enableAsCollateral?: boolean | undefined;
+    sourceChainId?: number | undefined;
+    slippage?: number | undefined;
+}>;
+type CrossChainSupplyInput = z.input<typeof crossChainSupplySchema>;
+/**
+ * Builds a cross-chain supply intent using Biconomy MEE.
+ *
+ * Biconomy orchestrates all steps atomically from a single user signature:
+ * 1. Bridge asset from source chain → BSC (via Axelar/Squid internally)
+ * 2. Approve p{Asset} to spend underlying on BSC
+ * 3. mint(amount)      — supply to Peridot, receive pTokens
+ * 4. enterMarkets([])  — (optional) enable as collateral
+ * 5. transfer pTokens  — return pTokens to user's EOA on BSC
+ *
+ * Returns a CrossChainIntent — the user's dApp must pass biconomyInstructions
+ * to POST /api/biconomy/execute (or directly to Biconomy's execute endpoint).
+ */
+declare function buildCrossChainSupplyIntent(input: CrossChainSupplyInput, config: PeridotConfig): Promise<CrossChainIntent>;
+
+declare const crossChainBorrowSchema: z.ZodObject<{
+    userAddress: z.ZodString;
+    collateralAssets: z.ZodArray<z.ZodString, "many">;
+    borrowAsset: z.ZodString;
+    borrowAmount: z.ZodString;
+    targetChainId: z.ZodEffects<z.ZodOptional<z.ZodNumber>, number | undefined, number | undefined>;
+    slippage: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    borrowAmount: string;
+    userAddress: string;
+    borrowAsset: string;
+    collateralAssets: string[];
+    slippage: number;
+    targetChainId?: number | undefined;
+}, {
+    borrowAmount: string;
+    userAddress: string;
+    borrowAsset: string;
+    collateralAssets: string[];
+    slippage?: number | undefined;
+    targetChainId?: number | undefined;
+}>;
+type CrossChainBorrowInput = z.input<typeof crossChainBorrowSchema>;
+/**
+ * Borrows from Peridot hub and optionally bridges the proceeds to a spoke chain.
+ *
+ * Call sequence (via Biconomy MEE):
+ * 1. enterMarkets(collateralPTokens)  — ensure collateral is active
+ * 2. borrow(amount)                    — borrow from pToken market on hub
+ * 3a. Bridge borrowed tokens → target chain  (if targetChainId provided), OR
+ * 3b. Transfer borrowed tokens to user's EOA on hub chain
+ */
+declare function buildCrossChainBorrowIntent(input: CrossChainBorrowInput, config: PeridotConfig): Promise<CrossChainIntent>;
+
+declare const crossChainRepaySchema: z.ZodObject<{
+    userAddress: z.ZodString;
+    sourceChainId: z.ZodEffects<z.ZodDefault<z.ZodNumber>, number, number | undefined>;
+    asset: z.ZodString;
+    amount: z.ZodString;
+    repayForAddress: z.ZodOptional<z.ZodString>;
+    slippage: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    asset: string;
+    amount: string;
+    userAddress: string;
+    sourceChainId: number;
+    slippage: number;
+    repayForAddress?: string | undefined;
+}, {
+    asset: string;
+    amount: string;
+    userAddress: string;
+    sourceChainId?: number | undefined;
+    slippage?: number | undefined;
+    repayForAddress?: string | undefined;
+}>;
+type CrossChainRepayInput = z.input<typeof crossChainRepaySchema>;
+/**
+ * Repays a Peridot borrow from a spoke chain using Biconomy MEE.
+ *
+ * Call sequence:
+ * 1. Bridge repayment tokens from source chain → BSC hub
+ * 2. Approve p{Asset} to pull repayment tokens
+ * 3. repayBorrow(amount)  — or repayBorrowBehalf if repayForAddress set
+ * 4. Return any excess tokens to user's EOA on BSC
+ */
+declare function buildCrossChainRepayIntent(input: CrossChainRepayInput, config: PeridotConfig): Promise<CrossChainIntent>;
+
+declare const crossChainWithdrawSchema: z.ZodObject<{
+    userAddress: z.ZodString;
+    asset: z.ZodString;
+    amount: z.ZodString;
+    targetChainId: z.ZodEffects<z.ZodOptional<z.ZodNumber>, number | undefined, number | undefined>;
+    slippage: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    asset: string;
+    amount: string;
+    userAddress: string;
+    slippage: number;
+    targetChainId?: number | undefined;
+}, {
+    asset: string;
+    amount: string;
+    userAddress: string;
+    slippage?: number | undefined;
+    targetChainId?: number | undefined;
+}>;
+type CrossChainWithdrawInput = z.input<typeof crossChainWithdrawSchema>;
+/**
+ * Withdraws from Peridot hub and optionally bridges proceeds to a spoke chain.
+ *
+ * Call sequence (via Biconomy MEE):
+ * 1. redeemUnderlying(amount)    — redeem pTokens for underlying on hub
+ * 2a. Bridge underlying → target spoke chain (if targetChainId set), OR
+ * 2b. Transfer to user's EOA on hub chain
+ */
+declare function buildCrossChainWithdrawIntent(input: CrossChainWithdrawInput, config: PeridotConfig): Promise<CrossChainIntent>;
+
+declare const checkTransactionStatusSchema: z.ZodObject<{
+    superTxHash: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    superTxHash: string;
+}, {
+    superTxHash: string;
+}>;
+type CheckTransactionStatusInput = z.infer<typeof checkTransactionStatusSchema>;
+/**
+ * Polls Biconomy for the status of a cross-chain super-transaction.
+ * Call this after the user has signed and submitted a CrossChainIntent.
+ */
+declare function checkTransactionStatus(input: CheckTransactionStatusInput, config: PeridotConfig): Promise<TransactionStatus>;
+
+export { ARBITRUM_CHAIN_ID, ASSET_DECIMALS, AccountLiquidity, BASE_CHAIN_ID, BSC_MAINNET_CHAIN_ID, BSC_TESTNET_CHAIN_ID, BSC_UNDERLYING_TOKENS, BiconomyResponse, COMPTROLLER_ABI, ComposeRequest, CrossChainIntent, ERC20_ABI, ETHEREUM_CHAIN_ID, HubTransactionIntent, LeaderboardEntry, MONAD_MAINNET_CHAIN_ID, MarketRates, MarketSummary, PERIDOT_CONTROLLER, PERIDOT_MARKETS, PTOKEN_ABI, PeridotApiClient, PeridotConfig, SOMNIA_MAINNET_CHAIN_ID, SPOKE_TOKENS, SimulateBorrowResult, ToolDefinition, TransactionStatus, UserPosition, buildCrossChainBorrowIntent, buildCrossChainRepayIntent, buildCrossChainSupplyIntent, buildCrossChainWithdrawIntent, buildHubBorrowIntent, buildHubDisableCollateralIntent, buildHubEnableCollateralIntent, buildHubRepayIntent, buildHubSupplyIntent, buildHubWithdrawIntent, checkTransactionStatus, getAccountLiquidity, getAssetDecimals, getControllerAddress, getLeaderboard, getMarketRates, getPTokenAddress, getUnderlyingTokenAddress, getUserPosition, isHubChain, lendingTools, listMarkets, resolveHubChainId, simulateBorrow };