mantle-agent-kit-sdk 1.0.2 → 1.0.4

package/dist/index.cjs

@@ -6,6 +6,7 @@ var chains = require('viem/chains');
 var actions = require('viem/actions');
 var axios6 = require('axios');
 var CryptoJS = require('crypto-js');
+var experimental = require('viem/experimental');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -17,11 +18,43 @@ 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: viem.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, viem.parseUnits(amount, decimals)]
+    });
+  } else {
+    hash = await agent.client.sendTransaction({
+      to,
+      value: viem.parseEther(amount)
+    });
+  }
   const receipt = await actions.getTransactionReceipt(agent.client, {
     hash
   });
@@ -195,9 +228,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) {
@@ -331,6 +440,9 @@ 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) {
@@ -360,8 +472,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: viem.erc20Abi,
     functionName: "approve",
     args: [spenderAddress, BigInt(amount)]
@@ -387,6 +499,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);
@@ -498,11 +616,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);
@@ -669,11 +793,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);
@@ -772,6 +902,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,
@@ -800,6 +933,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,
@@ -818,8 +954,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 = {
@@ -934,11 +1072,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.`
     );
@@ -965,6 +1165,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.`
     );
@@ -986,6 +1189,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.`
     );
@@ -1008,6 +1214,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.`
     );
@@ -1027,6 +1236,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 = viem.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 = {};
@@ -1088,6 +1358,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);
@@ -1160,6 +1433,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);
@@ -1183,15 +1459,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 = viem.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 = viem.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 = viem.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: viem.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);
 };
@@ -1278,21 +2281,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 = accounts.privateKeyToAccount(privateKey);
-    this.chain = chain;
+    this.demo = chain === "testnet-demo";
+    this.chain = chain === "testnet-demo" ? "testnet" : chain;
     this.client = viem.createWalletClient({
-      chain: chain == "mainnet" ? chains.mantle : chains.mantleSepoliaTestnet,
+      chain: this.chain == "mainnet" ? chains.mantle : chains.mantleSepoliaTestnet,
       transport: viem.http(),
       account: this.account
-    }).extend(viem.publicActions);
+    }).extend(viem.publicActions).extend(experimental.erc7811Actions());
   }
   /**
    * Initialize the agent with platform validation
@@ -1327,15 +2353,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) {
@@ -1395,6 +2419,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(
@@ -1418,8 +2460,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(
@@ -1443,6 +2515,54 @@ 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);
+  }
 };
 
 exports.AgniConstants = agni_exports;
@@ -1454,6 +2574,7 @@ exports.MethConstants = meth_exports;
 exports.OKXConstants = okx_exports;
 exports.OneInchConstants = oneinch_exports;
 exports.OpenOceanConstants = openocean_exports;
+exports.PikePerpsConstants = pikeperps_exports;
 exports.SquidConstants = squid_exports;
 exports.UniswapConstants = uniswap_exports;
 exports.agniSwap = agniSwap;
@@ -1467,13 +2588,22 @@ exports.getSquidRoute = getSquidRoute;
 exports.getUniswapQuote = getUniswapQuote;
 exports.initializePlatform = initializePlatform;
 exports.lendleBorrow = lendleBorrow;
+exports.lendleGetPositions = lendleGetPositions;
 exports.lendleRepay = lendleRepay;
 exports.lendleSupply = lendleSupply;
 exports.lendleWithdraw = lendleWithdraw;
 exports.merchantMoeSwap = merchantMoeSwap;
+exports.methGetPosition = methGetPosition;
+exports.pikeperpsClosePosition = pikeperpsClosePosition;
+exports.pikeperpsGetMarketData = pikeperpsGetMarketData;
+exports.pikeperpsGetPositions = pikeperpsGetPositions;
+exports.pikeperpsOpenLong = pikeperpsOpenLong;
+exports.pikeperpsOpenShort = pikeperpsOpenShort;
 exports.sendTransaction = sendTransaction;
+exports.swapFromMeth = swapFromMeth;
 exports.swapOn1inch = swapOn1inch;
 exports.swapOnOpenOcean = swapOnOpenOcean;
 exports.swapOnUniswap = swapOnUniswap;
+exports.swapToMeth = swapToMeth;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map