mantle-agent-kit-sdk 1.0.3 → 1.0.4

package/dist/index.js

@@ -1,4 +1,4 @@
-import { parseUnits, parseEther, encodeFunctionData, createWalletClient, http, publicActions, erc20Abi as erc20Abi$1 } 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';
@@ -465,8 +465,8 @@ 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({
+  const { encodeFunctionData: encodeFunctionData11 } = await import('viem');
+  const approveData = encodeFunctionData11({
     abi: erc20Abi$1,
     functionName: "approve",
     args: [spenderAddress, BigInt(amount)]
@@ -495,6 +495,9 @@ 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);
@@ -944,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 = {
@@ -1060,6 +1065,65 @@ 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) {
@@ -1165,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 = {};
@@ -1327,12 +1452,736 @@ 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) => {
@@ -1425,6 +2274,29 @@ function getProjectConfig() {
   }
   return cachedConfig;
 }
+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;
@@ -1540,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(
@@ -1568,6 +2458,33 @@ var MNTAgentKit = class {
     }
     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(
@@ -1591,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