mantle-agent-kit-sdk 1.0.2 → 1.0.4

package/dist/index.js

@@ -1,20 +1,53 @@
-import { parseEther, encodeFunctionData, createWalletClient, http, publicActions, erc20Abi } from 'viem';
+import { parseUnits, parseEther, encodeFunctionData, getAddress, parseAbiItem, createWalletClient, http, publicActions, erc20Abi as erc20Abi$1 } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 import { mantle, mantleSepoliaTestnet } from 'viem/chains';
 import { getTransactionReceipt } from 'viem/actions';
 import axios6 from 'axios';
 import CryptoJS from 'crypto-js';
+import { erc7811Actions } from 'viem/experimental';
 
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var sendTransaction = async (agent, to, amount) => {
-  const hash = await agent.client.sendTransaction({
-    to,
-    value: parseEther(amount)
-  });
+var erc20Abi = [
+  {
+    name: "transfer",
+    type: "function",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ type: "bool" }]
+  },
+  {
+    name: "decimals",
+    type: "function",
+    inputs: [],
+    outputs: [{ type: "uint8" }]
+  }
+];
+var sendTransaction = async (agent, to, amount, tokenAddress) => {
+  let hash;
+  if (tokenAddress) {
+    const decimals = await agent.client.readContract({
+      address: tokenAddress,
+      abi: erc20Abi,
+      functionName: "decimals"
+    });
+    hash = await agent.client.writeContract({
+      address: tokenAddress,
+      abi: erc20Abi,
+      functionName: "transfer",
+      args: [to, parseUnits(amount, decimals)]
+    });
+  } else {
+    hash = await agent.client.sendTransaction({
+      to,
+      value: parseEther(amount)
+    });
+  }
   const receipt = await getTransactionReceipt(agent.client, {
     hash
   });
@@ -24,7 +57,7 @@ async function checkAllowance(agent, tokenAddress, ownerAddress, spenderAddress)
   try {
     const allowance = await agent.client.readContract({
       address: tokenAddress,
-      abi: erc20Abi,
+      abi: erc20Abi$1,
       functionName: "allowance",
       args: [ownerAddress, spenderAddress]
     });
@@ -188,9 +221,85 @@ async function getSwapTransaction(fromTokenAddress, toTokenAddress, amount, user
     throw error;
   }
 }
+var DEMO_TX_HASH = "0xdemo000000000000000000000000000000000000000000000000000000000001";
+function createMockSwapResponse(protocol, inputAmount) {
+  return {
+    txHash: DEMO_TX_HASH,
+    amountOut: inputAmount,
+    demo: true,
+    message: `[DEMO] ${protocol} swap simulated`
+  };
+}
+function createMockQuoteResponse(protocol, inputAmount) {
+  return {
+    estimatedAmount: inputAmount,
+    demo: true,
+    message: `[DEMO] ${protocol} quote simulated`
+  };
+}
+function createMockLendleResponse(action, amount) {
+  return {
+    txHash: DEMO_TX_HASH,
+    amount,
+    demo: true,
+    message: `[DEMO] Lendle ${action} simulated`
+  };
+}
+function createMockTxHash() {
+  return DEMO_TX_HASH;
+}
+function createMock1inchSwapResponse(inputAmount) {
+  return {
+    txHash: DEMO_TX_HASH,
+    dstAmount: inputAmount,
+    demo: true,
+    message: "[DEMO] 1inch swap simulated"
+  };
+}
+function createMockOkxSwapResponse(inputAmount) {
+  return {
+    data: DEMO_TX_HASH,
+    demo: true,
+    message: "[DEMO] OKX swap simulated"
+  };
+}
+function createMockOpenOceanSwapResponse(inputAmount) {
+  return {
+    txHash: DEMO_TX_HASH,
+    outAmount: inputAmount,
+    demo: true,
+    message: "[DEMO] OpenOcean swap simulated"
+  };
+}
+function createMockUniswapSwapResponse(inputAmount) {
+  return {
+    txHash: DEMO_TX_HASH,
+    amountOut: inputAmount,
+    demo: true,
+    message: "[DEMO] Uniswap swap simulated"
+  };
+}
+function createMockSquidRoute(amount) {
+  return {
+    route: {
+      estimate: { toAmount: amount },
+      transactionRequest: {
+        targetAddress: "0x0000000000000000000000000000000000000000",
+        data: "0x",
+        value: "0",
+        gasLimit: "0"
+      }
+    },
+    demo: true,
+    message: "[DEMO] Squid route simulated"
+  };
+}
 
 // src/tools/okx/swap.ts
 async function executeSwap(agent, fromTokenAddress, toTokenAddress, amount, slippagePercent) {
+  if (agent.demo) {
+    return createMockOkxSwapResponse();
+  }
   const chainIndex = agent.chain === "mainnet" ? "5000" : "5003";
   const walletAddress = agent.account.address;
   if (fromTokenAddress !== ETH_ADDRESS) {
@@ -324,13 +433,16 @@ async function getSwapData(fromToken, toToken, amount, userAddress, slippage, ch
 
 // src/tools/openocean/getQuote.ts
 async function getOpenOceanQuote(agent, fromToken, toToken, amount) {
+  if (agent.demo) {
+    return createMockQuoteResponse("OpenOcean", amount);
+  }
   return await getQuoteData(fromToken, toToken, amount, agent.chain);
 }
 async function checkAllowance2(agent, tokenAddress, ownerAddress, spenderAddress) {
   try {
     const allowance = await agent.client.readContract({
       address: tokenAddress,
-      abi: erc20Abi,
+      abi: erc20Abi$1,
       functionName: "allowance",
       args: [ownerAddress, spenderAddress]
     });
@@ -353,9 +465,9 @@ async function approveToken2(agent, tokenAddress, spenderAddress, amount) {
     return { approved: true, txHash: null };
   }
   console.log("Insufficient allowance, approving tokens...");
-  const { encodeFunctionData: encodeFunctionData8 } = await import('viem');
-  const approveData = encodeFunctionData8({
-    abi: erc20Abi,
+  const { encodeFunctionData: encodeFunctionData11 } = await import('viem');
+  const approveData = encodeFunctionData11({
+    abi: erc20Abi$1,
     functionName: "approve",
     args: [spenderAddress, BigInt(amount)]
   });
@@ -380,6 +492,12 @@ async function approveToken2(agent, tokenAddress, spenderAddress, amount) {
 
 // src/tools/openocean/swap.ts
 async function swapOnOpenOcean(agent, fromToken, toToken, amount, slippage = "1") {
+  if (agent.demo) {
+    return createMockOpenOceanSwapResponse(amount);
+  }
+  if (!agent.demo && agent.chain != "mainnet") {
+    throw new Error("Openocean swaps happen only on mainnet");
+  }
   const walletAddress = agent.account.address;
   if (fromToken.toLowerCase() !== NATIVE_TOKEN_ADDRESS.toLowerCase()) {
     await approveToken2(agent, fromToken, OPENOCEAN_EXCHANGE_PROXY, amount);
@@ -491,11 +609,17 @@ async function getSwapData2(fromToken, toToken, amount, userAddress, slippage, c
 
 // src/tools/oneinch/getQuote.ts
 async function get1inchQuote(agent, fromToken, toToken, amount) {
+  if (agent.demo) {
+    return createMockQuoteResponse("1inch", amount);
+  }
   return await getQuoteData2(fromToken, toToken, amount, agent.chain);
 }
 
 // src/tools/oneinch/swap.ts
 async function swapOn1inch(agent, fromToken, toToken, amount, slippage = "1") {
+  if (agent.demo) {
+    return createMock1inchSwapResponse(amount);
+  }
   const walletAddress = agent.account.address;
   if (fromToken.toLowerCase() !== NATIVE_TOKEN_ADDRESS2.toLowerCase()) {
     await approveToken2(agent, fromToken, ONEINCH_ROUTER_ADDRESS, amount);
@@ -662,11 +786,17 @@ function buildSwapCalldata(params, fee = DEFAULT_POOL_FEE) {
 
 // src/tools/uniswap/getQuote.ts
 async function getUniswapQuote(agent, fromToken, toToken, amount, fee = DEFAULT_POOL_FEE) {
+  if (agent.demo) {
+    return createMockQuoteResponse("Uniswap", amount);
+  }
   return await getUniswapQuoteData(agent, fromToken, toToken, amount, fee);
 }
 
 // src/tools/uniswap/swap.ts
 async function swapOnUniswap(agent, fromToken, toToken, amount, slippage = "0.5", fee = DEFAULT_POOL_FEE) {
+  if (agent.demo) {
+    return createMockUniswapSwapResponse(amount);
+  }
   const walletAddress = agent.account.address;
   const isNativeIn = fromToken.toLowerCase() === NATIVE_TOKEN_ADDRESS3.toLowerCase();
   const quote = await getUniswapQuoteData(agent, fromToken, toToken, amount, fee);
@@ -765,6 +895,9 @@ async function getRouteData(fromToken, toToken, fromChain, toChain, amount, from
 
 // src/tools/squid/crossChainSwap.ts
 async function crossChainSwapViaSquid(agent, fromToken, toToken, fromChain, toChain, amount, slippage = 1) {
+  if (agent.demo) {
+    return createMockTxHash();
+  }
   const routeData = await getRouteData(
     fromToken,
     toToken,
@@ -793,6 +926,9 @@ async function crossChainSwapViaSquid(agent, fromToken, toToken, fromChain, toCh
   return hash;
 }
 async function getSquidRoute(agent, fromToken, toToken, fromChain, toChain, amount, slippage = 1) {
+  if (agent.demo) {
+    return createMockSquidRoute(amount);
+  }
   return await getRouteData(
     fromToken,
     toToken,
@@ -811,8 +947,10 @@ __export(lendle_exports, {
   LENDING_POOL: () => LENDING_POOL,
   LENDING_POOL_ABI: () => LENDING_POOL_ABI,
   LENDING_POOL_ADDRESSES_PROVIDER: () => LENDING_POOL_ADDRESSES_PROVIDER,
+  LENDLE_SUPPORTED_ASSETS: () => LENDLE_SUPPORTED_ASSETS,
   ORACLE: () => ORACLE,
   PROTOCOL_DATA_PROVIDER: () => PROTOCOL_DATA_PROVIDER,
+  PROTOCOL_DATA_PROVIDER_ABI: () => PROTOCOL_DATA_PROVIDER_ABI,
   WMNT_ADDRESS: () => WMNT_ADDRESS2
 });
 var LENDING_POOL = {
@@ -927,11 +1065,73 @@ var LENDING_POOL_ABI = [
     type: "function"
   }
 ];
+var PROTOCOL_DATA_PROVIDER_ABI = [
+  {
+    inputs: [],
+    name: "getAllReservesTokens",
+    outputs: [
+      {
+        components: [
+          { name: "symbol", type: "string" },
+          { name: "tokenAddress", type: "address" }
+        ],
+        name: "",
+        type: "tuple[]"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "asset", type: "address" },
+      { name: "user", type: "address" }
+    ],
+    name: "getUserReserveData",
+    outputs: [
+      { name: "currentATokenBalance", type: "uint256" },
+      { name: "currentStableDebt", type: "uint256" },
+      { name: "currentVariableDebt", type: "uint256" },
+      { name: "principalStableDebt", type: "uint256" },
+      { name: "scaledVariableDebt", type: "uint256" },
+      { name: "stableBorrowRate", type: "uint256" },
+      { name: "liquidityRate", type: "uint256" },
+      { name: "stableRateLastUpdated", type: "uint40" },
+      { name: "usageAsCollateralEnabled", type: "bool" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "asset", type: "address" }],
+    name: "getReserveTokensAddresses",
+    outputs: [
+      { name: "aTokenAddress", type: "address" },
+      { name: "stableDebtTokenAddress", type: "address" },
+      { name: "variableDebtTokenAddress", type: "address" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+var LENDLE_SUPPORTED_ASSETS = {
+  mainnet: [
+    { symbol: "WMNT", address: "0x78c1b0C915c4FAA5FffA6CAbf0219DA63d7f4cb8" },
+    { symbol: "WETH", address: "0xdEAddEaDdeadDEadDEADDEAddEADDEAddead1111" },
+    { symbol: "USDC", address: "0x09Bc4E0D10C81b3a3766c49F0f98a8aaa7adA8D2" },
+    { symbol: "USDT", address: "0x201EBa5CC46D216Ce6DC03F6a759e8E766e956aE" },
+    { symbol: "mETH", address: "0xcDA86A272531e8640cD7F1a92c01839911B90bb0" }
+  ],
+  testnet: []
+};
 
 // src/tools/lendle/supply.ts
 async function lendleSupply(agent, tokenAddress, amount) {
   const lendingPoolAddress = LENDING_POOL[agent.chain];
   if (lendingPoolAddress === "0x0000000000000000000000000000000000000000") {
+    if (agent.demo) {
+      return createMockLendleResponse("supply", amount).txHash;
+    }
     throw new Error(
       `Lendle LendingPool not configured for ${agent.chain}. Only available on mainnet.`
     );
@@ -958,6 +1158,9 @@ async function lendleSupply(agent, tokenAddress, amount) {
 async function lendleWithdraw(agent, tokenAddress, amount, to) {
   const lendingPoolAddress = LENDING_POOL[agent.chain];
   if (lendingPoolAddress === "0x0000000000000000000000000000000000000000") {
+    if (agent.demo) {
+      return createMockLendleResponse("withdraw", amount).txHash;
+    }
     throw new Error(
       `Lendle LendingPool not configured for ${agent.chain}. Only available on mainnet.`
     );
@@ -979,6 +1182,9 @@ async function lendleWithdraw(agent, tokenAddress, amount, to) {
 async function lendleBorrow(agent, tokenAddress, amount, interestRateMode = INTEREST_RATE_MODE.VARIABLE, onBehalfOf) {
   const lendingPoolAddress = LENDING_POOL[agent.chain];
   if (lendingPoolAddress === "0x0000000000000000000000000000000000000000") {
+    if (agent.demo) {
+      return createMockLendleResponse("borrow", amount).txHash;
+    }
     throw new Error(
       `Lendle LendingPool not configured for ${agent.chain}. Only available on mainnet.`
     );
@@ -1001,6 +1207,9 @@ async function lendleBorrow(agent, tokenAddress, amount, interestRateMode = INTE
 async function lendleRepay(agent, tokenAddress, amount, rateMode = INTEREST_RATE_MODE.VARIABLE, onBehalfOf) {
   const lendingPoolAddress = LENDING_POOL[agent.chain];
   if (lendingPoolAddress === "0x0000000000000000000000000000000000000000") {
+    if (agent.demo) {
+      return createMockLendleResponse("repay", amount).txHash;
+    }
     throw new Error(
       `Lendle LendingPool not configured for ${agent.chain}. Only available on mainnet.`
     );
@@ -1020,6 +1229,67 @@ async function lendleRepay(agent, tokenAddress, amount, rateMode = INTEREST_RATE
   await agent.client.waitForTransactionReceipt({ hash });
   return hash;
 }
+async function lendleGetPositions(agent, userAddress) {
+  const dataProviderAddress = PROTOCOL_DATA_PROVIDER[agent.chain];
+  const address = userAddress || agent.account.address;
+  if (dataProviderAddress === "0x0000000000000000000000000000000000000000") {
+    throw new Error(
+      `Lendle ProtocolDataProvider not configured for ${agent.chain}. Only available on mainnet.`
+    );
+  }
+  const supportedAssets = LENDLE_SUPPORTED_ASSETS[agent.chain];
+  if (!supportedAssets || supportedAssets.length === 0) {
+    throw new Error(`No supported assets configured for ${agent.chain}`);
+  }
+  const positions = [];
+  let totalSupplied = 0n;
+  let totalDebt = 0n;
+  for (const asset of supportedAssets) {
+    try {
+      const assetAddress = getAddress(asset.address);
+      const result = await agent.client.readContract({
+        address: dataProviderAddress,
+        abi: PROTOCOL_DATA_PROVIDER_ABI,
+        functionName: "getUserReserveData",
+        args: [assetAddress, address]
+      });
+      const [
+        currentATokenBalance,
+        currentStableDebt,
+        currentVariableDebt,
+        _principalStableDebt,
+        _scaledVariableDebt,
+        stableBorrowRate,
+        liquidityRate,
+        _stableRateLastUpdated,
+        usageAsCollateralEnabled
+      ] = result;
+      if (currentATokenBalance > 0n || currentStableDebt > 0n || currentVariableDebt > 0n) {
+        const assetTotalDebt = currentStableDebt + currentVariableDebt;
+        positions.push({
+          asset: assetAddress,
+          symbol: asset.symbol,
+          supplied: currentATokenBalance,
+          stableDebt: currentStableDebt,
+          variableDebt: currentVariableDebt,
+          totalDebt: assetTotalDebt,
+          liquidityRate,
+          stableBorrowRate,
+          usageAsCollateralEnabled
+        });
+        totalSupplied += currentATokenBalance;
+        totalDebt += assetTotalDebt;
+      }
+    } catch (error) {
+      console.warn(`Failed to get position for ${asset.symbol}:`, error);
+    }
+  }
+  return {
+    positions,
+    totalSupplied,
+    totalDebt
+  };
+}
 
 // src/constants/agni/index.ts
 var agni_exports = {};
@@ -1081,6 +1351,9 @@ var FEE_TIERS2 = {
 async function agniSwap(agent, tokenIn, tokenOut, amountIn, slippagePercent = 0.5, feeTier = FEE_TIERS2.MEDIUM) {
   const swapRouterAddress = SWAP_ROUTER[agent.chain];
   if (swapRouterAddress === "0x0000000000000000000000000000000000000000") {
+    if (agent.demo) {
+      return createMockSwapResponse("Agni", amountIn).txHash;
+    }
     throw new Error(`Agni SwapRouter not available on ${agent.chain}`);
   }
   const amountInBigInt = BigInt(amountIn);
@@ -1153,6 +1426,9 @@ var LB_ROUTER_ABI = [
 async function merchantMoeSwap(agent, tokenIn, tokenOut, amountIn, slippagePercent = 0.5) {
   const routerAddress = LB_ROUTER[agent.chain];
   if (routerAddress === "0x0000000000000000000000000000000000000000") {
+    if (agent.demo) {
+      return createMockSwapResponse("MerchantMoe", amountIn).txHash;
+    }
     throw new Error(`Merchant Moe LB Router not available on ${agent.chain}`);
   }
   const amountInBigInt = BigInt(amountIn);
@@ -1176,15 +1452,742 @@ async function merchantMoeSwap(agent, tokenIn, tokenOut, amountIn, slippagePerce
 // src/constants/meth/index.ts
 var meth_exports = {};
 __export(meth_exports, {
-  METH_TOKEN: () => METH_TOKEN
+  METH_ABI: () => METH_ABI,
+  METH_TOKEN: () => METH_TOKEN,
+  NATIVE_MNT_ADDRESS: () => NATIVE_MNT_ADDRESS,
+  WETH_TOKEN: () => WETH_TOKEN,
+  WMNT_TOKEN: () => WMNT_TOKEN
 });
 var METH_TOKEN = {
   mainnet: "0xcDA86A272531e8640cD7F1a92c01839911B90bb0",
   testnet: "0x0000000000000000000000000000000000000000"
 };
+var WETH_TOKEN = {
+  mainnet: "0xdEAddEaDdeadDEadDEADDEAddEADDEAddead1111",
+  testnet: "0xdEAddEaDdeadDEadDEADDEAddEADDEAddead1111"
+};
+var WMNT_TOKEN = {
+  mainnet: "0x78c1b0C915c4FAA5FffA6CAbf0219DA63d7f4cb8",
+  testnet: "0x78c1b0C915c4FAA5FffA6CAbf0219DA63d7f4cb8"
+};
+var NATIVE_MNT_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+var METH_ABI = [
+  {
+    inputs: [{ name: "account", type: "address" }],
+    name: "balanceOf",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "totalSupply",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "decimals",
+    outputs: [{ name: "", type: "uint8" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "symbol",
+    outputs: [{ name: "", type: "string" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    name: "approve",
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    name: "allowance",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+async function methGetPosition(agent, userAddress) {
+  const methTokenAddress = METH_TOKEN[agent.chain];
+  const wethTokenAddress = WETH_TOKEN[agent.chain];
+  const wmntTokenAddress = WMNT_TOKEN[agent.chain];
+  const address = userAddress || agent.account.address;
+  if (methTokenAddress === "0x0000000000000000000000000000000000000000") {
+    throw new Error(
+      `mETH not available on ${agent.chain}. Only available on mainnet.`
+    );
+  }
+  const methBalance = await agent.client.readContract({
+    address: methTokenAddress,
+    abi: METH_ABI,
+    functionName: "balanceOf",
+    args: [address]
+  });
+  let wethBalance = 0n;
+  try {
+    wethBalance = await agent.client.readContract({
+      address: wethTokenAddress,
+      abi: METH_ABI,
+      // Same ERC20 ABI works for WETH
+      functionName: "balanceOf",
+      args: [address]
+    });
+  } catch {
+  }
+  let wmntBalance = 0n;
+  try {
+    wmntBalance = await agent.client.readContract({
+      address: wmntTokenAddress,
+      abi: METH_ABI,
+      // Same ERC20 ABI works for WMNT
+      functionName: "balanceOf",
+      args: [address]
+    });
+  } catch {
+  }
+  return {
+    methBalance,
+    wethBalance,
+    wmntBalance,
+    methTokenAddress,
+    wethTokenAddress,
+    wmntTokenAddress
+  };
+}
+async function swapToMeth(agent, amount, slippage = 0.5) {
+  const methTokenAddress = METH_TOKEN[agent.chain];
+  const wethTokenAddress = WETH_TOKEN[agent.chain];
+  if (methTokenAddress === "0x0000000000000000000000000000000000000000") {
+    throw new Error(
+      `mETH not available on ${agent.chain}. Only available on mainnet.`
+    );
+  }
+  const result = await swapOnOpenOcean(
+    agent,
+    wethTokenAddress,
+    methTokenAddress,
+    amount,
+    slippage.toString()
+  );
+  return result.txHash;
+}
+async function swapFromMeth(agent, amount, slippage = 0.5) {
+  const methTokenAddress = METH_TOKEN[agent.chain];
+  const wethTokenAddress = WETH_TOKEN[agent.chain];
+  if (methTokenAddress === "0x0000000000000000000000000000000000000000") {
+    throw new Error(
+      `mETH not available on ${agent.chain}. Only available on mainnet.`
+    );
+  }
+  const result = await swapOnOpenOcean(
+    agent,
+    methTokenAddress,
+    wethTokenAddress,
+    amount,
+    slippage.toString()
+  );
+  return result.txHash;
+}
+
+// src/constants/pikeperps/index.ts
+var pikeperps_exports = {};
+__export(pikeperps_exports, {
+  BONDING_CURVE_MARKET: () => BONDING_CURVE_MARKET,
+  BONDING_CURVE_MARKET_ABI: () => BONDING_CURVE_MARKET_ABI,
+  PERPETUAL_TRADING: () => PERPETUAL_TRADING,
+  PERPETUAL_TRADING_ABI: () => PERPETUAL_TRADING_ABI,
+  PIKE_PERPS_CONFIG: () => PIKE_PERPS_CONFIG
+});
+var PERPETUAL_TRADING = {
+  mainnet: "0x0000000000000000000000000000000000000000",
+  // Not deployed yet
+  testnet: "0x8081b646f349c049f2d5e8a400057d411dd657bd"
+};
+var BONDING_CURVE_MARKET = {
+  mainnet: "0x0000000000000000000000000000000000000000",
+  testnet: "0x93b268325A9862645c82b32229f3B52264750Ca2"
+};
+var PIKE_PERPS_CONFIG = {
+  MAX_LEVERAGE: 100,
+  DEFAULT_LEVERAGE: 10,
+  MIN_LEVERAGE: 1,
+  TRADING_FEE_BPS: 5,
+  // 0.05%
+  LIQUIDATION_REWARD_BPS: 500,
+  // 5%
+  PRICE_DECIMALS: 8
+  // Prices are scaled by 1e8
+};
+var PERPETUAL_TRADING_ABI = [
+  {
+    inputs: [
+      { internalType: "address", name: "_pyth", type: "address" }
+    ],
+    stateMutability: "nonpayable",
+    type: "constructor"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "uint256", name: "positionId", type: "uint256" },
+      { indexed: true, internalType: "address", name: "user", type: "address" },
+      { indexed: false, internalType: "uint256", name: "pnl", type: "uint256" },
+      { indexed: false, internalType: "uint256", name: "exitPrice", type: "uint256" }
+    ],
+    name: "PositionClosed",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "uint256", name: "positionId", type: "uint256" },
+      { indexed: true, internalType: "address", name: "user", type: "address" },
+      { indexed: false, internalType: "uint256", name: "liquidationPrice", type: "uint256" }
+    ],
+    name: "PositionLiquidated",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "uint256", name: "positionId", type: "uint256" },
+      { indexed: true, internalType: "address", name: "user", type: "address" },
+      { indexed: true, internalType: "address", name: "token", type: "address" },
+      { indexed: false, internalType: "bool", name: "isLong", type: "bool" },
+      { indexed: false, internalType: "uint256", name: "size", type: "uint256" },
+      { indexed: false, internalType: "uint256", name: "margin", type: "uint256" },
+      { indexed: false, internalType: "uint256", name: "leverage", type: "uint256" },
+      { indexed: false, internalType: "uint256", name: "entryPrice", type: "uint256" }
+    ],
+    name: "PositionOpened",
+    type: "event"
+  },
+  {
+    inputs: [{ internalType: "uint256", name: "_positionId", type: "uint256" }],
+    name: "closePosition",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "address", name: "_token", type: "address" }],
+    name: "getCurrentPrice",
+    outputs: [
+      { internalType: "uint256", name: "currentPrice", type: "uint256" },
+      { internalType: "bool", name: "hasPrice", type: "bool" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "uint256", name: "_positionId", type: "uint256" }],
+    name: "getLiquidationPrice",
+    outputs: [{ internalType: "uint256", name: "liquidationPrice", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "uint256", name: "_positionId", type: "uint256" }],
+    name: "getPosition",
+    outputs: [
+      {
+        components: [
+          { internalType: "address", name: "user", type: "address" },
+          { internalType: "address", name: "token", type: "address" },
+          { internalType: "bool", name: "isLong", type: "bool" },
+          { internalType: "uint256", name: "size", type: "uint256" },
+          { internalType: "uint256", name: "margin", type: "uint256" },
+          { internalType: "uint256", name: "leverage", type: "uint256" },
+          { internalType: "uint256", name: "entryPrice", type: "uint256" },
+          { internalType: "uint256", name: "entryTime", type: "uint256" },
+          { internalType: "uint256", name: "lastFundingTime", type: "uint256" },
+          { internalType: "bool", name: "isOpen", type: "bool" }
+        ],
+        internalType: "struct PerpetualTrading.Position",
+        name: "",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "uint256", name: "_positionId", type: "uint256" }],
+    name: "getPositionPnL",
+    outputs: [
+      { internalType: "uint256", name: "pnl", type: "uint256" },
+      { internalType: "bool", name: "isProfit", type: "bool" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "address", name: "_user", type: "address" }],
+    name: "getUserPositions",
+    outputs: [{ internalType: "uint256[]", name: "", type: "uint256[]" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "uint256", name: "_positionId", type: "uint256" }],
+    name: "liquidatePosition",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "maxLeverage",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "minMarginBps",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "nextPositionId",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "_token", type: "address" },
+      { internalType: "bool", name: "_isLong", type: "bool" },
+      { internalType: "uint256", name: "_margin", type: "uint256" },
+      { internalType: "uint256", name: "_leverage", type: "uint256" }
+    ],
+    name: "openPosition",
+    outputs: [{ internalType: "uint256", name: "positionId", type: "uint256" }],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "uint256", name: "_positionId", type: "uint256" }],
+    name: "shouldLiquidate",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "tradingFeeBps",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+var BONDING_CURVE_MARKET_ABI = [
+  {
+    inputs: [{ internalType: "address", name: "_token", type: "address" }],
+    name: "getCurrentPrice",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "address", name: "_token", type: "address" }],
+    name: "isListed",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "address", name: "_token", type: "address" }],
+    name: "getCurveProgress",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+
+// src/tools/pikeperps/openLong.ts
+async function pikeperpsOpenLong(agent, tokenAddress, margin, leverage = PIKE_PERPS_CONFIG.DEFAULT_LEVERAGE) {
+  const perpetualTradingAddress = PERPETUAL_TRADING[agent.chain];
+  if (perpetualTradingAddress === "0x0000000000000000000000000000000000000000") {
+    throw new Error(
+      `PikePerps not available on ${agent.chain}. Only available on testnet.`
+    );
+  }
+  if (leverage < PIKE_PERPS_CONFIG.MIN_LEVERAGE || leverage > PIKE_PERPS_CONFIG.MAX_LEVERAGE) {
+    throw new Error(
+      `Leverage must be between ${PIKE_PERPS_CONFIG.MIN_LEVERAGE} and ${PIKE_PERPS_CONFIG.MAX_LEVERAGE}`
+    );
+  }
+  if (agent.demo) {
+    return {
+      positionId: BigInt(Math.floor(Math.random() * 1e3)),
+      txHash: "0xdemo_open_long_tx_hash"
+    };
+  }
+  const marginBigInt = BigInt(margin);
+  const data = encodeFunctionData({
+    abi: PERPETUAL_TRADING_ABI,
+    functionName: "openPosition",
+    args: [tokenAddress, true, marginBigInt, BigInt(leverage)]
+  });
+  const txHash = await agent.client.sendTransaction({
+    to: perpetualTradingAddress,
+    data,
+    value: marginBigInt
+  });
+  const receipt = await agent.client.waitForTransactionReceipt({ hash: txHash });
+  let positionId = 0n;
+  for (const log of receipt.logs) {
+    try {
+      if (log.topics[0] === "0x2e5b0e8c5f5d55d89e89f5b5d5e5f5d55d89e89f5b5d5e5f5d55d89e89f5b5d5") {
+        positionId = BigInt(log.topics[1] || "0");
+        break;
+      }
+    } catch {
+    }
+  }
+  if (positionId === 0n) {
+    try {
+      const nextId = await agent.client.readContract({
+        address: perpetualTradingAddress,
+        abi: PERPETUAL_TRADING_ABI,
+        functionName: "nextPositionId"
+      });
+      positionId = nextId - 1n;
+    } catch {
+    }
+  }
+  return {
+    positionId,
+    txHash
+  };
+}
+async function pikeperpsOpenShort(agent, tokenAddress, margin, leverage = PIKE_PERPS_CONFIG.DEFAULT_LEVERAGE) {
+  const perpetualTradingAddress = PERPETUAL_TRADING[agent.chain];
+  if (perpetualTradingAddress === "0x0000000000000000000000000000000000000000") {
+    throw new Error(
+      `PikePerps not available on ${agent.chain}. Only available on testnet.`
+    );
+  }
+  if (leverage < PIKE_PERPS_CONFIG.MIN_LEVERAGE || leverage > PIKE_PERPS_CONFIG.MAX_LEVERAGE) {
+    throw new Error(
+      `Leverage must be between ${PIKE_PERPS_CONFIG.MIN_LEVERAGE} and ${PIKE_PERPS_CONFIG.MAX_LEVERAGE}`
+    );
+  }
+  if (agent.demo) {
+    return {
+      positionId: BigInt(Math.floor(Math.random() * 1e3)),
+      txHash: "0xdemo_open_short_tx_hash"
+    };
+  }
+  const marginBigInt = BigInt(margin);
+  const data = encodeFunctionData({
+    abi: PERPETUAL_TRADING_ABI,
+    functionName: "openPosition",
+    args: [tokenAddress, false, marginBigInt, BigInt(leverage)]
+  });
+  const txHash = await agent.client.sendTransaction({
+    to: perpetualTradingAddress,
+    data,
+    value: marginBigInt
+  });
+  const receipt = await agent.client.waitForTransactionReceipt({ hash: txHash });
+  let positionId = 0n;
+  for (const log of receipt.logs) {
+    try {
+      if (log.topics[0] === "0x2e5b0e8c5f5d55d89e89f5b5d5e5f5d55d89e89f5b5d5e5f5d55d89e89f5b5d5") {
+        positionId = BigInt(log.topics[1] || "0");
+        break;
+      }
+    } catch {
+    }
+  }
+  if (positionId === 0n) {
+    try {
+      const nextId = await agent.client.readContract({
+        address: perpetualTradingAddress,
+        abi: PERPETUAL_TRADING_ABI,
+        functionName: "nextPositionId"
+      });
+      positionId = nextId - 1n;
+    } catch {
+    }
+  }
+  return {
+    positionId,
+    txHash
+  };
+}
+async function pikeperpsClosePosition(agent, positionId) {
+  const perpetualTradingAddress = PERPETUAL_TRADING[agent.chain];
+  if (perpetualTradingAddress === "0x0000000000000000000000000000000000000000") {
+    throw new Error(
+      `PikePerps not available on ${agent.chain}. Only available on testnet.`
+    );
+  }
+  if (agent.demo) {
+    return "0xdemo_close_position_tx_hash";
+  }
+  const data = encodeFunctionData({
+    abi: PERPETUAL_TRADING_ABI,
+    functionName: "closePosition",
+    args: [positionId]
+  });
+  const txHash = await agent.client.sendTransaction({
+    to: perpetualTradingAddress,
+    data
+  });
+  await agent.client.waitForTransactionReceipt({ hash: txHash });
+  return txHash;
+}
+async function pikeperpsGetPositions(agent, userAddress) {
+  const perpetualTradingAddress = PERPETUAL_TRADING[agent.chain];
+  const address = userAddress || agent.account.address;
+  if (perpetualTradingAddress === "0x0000000000000000000000000000000000000000") {
+    throw new Error(
+      `PikePerps not available on ${agent.chain}. Only available on testnet.`
+    );
+  }
+  if (agent.demo) {
+    return [
+      {
+        positionId: 1n,
+        token: "0x0000000000000000000000000000000000000001",
+        isLong: true,
+        size: BigInt("1000000000000000000"),
+        // 1 ETH equivalent
+        margin: BigInt("100000000000000000"),
+        // 0.1 ETH
+        leverage: 10,
+        entryPrice: BigInt("100000000"),
+        // $1.00 scaled by 1e8
+        entryTime: BigInt(Math.floor(Date.now() / 1e3) - 3600),
+        currentPrice: BigInt("110000000"),
+        // $1.10
+        pnl: BigInt("10000000000000000"),
+        // 0.01 ETH profit
+        isProfit: true,
+        liquidationPrice: BigInt("90000000"),
+        // $0.90
+        isOpen: true
+      }
+    ];
+  }
+  const positionIds = await agent.client.readContract({
+    address: perpetualTradingAddress,
+    abi: PERPETUAL_TRADING_ABI,
+    functionName: "getUserPositions",
+    args: [address]
+  });
+  if (positionIds.length === 0) {
+    return [];
+  }
+  const positions = [];
+  for (const positionId of positionIds) {
+    try {
+      const rawPosition = await agent.client.readContract({
+        address: perpetualTradingAddress,
+        abi: PERPETUAL_TRADING_ABI,
+        functionName: "getPosition",
+        args: [positionId]
+      });
+      if (!rawPosition.isOpen) {
+        continue;
+      }
+      const [pnl, isProfit] = await agent.client.readContract({
+        address: perpetualTradingAddress,
+        abi: PERPETUAL_TRADING_ABI,
+        functionName: "getPositionPnL",
+        args: [positionId]
+      });
+      const liquidationPrice = await agent.client.readContract({
+        address: perpetualTradingAddress,
+        abi: PERPETUAL_TRADING_ABI,
+        functionName: "getLiquidationPrice",
+        args: [positionId]
+      });
+      let currentPrice = 0n;
+      try {
+        const [price, hasPrice] = await agent.client.readContract({
+          address: perpetualTradingAddress,
+          abi: PERPETUAL_TRADING_ABI,
+          functionName: "getCurrentPrice",
+          args: [rawPosition.token]
+        });
+        if (hasPrice) {
+          currentPrice = price;
+        }
+      } catch {
+        currentPrice = rawPosition.entryPrice;
+      }
+      positions.push({
+        positionId,
+        token: rawPosition.token,
+        isLong: rawPosition.isLong,
+        size: rawPosition.size,
+        margin: rawPosition.margin,
+        leverage: Number(rawPosition.leverage),
+        entryPrice: rawPosition.entryPrice,
+        entryTime: rawPosition.entryTime,
+        currentPrice,
+        pnl,
+        isProfit,
+        liquidationPrice,
+        isOpen: rawPosition.isOpen
+      });
+    } catch (error) {
+      console.warn(`Failed to fetch position ${positionId}:`, error);
+    }
+  }
+  return positions;
+}
+async function pikeperpsGetMarketData(agent, tokenAddress, limit = 20) {
+  const perpetualTradingAddress = PERPETUAL_TRADING[agent.chain];
+  const bondingCurveAddress = BONDING_CURVE_MARKET[agent.chain];
+  if (perpetualTradingAddress === "0x0000000000000000000000000000000000000000") {
+    throw new Error(
+      `PikePerps not available on ${agent.chain}. Only available on testnet.`
+    );
+  }
+  if (agent.demo) {
+    return {
+      token: tokenAddress,
+      currentPrice: BigInt("100000000"),
+      // $1.00 scaled by 1e8
+      hasPrice: true,
+      isListed: true,
+      curveProgress: BigInt("5000"),
+      // 50%
+      recentTrades: [
+        {
+          positionId: 1n,
+          trader: "0x0000000000000000000000000000000000000001",
+          token: tokenAddress,
+          isLong: true,
+          size: BigInt("1000000000000000000"),
+          margin: BigInt("100000000000000000"),
+          leverage: 10n,
+          entryPrice: BigInt("100000000"),
+          timestamp: Math.floor(Date.now() / 1e3) - 300,
+          txHash: "0xdemo_trade_hash",
+          blockNumber: 1000n
+        }
+      ]
+    };
+  }
+  let currentPrice = 0n;
+  let hasPrice = false;
+  try {
+    const [price, hasPriceResult] = await agent.client.readContract({
+      address: perpetualTradingAddress,
+      abi: PERPETUAL_TRADING_ABI,
+      functionName: "getCurrentPrice",
+      args: [tokenAddress]
+    });
+    currentPrice = price;
+    hasPrice = hasPriceResult;
+  } catch {
+  }
+  let isListed = false;
+  let curveProgress = 0n;
+  if (bondingCurveAddress !== "0x0000000000000000000000000000000000000000") {
+    try {
+      isListed = await agent.client.readContract({
+        address: bondingCurveAddress,
+        abi: BONDING_CURVE_MARKET_ABI,
+        functionName: "isListed",
+        args: [tokenAddress]
+      });
+      if (isListed) {
+        curveProgress = await agent.client.readContract({
+          address: bondingCurveAddress,
+          abi: BONDING_CURVE_MARKET_ABI,
+          functionName: "getCurveProgress",
+          args: [tokenAddress]
+        });
+      }
+    } catch {
+    }
+  }
+  const recentTrades = [];
+  try {
+    const currentBlock = await agent.client.getBlockNumber();
+    const fromBlock = currentBlock > 1000n ? currentBlock - 1000n : 0n;
+    const logs = await agent.client.getLogs({
+      address: perpetualTradingAddress,
+      event: parseAbiItem(
+        "event PositionOpened(uint256 indexed positionId, address indexed user, address indexed token, bool isLong, uint256 size, uint256 margin, uint256 leverage, uint256 entryPrice)"
+      ),
+      args: {
+        token: tokenAddress
+      },
+      fromBlock,
+      toBlock: currentBlock
+    });
+    const blockCache = /* @__PURE__ */ new Map();
+    for (const log of logs.slice(-limit)) {
+      let timestamp = 0;
+      if (!blockCache.has(log.blockNumber)) {
+        try {
+          const block = await agent.client.getBlock({
+            blockNumber: log.blockNumber
+          });
+          timestamp = Number(block.timestamp);
+          blockCache.set(log.blockNumber, timestamp);
+        } catch {
+          timestamp = Math.floor(Date.now() / 1e3);
+        }
+      } else {
+        timestamp = blockCache.get(log.blockNumber) || 0;
+      }
+      recentTrades.push({
+        positionId: BigInt(log.topics[1] || "0"),
+        trader: log.topics[2],
+        token: tokenAddress,
+        isLong: log.args.isLong || false,
+        size: log.args.size || 0n,
+        margin: log.args.margin || 0n,
+        leverage: log.args.leverage || 0n,
+        entryPrice: log.args.entryPrice || 0n,
+        timestamp,
+        txHash: log.transactionHash,
+        blockNumber: log.blockNumber
+      });
+    }
+  } catch (error) {
+    console.warn("Failed to fetch recent trades:", error);
+  }
+  return {
+    token: tokenAddress,
+    currentPrice,
+    hasPrice,
+    isListed,
+    curveProgress,
+    recentTrades
+  };
+}
 
 // src/tools/okx/getSwapQuote.ts
 var getSwapQuote = async (agent, from, to, amount, slippagePercentage) => {
+  if (agent.demo) {
+    return createMockQuoteResponse("OKX", amount);
+  }
   const chainIndex = agent.chain === "mainnet" ? "5000" : "5003";
   return getSwapTransaction(from, to, amount, chainIndex, slippagePercentage);
 };
@@ -1271,21 +2274,44 @@ function getProjectConfig() {
   }
   return cachedConfig;
 }
-
-// src/agent.ts
+async function getUserAccountData(agent, userAddress) {
+  const lendingPoolAddress = LENDING_POOL[agent.chain];
+  const address = userAddress || agent.account.address;
+  if (lendingPoolAddress === "0x0000000000000000000000000000000000000000") {
+    throw new Error(
+      `Lendle LendingPool not configured for ${agent.chain}. Only available on mainnet.`
+    );
+  }
+  const result = await agent.client.readContract({
+    address: lendingPoolAddress,
+    abi: LENDING_POOL_ABI,
+    functionName: "getUserAccountData",
+    args: [address]
+  });
+  return {
+    totalCollateralETH: result[0],
+    totalDebtETH: result[1],
+    availableBorrowsETH: result[2],
+    currentLiquidationThreshold: result[3],
+    ltv: result[4],
+    healthFactor: result[5]
+  };
+}
 var MNTAgentKit = class {
   account;
   client;
   chain;
+  demo;
   projectConfig;
   constructor(privateKey, chain) {
     this.account = privateKeyToAccount(privateKey);
-    this.chain = chain;
+    this.demo = chain === "testnet-demo";
+    this.chain = chain === "testnet-demo" ? "testnet" : chain;
     this.client = createWalletClient({
-      chain: chain == "mainnet" ? mantle : mantleSepoliaTestnet,
+      chain: this.chain == "mainnet" ? mantle : mantleSepoliaTestnet,
       transport: http(),
       account: this.account
-    }).extend(publicActions);
+    }).extend(publicActions).extend(erc7811Actions());
   }
   /**
    * Initialize the agent with platform validation
@@ -1320,15 +2346,13 @@ var MNTAgentKit = class {
     );
   }
   async executeSwap(fromTokenAddress, toTokenAddress, amount, slippagePercentage = "0.5") {
-    if (this.chain === "mainnet") {
-      return await executeSwap(
-        this,
-        fromTokenAddress,
-        toTokenAddress,
-        amount,
-        slippagePercentage
-      );
-    }
+    return await executeSwap(
+      this,
+      fromTokenAddress,
+      toTokenAddress,
+      amount,
+      slippagePercentage
+    );
   }
   // OpenOcean DEX Aggregator
   async getOpenOceanQuote(fromToken, toToken, amount) {
@@ -1388,6 +2412,24 @@ var MNTAgentKit = class {
   async lendleRepay(tokenAddress, amount, rateMode = 2, onBehalfOf) {
     return await lendleRepay(this, tokenAddress, amount, rateMode, onBehalfOf);
   }
+  /**
+   * 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
+   */
+  async lendleGetUserAccountData(userAddress) {
+    return await getUserAccountData(this, userAddress);
+  }
+  /**
+   * 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
+   */
+  async lendleGetPositions(userAddress) {
+    return await lendleGetPositions(this, userAddress);
+  }
   // Agni Finance DEX (#1 on Mantle)
   async agniSwap(tokenIn, tokenOut, amountIn, slippagePercent = 0.5, feeTier) {
     return await agniSwap(
@@ -1411,8 +2453,38 @@ var MNTAgentKit = class {
   }
   // mETH Protocol - Liquid Staking Token
   getMethTokenAddress() {
+    if (this.demo) {
+      return METH_TOKEN.mainnet;
+    }
     return METH_TOKEN[this.chain];
   }
+  /**
+   * 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
+   */
+  async methGetPosition(userAddress) {
+    return await methGetPosition(this, userAddress);
+  }
+  /**
+   * 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
+   */
+  async swapToMeth(amount, slippage = 0.5) {
+    return await swapToMeth(this, amount, slippage);
+  }
+  /**
+   * 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
+   */
+  async swapFromMeth(amount, slippage = 0.5) {
+    return await swapFromMeth(this, amount, slippage);
+  }
   // Squid Router Cross-chain
   async getSquidRoute(fromToken, toToken, fromChain, toChain, amount, slippage = 1) {
     return await getSquidRoute(
@@ -1436,8 +2508,56 @@ var MNTAgentKit = class {
       slippage
     );
   }
+  // PikePerps - Perpetual Trading
+  /**
+   * 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
+   */
+  async pikeperpsOpenLong(tokenAddress, margin, leverage = 10) {
+    return await pikeperpsOpenLong(this, tokenAddress, margin, leverage);
+  }
+  /**
+   * 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
+   */
+  async pikeperpsOpenShort(tokenAddress, margin, leverage = 10) {
+    return await pikeperpsOpenShort(this, tokenAddress, margin, leverage);
+  }
+  /**
+   * Close an existing position on PikePerps
+   * @param positionId - Position ID to close
+   * @returns Transaction hash
+   */
+  async pikeperpsClosePosition(positionId) {
+    return await pikeperpsClosePosition(this, positionId);
+  }
+  /**
+   * 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
+   */
+  async pikeperpsGetPositions(userAddress) {
+    return await pikeperpsGetPositions(this, userAddress);
+  }
+  /**
+   * 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
+   */
+  async pikeperpsGetMarketData(tokenAddress, limit = 20) {
+    return await pikeperpsGetMarketData(this, tokenAddress, limit);
+  }
 };
 
-export { agni_exports as AgniConstants, lendle_exports as LendleConstants, METH_TOKEN, MNTAgentKit, merchantmoe_exports as MerchantMoeConstants, meth_exports as MethConstants, okx_exports as OKXConstants, oneinch_exports as OneInchConstants, openocean_exports as OpenOceanConstants, squid_exports as SquidConstants, uniswap_exports as UniswapConstants, agniSwap, approveToken, crossChainSwapViaSquid, executeSwap, get1inchQuote, getOpenOceanQuote, getProjectConfig, getSquidRoute, getUniswapQuote, initializePlatform, lendleBorrow, lendleRepay, lendleSupply, lendleWithdraw, merchantMoeSwap, sendTransaction, swapOn1inch, swapOnOpenOcean, swapOnUniswap };
+export { agni_exports as AgniConstants, lendle_exports as LendleConstants, METH_TOKEN, MNTAgentKit, merchantmoe_exports as MerchantMoeConstants, meth_exports as MethConstants, okx_exports as OKXConstants, oneinch_exports as OneInchConstants, openocean_exports as OpenOceanConstants, pikeperps_exports as PikePerpsConstants, squid_exports as SquidConstants, uniswap_exports as UniswapConstants, 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 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map