mantle-agent-kit-sdk 1.0.3 → 1.0.4

package/dist/index.d.ts

@@ -1,8 +1,36 @@
 import * as viem from 'viem';
-import { WalletClient, Transport, Chain, PublicActions, Address as Address$1, Hex } from 'viem';
-import { PrivateKeyAccount, Address } from 'viem/accounts';
+import { Hex, Address, WalletClient, Transport, Chain, PublicActions } from 'viem';
+import { PrivateKeyAccount, Address as Address$1 } from 'viem/accounts';
 import { Erc7811Actions } from 'viem/experimental';
 
+interface OpenPositionResult$1 {
+    positionId: bigint;
+    txHash: Hex;
+}
+/**
+ * Open a short position on PikePerps
+ * @param agent - MNTAgentKit instance
+ * @param tokenAddress - Token to trade (meme token address)
+ * @param margin - Margin amount in wei (as string)
+ * @param leverage - Leverage multiplier (1-100)
+ * @returns Position ID and transaction hash
+ */
+declare function pikeperpsOpenShort(agent: MNTAgentKit, tokenAddress: Address, margin: string, leverage?: number): Promise<OpenPositionResult$1>;
+
+interface OpenPositionResult {
+    positionId: bigint;
+    txHash: Hex;
+}
+/**
+ * Open a long position on PikePerps
+ * @param agent - MNTAgentKit instance
+ * @param tokenAddress - Token to trade (meme token address)
+ * @param margin - Margin amount in wei (as string)
+ * @param leverage - Leverage multiplier (1-100)
+ * @returns Position ID and transaction hash
+ */
+declare function pikeperpsOpenLong(agent: MNTAgentKit, tokenAddress: Address, margin: string, leverage?: number): Promise<OpenPositionResult>;
+
 interface SquidRoute {
     route: {
         estimate: {
@@ -52,166 +80,7 @@ interface SquidRoute {
     };
 }
 
-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 & Erc7811Actions;
-    chain: "testnet" | "mainnet";
-    demo: boolean;
-    projectConfig?: ProjectConfig;
-    constructor(privateKey: Address, chain: "mainnet" | "testnet" | "testnet-demo");
-    /**
-     * 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;
-    }>;
-    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<{
-        route: {
-            estimate: {
-                toAmount: string;
-            };
-            transactionRequest: {
-                targetAddress: string;
-                data: string;
-                value: string;
-                gasLimit: string;
-            };
-        };
-        demo: boolean;
-        message: string;
-    } | 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, tokenAddress?: Address$1) => Promise<viem.TransactionReceipt<bigint, number, "success" | "reverted", viem.TransactionType>>;
+declare const sendTransaction: (agent: MNTAgentKit, to: Address, amount: string, tokenAddress?: Address) => Promise<viem.TransactionReceipt<bigint, number, "success" | "reverted", viem.TransactionType>>;
 
 /**
  * Check allowance and get approve tx data if needed
@@ -237,6 +106,24 @@ declare function executeSwap(agent: MNTAgentKit, fromTokenAddress: string, toTok
     data: any;
 }>;
 
+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;
+}
+
 /**
  * Get swap quote from OpenOcean
  * @param agent - MNTAgentKit instance
@@ -261,6 +148,22 @@ declare function swapOnOpenOcean(agent: MNTAgentKit, fromToken: string, toToken:
     outAmount: string;
 }>;
 
+interface OneInchQuote {
+    srcToken: {
+        address: string;
+        symbol: string;
+        decimals: number;
+    };
+    dstToken: {
+        address: string;
+        symbol: string;
+        decimals: number;
+    };
+    srcAmount: string;
+    dstAmount: string;
+    gas: number;
+}
+
 /**
  * Get swap quote from 1inch
  * @param agent - MNTAgentKit instance
@@ -285,6 +188,33 @@ declare function swapOn1inch(agent: MNTAgentKit, fromToken: string, toToken: str
     dstAmount: 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$9_DEFAULT_POOL_FEE: typeof DEFAULT_POOL_FEE;
+declare const index$9_FACTORY_ADDRESS: typeof FACTORY_ADDRESS;
+declare const index$9_QUOTER_V2_ADDRESS: typeof QUOTER_V2_ADDRESS;
+declare const index$9_SWAP_ROUTER_ADDRESS: typeof SWAP_ROUTER_ADDRESS;
+declare namespace index$9 {
+  export { index$9_DEFAULT_POOL_FEE as DEFAULT_POOL_FEE, index$9_FACTORY_ADDRESS as FACTORY_ADDRESS, FEE_TIERS$1 as FEE_TIERS, NATIVE_TOKEN_ADDRESS$3 as NATIVE_TOKEN_ADDRESS, index$9_QUOTER_V2_ADDRESS as QUOTER_V2_ADDRESS, index$9_SWAP_ROUTER_ADDRESS as SWAP_ROUTER_ADDRESS, WMNT_ADDRESS$1 as WMNT_ADDRESS };
+}
+
+interface UniswapQuoteResult {
+    amountOut: bigint;
+    sqrtPriceX96After: bigint;
+    gasEstimate: bigint;
+}
+
 /**
  * Get swap quote from Uniswap V3
  * @param agent - MNTAgentKit instance
@@ -322,7 +252,7 @@ declare function swapOnUniswap(agent: MNTAgentKit, fromToken: string, toToken: s
  * @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>;
+declare function crossChainSwapViaSquid(agent: MNTAgentKit, fromToken: Address, toToken: Address, fromChain: number, toChain: number, amount: string, slippage?: number): Promise<Hex>;
 /**
  * Get cross-chain swap route from Squid Router
  * @param agent - MNTAgentKit instance
@@ -334,7 +264,7 @@ declare function crossChainSwapViaSquid(agent: MNTAgentKit, fromToken: Address$1
  * @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<{
+declare function getSquidRoute(agent: MNTAgentKit, fromToken: Address, toToken: Address, fromChain: number, toChain: number, amount: string, slippage?: number): Promise<{
     route: {
         estimate: {
             toAmount: string;
@@ -357,7 +287,7 @@ declare function getSquidRoute(agent: MNTAgentKit, fromToken: Address$1, toToken
  * @param amount - Amount to supply (in smallest units)
  * @returns Transaction hash
  */
-declare function lendleSupply(agent: MNTAgentKit, tokenAddress: Address$1, amount: string): Promise<Hex>;
+declare function lendleSupply(agent: MNTAgentKit, tokenAddress: Address, amount: string): Promise<Hex>;
 
 /**
  * Withdraw tokens from Lendle Protocol
@@ -367,7 +297,7 @@ declare function lendleSupply(agent: MNTAgentKit, tokenAddress: Address$1, amoun
  * @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>;
+declare function lendleWithdraw(agent: MNTAgentKit, tokenAddress: Address, amount: string, to?: Address): Promise<Hex>;
 
 /**
  * Borrow tokens from Lendle Protocol
@@ -378,7 +308,7 @@ declare function lendleWithdraw(agent: MNTAgentKit, tokenAddress: Address$1, amo
  * @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>;
+declare function lendleBorrow(agent: MNTAgentKit, tokenAddress: Address, amount: string, interestRateMode?: 1 | 2, onBehalfOf?: Address): Promise<Hex>;
 
 /**
  * Repay borrowed tokens to Lendle Protocol
@@ -389,7 +319,32 @@ declare function lendleBorrow(agent: MNTAgentKit, tokenAddress: Address$1, amoun
  * @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>;
+declare function lendleRepay(agent: MNTAgentKit, tokenAddress: Address, amount: string, rateMode?: 1 | 2, onBehalfOf?: Address): Promise<Hex>;
+
+interface LendlePosition {
+    asset: Address;
+    symbol: string;
+    supplied: bigint;
+    stableDebt: bigint;
+    variableDebt: bigint;
+    totalDebt: bigint;
+    liquidityRate: bigint;
+    stableBorrowRate: bigint;
+    usageAsCollateralEnabled: boolean;
+}
+interface LendlePositionsResult {
+    positions: LendlePosition[];
+    totalSupplied: bigint;
+    totalDebt: bigint;
+}
+/**
+ * Get all Lendle positions for a user
+ * Returns per-token supply and borrow amounts
+ * @param agent - MNTAgentKit instance
+ * @param userAddress - User wallet address (optional, defaults to agent account)
+ * @returns Array of positions with supply/borrow amounts per asset
+ */
+declare function lendleGetPositions(agent: MNTAgentKit, userAddress?: Address): Promise<LendlePositionsResult>;
 
 /**
  * Swap tokens on Agni Finance DEX
@@ -401,7 +356,7 @@ declare function lendleRepay(agent: MNTAgentKit, tokenAddress: Address$1, amount
  * @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>;
+declare function agniSwap(agent: MNTAgentKit, tokenIn: Address, tokenOut: Address, amountIn: string, slippagePercent?: number, feeTier?: number): Promise<Hex>;
 
 /**
  * Swap tokens on Merchant Moe DEX
@@ -412,66 +367,419 @@ declare function agniSwap(agent: MNTAgentKit, tokenIn: Address$1, tokenOut: Addr
  * @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 function merchantMoeSwap(agent: MNTAgentKit, tokenIn: Address, tokenOut: Address, 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 WETH_TOKEN: {
+    readonly mainnet: "0xdEAddEaDdeadDEadDEADDEAddEADDEAddead1111";
+    readonly testnet: "0xdEAddEaDdeadDEadDEADDEAddEADDEAddead1111";
 };
-declare const POSITION_MANAGER: {
-    readonly mainnet: "0x218bf598d1453383e2f4aa7b14ffb9bfb102d637";
-    readonly testnet: "0x0000000000000000000000000000000000000000";
+declare const WMNT_TOKEN: {
+    readonly mainnet: "0x78c1b0C915c4FAA5FffA6CAbf0219DA63d7f4cb8";
+    readonly testnet: "0x78c1b0C915c4FAA5FffA6CAbf0219DA63d7f4cb8";
 };
-declare const SWAP_ROUTER_ABI: readonly [{
+declare const NATIVE_MNT_ADDRESS: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+declare const METH_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: "account";
+        readonly type: "address";
     }];
-    readonly name: "exactInputSingle";
+    readonly name: "balanceOf";
     readonly outputs: readonly [{
-        readonly name: "amountOut";
+        readonly name: "";
         readonly type: "uint256";
     }];
-    readonly stateMutability: "payable";
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "totalSupply";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "decimals";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint8";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "symbol";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "approve";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly name: "spender";
+        readonly type: "address";
+    }];
+    readonly name: "allowance";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];
+
+declare const index$8_METH_ABI: typeof METH_ABI;
+declare const index$8_METH_TOKEN: typeof METH_TOKEN;
+declare const index$8_NATIVE_MNT_ADDRESS: typeof NATIVE_MNT_ADDRESS;
+declare const index$8_WETH_TOKEN: typeof WETH_TOKEN;
+declare const index$8_WMNT_TOKEN: typeof WMNT_TOKEN;
+declare namespace index$8 {
+  export { index$8_METH_ABI as METH_ABI, index$8_METH_TOKEN as METH_TOKEN, index$8_NATIVE_MNT_ADDRESS as NATIVE_MNT_ADDRESS, index$8_WETH_TOKEN as WETH_TOKEN, index$8_WMNT_TOKEN as WMNT_TOKEN };
+}
+
+interface MethPosition {
+    methBalance: bigint;
+    wethBalance: bigint;
+    wmntBalance: bigint;
+    methTokenAddress: Address;
+    wethTokenAddress: Address;
+    wmntTokenAddress: Address;
+}
+/**
+ * Get mETH position for a user
+ * Returns mETH balance, WETH balance (for swaps), and WMNT balance
+ * @param agent - MNTAgentKit instance
+ * @param userAddress - User wallet address (optional, defaults to agent account)
+ * @returns mETH position with balances
+ */
+declare function methGetPosition(agent: MNTAgentKit, userAddress?: Address): Promise<MethPosition>;
+
+/**
+ * Swap WETH to mETH using DEX aggregator
+ * This is the L2 way to acquire mETH - swap via DEX
+ * @param agent - MNTAgentKit instance
+ * @param amount - Amount of WETH to swap (in wei as string)
+ * @param slippage - Slippage tolerance percentage (default 0.5%)
+ * @returns Transaction hash
+ */
+declare function swapToMeth(agent: MNTAgentKit, amount: string, slippage?: number): Promise<Hex>;
+
+/**
+ * Swap mETH to WETH using DEX aggregator
+ * This is the L2 way to exit mETH position - swap via DEX
+ * @param agent - MNTAgentKit instance
+ * @param amount - Amount of mETH to swap (in wei as string)
+ * @param slippage - Slippage tolerance percentage (default 0.5%)
+ * @returns Transaction hash
+ */
+declare function swapFromMeth(agent: MNTAgentKit, amount: string, slippage?: number): Promise<Hex>;
+
+/**
+ * Close an existing position on PikePerps
+ * @param agent - MNTAgentKit instance
+ * @param positionId - Position ID to close
+ * @returns Transaction hash
+ */
+declare function pikeperpsClosePosition(agent: MNTAgentKit, positionId: bigint): Promise<Hex>;
+
+interface PikePerpsPosition {
+    positionId: bigint;
+    token: Address;
+    isLong: boolean;
+    size: bigint;
+    margin: bigint;
+    leverage: number;
+    entryPrice: bigint;
+    entryTime: bigint;
+    currentPrice: bigint;
+    pnl: bigint;
+    isProfit: boolean;
+    liquidationPrice: bigint;
+    isOpen: boolean;
+}
+/**
+ * Get all positions for a user on PikePerps
+ * Returns detailed position data including PnL and liquidation prices
+ * @param agent - MNTAgentKit instance
+ * @param userAddress - User wallet address (optional, defaults to agent account)
+ * @returns Array of positions with PnL and liquidation data
+ */
+declare function pikeperpsGetPositions(agent: MNTAgentKit, userAddress?: Address): Promise<PikePerpsPosition[]>;
+
+interface PikePerpsTrade {
+    positionId: bigint;
+    trader: Address;
+    token: Address;
+    isLong: boolean;
+    size: bigint;
+    margin: bigint;
+    leverage: bigint;
+    entryPrice: bigint;
+    timestamp: number;
+    txHash: Hex;
+    blockNumber: bigint;
+}
+interface PikePerpsMarketData {
+    token: Address;
+    currentPrice: bigint;
+    hasPrice: boolean;
+    isListed: boolean;
+    curveProgress: bigint;
+    recentTrades: PikePerpsTrade[];
+}
+/**
+ * Get market data for a token on PikePerps
+ * Returns current price and recent trades
+ * @param agent - MNTAgentKit instance
+ * @param tokenAddress - Token address to get market data for
+ * @param limit - Maximum number of recent trades to return (default 20)
+ * @returns Market data with price and recent trades
+ */
+declare function pikeperpsGetMarketData(agent: MNTAgentKit, tokenAddress: Address, limit?: number): Promise<PikePerpsMarketData>;
+
+/**
+ * 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 & Erc7811Actions;
+    chain: "testnet" | "mainnet";
+    demo: boolean;
+    projectConfig?: ProjectConfig;
+    constructor(privateKey: Address$1, chain: "mainnet" | "testnet" | "testnet-demo");
+    /**
+     * 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$1, 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;
+    }>;
+    getOpenOceanQuote(fromToken: Address$1, toToken: Address$1, amount: string): Promise<OpenOceanQuote>;
+    swapOnOpenOcean(fromToken: Address$1, toToken: Address$1, amount: string, slippage?: number): Promise<{
+        txHash: string;
+        outAmount: string;
+    }>;
+    get1inchQuote(fromToken: Address$1, toToken: Address$1, amount: string): Promise<OneInchQuote>;
+    swapOn1inch(fromToken: Address$1, toToken: Address$1, amount: string, slippage?: number): Promise<{
+        txHash: string;
+        dstAmount: string;
+    }>;
+    getUniswapQuote(fromToken: Address$1, toToken: Address$1, amount: string): Promise<UniswapQuoteResult>;
+    swapOnUniswap(fromToken: Address$1, toToken: Address$1, amount: string, slippage?: number): Promise<{
+        txHash: string;
+        amountOut: string;
+    }>;
+    lendleSupply(tokenAddress: Address$1, amount: string): Promise<`0x${string}`>;
+    lendleWithdraw(tokenAddress: Address$1, amount: string, to?: Address$1): Promise<`0x${string}`>;
+    lendleBorrow(tokenAddress: Address$1, amount: string, interestRateMode?: 1 | 2, onBehalfOf?: Address$1): Promise<`0x${string}`>;
+    lendleRepay(tokenAddress: Address$1, amount: string, rateMode?: 1 | 2, onBehalfOf?: Address$1): Promise<`0x${string}`>;
+    /**
+     * Get user account data from Lendle LendingPool
+     * Returns overall position including total collateral, debt, and health factor
+     * @param userAddress - User wallet address (optional, defaults to agent account)
+     * @returns User account data with collateral, debt, available borrows, and health factor
+     */
+    lendleGetUserAccountData(userAddress?: Address$1): Promise<UserAccountData>;
+    /**
+     * Get all Lendle positions for a user (per-token breakdown)
+     * Returns detailed supply and borrow amounts for each asset
+     * @param userAddress - User wallet address (optional, defaults to agent account)
+     * @returns Array of positions with supply/borrow amounts per asset
+     */
+    lendleGetPositions(userAddress?: Address$1): Promise<LendlePositionsResult>;
+    agniSwap(tokenIn: Address$1, tokenOut: Address$1, amountIn: string, slippagePercent?: number, feeTier?: number): Promise<`0x${string}`>;
+    merchantMoeSwap(tokenIn: Address$1, tokenOut: Address$1, amountIn: string, slippagePercent?: number): Promise<`0x${string}`>;
+    getMethTokenAddress(): "0x0000000000000000000000000000000000000000" | "0xcDA86A272531e8640cD7F1a92c01839911B90bb0";
+    /**
+     * Get mETH staking position for a user
+     * Returns mETH balance and WETH balance for comparison
+     * @param userAddress - User wallet address (optional, defaults to agent account)
+     * @returns mETH position with balances
+     */
+    methGetPosition(userAddress?: Address$1): Promise<MethPosition>;
+    /**
+     * Swap WETH to mETH using DEX aggregator
+     * @param amount - Amount of WETH to swap (in wei as string)
+     * @param slippage - Slippage tolerance percentage (default 0.5%)
+     * @returns Transaction hash
+     */
+    swapToMeth(amount: string, slippage?: number): Promise<`0x${string}`>;
+    /**
+     * Swap mETH to WETH using DEX aggregator
+     * @param amount - Amount of mETH to swap (in wei as string)
+     * @param slippage - Slippage tolerance percentage (default 0.5%)
+     * @returns Transaction hash
+     */
+    swapFromMeth(amount: string, slippage?: number): Promise<`0x${string}`>;
+    getSquidRoute(fromToken: Address$1, toToken: Address$1, fromChain: number, toChain: number, amount: string, slippage?: number): Promise<{
+        route: {
+            estimate: {
+                toAmount: string;
+            };
+            transactionRequest: {
+                targetAddress: string;
+                data: string;
+                value: string;
+                gasLimit: string;
+            };
+        };
+        demo: boolean;
+        message: string;
+    } | SquidRoute>;
+    crossChainSwapViaSquid(fromToken: Address$1, toToken: Address$1, fromChain: number, toChain: number, amount: string, slippage?: number): Promise<`0x${string}`>;
+    /**
+     * Open a long position on PikePerps
+     * @param tokenAddress - Token to trade (meme token address)
+     * @param margin - Margin amount in wei (as string)
+     * @param leverage - Leverage multiplier (1-100, default 10)
+     * @returns Position ID and transaction hash
+     */
+    pikeperpsOpenLong(tokenAddress: Address$1, margin: string, leverage?: number): Promise<OpenPositionResult>;
+    /**
+     * Open a short position on PikePerps
+     * @param tokenAddress - Token to trade (meme token address)
+     * @param margin - Margin amount in wei (as string)
+     * @param leverage - Leverage multiplier (1-100, default 10)
+     * @returns Position ID and transaction hash
+     */
+    pikeperpsOpenShort(tokenAddress: Address$1, margin: string, leverage?: number): Promise<OpenPositionResult$1>;
+    /**
+     * Close an existing position on PikePerps
+     * @param positionId - Position ID to close
+     * @returns Transaction hash
+     */
+    pikeperpsClosePosition(positionId: bigint): Promise<`0x${string}`>;
+    /**
+     * Get all positions for a user on PikePerps
+     * Returns detailed position data including PnL and liquidation prices
+     * @param userAddress - User wallet address (optional, defaults to agent account)
+     * @returns Array of positions with PnL and liquidation data
+     */
+    pikeperpsGetPositions(userAddress?: Address$1): Promise<PikePerpsPosition[]>;
+    /**
+     * Get market data for a token on PikePerps
+     * Returns current price and recent trades
+     * @param tokenAddress - Token address to get market data for
+     * @param limit - Maximum number of recent trades to return (default 20)
+     * @returns Market data with price and recent trades
+     */
+    pikeperpsGetMarketData(tokenAddress: Address$1, limit?: number): Promise<PikePerpsMarketData>;
+}
+
+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: {
@@ -481,13 +789,13 @@ declare const FEE_TIERS: {
     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 index$7_FACTORY: typeof FACTORY;
+declare const index$7_FEE_TIERS: typeof FEE_TIERS;
+declare const index$7_POSITION_MANAGER: typeof POSITION_MANAGER;
+declare const index$7_SWAP_ROUTER: typeof SWAP_ROUTER;
+declare const index$7_SWAP_ROUTER_ABI: typeof SWAP_ROUTER_ABI;
+declare namespace index$7 {
+  export { index$7_FACTORY as FACTORY, index$7_FEE_TIERS as FEE_TIERS, index$7_POSITION_MANAGER as POSITION_MANAGER, index$7_SWAP_ROUTER as SWAP_ROUTER, index$7_SWAP_ROUTER_ABI as SWAP_ROUTER_ABI };
 }
 
 declare const LENDING_POOL: {
@@ -666,16 +974,111 @@ declare const LENDING_POOL_ABI: readonly [{
     readonly stateMutability: "view";
     readonly type: "function";
 }];
+declare const PROTOCOL_DATA_PROVIDER_ABI: readonly [{
+    readonly inputs: readonly [];
+    readonly name: "getAllReservesTokens";
+    readonly outputs: readonly [{
+        readonly components: readonly [{
+            readonly name: "symbol";
+            readonly type: "string";
+        }, {
+            readonly name: "tokenAddress";
+            readonly type: "address";
+        }];
+        readonly name: "";
+        readonly type: "tuple[]";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "asset";
+        readonly type: "address";
+    }, {
+        readonly name: "user";
+        readonly type: "address";
+    }];
+    readonly name: "getUserReserveData";
+    readonly outputs: readonly [{
+        readonly name: "currentATokenBalance";
+        readonly type: "uint256";
+    }, {
+        readonly name: "currentStableDebt";
+        readonly type: "uint256";
+    }, {
+        readonly name: "currentVariableDebt";
+        readonly type: "uint256";
+    }, {
+        readonly name: "principalStableDebt";
+        readonly type: "uint256";
+    }, {
+        readonly name: "scaledVariableDebt";
+        readonly type: "uint256";
+    }, {
+        readonly name: "stableBorrowRate";
+        readonly type: "uint256";
+    }, {
+        readonly name: "liquidityRate";
+        readonly type: "uint256";
+    }, {
+        readonly name: "stableRateLastUpdated";
+        readonly type: "uint40";
+    }, {
+        readonly name: "usageAsCollateralEnabled";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "asset";
+        readonly type: "address";
+    }];
+    readonly name: "getReserveTokensAddresses";
+    readonly outputs: readonly [{
+        readonly name: "aTokenAddress";
+        readonly type: "address";
+    }, {
+        readonly name: "stableDebtTokenAddress";
+        readonly type: "address";
+    }, {
+        readonly name: "variableDebtTokenAddress";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];
+declare const LENDLE_SUPPORTED_ASSETS: {
+    readonly mainnet: readonly [{
+        readonly symbol: "WMNT";
+        readonly address: "0x78c1b0C915c4FAA5FffA6CAbf0219DA63d7f4cb8";
+    }, {
+        readonly symbol: "WETH";
+        readonly address: "0xdEAddEaDdeadDEadDEADDEAddEADDEAddead1111";
+    }, {
+        readonly symbol: "USDC";
+        readonly address: "0x09Bc4E0D10C81b3a3766c49F0f98a8aaa7adA8D2";
+    }, {
+        readonly symbol: "USDT";
+        readonly address: "0x201EBa5CC46D216Ce6DC03F6a759e8E766e956aE";
+    }, {
+        readonly symbol: "mETH";
+        readonly address: "0xcDA86A272531e8640cD7F1a92c01839911B90bb0";
+    }];
+    readonly testnet: readonly [];
+};
 
-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 index$6_INTEREST_RATE_MODE: typeof INTEREST_RATE_MODE;
+declare const index$6_LENDING_POOL: typeof LENDING_POOL;
+declare const index$6_LENDING_POOL_ABI: typeof LENDING_POOL_ABI;
+declare const index$6_LENDING_POOL_ADDRESSES_PROVIDER: typeof LENDING_POOL_ADDRESSES_PROVIDER;
+declare const index$6_LENDLE_SUPPORTED_ASSETS: typeof LENDLE_SUPPORTED_ASSETS;
+declare const index$6_ORACLE: typeof ORACLE;
+declare const index$6_PROTOCOL_DATA_PROVIDER: typeof PROTOCOL_DATA_PROVIDER;
+declare const index$6_PROTOCOL_DATA_PROVIDER_ABI: typeof PROTOCOL_DATA_PROVIDER_ABI;
+declare const index$6_WMNT_ADDRESS: typeof WMNT_ADDRESS;
+declare namespace index$6 {
+  export { index$6_INTEREST_RATE_MODE as INTEREST_RATE_MODE, index$6_LENDING_POOL as LENDING_POOL, index$6_LENDING_POOL_ABI as LENDING_POOL_ABI, index$6_LENDING_POOL_ADDRESSES_PROVIDER as LENDING_POOL_ADDRESSES_PROVIDER, index$6_LENDLE_SUPPORTED_ASSETS as LENDLE_SUPPORTED_ASSETS, index$6_ORACLE as ORACLE, index$6_PROTOCOL_DATA_PROVIDER as PROTOCOL_DATA_PROVIDER, index$6_PROTOCOL_DATA_PROVIDER_ABI as PROTOCOL_DATA_PROVIDER_ABI, index$6_WMNT_ADDRESS as WMNT_ADDRESS };
 }
 
 declare const LB_ROUTER: {
@@ -717,13 +1120,13 @@ declare const LB_ROUTER_ABI: readonly [{
     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 index$5_LB_FACTORY: typeof LB_FACTORY;
+declare const index$5_LB_QUOTER: typeof LB_QUOTER;
+declare const index$5_LB_ROUTER: typeof LB_ROUTER;
+declare const index$5_LB_ROUTER_ABI: typeof LB_ROUTER_ABI;
+declare const index$5_MOE_TOKEN: typeof MOE_TOKEN;
+declare namespace index$5 {
+  export { index$5_LB_FACTORY as LB_FACTORY, index$5_LB_QUOTER as LB_QUOTER, index$5_LB_ROUTER as LB_ROUTER, index$5_LB_ROUTER_ABI as LB_ROUTER_ABI, index$5_MOE_TOKEN as MOE_TOKEN };
 }
 
 declare const configs$1: {
@@ -735,10 +1138,10 @@ declare const configs$1: {
 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 index$4_ETH_ADDRESS: typeof ETH_ADDRESS;
+declare const index$4_baseUrl: typeof baseUrl;
+declare namespace index$4 {
+  export { index$4_ETH_ADDRESS as ETH_ADDRESS, index$4_baseUrl as baseUrl, configs$1 as configs };
 }
 
 declare const ONEINCH_BASE_URL = "https://api.1inch.dev/swap/v6.0";
@@ -752,12 +1155,12 @@ 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 index$3_ONEINCH_BASE_URL: typeof ONEINCH_BASE_URL;
+declare const index$3_ONEINCH_CHAIN_ID: typeof ONEINCH_CHAIN_ID;
+declare const index$3_ONEINCH_ROUTER_ADDRESS: typeof ONEINCH_ROUTER_ADDRESS;
+declare const index$3_configs: typeof configs;
+declare namespace index$3 {
+  export { NATIVE_TOKEN_ADDRESS$2 as NATIVE_TOKEN_ADDRESS, index$3_ONEINCH_BASE_URL as ONEINCH_BASE_URL, index$3_ONEINCH_CHAIN_ID as ONEINCH_CHAIN_ID, index$3_ONEINCH_ROUTER_ADDRESS as ONEINCH_ROUTER_ADDRESS, index$3_configs as configs };
 }
 
 declare const OPENOCEAN_BASE_URL = "https://open-api.openocean.finance/v4";
@@ -768,11 +1171,11 @@ declare const OPENOCEAN_CHAIN: {
 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 index$2_OPENOCEAN_BASE_URL: typeof OPENOCEAN_BASE_URL;
+declare const index$2_OPENOCEAN_CHAIN: typeof OPENOCEAN_CHAIN;
+declare const index$2_OPENOCEAN_EXCHANGE_PROXY: typeof OPENOCEAN_EXCHANGE_PROXY;
+declare namespace index$2 {
+  export { NATIVE_TOKEN_ADDRESS$1 as NATIVE_TOKEN_ADDRESS, index$2_OPENOCEAN_BASE_URL as OPENOCEAN_BASE_URL, index$2_OPENOCEAN_CHAIN as OPENOCEAN_CHAIN, index$2_OPENOCEAN_EXCHANGE_PROXY as OPENOCEAN_EXCHANGE_PROXY };
 }
 
 declare const SQUID_BASE_URL = "https://api.squidrouter.com/v2";
@@ -792,12 +1195,399 @@ declare const DESTINATION_CHAINS: {
 };
 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 const index$1_DESTINATION_CHAINS: typeof DESTINATION_CHAINS;
+declare const index$1_NATIVE_TOKEN_ADDRESS: typeof NATIVE_TOKEN_ADDRESS;
+declare const index$1_SQUID_BASE_URL: typeof SQUID_BASE_URL;
+declare const index$1_SQUID_CHAIN_ID: typeof SQUID_CHAIN_ID;
+declare namespace index$1 {
+  export { index$1_DESTINATION_CHAINS as DESTINATION_CHAINS, index$1_NATIVE_TOKEN_ADDRESS as NATIVE_TOKEN_ADDRESS, index$1_SQUID_BASE_URL as SQUID_BASE_URL, index$1_SQUID_CHAIN_ID as SQUID_CHAIN_ID };
+}
+
+declare const PERPETUAL_TRADING: {
+    readonly mainnet: "0x0000000000000000000000000000000000000000";
+    readonly testnet: "0x8081b646f349c049f2d5e8a400057d411dd657bd";
+};
+declare const BONDING_CURVE_MARKET: {
+    readonly mainnet: "0x0000000000000000000000000000000000000000";
+    readonly testnet: "0x93b268325A9862645c82b32229f3B52264750Ca2";
+};
+declare const PIKE_PERPS_CONFIG: {
+    readonly MAX_LEVERAGE: 100;
+    readonly DEFAULT_LEVERAGE: 10;
+    readonly MIN_LEVERAGE: 1;
+    readonly TRADING_FEE_BPS: 5;
+    readonly LIQUIDATION_REWARD_BPS: 500;
+    readonly PRICE_DECIMALS: 8;
+};
+declare const PERPETUAL_TRADING_ABI: readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "_pyth";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "constructor";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "uint256";
+        readonly name: "positionId";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "user";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "pnl";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "exitPrice";
+        readonly type: "uint256";
+    }];
+    readonly name: "PositionClosed";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "uint256";
+        readonly name: "positionId";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "user";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "liquidationPrice";
+        readonly type: "uint256";
+    }];
+    readonly name: "PositionLiquidated";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "uint256";
+        readonly name: "positionId";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "user";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "token";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "bool";
+        readonly name: "isLong";
+        readonly type: "bool";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "size";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "margin";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "leverage";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "entryPrice";
+        readonly type: "uint256";
+    }];
+    readonly name: "PositionOpened";
+    readonly type: "event";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "_positionId";
+        readonly type: "uint256";
+    }];
+    readonly name: "closePosition";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "_token";
+        readonly type: "address";
+    }];
+    readonly name: "getCurrentPrice";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "currentPrice";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bool";
+        readonly name: "hasPrice";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "_positionId";
+        readonly type: "uint256";
+    }];
+    readonly name: "getLiquidationPrice";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "liquidationPrice";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "_positionId";
+        readonly type: "uint256";
+    }];
+    readonly name: "getPosition";
+    readonly outputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "address";
+            readonly name: "user";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address";
+            readonly name: "token";
+            readonly type: "address";
+        }, {
+            readonly internalType: "bool";
+            readonly name: "isLong";
+            readonly type: "bool";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "size";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "margin";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "leverage";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "entryPrice";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "entryTime";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "lastFundingTime";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "bool";
+            readonly name: "isOpen";
+            readonly type: "bool";
+        }];
+        readonly internalType: "struct PerpetualTrading.Position";
+        readonly name: "";
+        readonly type: "tuple";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "_positionId";
+        readonly type: "uint256";
+    }];
+    readonly name: "getPositionPnL";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "pnl";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bool";
+        readonly name: "isProfit";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "_user";
+        readonly type: "address";
+    }];
+    readonly name: "getUserPositions";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256[]";
+        readonly name: "";
+        readonly type: "uint256[]";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "_positionId";
+        readonly type: "uint256";
+    }];
+    readonly name: "liquidatePosition";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "maxLeverage";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "minMarginBps";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "nextPositionId";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "_token";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bool";
+        readonly name: "_isLong";
+        readonly type: "bool";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_margin";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_leverage";
+        readonly type: "uint256";
+    }];
+    readonly name: "openPosition";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "positionId";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "_positionId";
+        readonly type: "uint256";
+    }];
+    readonly name: "shouldLiquidate";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "tradingFeeBps";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];
+declare const BONDING_CURVE_MARKET_ABI: readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "_token";
+        readonly type: "address";
+    }];
+    readonly name: "getCurrentPrice";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "_token";
+        readonly type: "address";
+    }];
+    readonly name: "isListed";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "_token";
+        readonly type: "address";
+    }];
+    readonly name: "getCurveProgress";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];
+
+declare const index_BONDING_CURVE_MARKET: typeof BONDING_CURVE_MARKET;
+declare const index_BONDING_CURVE_MARKET_ABI: typeof BONDING_CURVE_MARKET_ABI;
+declare const index_PERPETUAL_TRADING: typeof PERPETUAL_TRADING;
+declare const index_PERPETUAL_TRADING_ABI: typeof PERPETUAL_TRADING_ABI;
+declare const index_PIKE_PERPS_CONFIG: typeof PIKE_PERPS_CONFIG;
 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 };
