mantle-agent-kit-sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,1443 @@
+import { parseEther, encodeFunctionData, createWalletClient, http, publicActions, erc20Abi } 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';
+
+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)
+  });
+  const receipt = await getTransactionReceipt(agent.client, {
+    hash
+  });
+  return receipt;
+};
+async function checkAllowance(agent, tokenAddress, ownerAddress, spenderAddress) {
+  try {
+    const allowance = await agent.client.readContract({
+      address: tokenAddress,
+      abi: erc20Abi,
+      functionName: "allowance",
+      args: [ownerAddress, spenderAddress]
+    });
+    return allowance;
+  } catch (error) {
+    console.error("Failed to query allowance:", error);
+    throw error;
+  }
+}
+
+// src/constants/okx/index.ts
+var okx_exports = {};
+__export(okx_exports, {
+  ETH_ADDRESS: () => ETH_ADDRESS,
+  baseUrl: () => baseUrl,
+  configs: () => configs
+});
+var configs = {
+  apiKey: process.env.OKX_API_KEY,
+  secretKey: process.env.OKX_SECRET_KEY,
+  apiPassphrase: process.env.OKX_API_PASSPHRASE,
+  projectId: process.env.OKX_PROJECT_ID
+};
+var baseUrl = "https://web3.okx.com/api/v6/";
+var ETH_ADDRESS = "0xdeaddeaddeaddeaddeaddeaddeaddeaddead0000";
+function getHeaders(timestamp, method, requestPath, queryString = "", body = "") {
+  const { apiKey, secretKey, apiPassphrase, projectId } = configs;
+  if (!apiKey || !secretKey || !apiPassphrase || !projectId) {
+    throw new Error(
+      "Missing required environment variables for API authentication"
+    );
+  }
+  const stringToSign = timestamp + method + requestPath + (queryString || body);
+  return {
+    "Content-Type": "application/json",
+    "OK-ACCESS-KEY": apiKey,
+    "OK-ACCESS-SIGN": CryptoJS.enc.Base64.stringify(
+      CryptoJS.HmacSHA256(stringToSign, secretKey)
+    ),
+    "OK-ACCESS-TIMESTAMP": timestamp,
+    "OK-ACCESS-PASSPHRASE": apiPassphrase,
+    "OK-ACCESS-PROJECT": projectId
+  };
+}
+
+// src/utils/okx/getApproveTx.ts
+async function getApproveTx(tokenAddress, amount, chainIndex) {
+  try {
+    const path = "dex/aggregator/approve-transaction";
+    const url = `${baseUrl}${path}`;
+    const params = {
+      chainIndex,
+      tokenContractAddress: tokenAddress,
+      approveAmount: amount
+    };
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const requestPath = `/api/v6/${path}`;
+    const queryString = "?" + new URLSearchParams(params).toString();
+    const headers = getHeaders(timestamp, "GET", requestPath, queryString);
+    const response = await axios6.get(url, { params, headers });
+    if (response.data.code === "0") {
+      return response.data.data[0];
+    } else {
+      throw new Error(`API Error: ${response.data.msg || "Unknown error"}`);
+    }
+  } catch (error) {
+    console.error(
+      "Failed to get approval transaction data:",
+      error.message
+    );
+    throw error;
+  }
+}
+async function getGasLimit(fromAddress, toAddress, chainIndex, txAmount = "0", inputData = "") {
+  try {
+    const path = "dex/pre-transaction/gas-limit";
+    const url = `https://web3.okx.com/api/v6/${path}`;
+    const body = {
+      chainIndex,
+      fromAddress,
+      toAddress,
+      txAmount,
+      extJson: {
+        inputData
+      }
+    };
+    const bodyString = JSON.stringify(body);
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const requestPath = `/api/v6/${path}`;
+    const headers = getHeaders(timestamp, "POST", requestPath, "", bodyString);
+    const response = await axios6.post(url, body, { headers });
+    if (response.data.code === "0") {
+      return response.data.data[0].gasLimit;
+    } else {
+      throw new Error(`API Error: ${response.data.msg || "Unknown error"}`);
+    }
+  } catch (error) {
+    console.error("Failed to get gas limit:", error.message);
+    throw error;
+  }
+}
+
+// src/utils/okx/approveToken.ts
+async function approveToken(agent, tokenAddress, amount) {
+  const chainIndex = agent.chain === "mainnet" ? "5000" : "5003";
+  const walletAddress = agent.account.address;
+  const spenderAddress = "0x1f16A607a7f3F3044E477abFFc8BD33952cE306b";
+  const currentAllowance = await checkAllowance(
+    agent,
+    tokenAddress,
+    walletAddress,
+    spenderAddress
+  );
+  if (currentAllowance >= BigInt(amount)) {
+    console.log("Sufficient allowance already exists");
+    return { allowanceExists: true, data: null };
+  }
+  console.log("Insufficient allowance, approving tokens...");
+  const approveData = await getApproveTx(tokenAddress, amount, chainIndex);
+  const gasLimit = await getGasLimit(
+    walletAddress,
+    tokenAddress,
+    chainIndex,
+    "0",
+    approveData.data
+  );
+  const txObject = {
+    to: tokenAddress,
+    data: approveData.data,
+    gas: gasLimit
+  };
+  return { allowanceExists: false, data: txObject };
+}
+async function getSwapTransaction(fromTokenAddress, toTokenAddress, amount, userWalletAddress, chainIndex, slippagePercent = "0.5") {
+  try {
+    const path = "dex/aggregator/swap";
+    const url = `${baseUrl}${path}`;
+    const params = {
+      chainIndex,
+      fromTokenAddress,
+      toTokenAddress,
+      amount,
+      userWalletAddress,
+      slippage: slippagePercent
+    };
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const requestPath = `/api/v6/${path}`;
+    const queryString = "?" + new URLSearchParams(params).toString();
+    const headers = getHeaders(timestamp, "GET", requestPath, queryString);
+    const response = await axios6.get(url, { params, headers });
+    if (response.data.code === "0") {
+      return response.data.data[0];
+    } else {
+      throw new Error(`API Error: ${response.data.msg || "Unknown error"}`);
+    }
+  } catch (error) {
+    console.error(
+      "Failed to get swap transaction data:",
+      error.message
+    );
+    throw error;
+  }
+}
+
+// src/tools/okx/swap.ts
+async function executeSwap(agent, fromTokenAddress, toTokenAddress, amount, slippagePercent) {
+  const chainIndex = agent.chain === "mainnet" ? "5000" : "5003";
+  const walletAddress = agent.account.address;
+  if (fromTokenAddress !== ETH_ADDRESS) {
+    const approval = await approveToken(agent, fromTokenAddress, amount);
+    if (!approval.allowanceExists && approval.data) {
+      const approveTxHash = await agent.client.sendTransaction({
+        to: approval.data.to,
+        data: approval.data.data,
+        value: BigInt(0),
+        gas: BigInt(approval.data.gas)
+      });
+      console.log(`Approval tx sent: ${approveTxHash}`);
+      const approveReceipt = await agent.client.waitForTransactionReceipt({
+        hash: approveTxHash
+      });
+      console.log(`Approval confirmed: ${approveReceipt.status}`);
+    }
+  }
+  const swapData = await getSwapTransaction(
+    fromTokenAddress,
+    toTokenAddress,
+    amount,
+    walletAddress,
+    chainIndex,
+    slippagePercent
+  );
+  const txData = swapData.tx;
+  console.log("Swap TX data received");
+  const gasLimit = await getGasLimit(
+    walletAddress,
+    txData.to,
+    chainIndex,
+    txData.value || "0",
+    txData.data
+  );
+  console.log("Gas limit received");
+  const txHash = await agent.client.sendTransaction({
+    to: txData.to,
+    data: txData.data,
+    value: BigInt(txData.value || "0"),
+    gas: BigInt(gasLimit)
+  });
+  console.log(`Swap tx sent: ${txHash}`);
+  const swapReceipt = await agent.client.waitForTransactionReceipt({
+    hash: txHash
+  });
+  console.log(`Swap confirmed: ${swapReceipt.status}`);
+  return {
+    data: txHash
+  };
+}
+
+// src/constants/openocean/index.ts
+var openocean_exports = {};
+__export(openocean_exports, {
+  NATIVE_TOKEN_ADDRESS: () => NATIVE_TOKEN_ADDRESS,
+  OPENOCEAN_BASE_URL: () => OPENOCEAN_BASE_URL,
+  OPENOCEAN_CHAIN: () => OPENOCEAN_CHAIN,
+  OPENOCEAN_EXCHANGE_PROXY: () => OPENOCEAN_EXCHANGE_PROXY
+});
+var OPENOCEAN_BASE_URL = "https://open-api.openocean.finance/v4";
+var OPENOCEAN_CHAIN = {
+  mainnet: "mantle",
+  testnet: "mantle"
+  // OpenOcean may not support testnet
+};
+var NATIVE_TOKEN_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+var OPENOCEAN_EXCHANGE_PROXY = "0x6352a56caadC4F1E25CD6c75970Fa768A3304e64";
+
+// src/helpers/openocean/index.ts
+function getHeaders2(apiKey) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  return headers;
+}
+
+// src/utils/openocean/getQuoteData.ts
+async function getQuoteData(fromToken, toToken, amount, chain) {
+  try {
+    const chainName = OPENOCEAN_CHAIN[chain];
+    const url = `${OPENOCEAN_BASE_URL}/${chainName}/quote`;
+    const params = {
+      inTokenAddress: fromToken,
+      outTokenAddress: toToken,
+      amount,
+      gasPrice: "5"
+      // Default gas price in gwei
+    };
+    const response = await axios6.get(url, {
+      params,
+      headers: getHeaders2()
+    });
+    if (response.data.code === 200) {
+      return response.data.data;
+    } else {
+      throw new Error(`OpenOcean API Error: ${response.data.message || "Unknown error"}`);
+    }
+  } catch (error) {
+    console.error("Failed to get OpenOcean quote:", error.message);
+    throw error;
+  }
+}
+async function getSwapData(fromToken, toToken, amount, userAddress, slippage, chain) {
+  try {
+    const chainName = OPENOCEAN_CHAIN[chain];
+    const url = `${OPENOCEAN_BASE_URL}/${chainName}/swap`;
+    const params = {
+      inTokenAddress: fromToken,
+      outTokenAddress: toToken,
+      amount,
+      gasPrice: "5",
+      // Default gas price in gwei
+      slippage,
+      account: userAddress
+    };
+    const response = await axios6.get(url, {
+      params,
+      headers: getHeaders2()
+    });
+    if (response.data.code === 200) {
+      return response.data.data;
+    } else {
+      throw new Error(`OpenOcean API Error: ${response.data.message || "Unknown error"}`);
+    }
+  } catch (error) {
+    console.error("Failed to get OpenOcean swap data:", error.message);
+    throw error;
+  }
+}
+
+// src/tools/openocean/getQuote.ts
+async function getOpenOceanQuote(agent, fromToken, toToken, 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,
+      functionName: "allowance",
+      args: [ownerAddress, spenderAddress]
+    });
+    return allowance;
+  } catch (error) {
+    console.error("Failed to query allowance:", error);
+    throw error;
+  }
+}
+async function approveToken2(agent, tokenAddress, spenderAddress, amount) {
+  const walletAddress = agent.account.address;
+  const currentAllowance = await checkAllowance2(
+    agent,
+    tokenAddress,
+    walletAddress,
+    spenderAddress
+  );
+  if (currentAllowance >= BigInt(amount)) {
+    console.log("Sufficient allowance already exists");
+    return { approved: true, txHash: null };
+  }
+  console.log("Insufficient allowance, approving tokens...");
+  const { encodeFunctionData: encodeFunctionData8 } = await import('viem');
+  const approveData = encodeFunctionData8({
+    abi: erc20Abi,
+    functionName: "approve",
+    args: [spenderAddress, BigInt(amount)]
+  });
+  const gasEstimate = await agent.client.estimateGas({
+    account: agent.account,
+    to: tokenAddress,
+    data: approveData
+  });
+  const txHash = await agent.client.sendTransaction({
+    to: tokenAddress,
+    data: approveData,
+    value: BigInt(0),
+    gas: gasEstimate
+  });
+  console.log(`Approval tx sent: ${txHash}`);
+  const receipt = await agent.client.waitForTransactionReceipt({
+    hash: txHash
+  });
+  console.log(`Approval confirmed: ${receipt.status}`);
+  return { approved: true, txHash };
+}
+
+// src/tools/openocean/swap.ts
+async function swapOnOpenOcean(agent, fromToken, toToken, amount, slippage = "1") {
+  const walletAddress = agent.account.address;
+  if (fromToken.toLowerCase() !== NATIVE_TOKEN_ADDRESS.toLowerCase()) {
+    await approveToken2(agent, fromToken, OPENOCEAN_EXCHANGE_PROXY, amount);
+  }
+  const swapData = await getSwapData(
+    fromToken,
+    toToken,
+    amount,
+    walletAddress,
+    slippage,
+    agent.chain
+  );
+  console.log("OpenOcean swap data received");
+  console.log(`Expected output: ${swapData.outAmount}`);
+  const txHash = await agent.client.sendTransaction({
+    to: swapData.to,
+    data: swapData.data,
+    value: BigInt(swapData.value || "0"),
+    gas: BigInt(swapData.estimatedGas)
+  });
+  console.log(`OpenOcean swap tx sent: ${txHash}`);
+  const receipt = await agent.client.waitForTransactionReceipt({
+    hash: txHash
+  });
+  console.log(`Swap confirmed: ${receipt.status}`);
+  return {
+    txHash,
+    outAmount: swapData.outAmount
+  };
+}
+
+// src/constants/oneinch/index.ts
+var oneinch_exports = {};
+__export(oneinch_exports, {
+  NATIVE_TOKEN_ADDRESS: () => NATIVE_TOKEN_ADDRESS2,
+  ONEINCH_BASE_URL: () => ONEINCH_BASE_URL,
+  ONEINCH_CHAIN_ID: () => ONEINCH_CHAIN_ID,
+  ONEINCH_ROUTER_ADDRESS: () => ONEINCH_ROUTER_ADDRESS,
+  configs: () => configs2
+});
+var ONEINCH_BASE_URL = "https://api.1inch.dev/swap/v6.0";
+var ONEINCH_CHAIN_ID = {
+  mainnet: "5000",
+  // Mantle mainnet
+  testnet: "5003"
+  // Mantle testnet (may not be supported)
+};
+var NATIVE_TOKEN_ADDRESS2 = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+var ONEINCH_ROUTER_ADDRESS = "0x111111125421cA6dc452d289314280a0f8842A65";
+var configs2 = {
+  apiKey: process.env.ONEINCH_API_KEY
+  // Optional: for higher rate limits
+};
+
+// src/helpers/oneinch/index.ts
+function getHeaders3() {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (configs2.apiKey) {
+    headers["Authorization"] = `Bearer ${configs2.apiKey}`;
+  }
+  return headers;
+}
+
+// src/utils/oneinch/getSwapData.ts
+async function getQuoteData2(fromToken, toToken, amount, chain) {
+  try {
+    const chainId = ONEINCH_CHAIN_ID[chain];
+    const url = `${ONEINCH_BASE_URL}/${chainId}/quote`;
+    const params = {
+      src: fromToken,
+      dst: toToken,
+      amount
+    };
+    const response = await axios6.get(url, {
+      params,
+      headers: getHeaders3()
+    });
+    return response.data;
+  } catch (error) {
+    console.error("Failed to get 1inch quote:", error.message);
+    throw error;
+  }
+}
+async function getSwapData2(fromToken, toToken, amount, userAddress, slippage, chain) {
+  try {
+    const chainId = ONEINCH_CHAIN_ID[chain];
+    const url = `${ONEINCH_BASE_URL}/${chainId}/swap`;
+    const params = {
+      src: fromToken,
+      dst: toToken,
+      amount,
+      from: userAddress,
+      slippage,
+      disableEstimate: "true"
+      // We'll estimate gas ourselves
+    };
+    const response = await axios6.get(url, {
+      params,
+      headers: getHeaders3()
+    });
+    return response.data;
+  } catch (error) {
+    console.error("Failed to get 1inch swap data:", error.message);
+    throw error;
+  }
+}
+
+// src/tools/oneinch/getQuote.ts
+async function get1inchQuote(agent, fromToken, toToken, amount) {
+  return await getQuoteData2(fromToken, toToken, amount, agent.chain);
+}
+
+// src/tools/oneinch/swap.ts
+async function swapOn1inch(agent, fromToken, toToken, amount, slippage = "1") {
+  const walletAddress = agent.account.address;
+  if (fromToken.toLowerCase() !== NATIVE_TOKEN_ADDRESS2.toLowerCase()) {
+    await approveToken2(agent, fromToken, ONEINCH_ROUTER_ADDRESS, amount);
+  }
+  const swapData = await getSwapData2(
+    fromToken,
+    toToken,
+    amount,
+    walletAddress,
+    slippage,
+    agent.chain
+  );
+  console.log("1inch swap data received");
+  console.log(`Expected output: ${swapData.dstAmount}`);
+  const gasEstimate = await agent.client.estimateGas({
+    account: agent.account,
+    to: swapData.tx.to,
+    data: swapData.tx.data,
+    value: BigInt(swapData.tx.value || "0")
+  });
+  const txHash = await agent.client.sendTransaction({
+    to: swapData.tx.to,
+    data: swapData.tx.data,
+    value: BigInt(swapData.tx.value || "0"),
+    gas: gasEstimate
+  });
+  console.log(`1inch swap tx sent: ${txHash}`);
+  const receipt = await agent.client.waitForTransactionReceipt({
+    hash: txHash
+  });
+  console.log(`Swap confirmed: ${receipt.status}`);
+  return {
+    txHash,
+    dstAmount: swapData.dstAmount
+  };
+}
+
+// src/constants/uniswap/index.ts
+var uniswap_exports = {};
+__export(uniswap_exports, {
+  DEFAULT_POOL_FEE: () => DEFAULT_POOL_FEE,
+  FACTORY_ADDRESS: () => FACTORY_ADDRESS,
+  FEE_TIERS: () => FEE_TIERS,
+  NATIVE_TOKEN_ADDRESS: () => NATIVE_TOKEN_ADDRESS3,
+  QUOTER_V2_ADDRESS: () => QUOTER_V2_ADDRESS,
+  SWAP_ROUTER_ADDRESS: () => SWAP_ROUTER_ADDRESS,
+  WMNT_ADDRESS: () => WMNT_ADDRESS
+});
+var SWAP_ROUTER_ADDRESS = "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45";
+var QUOTER_V2_ADDRESS = "0x61fFE014bA17989E743c5F6cB21bF9697530B21e";
+var FACTORY_ADDRESS = "0x1F98431c8aD98523631AE4a59f267346ea31F984";
+var WMNT_ADDRESS = "0x78c1b0C915c4FAA5FffA6CAbf0219DA63d7f4cb8";
+var NATIVE_TOKEN_ADDRESS3 = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+var FEE_TIERS = {
+  LOWEST: 100,
+  // 0.01%
+  LOW: 500,
+  // 0.05%
+  MEDIUM: 3e3,
+  // 0.3%
+  HIGH: 1e4
+  // 1%
+};
+var DEFAULT_POOL_FEE = FEE_TIERS.MEDIUM;
+var quoterV2Abi = [
+  {
+    inputs: [
+      {
+        components: [
+          { name: "tokenIn", type: "address" },
+          { name: "tokenOut", type: "address" },
+          { name: "amountIn", type: "uint256" },
+          { name: "fee", type: "uint24" },
+          { name: "sqrtPriceLimitX96", type: "uint160" }
+        ],
+        name: "params",
+        type: "tuple"
+      }
+    ],
+    name: "quoteExactInputSingle",
+    outputs: [
+      { name: "amountOut", type: "uint256" },
+      { name: "sqrtPriceX96After", type: "uint160" },
+      { name: "initializedTicksCrossed", type: "uint32" },
+      { name: "gasEstimate", type: "uint256" }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+var swapRouterAbi = [
+  {
+    inputs: [
+      {
+        components: [
+          { name: "tokenIn", type: "address" },
+          { name: "tokenOut", type: "address" },
+          { name: "fee", type: "uint24" },
+          { name: "recipient", type: "address" },
+          { name: "amountIn", type: "uint256" },
+          { name: "amountOutMinimum", type: "uint256" },
+          { name: "sqrtPriceLimitX96", type: "uint160" }
+        ],
+        name: "params",
+        type: "tuple"
+      }
+    ],
+    name: "exactInputSingle",
+    outputs: [{ name: "amountOut", type: "uint256" }],
+    stateMutability: "payable",
+    type: "function"
+  }
+];
+function getTokenAddress(token) {
+  if (token.toLowerCase() === NATIVE_TOKEN_ADDRESS3.toLowerCase()) {
+    return WMNT_ADDRESS;
+  }
+  return token;
+}
+async function getUniswapQuoteData(agent, tokenIn, tokenOut, amountIn, fee = DEFAULT_POOL_FEE) {
+  try {
+    const result = await agent.client.simulateContract({
+      address: QUOTER_V2_ADDRESS,
+      abi: quoterV2Abi,
+      functionName: "quoteExactInputSingle",
+      args: [
+        {
+          tokenIn: getTokenAddress(tokenIn),
+          tokenOut: getTokenAddress(tokenOut),
+          amountIn: BigInt(amountIn),
+          fee,
+          sqrtPriceLimitX96: BigInt(0)
+        }
+      ]
+    });
+    const [amountOut, sqrtPriceX96After, , gasEstimate] = result.result;
+    return {
+      amountOut,
+      sqrtPriceX96After,
+      gasEstimate
+    };
+  } catch (error) {
+    console.error("Failed to get Uniswap quote:", error);
+    throw error;
+  }
+}
+function buildSwapCalldata(params, fee = DEFAULT_POOL_FEE) {
+  return encodeFunctionData({
+    abi: swapRouterAbi,
+    functionName: "exactInputSingle",
+    args: [
+      {
+        tokenIn: getTokenAddress(params.tokenIn),
+        tokenOut: getTokenAddress(params.tokenOut),
+        fee,
+        recipient: params.recipient,
+        amountIn: BigInt(params.amountIn),
+        amountOutMinimum: BigInt(params.amountOutMinimum),
+        sqrtPriceLimitX96: BigInt(0)
+      }
+    ]
+  });
+}
+
+// src/tools/uniswap/getQuote.ts
+async function getUniswapQuote(agent, fromToken, toToken, amount, fee = DEFAULT_POOL_FEE) {
+  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) {
+  const walletAddress = agent.account.address;
+  const isNativeIn = fromToken.toLowerCase() === NATIVE_TOKEN_ADDRESS3.toLowerCase();
+  const quote = await getUniswapQuoteData(agent, fromToken, toToken, amount, fee);
+  console.log(`Uniswap quote: ${quote.amountOut.toString()}`);
+  const slippageBps = Math.floor(parseFloat(slippage) * 100);
+  const amountOutMinimum = quote.amountOut * BigInt(1e4 - slippageBps) / BigInt(1e4);
+  if (!isNativeIn) {
+    await approveToken2(agent, fromToken, SWAP_ROUTER_ADDRESS, amount);
+  }
+  const calldata = buildSwapCalldata(
+    {
+      tokenIn: fromToken,
+      tokenOut: toToken,
+      amountIn: amount,
+      amountOutMinimum: amountOutMinimum.toString(),
+      recipient: walletAddress
+    },
+    fee
+  );
+  const gasEstimate = await agent.client.estimateGas({
+    account: agent.account,
+    to: SWAP_ROUTER_ADDRESS,
+    data: calldata,
+    value: isNativeIn ? BigInt(amount) : BigInt(0)
+  });
+  const txHash = await agent.client.sendTransaction({
+    to: SWAP_ROUTER_ADDRESS,
+    data: calldata,
+    value: isNativeIn ? BigInt(amount) : BigInt(0),
+    gas: gasEstimate
+  });
+  console.log(`Uniswap swap tx sent: ${txHash}`);
+  const receipt = await agent.client.waitForTransactionReceipt({
+    hash: txHash
+  });
+  console.log(`Swap confirmed: ${receipt.status}`);
+  return {
+    txHash,
+    amountOut: quote.amountOut.toString()
+  };
+}
+
+// src/constants/squid/index.ts
+var squid_exports = {};
+__export(squid_exports, {
+  DESTINATION_CHAINS: () => DESTINATION_CHAINS,
+  NATIVE_TOKEN_ADDRESS: () => NATIVE_TOKEN_ADDRESS4,
+  SQUID_BASE_URL: () => SQUID_BASE_URL,
+  SQUID_CHAIN_ID: () => SQUID_CHAIN_ID
+});
+var SQUID_BASE_URL = "https://api.squidrouter.com/v2";
+var SQUID_CHAIN_ID = {
+  mainnet: 5e3,
+  // Mantle mainnet
+  testnet: 5003
+  // Mantle testnet
+};
+var DESTINATION_CHAINS = {
+  ethereum: 101,
+  arbitrum: 110,
+  optimism: 111,
+  polygon: 109,
+  base: 184,
+  bsc: 102,
+  avalanche: 106,
+  mantle: 5e3
+};
+var NATIVE_TOKEN_ADDRESS4 = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+
+// src/helpers/squid/index.ts
+function getHeaders4(integratorId) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  return headers;
+}
+
+// src/utils/squid/getRouteData.ts
+async function getRouteData(fromToken, toToken, fromChain, toChain, amount, fromAddress, slippage = 1) {
+  const params = {
+    fromChain: fromChain.toString(),
+    toChain: toChain.toString(),
+    fromToken: fromToken.toLowerCase() === NATIVE_TOKEN_ADDRESS4.toLowerCase() ? "native" : fromToken,
+    toToken: toToken.toLowerCase() === NATIVE_TOKEN_ADDRESS4.toLowerCase() ? "native" : toToken,
+    fromAmount: amount,
+    fromAddress,
+    slippage: slippage.toString(),
+    enableForecast: false
+  };
+  const response = await axios6.get(`${SQUID_BASE_URL}/route`, {
+    params,
+    headers: getHeaders4()
+  });
+  return response.data;
+}
+
+// src/tools/squid/crossChainSwap.ts
+async function crossChainSwapViaSquid(agent, fromToken, toToken, fromChain, toChain, amount, slippage = 1) {
+  const routeData = await getRouteData(
+    fromToken,
+    toToken,
+    fromChain,
+    toChain,
+    amount,
+    agent.account.address,
+    slippage
+  );
+  const transactionRequest = routeData.route.transactionRequest;
+  if (fromToken.toLowerCase() !== NATIVE_TOKEN_ADDRESS4.toLowerCase() && transactionRequest.targetAddress) {
+    await approveToken2(
+      agent,
+      fromToken,
+      transactionRequest.targetAddress,
+      amount
+    );
+  }
+  const hash = await agent.client.sendTransaction({
+    to: transactionRequest.targetAddress,
+    data: transactionRequest.data,
+    value: BigInt(transactionRequest.value || "0"),
+    gas: BigInt(transactionRequest.gasLimit || "0")
+  });
+  await agent.client.waitForTransactionReceipt({ hash });
+  return hash;
+}
+async function getSquidRoute(agent, fromToken, toToken, fromChain, toChain, amount, slippage = 1) {
+  return await getRouteData(
+    fromToken,
+    toToken,
+    fromChain,
+    toChain,
+    amount,
+    agent.account.address,
+    slippage
+  );
+}
+
+// src/constants/lendle/index.ts
+var lendle_exports = {};
+__export(lendle_exports, {
+  INTEREST_RATE_MODE: () => INTEREST_RATE_MODE,
+  LENDING_POOL: () => LENDING_POOL,
+  LENDING_POOL_ABI: () => LENDING_POOL_ABI,
+  LENDING_POOL_ADDRESSES_PROVIDER: () => LENDING_POOL_ADDRESSES_PROVIDER,
+  ORACLE: () => ORACLE,
+  PROTOCOL_DATA_PROVIDER: () => PROTOCOL_DATA_PROVIDER,
+  WMNT_ADDRESS: () => WMNT_ADDRESS2
+});
+var LENDING_POOL = {
+  mainnet: "0xCFa5aE7c2CE8Fadc6426C1ff872cA45378Fb7cF3",
+  testnet: "0x0000000000000000000000000000000000000000"
+  // Not deployed on testnet
+};
+var LENDING_POOL_ADDRESSES_PROVIDER = {
+  mainnet: "0xAb94Bedd21ae3411eB2698945dfCab1D5C19C3d4",
+  testnet: "0x0000000000000000000000000000000000000000"
+};
+var PROTOCOL_DATA_PROVIDER = {
+  mainnet: "0x552b9e4bae485C4B7F540777d7D25614CdB84773",
+  testnet: "0x0000000000000000000000000000000000000000"
+};
+var ORACLE = {
+  mainnet: "0x870c9692Ab04944C86ec6FEeF63F261226506EfC",
+  testnet: "0x0000000000000000000000000000000000000000"
+};
+var WMNT_ADDRESS2 = "0x78c1b0C915c4FAA5FffA6CAbf0219DA63d7f4cb8";
+var INTEREST_RATE_MODE = {
+  STABLE: 1,
+  VARIABLE: 2
+};
+var LENDING_POOL_ABI = [
+  {
+    inputs: [
+      { name: "asset", type: "address" },
+      { name: "amount", type: "uint256" },
+      { name: "onBehalfOf", type: "address" },
+      { name: "referralCode", type: "uint16" }
+    ],
+    name: "deposit",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "asset", type: "address" },
+      { name: "amount", type: "uint256" },
+      { name: "to", type: "address" }
+    ],
+    name: "withdraw",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "asset", type: "address" },
+      { name: "amount", type: "uint256" },
+      { name: "interestRateMode", type: "uint256" },
+      { name: "referralCode", type: "uint16" },
+      { name: "onBehalfOf", type: "address" }
+    ],
+    name: "borrow",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "asset", type: "address" },
+      { name: "amount", type: "uint256" },
+      { name: "rateMode", type: "uint256" },
+      { name: "onBehalfOf", type: "address" }
+    ],
+    name: "repay",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "user", type: "address" }],
+    name: "getUserAccountData",
+    outputs: [
+      { name: "totalCollateralETH", type: "uint256" },
+      { name: "totalDebtETH", type: "uint256" },
+      { name: "availableBorrowsETH", type: "uint256" },
+      { name: "currentLiquidationThreshold", type: "uint256" },
+      { name: "ltv", type: "uint256" },
+      { name: "healthFactor", type: "uint256" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "asset", type: "address" }],
+    name: "getReserveData",
+    outputs: [
+      {
+        components: [
+          { name: "configuration", type: "uint256" },
+          { name: "liquidityIndex", type: "uint128" },
+          { name: "variableBorrowIndex", type: "uint128" },
+          { name: "currentLiquidityRate", type: "uint128" },
+          { name: "currentVariableBorrowRate", type: "uint128" },
+          { name: "currentStableBorrowRate", type: "uint128" },
+          { name: "lastUpdateTimestamp", type: "uint40" },
+          { name: "aTokenAddress", type: "address" },
+          { name: "stableDebtTokenAddress", type: "address" },
+          { name: "variableDebtTokenAddress", type: "address" },
+          { name: "interestRateStrategyAddress", type: "address" },
+          { name: "id", type: "uint8" }
+        ],
+        name: "",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+
+// src/tools/lendle/supply.ts
+async function lendleSupply(agent, tokenAddress, amount) {
+  const lendingPoolAddress = LENDING_POOL[agent.chain];
+  if (lendingPoolAddress === "0x0000000000000000000000000000000000000000") {
+    throw new Error(
+      `Lendle LendingPool not configured for ${agent.chain}. Only available on mainnet.`
+    );
+  }
+  const amountBigInt = BigInt(amount);
+  const isNative = tokenAddress.toLowerCase() === WMNT_ADDRESS2.toLowerCase();
+  if (!isNative) {
+    await approveToken2(agent, tokenAddress, lendingPoolAddress, amount);
+  }
+  const data = encodeFunctionData({
+    abi: LENDING_POOL_ABI,
+    functionName: "deposit",
+    args: [tokenAddress, amountBigInt, agent.account.address, 0]
+    // referralCode = 0 (uint16)
+  });
+  const hash = await agent.client.sendTransaction({
+    to: lendingPoolAddress,
+    data,
+    value: isNative ? amountBigInt : 0n
+  });
+  await agent.client.waitForTransactionReceipt({ hash });
+  return hash;
+}
+async function lendleWithdraw(agent, tokenAddress, amount, to) {
+  const lendingPoolAddress = LENDING_POOL[agent.chain];
+  if (lendingPoolAddress === "0x0000000000000000000000000000000000000000") {
+    throw new Error(
+      `Lendle LendingPool not configured for ${agent.chain}. Only available on mainnet.`
+    );
+  }
+  const amountBigInt = BigInt(amount);
+  const toAddress = to || agent.account.address;
+  const data = encodeFunctionData({
+    abi: LENDING_POOL_ABI,
+    functionName: "withdraw",
+    args: [tokenAddress, amountBigInt, toAddress]
+  });
+  const hash = await agent.client.sendTransaction({
+    to: lendingPoolAddress,
+    data
+  });
+  await agent.client.waitForTransactionReceipt({ hash });
+  return hash;
+}
+async function lendleBorrow(agent, tokenAddress, amount, interestRateMode = INTEREST_RATE_MODE.VARIABLE, onBehalfOf) {
+  const lendingPoolAddress = LENDING_POOL[agent.chain];
+  if (lendingPoolAddress === "0x0000000000000000000000000000000000000000") {
+    throw new Error(
+      `Lendle LendingPool not configured for ${agent.chain}. Only available on mainnet.`
+    );
+  }
+  const amountBigInt = BigInt(amount);
+  const onBehalfOfAddress = onBehalfOf || agent.account.address;
+  const data = encodeFunctionData({
+    abi: LENDING_POOL_ABI,
+    functionName: "borrow",
+    args: [tokenAddress, amountBigInt, BigInt(interestRateMode), 0, onBehalfOfAddress]
+    // referralCode = 0 (uint16)
+  });
+  const hash = await agent.client.sendTransaction({
+    to: lendingPoolAddress,
+    data
+  });
+  await agent.client.waitForTransactionReceipt({ hash });
+  return hash;
+}
+async function lendleRepay(agent, tokenAddress, amount, rateMode = INTEREST_RATE_MODE.VARIABLE, onBehalfOf) {
+  const lendingPoolAddress = LENDING_POOL[agent.chain];
+  if (lendingPoolAddress === "0x0000000000000000000000000000000000000000") {
+    throw new Error(
+      `Lendle LendingPool not configured for ${agent.chain}. Only available on mainnet.`
+    );
+  }
+  const amountBigInt = BigInt(amount);
+  const onBehalfOfAddress = onBehalfOf || agent.account.address;
+  await approveToken2(agent, tokenAddress, lendingPoolAddress, amount);
+  const data = encodeFunctionData({
+    abi: LENDING_POOL_ABI,
+    functionName: "repay",
+    args: [tokenAddress, amountBigInt, BigInt(rateMode), onBehalfOfAddress]
+  });
+  const hash = await agent.client.sendTransaction({
+    to: lendingPoolAddress,
+    data
+  });
+  await agent.client.waitForTransactionReceipt({ hash });
+  return hash;
+}
+
+// src/constants/agni/index.ts
+var agni_exports = {};
+__export(agni_exports, {
+  FACTORY: () => FACTORY,
+  FEE_TIERS: () => FEE_TIERS2,
+  POSITION_MANAGER: () => POSITION_MANAGER,
+  SWAP_ROUTER: () => SWAP_ROUTER,
+  SWAP_ROUTER_ABI: () => SWAP_ROUTER_ABI
+});
+var FACTORY = {
+  mainnet: "0x25780dc8Fc3cfBD75F33bFDAB65e969b603b2035",
+  testnet: "0x0000000000000000000000000000000000000000"
+};
+var SWAP_ROUTER = {
+  mainnet: "0x319B69888b0d11cEC22caA5034e25FfFBDc88421",
+  testnet: "0x0000000000000000000000000000000000000000"
+};
+var POSITION_MANAGER = {
+  mainnet: "0x218bf598d1453383e2f4aa7b14ffb9bfb102d637",
+  testnet: "0x0000000000000000000000000000000000000000"
+};
+var SWAP_ROUTER_ABI = [
+  {
+    inputs: [
+      {
+        components: [
+          { name: "tokenIn", type: "address" },
+          { name: "tokenOut", type: "address" },
+          { name: "fee", type: "uint24" },
+          { name: "recipient", type: "address" },
+          { name: "deadline", type: "uint256" },
+          { name: "amountIn", type: "uint256" },
+          { name: "amountOutMinimum", type: "uint256" },
+          { name: "sqrtPriceLimitX96", type: "uint160" }
+        ],
+        name: "params",
+        type: "tuple"
+      }
+    ],
+    name: "exactInputSingle",
+    outputs: [{ name: "amountOut", type: "uint256" }],
+    stateMutability: "payable",
+    type: "function"
+  }
+];
+var FEE_TIERS2 = {
+  LOWEST: 100,
+  // 0.01%
+  LOW: 500,
+  // 0.05%
+  MEDIUM: 3e3,
+  // 0.3%
+  HIGH: 1e4
+  // 1%
+};
+
+// src/tools/agni/swap.ts
+async function agniSwap(agent, tokenIn, tokenOut, amountIn, slippagePercent = 0.5, feeTier = FEE_TIERS2.MEDIUM) {
+  const swapRouterAddress = SWAP_ROUTER[agent.chain];
+  if (swapRouterAddress === "0x0000000000000000000000000000000000000000") {
+    throw new Error(`Agni SwapRouter not available on ${agent.chain}`);
+  }
+  const amountInBigInt = BigInt(amountIn);
+  const deadline = BigInt(Math.floor(Date.now() / 1e3) + 1200);
+  const amountOutMinimum = amountInBigInt * BigInt(1e4 - Math.floor(slippagePercent * 100)) / 10000n;
+  await approveToken2(agent, tokenIn, swapRouterAddress, amountIn);
+  const data = encodeFunctionData({
+    abi: SWAP_ROUTER_ABI,
+    functionName: "exactInputSingle",
+    args: [
+      {
+        tokenIn,
+        tokenOut,
+        fee: feeTier,
+        recipient: agent.account.address,
+        deadline,
+        amountIn: amountInBigInt,
+        amountOutMinimum,
+        sqrtPriceLimitX96: 0n
+      }
+    ]
+  });
+  const hash = await agent.client.sendTransaction({
+    to: swapRouterAddress,
+    data
+  });
+  await agent.client.waitForTransactionReceipt({ hash });
+  return hash;
+}
+
+// src/constants/merchantmoe/index.ts
+var merchantmoe_exports = {};
+__export(merchantmoe_exports, {
+  LB_FACTORY: () => LB_FACTORY,
+  LB_QUOTER: () => LB_QUOTER,
+  LB_ROUTER: () => LB_ROUTER,
+  LB_ROUTER_ABI: () => LB_ROUTER_ABI,
+  MOE_TOKEN: () => MOE_TOKEN
+});
+var LB_ROUTER = {
+  mainnet: "0x013e138EF6008ae5FDFDE29700e3f2Bc61d21E3a",
+  testnet: "0x0000000000000000000000000000000000000000"
+};
+var LB_FACTORY = {
+  mainnet: "0xa6630671775c4EA2743840F9A5016dCf2A104054",
+  testnet: "0x0000000000000000000000000000000000000000"
+};
+var LB_QUOTER = {
+  mainnet: "0x501b8AFd35df20f531fF45F6f695793AC3316c85",
+  testnet: "0x0000000000000000000000000000000000000000"
+};
+var MOE_TOKEN = "0x4515a45337f461a11ff0fe8abf3c606ae5dc00c9";
+var LB_ROUTER_ABI = [
+  {
+    inputs: [
+      { name: "amountIn", type: "uint256" },
+      { name: "amountOutMin", type: "uint256" },
+      { name: "path", type: "uint256[]" },
+      { name: "to", type: "address" },
+      { name: "deadline", type: "uint256" }
+    ],
+    name: "swapExactTokensForTokens",
+    outputs: [{ name: "amountOut", type: "uint256" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+
+// src/tools/merchantmoe/swap.ts
+async function merchantMoeSwap(agent, tokenIn, tokenOut, amountIn, slippagePercent = 0.5) {
+  const routerAddress = LB_ROUTER[agent.chain];
+  if (routerAddress === "0x0000000000000000000000000000000000000000") {
+    throw new Error(`Merchant Moe LB Router not available on ${agent.chain}`);
+  }
+  const amountInBigInt = BigInt(amountIn);
+  const deadline = BigInt(Math.floor(Date.now() / 1e3) + 1200);
+  const amountOutMin = amountInBigInt * BigInt(1e4 - Math.floor(slippagePercent * 100)) / 10000n;
+  await approveToken2(agent, tokenIn, routerAddress, amountIn);
+  const path = [BigInt(tokenIn), BigInt(tokenOut)];
+  const data = encodeFunctionData({
+    abi: LB_ROUTER_ABI,
+    functionName: "swapExactTokensForTokens",
+    args: [amountInBigInt, amountOutMin, path, agent.account.address, deadline]
+  });
+  const hash = await agent.client.sendTransaction({
+    to: routerAddress,
+    data
+  });
+  await agent.client.waitForTransactionReceipt({ hash });
+  return hash;
+}
+
+// src/constants/meth/index.ts
+var meth_exports = {};
+__export(meth_exports, {
+  METH_TOKEN: () => METH_TOKEN
+});
+var METH_TOKEN = {
+  mainnet: "0xcDA86A272531e8640cD7F1a92c01839911B90bb0",
+  testnet: "0x0000000000000000000000000000000000000000"
+};
+
+// src/tools/okx/getSwapQuote.ts
+var getSwapQuote = async (agent, from, to, amount, slippagePercentage) => {
+  const chainIndex = agent.chain === "mainnet" ? "5000" : "5003";
+  return getSwapTransaction(from, to, amount, chainIndex, slippagePercentage);
+};
+
+// src/utils/x402/index.ts
+var DEFAULT_PLATFORM_URL = "https://mantle-x402.vercel.app";
+var cachedConfig = null;
+var validationPromise = null;
+function getPlatformBaseUrl() {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env.PLATFORM_URL || process.env.NEXT_PUBLIC_PLATFORM_URL || DEFAULT_PLATFORM_URL;
+  }
+  return DEFAULT_PLATFORM_URL;
+}
+async function validateAppId(appId) {
+  const baseUrl2 = getPlatformBaseUrl();
+  const url = `${baseUrl2}/api/v1/validate?appId=${encodeURIComponent(appId)}`;
+  const response = await fetch(url, {
+    method: "GET",
+    headers: { "Content-Type": "application/json" }
+  });
+  if (!response.ok) {
+    if (response.status === 404) {
+      throw new Error(
+        "Platform: Project not found. Invalid APP_ID. Please check your APP_ID configuration."
+      );
+    }
+    if (response.status === 401) {
+      throw new Error(
+        "Platform: Unauthorized. Invalid APP_ID. Please verify your APP_ID."
+      );
+    }
+    throw new Error(
+      `Platform: Validation failed: ${response.status} ${response.statusText}`
+    );
+  }
+  const data = await response.json();
+  if (!data.appId || !data.payTo || !data.network) {
+    throw new Error("Platform: Invalid response - missing required fields");
+  }
+  if (data.status !== "ACTIVE") {
+    throw new Error(
+      `Platform: Project is not active. Current status: ${data.status}`
+    );
+  }
+  return {
+    appId: data.appId,
+    name: data.name,
+    payTo: data.payTo,
+    network: data.network,
+    status: data.status
+  };
+}
+async function initializePlatform() {
+  if (cachedConfig) {
+    return cachedConfig;
+  }
+  if (validationPromise) {
+    return validationPromise;
+  }
+  let appId;
+  if (typeof process !== "undefined" && process.env) {
+    appId = process.env.APP_ID || process.env.NEXT_PUBLIC_APP_ID;
+  }
+  if (!appId || typeof appId !== "string" || appId.trim().length === 0) {
+    throw new Error(
+      "APP_ID is required. Set it in your .env file:\nAPP_ID=your_app_id_here"
+    );
+  }
+  validationPromise = validateAppId(appId.trim());
+  try {
+    cachedConfig = await validationPromise;
+    return cachedConfig;
+  } catch (error) {
+    validationPromise = null;
+    throw error;
+  }
+}
+function getProjectConfig() {
+  if (!cachedConfig) {
+    throw new Error(
+      "Platform not initialized. Call initializePlatform() first."
+    );
+  }
+  return cachedConfig;
+}
+
+// src/agent.ts
+var MNTAgentKit = class {
+  account;
+  client;
+  chain;
+  projectConfig;
+  constructor(privateKey, chain) {
+    this.account = privateKeyToAccount(privateKey);
+    this.chain = chain;
+    this.client = createWalletClient({
+      chain: chain == "mainnet" ? mantle : mantleSepoliaTestnet,
+      transport: http(),
+      account: this.account
+    }).extend(publicActions);
+  }
+  /**
+   * Initialize the agent with platform validation
+   *
+   * Validates APP_ID with the platform API.
+   * Must be called after creating the agent instance.
+   *
+   * @returns The initialized agent instance
+   * @throws Error if APP_ID is not set or validation fails
+   *
+   * @example
+   * ```typescript
+   * const agent = new MNTAgentKit(privateKey, "mainnet");
+   * await agent.initialize(); // Validates APP_ID
+   * ```
+   */
+  async initialize() {
+    this.projectConfig = await initializePlatform();
+    return this;
+  }
+  async sendTransaction(to, amount) {
+    return await sendTransaction(this, to, amount);
+  }
+  // OKX DEX Aggregator
+  async getSwapQuote(fromTokenAddress, toTokenAddress, amount, slippagePercentage = "0.5") {
+    return await getSwapQuote(
+      this,
+      fromTokenAddress,
+      toTokenAddress,
+      amount,
+      slippagePercentage
+    );
+  }
+  async executeSwap(fromTokenAddress, toTokenAddress, amount, slippagePercentage = "0.5") {
+    if (this.chain === "mainnet") {
+      return await executeSwap(
+        this,
+        fromTokenAddress,
+        toTokenAddress,
+        amount,
+        slippagePercentage
+      );
+    }
+  }
+  // OpenOcean DEX Aggregator
+  async getOpenOceanQuote(fromToken, toToken, amount) {
+    return await getOpenOceanQuote(this, fromToken, toToken, amount);
+  }
+  async swapOnOpenOcean(fromToken, toToken, amount, slippage = 0.5) {
+    return await swapOnOpenOcean(
+      this,
+      fromToken,
+      toToken,
+      amount,
+      slippage.toString()
+    );
+  }
+  // 1inch DEX Aggregator
+  async get1inchQuote(fromToken, toToken, amount) {
+    return await get1inchQuote(this, fromToken, toToken, amount);
+  }
+  async swapOn1inch(fromToken, toToken, amount, slippage = 0.5) {
+    return await swapOn1inch(
+      this,
+      fromToken,
+      toToken,
+      amount,
+      slippage.toString()
+    );
+  }
+  // Uniswap V3 DEX
+  async getUniswapQuote(fromToken, toToken, amount) {
+    return await getUniswapQuote(this, fromToken, toToken, amount);
+  }
+  async swapOnUniswap(fromToken, toToken, amount, slippage = 0.5) {
+    return await swapOnUniswap(
+      this,
+      fromToken,
+      toToken,
+      amount,
+      slippage.toString()
+    );
+  }
+  // Lendle Lending Protocol
+  async lendleSupply(tokenAddress, amount) {
+    return await lendleSupply(this, tokenAddress, amount);
+  }
+  async lendleWithdraw(tokenAddress, amount, to) {
+    return await lendleWithdraw(this, tokenAddress, amount, to);
+  }
+  async lendleBorrow(tokenAddress, amount, interestRateMode = 2, onBehalfOf) {
+    return await lendleBorrow(
+      this,
+      tokenAddress,
+      amount,
+      interestRateMode,
+      onBehalfOf
+    );
+  }
+  async lendleRepay(tokenAddress, amount, rateMode = 2, onBehalfOf) {
+    return await lendleRepay(this, tokenAddress, amount, rateMode, onBehalfOf);
+  }
+  // Agni Finance DEX (#1 on Mantle)
+  async agniSwap(tokenIn, tokenOut, amountIn, slippagePercent = 0.5, feeTier) {
+    return await agniSwap(
+      this,
+      tokenIn,
+      tokenOut,
+      amountIn,
+      slippagePercent,
+      feeTier
+    );
+  }
+  // Merchant Moe DEX (#2 on Mantle)
+  async merchantMoeSwap(tokenIn, tokenOut, amountIn, slippagePercent = 0.5) {
+    return await merchantMoeSwap(
+      this,
+      tokenIn,
+      tokenOut,
+      amountIn,
+      slippagePercent
+    );
+  }
+  // mETH Protocol - Liquid Staking Token
+  getMethTokenAddress() {
+    return METH_TOKEN[this.chain];
+  }
+  // Squid Router Cross-chain
+  async getSquidRoute(fromToken, toToken, fromChain, toChain, amount, slippage = 1) {
+    return await getSquidRoute(
+      this,
+      fromToken,
+      toToken,
+      fromChain,
+      toChain,
+      amount,
+      slippage
+    );
+  }
+  async crossChainSwapViaSquid(fromToken, toToken, fromChain, toChain, amount, slippage = 1) {
+    return await crossChainSwapViaSquid(
+      this,
+      fromToken,
+      toToken,
+      fromChain,
+      toChain,
+      amount,
+      slippage
+    );
+  }
+};
+
+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 };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map