mantle-agent-kit-sdk 1.0.0

package/dist/index.d.cts

@@ -0,0 +1,782 @@
+import * as viem from 'viem';
+import { WalletClient, Transport, Chain, PublicActions, Address as Address$1, Hex } from 'viem';
+import { PrivateKeyAccount, Address } from 'viem/accounts';
+
+interface SquidRoute {
+    route: {
+        estimate: {
+            fromAmount: string;
+            toAmount: string;
+            toAmountMin: string;
+            route: {
+                actionType: string;
+                chainType: string;
+                data: {
+                    tokenIn: string;
+                    tokenOut: string;
+                    amountIn: string;
+                    amountOut: string;
+                    path: string[];
+                };
+            }[];
+            estimatedRouteDuration: number;
+            aggregatePriceImpact: string;
+            feeCosts: {
+                name: string;
+                description: string;
+                percentage: string;
+                amount: string;
+                amountUSD: string;
+            }[];
+            gasCosts: {
+                type: string;
+                amount: string;
+                amountUSD: string;
+                gasPrice: string;
+                maxFeePerGas: string;
+                maxPriorityFeePerGas: string;
+                estimate: string;
+            }[];
+        };
+        transactionRequest: {
+            routeType: string;
+            targetAddress: string;
+            data: string;
+            value: string;
+            gasLimit: string;
+            gasPrice: string;
+            maxFeePerGas: string;
+            maxPriorityFeePerGas: string;
+        };
+    };
+}
+
+declare const SWAP_ROUTER_ADDRESS = "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45";
+declare const QUOTER_V2_ADDRESS = "0x61fFE014bA17989E743c5F6cB21bF9697530B21e";
+declare const FACTORY_ADDRESS = "0x1F98431c8aD98523631AE4a59f267346ea31F984";
+declare const WMNT_ADDRESS$1 = "0x78c1b0C915c4FAA5FffA6CAbf0219DA63d7f4cb8";
+declare const NATIVE_TOKEN_ADDRESS$3 = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+declare const FEE_TIERS$1: {
+    readonly LOWEST: 100;
+    readonly LOW: 500;
+    readonly MEDIUM: 3000;
+    readonly HIGH: 10000;
+};
+declare const DEFAULT_POOL_FEE: 3000;
+
+declare const index$8_DEFAULT_POOL_FEE: typeof DEFAULT_POOL_FEE;
+declare const index$8_FACTORY_ADDRESS: typeof FACTORY_ADDRESS;
+declare const index$8_QUOTER_V2_ADDRESS: typeof QUOTER_V2_ADDRESS;
+declare const index$8_SWAP_ROUTER_ADDRESS: typeof SWAP_ROUTER_ADDRESS;
+declare namespace index$8 {
+  export { index$8_DEFAULT_POOL_FEE as DEFAULT_POOL_FEE, index$8_FACTORY_ADDRESS as FACTORY_ADDRESS, FEE_TIERS$1 as FEE_TIERS, NATIVE_TOKEN_ADDRESS$3 as NATIVE_TOKEN_ADDRESS, index$8_QUOTER_V2_ADDRESS as QUOTER_V2_ADDRESS, index$8_SWAP_ROUTER_ADDRESS as SWAP_ROUTER_ADDRESS, WMNT_ADDRESS$1 as WMNT_ADDRESS };
+}
+
+interface UniswapQuoteResult {
+    amountOut: bigint;
+    sqrtPriceX96After: bigint;
+    gasEstimate: bigint;
+}
+
+interface OneInchQuote {
+    srcToken: {
+        address: string;
+        symbol: string;
+        decimals: number;
+    };
+    dstToken: {
+        address: string;
+        symbol: string;
+        decimals: number;
+    };
+    srcAmount: string;
+    dstAmount: string;
+    gas: number;
+}
+
+interface OpenOceanQuote {
+    inToken: {
+        address: string;
+        decimals: number;
+        symbol: string;
+        name: string;
+    };
+    outToken: {
+        address: string;
+        decimals: number;
+        symbol: string;
+        name: string;
+    };
+    inAmount: string;
+    outAmount: string;
+    estimatedGas: string;
+}
+
+/**
+ * Platform Configuration & Validation
+ *
+ * Validates APP_ID with Mantle platform API
+ */
+/** Project configuration from platform */
+interface ProjectConfig {
+    appId: string;
+    name: string;
+    payTo: string;
+    network: string;
+    status: string;
+}
+/**
+ * Initialize platform validation
+ *
+ * Reads APP_ID from environment and validates with platform API.
+ * Uses singleton pattern - multiple calls return same promise.
+ *
+ * @returns Project configuration from platform
+ * @throws Error if APP_ID is not set or validation fails
+ */
+declare function initializePlatform(): Promise<ProjectConfig>;
+/**
+ * Get cached project configuration
+ *
+ * @throws Error if platform not initialized
+ */
+declare function getProjectConfig(): ProjectConfig;
+
+declare class MNTAgentKit {
+    account: PrivateKeyAccount;
+    client: WalletClient<Transport, Chain, PrivateKeyAccount> & PublicActions;
+    chain: "testnet" | "mainnet";
+    projectConfig?: ProjectConfig;
+    constructor(privateKey: Address, chain: "mainnet" | "testnet");
+    /**
+     * Initialize the agent with platform validation
+     *
+     * Validates APP_ID with the platform API.
+     * Must be called after creating the agent instance.
+     *
+     * @returns The initialized agent instance
+     * @throws Error if APP_ID is not set or validation fails
+     *
+     * @example
+     * ```typescript
+     * const agent = new MNTAgentKit(privateKey, "mainnet");
+     * await agent.initialize(); // Validates APP_ID
+     * ```
+     */
+    initialize(): Promise<MNTAgentKit>;
+    sendTransaction(to: Address, amount: string): Promise<viem.TransactionReceipt<bigint, number, "success" | "reverted", viem.TransactionType>>;
+    getSwapQuote(fromTokenAddress: string, toTokenAddress: string, amount: string, slippagePercentage?: string): Promise<any>;
+    executeSwap(fromTokenAddress: string, toTokenAddress: string, amount: string, slippagePercentage?: string): Promise<{
+        data: any;
+    } | undefined>;
+    getOpenOceanQuote(fromToken: Address, toToken: Address, amount: string): Promise<OpenOceanQuote>;
+    swapOnOpenOcean(fromToken: Address, toToken: Address, amount: string, slippage?: number): Promise<{
+        txHash: string;
+        outAmount: string;
+    }>;
+    get1inchQuote(fromToken: Address, toToken: Address, amount: string): Promise<OneInchQuote>;
+    swapOn1inch(fromToken: Address, toToken: Address, amount: string, slippage?: number): Promise<{
+        txHash: string;
+        dstAmount: string;
+    }>;
+    getUniswapQuote(fromToken: Address, toToken: Address, amount: string): Promise<UniswapQuoteResult>;
+    swapOnUniswap(fromToken: Address, toToken: Address, amount: string, slippage?: number): Promise<{
+        txHash: string;
+        amountOut: string;
+    }>;
+    lendleSupply(tokenAddress: Address, amount: string): Promise<`0x${string}`>;
+    lendleWithdraw(tokenAddress: Address, amount: string, to?: Address): Promise<`0x${string}`>;
+    lendleBorrow(tokenAddress: Address, amount: string, interestRateMode?: 1 | 2, onBehalfOf?: Address): Promise<`0x${string}`>;
+    lendleRepay(tokenAddress: Address, amount: string, rateMode?: 1 | 2, onBehalfOf?: Address): Promise<`0x${string}`>;
+    agniSwap(tokenIn: Address, tokenOut: Address, amountIn: string, slippagePercent?: number, feeTier?: number): Promise<`0x${string}`>;
+    merchantMoeSwap(tokenIn: Address, tokenOut: Address, amountIn: string, slippagePercent?: number): Promise<`0x${string}`>;
+    getMethTokenAddress(): "0x0000000000000000000000000000000000000000" | "0xcDA86A272531e8640cD7F1a92c01839911B90bb0";
+    getSquidRoute(fromToken: Address, toToken: Address, fromChain: number, toChain: number, amount: string, slippage?: number): Promise<SquidRoute>;
+    crossChainSwapViaSquid(fromToken: Address, toToken: Address, fromChain: number, toChain: number, amount: string, slippage?: number): Promise<`0x${string}`>;
+}
+
+declare const sendTransaction: (agent: MNTAgentKit, to: Address$1, amount: string) => Promise<viem.TransactionReceipt<bigint, number, "success" | "reverted", viem.TransactionType>>;
+
+/**
+ * Check allowance and get approve tx data if needed
+ * @param agent - MNTAgentKit instance
+ * @param tokenAddress - Token to approve
+ * @param amount - Amount to approve
+ * @returns Allowance status and tx data
+ */
+declare function approveToken(agent: MNTAgentKit, tokenAddress: string, amount: string): Promise<{
+    allowanceExists: boolean;
+    data: any;
+}>;
+
+/**
+ * Execute token swap
+ * @param fromTokenAddress - Source token address
+ * @param toTokenAddress - Destination token address
+ * @param amount - Amount to swap
+ * @param slippagePercent - Maximum slippagePercent
+ * @returns Transaction hash
+ */
+declare function executeSwap(agent: MNTAgentKit, fromTokenAddress: string, toTokenAddress: string, amount: string, slippagePercent: string): Promise<{
+    data: any;
+}>;
+
+/**
+ * Get swap quote from OpenOcean
+ * @param agent - MNTAgentKit instance
+ * @param fromToken - Source token address
+ * @param toToken - Destination token address
+ * @param amount - Amount to swap (in smallest units)
+ * @returns Quote data including estimated output amount
+ */
+declare function getOpenOceanQuote(agent: MNTAgentKit, fromToken: string, toToken: string, amount: string): Promise<OpenOceanQuote>;
+
+/**
+ * Execute token swap on OpenOcean
+ * @param agent - MNTAgentKit instance
+ * @param fromToken - Source token address
+ * @param toToken - Destination token address
+ * @param amount - Amount to swap (in smallest units)
+ * @param slippage - Slippage percentage (e.g., "1" for 1%)
+ * @returns Transaction hash
+ */
+declare function swapOnOpenOcean(agent: MNTAgentKit, fromToken: string, toToken: string, amount: string, slippage?: string): Promise<{
+    txHash: string;
+    outAmount: string;
+}>;
+
+/**
+ * Get swap quote from 1inch
+ * @param agent - MNTAgentKit instance
+ * @param fromToken - Source token address
+ * @param toToken - Destination token address
+ * @param amount - Amount to swap (in smallest units)
+ * @returns Quote data including estimated output amount
+ */
+declare function get1inchQuote(agent: MNTAgentKit, fromToken: string, toToken: string, amount: string): Promise<OneInchQuote>;
+
+/**
+ * Execute token swap on 1inch
+ * @param agent - MNTAgentKit instance
+ * @param fromToken - Source token address
+ * @param toToken - Destination token address
+ * @param amount - Amount to swap (in smallest units)
+ * @param slippage - Slippage percentage (e.g., "1" for 1%)
+ * @returns Transaction hash and output amount
+ */
+declare function swapOn1inch(agent: MNTAgentKit, fromToken: string, toToken: string, amount: string, slippage?: string): Promise<{
+    txHash: string;
+    dstAmount: string;
+}>;
+
+/**
+ * Get swap quote from Uniswap V3
+ * @param agent - MNTAgentKit instance
+ * @param fromToken - Source token address
+ * @param toToken - Destination token address
+ * @param amount - Amount to swap (in smallest units)
+ * @param fee - Pool fee tier (default: 3000 = 0.3%)
+ * @returns Quote with expected output amount
+ */
+declare function getUniswapQuote(agent: MNTAgentKit, fromToken: string, toToken: string, amount: string, fee?: number): Promise<UniswapQuoteResult>;
+
+/**
+ * Execute token swap on Uniswap V3
+ * @param agent - MNTAgentKit instance
+ * @param fromToken - Source token address
+ * @param toToken - Destination token address
+ * @param amount - Amount to swap (in smallest units)
+ * @param slippage - Slippage percentage (e.g., "0.5" for 0.5%)
+ * @param fee - Pool fee tier (default: 3000 = 0.3%)
+ * @returns Transaction hash and output amount
+ */
+declare function swapOnUniswap(agent: MNTAgentKit, fromToken: string, toToken: string, amount: string, slippage?: string, fee?: number): Promise<{
+    txHash: string;
+    amountOut: string;
+}>;
+
+/**
+ * Execute cross-chain swap via Squid Router
+ * @param agent - MNTAgentKit instance
+ * @param fromToken - Source token address
+ * @param toToken - Destination token address
+ * @param fromChain - Source chain ID (LayerZero chain ID)
+ * @param toChain - Destination chain ID (LayerZero chain ID)
+ * @param amount - Amount to swap (in smallest units)
+ * @param slippage - Slippage tolerance percentage (default: 1%)
+ * @returns Transaction hash
+ */
+declare function crossChainSwapViaSquid(agent: MNTAgentKit, fromToken: Address$1, toToken: Address$1, fromChain: number, toChain: number, amount: string, slippage?: number): Promise<Hex>;
+/**
+ * Get cross-chain swap route from Squid Router
+ * @param agent - MNTAgentKit instance
+ * @param fromToken - Source token address
+ * @param toToken - Destination token address
+ * @param fromChain - Source chain ID (LayerZero chain ID)
+ * @param toChain - Destination chain ID (LayerZero chain ID)
+ * @param amount - Amount to swap (in smallest units)
+ * @param slippage - Slippage tolerance percentage (default: 1%)
+ * @returns Route data including estimated output and fees
+ */
+declare function getSquidRoute(agent: MNTAgentKit, fromToken: Address$1, toToken: Address$1, fromChain: number, toChain: number, amount: string, slippage?: number): Promise<SquidRoute>;
+
+/**
+ * Supply (deposit) tokens to Lendle Protocol
+ * @param agent - MNTAgentKit instance
+ * @param tokenAddress - Token address to supply
+ * @param amount - Amount to supply (in smallest units)
+ * @returns Transaction hash
+ */
+declare function lendleSupply(agent: MNTAgentKit, tokenAddress: Address$1, amount: string): Promise<Hex>;
+
+/**
+ * Withdraw tokens from Lendle Protocol
+ * @param agent - MNTAgentKit instance
+ * @param tokenAddress - Token address to withdraw
+ * @param amount - Amount to withdraw (in smallest units, use max uint256 for max)
+ * @param to - Address to receive withdrawn tokens (optional, defaults to agent address)
+ * @returns Transaction hash
+ */
+declare function lendleWithdraw(agent: MNTAgentKit, tokenAddress: Address$1, amount: string, to?: Address$1): Promise<Hex>;
+
+/**
+ * Borrow tokens from Lendle Protocol
+ * @param agent - MNTAgentKit instance
+ * @param tokenAddress - Token address to borrow
+ * @param amount - Amount to borrow (in smallest units)
+ * @param interestRateMode - Interest rate mode (1 = stable, 2 = variable)
+ * @param onBehalfOf - Address to receive borrowed tokens (optional, defaults to agent address)
+ * @returns Transaction hash
+ */
+declare function lendleBorrow(agent: MNTAgentKit, tokenAddress: Address$1, amount: string, interestRateMode?: 1 | 2, onBehalfOf?: Address$1): Promise<Hex>;
+
+/**
+ * Repay borrowed tokens to Lendle Protocol
+ * @param agent - MNTAgentKit instance
+ * @param tokenAddress - Token address to repay
+ * @param amount - Amount to repay (in smallest units, use max uint256 for full repayment)
+ * @param rateMode - Interest rate mode (1 = stable, 2 = variable)
+ * @param onBehalfOf - Address whose debt to repay (optional, defaults to agent address)
+ * @returns Transaction hash
+ */
+declare function lendleRepay(agent: MNTAgentKit, tokenAddress: Address$1, amount: string, rateMode?: 1 | 2, onBehalfOf?: Address$1): Promise<Hex>;
+
+/**
+ * Swap tokens on Agni Finance DEX
+ * @param agent - MNTAgentKit instance
+ * @param tokenIn - Input token address
+ * @param tokenOut - Output token address
+ * @param amountIn - Amount to swap (in smallest units)
+ * @param slippagePercent - Slippage tolerance (default: 0.5%)
+ * @param feeTier - Pool fee tier (default: MEDIUM = 0.3%)
+ * @returns Transaction hash
+ */
+declare function agniSwap(agent: MNTAgentKit, tokenIn: Address$1, tokenOut: Address$1, amountIn: string, slippagePercent?: number, feeTier?: number): Promise<Hex>;
+
+/**
+ * Swap tokens on Merchant Moe DEX
+ * @param agent - MNTAgentKit instance
+ * @param tokenIn - Input token address
+ * @param tokenOut - Output token address
+ * @param amountIn - Amount to swap (in smallest units)
+ * @param slippagePercent - Slippage tolerance (default: 0.5%)
+ * @returns Transaction hash
+ */
+declare function merchantMoeSwap(agent: MNTAgentKit, tokenIn: Address$1, tokenOut: Address$1, amountIn: string, slippagePercent?: number): Promise<Hex>;
+
+declare const METH_TOKEN: {
+    readonly mainnet: "0xcDA86A272531e8640cD7F1a92c01839911B90bb0";
+    readonly testnet: "0x0000000000000000000000000000000000000000";
+};
+
+declare const index$7_METH_TOKEN: typeof METH_TOKEN;
+declare namespace index$7 {
+  export { index$7_METH_TOKEN as METH_TOKEN };
+}
+
+declare const FACTORY: {
+    readonly mainnet: "0x25780dc8Fc3cfBD75F33bFDAB65e969b603b2035";
+    readonly testnet: "0x0000000000000000000000000000000000000000";
+};
+declare const SWAP_ROUTER: {
+    readonly mainnet: "0x319B69888b0d11cEC22caA5034e25FfFBDc88421";
+    readonly testnet: "0x0000000000000000000000000000000000000000";
+};
+declare const POSITION_MANAGER: {
+    readonly mainnet: "0x218bf598d1453383e2f4aa7b14ffb9bfb102d637";
+    readonly testnet: "0x0000000000000000000000000000000000000000";
+};
+declare const SWAP_ROUTER_ABI: readonly [{
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly name: "tokenIn";
+            readonly type: "address";
+        }, {
+            readonly name: "tokenOut";
+            readonly type: "address";
+        }, {
+            readonly name: "fee";
+            readonly type: "uint24";
+        }, {
+            readonly name: "recipient";
+            readonly type: "address";
+        }, {
+            readonly name: "deadline";
+            readonly type: "uint256";
+        }, {
+            readonly name: "amountIn";
+            readonly type: "uint256";
+        }, {
+            readonly name: "amountOutMinimum";
+            readonly type: "uint256";
+        }, {
+            readonly name: "sqrtPriceLimitX96";
+            readonly type: "uint160";
+        }];
+        readonly name: "params";
+        readonly type: "tuple";
+    }];
+    readonly name: "exactInputSingle";
+    readonly outputs: readonly [{
+        readonly name: "amountOut";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}];
+declare const FEE_TIERS: {
+    readonly LOWEST: 100;
+    readonly LOW: 500;
+    readonly MEDIUM: 3000;
+    readonly HIGH: 10000;
+};
+
+declare const index$6_FACTORY: typeof FACTORY;
+declare const index$6_FEE_TIERS: typeof FEE_TIERS;
+declare const index$6_POSITION_MANAGER: typeof POSITION_MANAGER;
+declare const index$6_SWAP_ROUTER: typeof SWAP_ROUTER;
+declare const index$6_SWAP_ROUTER_ABI: typeof SWAP_ROUTER_ABI;
+declare namespace index$6 {
+  export { index$6_FACTORY as FACTORY, index$6_FEE_TIERS as FEE_TIERS, index$6_POSITION_MANAGER as POSITION_MANAGER, index$6_SWAP_ROUTER as SWAP_ROUTER, index$6_SWAP_ROUTER_ABI as SWAP_ROUTER_ABI };
+}
+
+declare const LENDING_POOL: {
+    readonly mainnet: "0xCFa5aE7c2CE8Fadc6426C1ff872cA45378Fb7cF3";
+    readonly testnet: "0x0000000000000000000000000000000000000000";
+};
+declare const LENDING_POOL_ADDRESSES_PROVIDER: {
+    readonly mainnet: "0xAb94Bedd21ae3411eB2698945dfCab1D5C19C3d4";
+    readonly testnet: "0x0000000000000000000000000000000000000000";
+};
+declare const PROTOCOL_DATA_PROVIDER: {
+    readonly mainnet: "0x552b9e4bae485C4B7F540777d7D25614CdB84773";
+    readonly testnet: "0x0000000000000000000000000000000000000000";
+};
+declare const ORACLE: {
+    readonly mainnet: "0x870c9692Ab04944C86ec6FEeF63F261226506EfC";
+    readonly testnet: "0x0000000000000000000000000000000000000000";
+};
+declare const WMNT_ADDRESS: "0x78c1b0C915c4FAA5FffA6CAbf0219DA63d7f4cb8";
+declare const INTEREST_RATE_MODE: {
+    readonly STABLE: 1;
+    readonly VARIABLE: 2;
+};
+declare const LENDING_POOL_ABI: readonly [{
+    readonly inputs: readonly [{
+        readonly name: "asset";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "onBehalfOf";
+        readonly type: "address";
+    }, {
+        readonly name: "referralCode";
+        readonly type: "uint16";
+    }];
+    readonly name: "deposit";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "asset";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "to";
+        readonly type: "address";
+    }];
+    readonly name: "withdraw";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "asset";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "interestRateMode";
+        readonly type: "uint256";
+    }, {
+        readonly name: "referralCode";
+        readonly type: "uint16";
+    }, {
+        readonly name: "onBehalfOf";
+        readonly type: "address";
+    }];
+    readonly name: "borrow";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "asset";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "rateMode";
+        readonly type: "uint256";
+    }, {
+        readonly name: "onBehalfOf";
+        readonly type: "address";
+    }];
+    readonly name: "repay";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "user";
+        readonly type: "address";
+    }];
+    readonly name: "getUserAccountData";
+    readonly outputs: readonly [{
+        readonly name: "totalCollateralETH";
+        readonly type: "uint256";
+    }, {
+        readonly name: "totalDebtETH";
+        readonly type: "uint256";
+    }, {
+        readonly name: "availableBorrowsETH";
+        readonly type: "uint256";
+    }, {
+        readonly name: "currentLiquidationThreshold";
+        readonly type: "uint256";
+    }, {
+        readonly name: "ltv";
+        readonly type: "uint256";
+    }, {
+        readonly name: "healthFactor";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "asset";
+        readonly type: "address";
+    }];
+    readonly name: "getReserveData";
+    readonly outputs: readonly [{
+        readonly components: readonly [{
+            readonly name: "configuration";
+            readonly type: "uint256";
+        }, {
+            readonly name: "liquidityIndex";
+            readonly type: "uint128";
+        }, {
+            readonly name: "variableBorrowIndex";
+            readonly type: "uint128";
+        }, {
+            readonly name: "currentLiquidityRate";
+            readonly type: "uint128";
+        }, {
+            readonly name: "currentVariableBorrowRate";
+            readonly type: "uint128";
+        }, {
+            readonly name: "currentStableBorrowRate";
+            readonly type: "uint128";
+        }, {
+            readonly name: "lastUpdateTimestamp";
+            readonly type: "uint40";
+        }, {
+            readonly name: "aTokenAddress";
+            readonly type: "address";
+        }, {
+            readonly name: "stableDebtTokenAddress";
+            readonly type: "address";
+        }, {
+            readonly name: "variableDebtTokenAddress";
+            readonly type: "address";
+        }, {
+            readonly name: "interestRateStrategyAddress";
+            readonly type: "address";
+        }, {
+            readonly name: "id";
+            readonly type: "uint8";
+        }];
+        readonly name: "";
+        readonly type: "tuple";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];
+
+declare const index$5_INTEREST_RATE_MODE: typeof INTEREST_RATE_MODE;
+declare const index$5_LENDING_POOL: typeof LENDING_POOL;
+declare const index$5_LENDING_POOL_ABI: typeof LENDING_POOL_ABI;
+declare const index$5_LENDING_POOL_ADDRESSES_PROVIDER: typeof LENDING_POOL_ADDRESSES_PROVIDER;
+declare const index$5_ORACLE: typeof ORACLE;
+declare const index$5_PROTOCOL_DATA_PROVIDER: typeof PROTOCOL_DATA_PROVIDER;
+declare const index$5_WMNT_ADDRESS: typeof WMNT_ADDRESS;
+declare namespace index$5 {
+  export { index$5_INTEREST_RATE_MODE as INTEREST_RATE_MODE, index$5_LENDING_POOL as LENDING_POOL, index$5_LENDING_POOL_ABI as LENDING_POOL_ABI, index$5_LENDING_POOL_ADDRESSES_PROVIDER as LENDING_POOL_ADDRESSES_PROVIDER, index$5_ORACLE as ORACLE, index$5_PROTOCOL_DATA_PROVIDER as PROTOCOL_DATA_PROVIDER, index$5_WMNT_ADDRESS as WMNT_ADDRESS };
+}
+
+declare const LB_ROUTER: {
+    readonly mainnet: "0x013e138EF6008ae5FDFDE29700e3f2Bc61d21E3a";
+    readonly testnet: "0x0000000000000000000000000000000000000000";
+};
+declare const LB_FACTORY: {
+    readonly mainnet: "0xa6630671775c4EA2743840F9A5016dCf2A104054";
+    readonly testnet: "0x0000000000000000000000000000000000000000";
+};
+declare const LB_QUOTER: {
+    readonly mainnet: "0x501b8AFd35df20f531fF45F6f695793AC3316c85";
+    readonly testnet: "0x0000000000000000000000000000000000000000";
+};
+declare const MOE_TOKEN: "0x4515a45337f461a11ff0fe8abf3c606ae5dc00c9";
+declare const LB_ROUTER_ABI: readonly [{
+    readonly inputs: readonly [{
+        readonly name: "amountIn";
+        readonly type: "uint256";
+    }, {
+        readonly name: "amountOutMin";
+        readonly type: "uint256";
+    }, {
+        readonly name: "path";
+        readonly type: "uint256[]";
+    }, {
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+    readonly name: "swapExactTokensForTokens";
+    readonly outputs: readonly [{
+        readonly name: "amountOut";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}];
+
+declare const index$4_LB_FACTORY: typeof LB_FACTORY;
+declare const index$4_LB_QUOTER: typeof LB_QUOTER;
+declare const index$4_LB_ROUTER: typeof LB_ROUTER;
+declare const index$4_LB_ROUTER_ABI: typeof LB_ROUTER_ABI;
+declare const index$4_MOE_TOKEN: typeof MOE_TOKEN;
+declare namespace index$4 {
+  export { index$4_LB_FACTORY as LB_FACTORY, index$4_LB_QUOTER as LB_QUOTER, index$4_LB_ROUTER as LB_ROUTER, index$4_LB_ROUTER_ABI as LB_ROUTER_ABI, index$4_MOE_TOKEN as MOE_TOKEN };
+}
+
+declare const configs$1: {
+    apiKey: string | undefined;
+    secretKey: string | undefined;
+    apiPassphrase: string | undefined;
+    projectId: string | undefined;
+};
+declare const baseUrl: string;
+declare const ETH_ADDRESS = "0xdeaddeaddeaddeaddeaddeaddeaddeaddead0000";
+
+declare const index$3_ETH_ADDRESS: typeof ETH_ADDRESS;
+declare const index$3_baseUrl: typeof baseUrl;
+declare namespace index$3 {
+  export { index$3_ETH_ADDRESS as ETH_ADDRESS, index$3_baseUrl as baseUrl, configs$1 as configs };
+}
+
+declare const ONEINCH_BASE_URL = "https://api.1inch.dev/swap/v6.0";
+declare const ONEINCH_CHAIN_ID: {
+    readonly mainnet: "5000";
+    readonly testnet: "5003";
+};
+declare const NATIVE_TOKEN_ADDRESS$2 = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+declare const ONEINCH_ROUTER_ADDRESS = "0x111111125421cA6dc452d289314280a0f8842A65";
+declare const configs: {
+    apiKey: string | undefined;
+};
+
+declare const index$2_ONEINCH_BASE_URL: typeof ONEINCH_BASE_URL;
+declare const index$2_ONEINCH_CHAIN_ID: typeof ONEINCH_CHAIN_ID;
+declare const index$2_ONEINCH_ROUTER_ADDRESS: typeof ONEINCH_ROUTER_ADDRESS;
+declare const index$2_configs: typeof configs;
+declare namespace index$2 {
+  export { NATIVE_TOKEN_ADDRESS$2 as NATIVE_TOKEN_ADDRESS, index$2_ONEINCH_BASE_URL as ONEINCH_BASE_URL, index$2_ONEINCH_CHAIN_ID as ONEINCH_CHAIN_ID, index$2_ONEINCH_ROUTER_ADDRESS as ONEINCH_ROUTER_ADDRESS, index$2_configs as configs };
+}
+
+declare const OPENOCEAN_BASE_URL = "https://open-api.openocean.finance/v4";
+declare const OPENOCEAN_CHAIN: {
+    readonly mainnet: "mantle";
+    readonly testnet: "mantle";
+};
+declare const NATIVE_TOKEN_ADDRESS$1 = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+declare const OPENOCEAN_EXCHANGE_PROXY = "0x6352a56caadC4F1E25CD6c75970Fa768A3304e64";
+
+declare const index$1_OPENOCEAN_BASE_URL: typeof OPENOCEAN_BASE_URL;
+declare const index$1_OPENOCEAN_CHAIN: typeof OPENOCEAN_CHAIN;
+declare const index$1_OPENOCEAN_EXCHANGE_PROXY: typeof OPENOCEAN_EXCHANGE_PROXY;
+declare namespace index$1 {
+  export { NATIVE_TOKEN_ADDRESS$1 as NATIVE_TOKEN_ADDRESS, index$1_OPENOCEAN_BASE_URL as OPENOCEAN_BASE_URL, index$1_OPENOCEAN_CHAIN as OPENOCEAN_CHAIN, index$1_OPENOCEAN_EXCHANGE_PROXY as OPENOCEAN_EXCHANGE_PROXY };
+}
+
+declare const SQUID_BASE_URL = "https://api.squidrouter.com/v2";
+declare const SQUID_CHAIN_ID: {
+    readonly mainnet: 5000;
+    readonly testnet: 5003;
+};
+declare const DESTINATION_CHAINS: {
+    readonly ethereum: 101;
+    readonly arbitrum: 110;
+    readonly optimism: 111;
+    readonly polygon: 109;
+    readonly base: 184;
+    readonly bsc: 102;
+    readonly avalanche: 106;
+    readonly mantle: 5000;
+};
+declare const NATIVE_TOKEN_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+
+declare const index_DESTINATION_CHAINS: typeof DESTINATION_CHAINS;
+declare const index_NATIVE_TOKEN_ADDRESS: typeof NATIVE_TOKEN_ADDRESS;
+declare const index_SQUID_BASE_URL: typeof SQUID_BASE_URL;
+declare const index_SQUID_CHAIN_ID: typeof SQUID_CHAIN_ID;
+declare namespace index {
+  export { index_DESTINATION_CHAINS as DESTINATION_CHAINS, index_NATIVE_TOKEN_ADDRESS as NATIVE_TOKEN_ADDRESS, index_SQUID_BASE_URL as SQUID_BASE_URL, index_SQUID_CHAIN_ID as SQUID_CHAIN_ID };
+}
+
+interface UserAccountData {
+    totalCollateralETH: bigint;
+    totalDebtETH: bigint;
+    availableBorrowsETH: bigint;
+    currentLiquidationThreshold: bigint;
+    ltv: bigint;
+    healthFactor: bigint;
+}
+
+export { index$6 as AgniConstants, index$5 as LendleConstants, METH_TOKEN, MNTAgentKit, index$4 as MerchantMoeConstants, index$7 as MethConstants, index$3 as OKXConstants, index$2 as OneInchConstants, index$1 as OpenOceanConstants, type ProjectConfig, index as SquidConstants, index$8 as UniswapConstants, type UserAccountData, agniSwap, approveToken, crossChainSwapViaSquid, executeSwap, get1inchQuote, getOpenOceanQuote, getProjectConfig, getSquidRoute, getUniswapQuote, initializePlatform, lendleBorrow, lendleRepay, lendleSupply, lendleWithdraw, merchantMoeSwap, sendTransaction, swapOn1inch, swapOnOpenOcean, swapOnUniswap };