+  export { index_BONDING_CURVE_MARKET as BONDING_CURVE_MARKET, index_BONDING_CURVE_MARKET_ABI as BONDING_CURVE_MARKET_ABI, index_PERPETUAL_TRADING as PERPETUAL_TRADING, index_PERPETUAL_TRADING_ABI as PERPETUAL_TRADING_ABI, index_PIKE_PERPS_CONFIG as PIKE_PERPS_CONFIG };
 }
 
 interface UserAccountData {
@@ -809,4 +1599,4 @@ interface UserAccountData {
     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 };
+export { index$7 as AgniConstants, index$6 as LendleConstants, type LendlePosition, type LendlePositionsResult, METH_TOKEN, MNTAgentKit, index$5 as MerchantMoeConstants, index$8 as MethConstants, type MethPosition, index$4 as OKXConstants, index$3 as OneInchConstants, index$2 as OpenOceanConstants, index as PikePerpsConstants, type PikePerpsMarketData, type PikePerpsPosition, type PikePerpsTrade, type ProjectConfig, index$1 as SquidConstants, index$9 as UniswapConstants, type UserAccountData, agniSwap, approveToken, crossChainSwapViaSquid, executeSwap, get1inchQuote, getOpenOceanQuote, getProjectConfig, getSquidRoute, getUniswapQuote, initializePlatform, lendleBorrow, lendleGetPositions, lendleRepay, lendleSupply, lendleWithdraw, merchantMoeSwap, methGetPosition, pikeperpsClosePosition, pikeperpsGetMarketData, pikeperpsGetPositions, pikeperpsOpenLong, pikeperpsOpenShort, sendTransaction, swapFromMeth, swapOn1inch, swapOnOpenOcean, swapOnUniswap, swapToMeth };