hak-saucerswap-plugin 1.0.0

package/dist/index.js

@@ -0,0 +1,683 @@
+import { z } from 'zod';
+import { ContractFunctionParameters, ContractExecuteTransaction, AccountId, TokenId, ContractId } from '@hashgraph/sdk';
+import axios from 'axios';
+import { AgentMode } from 'hedera-agent-kit';
+
+// src/tools/swap.ts
+
+// src/api/endpoints.ts
+var SAUCER_ENDPOINTS = {
+  poolsV1: "/pools",
+  poolsV2: "/v2/pools",
+  swapQuote: "/v1/swap/quote",
+  tokens: "/tokens",
+  farms: "/farms",
+  stats: "/stats"
+};
+
+// src/api/client.ts
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var isRetryableError = (error) => {
+  if (error.code === "ECONNRESET" || error.code === "ETIMEDOUT") {
+    return true;
+  }
+  const status = error.response?.status;
+  if (!status) {
+    return true;
+  }
+  return status === 429 || status >= 500 && status < 600;
+};
+var SaucerSwapClient = class {
+  constructor(options = {}) {
+    this.tokensCache = null;
+    this.tokenIndex = null;
+    this.retries = options.retries ?? 2;
+    this.http = options.http ?? axios.create({
+      baseURL: options.baseUrl ?? "https://api.saucerswap.finance",
+      timeout: options.timeoutMs ?? 1e4
+    });
+  }
+  async request(path, params) {
+    let lastError;
+    for (let attempt = 0; attempt <= this.retries; attempt += 1) {
+      try {
+        const response = await this.http.get(path, { params });
+        return response.data;
+      } catch (error) {
+        const axiosError = error;
+        lastError = axiosError;
+        if (attempt < this.retries && isRetryableError(axiosError)) {
+          await sleep(200 * 2 ** attempt);
+          continue;
+        }
+        throw axiosError;
+      }
+    }
+    throw lastError;
+  }
+  async getTokens() {
+    const tokens = await this.request(SAUCER_ENDPOINTS.tokens);
+    this.cacheTokens(tokens);
+    return tokens;
+  }
+  async getTokenByIdOrSymbol(input) {
+    if (!this.tokenIndex) {
+      await this.getTokens();
+    }
+    return this.tokenIndex?.get(input.toLowerCase()) ?? null;
+  }
+  async resolveTokenId(input) {
+    if (/^\d+\.\d+\.\d+$/.test(input)) {
+      return input;
+    }
+    const token = await this.getTokenByIdOrSymbol(input);
+    return token?.id ?? input;
+  }
+  async getPools(version) {
+    const endpoint = version === "v1" ? SAUCER_ENDPOINTS.poolsV1 : SAUCER_ENDPOINTS.poolsV2;
+    return this.request(endpoint);
+  }
+  async getPoolByTokens(tokenA, tokenB, version) {
+    const pools = await this.getPools(version);
+    const match = pools.find((pool) => {
+      const direct = pool.tokenA.id === tokenA && pool.tokenB.id === tokenB;
+      const inverse = pool.tokenA.id === tokenB && pool.tokenB.id === tokenA;
+      return direct || inverse;
+    });
+    return match ?? null;
+  }
+  async getSwapQuote(params) {
+    const { fromToken, toToken, amount } = params;
+    return this.request(SAUCER_ENDPOINTS.swapQuote, {
+      tokenIn: fromToken,
+      tokenOut: toToken,
+      amount,
+      fromToken,
+      toToken
+    });
+  }
+  async getFarms() {
+    return this.request(SAUCER_ENDPOINTS.farms);
+  }
+  async getStats() {
+    return this.request(SAUCER_ENDPOINTS.stats);
+  }
+  cacheTokens(tokens) {
+    this.tokensCache = tokens;
+    this.tokenIndex = /* @__PURE__ */ new Map();
+    for (const token of tokens) {
+      this.tokenIndex.set(token.id.toLowerCase(), token);
+      this.tokenIndex.set(token.symbol.toLowerCase(), token);
+      this.tokenIndex.set(token.name.toLowerCase(), token);
+    }
+  }
+};
+var createSaucerSwapClient = (options) => {
+  return new SaucerSwapClient(options);
+};
+
+// src/config.ts
+var DEFAULT_CONFIG = {
+  baseUrl: "https://api.saucerswap.finance",
+  timeoutMs: 1e4,
+  retries: 2,
+  routerContractId: void 0,
+  routerV2ContractId: void 0,
+  wrappedHbarTokenId: void 0,
+  tokenAliases: {},
+  defaultPoolVersion: "v2",
+  gasLimit: 2e6,
+  deadlineMinutes: 20
+};
+var toNumber = (value, fallback) => {
+  if (!value) {
+    return fallback;
+  }
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+};
+var readTokenAliases = (value) => {
+  if (!value) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(value);
+    if (parsed && typeof parsed === "object") {
+      return parsed;
+    }
+  } catch {
+    return {};
+  }
+  return {};
+};
+var readPoolVersion = (value) => {
+  if (value === "v1" || value === "v2") {
+    return value;
+  }
+  return void 0;
+};
+var readContextConfig = (context) => {
+  if (!context || typeof context !== "object") {
+    return {};
+  }
+  const ctx = context;
+  return {
+    ...ctx.pluginConfig?.saucerswap ?? {},
+    ...ctx.config?.saucerswap ?? {}
+  };
+};
+var resolveSaucerSwapConfig = (context) => {
+  const ctxConfig = readContextConfig(context);
+  const envAliases = readTokenAliases(process.env.SAUCERSWAP_TOKEN_ALIASES);
+  const envDefaultVersion = readPoolVersion(process.env.SAUCERSWAP_DEFAULT_POOL_VERSION);
+  return {
+    ...DEFAULT_CONFIG,
+    ...ctxConfig,
+    baseUrl: ctxConfig.baseUrl ?? process.env.SAUCERSWAP_BASE_URL ?? DEFAULT_CONFIG.baseUrl,
+    timeoutMs: ctxConfig.timeoutMs ?? toNumber(process.env.SAUCERSWAP_TIMEOUT_MS, DEFAULT_CONFIG.timeoutMs),
+    retries: ctxConfig.retries ?? toNumber(process.env.SAUCERSWAP_RETRIES, DEFAULT_CONFIG.retries),
+    routerContractId: ctxConfig.routerContractId ?? process.env.SAUCERSWAP_ROUTER_CONTRACT_ID,
+    routerV2ContractId: ctxConfig.routerV2ContractId ?? process.env.SAUCERSWAP_ROUTER_V2_CONTRACT_ID,
+    wrappedHbarTokenId: ctxConfig.wrappedHbarTokenId ?? process.env.SAUCERSWAP_WRAPPED_HBAR_TOKEN_ID,
+    tokenAliases: {
+      ...envAliases,
+      ...ctxConfig.tokenAliases ?? {}
+    },
+    defaultPoolVersion: ctxConfig.defaultPoolVersion ?? envDefaultVersion ?? DEFAULT_CONFIG.defaultPoolVersion,
+    gasLimit: ctxConfig.gasLimit ?? toNumber(process.env.SAUCERSWAP_GAS_LIMIT, DEFAULT_CONFIG.gasLimit),
+    deadlineMinutes: ctxConfig.deadlineMinutes ?? toNumber(process.env.SAUCERSWAP_DEADLINE_MINUTES, DEFAULT_CONFIG.deadlineMinutes)
+  };
+};
+
+// src/utils/amm.ts
+var calculatePriceImpact = (inputAmount, outputAmount, poolReserveIn, poolReserveOut) => {
+  const inAmount = Number(inputAmount);
+  const outAmount = Number(outputAmount);
+  const reserveIn = Number(poolReserveIn);
+  const reserveOut = Number(poolReserveOut);
+  if (!Number.isFinite(inAmount) || !Number.isFinite(outAmount) || !Number.isFinite(reserveIn) || !Number.isFinite(reserveOut) || inAmount <= 0 || outAmount <= 0 || reserveIn <= 0 || reserveOut <= 0) {
+    return null;
+  }
+  const expectedOutput = inAmount * reserveOut / (reserveIn + inAmount);
+  if (!Number.isFinite(expectedOutput) || expectedOutput <= 0) {
+    return null;
+  }
+  return (expectedOutput - outAmount) / expectedOutput * 100;
+};
+var applySlippageToAmount = (amount, slippageTolerance) => {
+  const amountBig = BigInt(amount);
+  const bps = Math.max(0, Math.round(slippageTolerance * 100));
+  const numerator = BigInt(1e4 - bps);
+  return (amountBig * numerator / 10000n).toString();
+};
+
+// src/utils/quote.ts
+var readAmount = (value) => {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value.toString();
+  }
+  return null;
+};
+var normalizeSwapQuote = (quote, fallbackAmountIn) => {
+  const amountIn = readAmount(quote.amountIn) ?? fallbackAmountIn;
+  const expectedOutput = readAmount(quote.expectedOutput) ?? readAmount(quote.amountOut) ?? readAmount(quote.amountOutMin) ?? "";
+  if (!expectedOutput) {
+    throw new Error("SaucerSwap quote did not include an output amount.");
+  }
+  return {
+    amountIn,
+    expectedOutput,
+    priceImpact: typeof quote.priceImpact === "number" ? quote.priceImpact : null,
+    route: Array.isArray(quote.route) ? quote.route : [],
+    raw: quote
+  };
+};
+
+// src/utils/units.ts
+var parseUnits = (amount, decimals) => {
+  if (!amount || typeof amount !== "string") {
+    throw new Error("Amount must be a non-empty string.");
+  }
+  if (decimals < 0) {
+    throw new Error("Decimals must be non-negative.");
+  }
+  const trimmed = amount.trim();
+  if (!/^\d+(\.\d+)?$/.test(trimmed)) {
+    throw new Error(`Invalid amount format: ${amount}`);
+  }
+  const [whole, fraction = ""] = trimmed.split(".");
+  if (fraction.length > decimals) {
+    throw new Error(`Amount has more than ${decimals} decimal places.`);
+  }
+  const paddedFraction = fraction.padEnd(decimals, "0");
+  const combined = `${whole}${paddedFraction}`;
+  const normalized = combined.replace(/^0+/, "");
+  return normalized === "" ? "0" : normalized;
+};
+var normalizeTokenAlias = (token, config) => {
+  const tokenLower = token.toLowerCase();
+  for (const [alias, value] of Object.entries(config.tokenAliases)) {
+    if (alias.toLowerCase() === tokenLower) {
+      return value;
+    }
+  }
+  if (tokenLower === "hbar" && config.wrappedHbarTokenId) {
+    return config.wrappedHbarTokenId;
+  }
+  return token;
+};
+var requireTokenId = (token) => {
+  if (!/^\d+\.\d+\.\d+$/.test(token)) {
+    throw new Error(`Token ID required for on-chain actions: ${token}`);
+  }
+  return token;
+};
+var tokenIdToSolidityAddress = (tokenId) => {
+  return TokenId.fromString(tokenId).toSolidityAddress();
+};
+var accountIdToSolidityAddress = (accountId) => {
+  return AccountId.fromString(accountId).toSolidityAddress();
+};
+var contractIdFromString = (contractId) => {
+  return ContractId.fromString(contractId);
+};
+var finalizeTransaction = async (transaction, client, context, extra) => {
+  const mode = context.mode;
+  if (mode === AgentMode.RETURN_BYTES || mode === "returnBytes" || mode === "RETURN_BYTES") {
+    const txBytes = await transaction.toBytes();
+    return {
+      success: true,
+      transactionBytes: Buffer.from(txBytes).toString("base64"),
+      ...extra
+    };
+  }
+  const response = await transaction.execute(client);
+  const receipt = await response.getReceipt(client);
+  return {
+    success: true,
+    transactionId: response.transactionId?.toString(),
+    status: receipt.status.toString(),
+    ...extra
+  };
+};
+
+// src/tools/swap.ts
+var swapInputSchema = z.object({
+  fromToken: z.string().describe("Token ID to swap from (e.g., 'HBAR' or '0.0.123456')"),
+  toToken: z.string().describe("Token ID to swap to"),
+  amount: z.string().describe("Amount to swap (decimal format)"),
+  slippageTolerance: z.number().optional().default(0.5).describe("Maximum slippage tolerance percentage"),
+  deadline: z.number().optional().describe("Transaction deadline in minutes from now or a unix timestamp")
+});
+var resolveDeadline = (deadlineInput, defaultMinutes) => {
+  const now = Math.floor(Date.now() / 1e3);
+  if (!deadlineInput) {
+    return now + defaultMinutes * 60;
+  }
+  if (deadlineInput > now + 60) {
+    return Math.floor(deadlineInput);
+  }
+  return now + Math.round(deadlineInput) * 60;
+};
+var amountToSmallest = (amount, decimals) => {
+  return parseUnits(amount, decimals);
+};
+var expectedToSmallest = (amount, decimals) => {
+  return amount.includes(".") ? parseUnits(amount, decimals) : amount;
+};
+var swapTool = {
+  method: "saucerswap_swap_tokens",
+  name: "SaucerSwap Swap Tokens",
+  description: "Execute a token swap on SaucerSwap DEX.",
+  parameters: swapInputSchema,
+  execute: async (client, context, params) => {
+    const args = swapInputSchema.parse(params);
+    const config = resolveSaucerSwapConfig(context);
+    const operatorAccountId = client?.operatorAccountId?.toString();
+    const slippageTolerance = args.slippageTolerance ?? 0.5;
+    if (!operatorAccountId) {
+      return {
+        success: false,
+        error: "Hedera client with an operator account is required for swaps."
+      };
+    }
+    try {
+      const api = context.saucerswapClient ?? createSaucerSwapClient(config);
+      const fromTokenAlias = normalizeTokenAlias(args.fromToken, config);
+      const toTokenAlias = normalizeTokenAlias(args.toToken, config);
+      const fromTokenId = await api.resolveTokenId(fromTokenAlias);
+      const toTokenId = await api.resolveTokenId(toTokenAlias);
+      const fromTokenMeta = await api.getTokenByIdOrSymbol(fromTokenId);
+      const toTokenMeta = await api.getTokenByIdOrSymbol(toTokenId);
+      if (!fromTokenMeta || !toTokenMeta) {
+        return {
+          success: false,
+          error: "Unable to resolve token metadata from SaucerSwap API."
+        };
+      }
+      const quote = normalizeSwapQuote(
+        await api.getSwapQuote({
+          fromToken: fromTokenId,
+          toToken: toTokenId,
+          amount: args.amount
+        }),
+        args.amount
+      );
+      const amountInSmallest = amountToSmallest(args.amount, fromTokenMeta.decimals);
+      const expectedOutSmallest = expectedToSmallest(
+        quote.expectedOutput,
+        toTokenMeta.decimals
+      );
+      const minOutSmallest = applySlippageToAmount(expectedOutSmallest, slippageTolerance);
+      const routerContractId = config.defaultPoolVersion === "v2" ? config.routerV2ContractId ?? config.routerContractId : config.routerContractId ?? config.routerV2ContractId;
+      if (!routerContractId) {
+        return {
+          success: false,
+          error: "Missing SaucerSwap router contract ID configuration."
+        };
+      }
+      const deadline = resolveDeadline(args.deadline, config.deadlineMinutes);
+      const toAddress = accountIdToSolidityAddress(operatorAccountId);
+      const path = [
+        tokenIdToSolidityAddress(requireTokenId(fromTokenId)),
+        tokenIdToSolidityAddress(requireTokenId(toTokenId))
+      ];
+      const params2 = new ContractFunctionParameters().addUint256(amountInSmallest).addUint256(minOutSmallest).addAddressArray(path).addAddress(toAddress).addUint256(deadline);
+      const transaction = new ContractExecuteTransaction().setContractId(contractIdFromString(routerContractId)).setGas(config.gasLimit).setFunction("swapExactTokensForTokens", params2);
+      return await finalizeTransaction(transaction, client, context, {
+        estimatedOutput: quote.expectedOutput,
+        minOutput: minOutSmallest,
+        priceImpact: quote.priceImpact,
+        route: quote.route
+      });
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+};
+var quoteInputSchema = z.object({
+  fromToken: z.string().describe("Token ID to swap from (e.g., 'HBAR' or '0.0.123456')"),
+  toToken: z.string().describe("Token ID to swap to"),
+  amount: z.string().describe("Amount to swap (decimal format)"),
+  slippageTolerance: z.number().optional().default(0.5).describe("Maximum slippage tolerance percentage")
+});
+var quoteTool = {
+  method: "saucerswap_get_swap_quote",
+  name: "SaucerSwap Get Swap Quote",
+  description: "Get a price quote for swapping tokens on SaucerSwap.",
+  parameters: quoteInputSchema,
+  execute: async (_client, context, params) => {
+    const args = quoteInputSchema.parse(params);
+    const config = resolveSaucerSwapConfig(context);
+    const client = context.saucerswapClient;
+    const api = client ?? createSaucerSwapClient(config);
+    const slippageTolerance = args.slippageTolerance ?? 0.5;
+    try {
+      const fromToken = normalizeTokenAlias(args.fromToken, config);
+      const toToken = normalizeTokenAlias(args.toToken, config);
+      const fromTokenId = await api.resolveTokenId(fromToken);
+      const toTokenId = await api.resolveTokenId(toToken);
+      const rawQuote = await api.getSwapQuote({
+        fromToken: fromTokenId,
+        toToken: toTokenId,
+        amount: args.amount
+      });
+      const normalized = normalizeSwapQuote(rawQuote, args.amount);
+      if (normalized.priceImpact === null) {
+        const pool = await api.getPoolByTokens(fromTokenId, toTokenId, config.defaultPoolVersion);
+        if (pool && rawQuote.amountIn && rawQuote.amountOut) {
+          const isAToB = pool.tokenA.id === fromTokenId;
+          const reserveIn = isAToB ? pool.tokenReserveA : pool.tokenReserveB;
+          const reserveOut = isAToB ? pool.tokenReserveB : pool.tokenReserveA;
+          normalized.priceImpact = calculatePriceImpact(
+            rawQuote.amountIn,
+            rawQuote.amountOut,
+            reserveIn,
+            reserveOut
+          );
+        }
+      }
+      let minOutput = null;
+      if (normalized.expectedOutput.includes(".")) {
+        const expectedNumber = Number(normalized.expectedOutput);
+        minOutput = Number.isFinite(expectedNumber) ? (expectedNumber * (1 - slippageTolerance / 100)).toString() : null;
+      } else {
+        minOutput = applySlippageToAmount(normalized.expectedOutput, slippageTolerance);
+      }
+      return {
+        success: true,
+        quote: normalized,
+        minOutput
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+};
+var poolsInputSchema = z.object({
+  tokenA: z.string().optional().describe("First token ID or symbol"),
+  tokenB: z.string().optional().describe("Second token ID or symbol"),
+  version: z.enum(["v1", "v2"]).optional().describe("Pool version"),
+  limit: z.number().int().positive().optional().describe("Maximum number of pools to return")
+});
+var poolsTool = {
+  method: "saucerswap_get_pools",
+  name: "SaucerSwap Get Pools",
+  description: "Query SaucerSwap liquidity pools and reserves.",
+  parameters: poolsInputSchema,
+  execute: async (_client, context, params) => {
+    const args = poolsInputSchema.parse(params);
+    const config = resolveSaucerSwapConfig(context);
+    const api = context.saucerswapClient ?? createSaucerSwapClient(config);
+    try {
+      const version = args.version ?? config.defaultPoolVersion;
+      const pools = await api.getPools(version);
+      let filtered = pools;
+      if (args.tokenA && args.tokenB) {
+        const tokenA = normalizeTokenAlias(args.tokenA, config);
+        const tokenB = normalizeTokenAlias(args.tokenB, config);
+        const tokenAId = await api.resolveTokenId(tokenA);
+        const tokenBId = await api.resolveTokenId(tokenB);
+        filtered = pools.filter((pool) => {
+          const direct = pool.tokenA.id === tokenAId && pool.tokenB.id === tokenBId;
+          const inverse = pool.tokenA.id === tokenBId && pool.tokenB.id === tokenAId;
+          return direct || inverse;
+        });
+      }
+      if (args.limit && args.limit > 0) {
+        filtered = filtered.slice(0, args.limit);
+      }
+      return {
+        success: true,
+        version,
+        pools: filtered
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+};
+var addLiquidityInputSchema = z.object({
+  tokenA: z.string().describe("First token ID"),
+  tokenB: z.string().describe("Second token ID"),
+  amountA: z.string().describe("Amount of tokenA to add"),
+  amountB: z.string().describe("Amount of tokenB to add"),
+  slippageTolerance: z.number().optional().default(0.5).describe("Maximum slippage tolerance percentage")
+});
+var removeLiquidityInputSchema = z.object({
+  tokenA: z.string().describe("First token ID"),
+  tokenB: z.string().describe("Second token ID"),
+  lpTokenAmount: z.string().describe("Amount of LP tokens to burn"),
+  minAmountA: z.string().describe("Minimum amount of tokenA to receive"),
+  minAmountB: z.string().describe("Minimum amount of tokenB to receive")
+});
+var resolveDeadline2 = (defaultMinutes) => {
+  return Math.floor(Date.now() / 1e3) + defaultMinutes * 60;
+};
+var resolveRouterContract = (config) => {
+  const routerContractId = config.defaultPoolVersion === "v2" ? config.routerV2ContractId ?? config.routerContractId : config.routerContractId ?? config.routerV2ContractId;
+  if (!routerContractId) {
+    throw new Error("Missing SaucerSwap router contract ID configuration.");
+  }
+  return routerContractId;
+};
+var addLiquidityTool = {
+  method: "saucerswap_add_liquidity",
+  name: "SaucerSwap Add Liquidity",
+  description: "Add liquidity to a SaucerSwap pool.",
+  parameters: addLiquidityInputSchema,
+  execute: async (client, context, params) => {
+    const args = addLiquidityInputSchema.parse(params);
+    const config = resolveSaucerSwapConfig(context);
+    const operatorAccountId = client?.operatorAccountId?.toString();
+    const slippageTolerance = args.slippageTolerance ?? 0.5;
+    if (!operatorAccountId) {
+      return {
+        success: false,
+        error: "Hedera client with an operator account is required for liquidity actions."
+      };
+    }
+    try {
+      const api = context.saucerswapClient ?? createSaucerSwapClient(config);
+      const tokenAInput = normalizeTokenAlias(args.tokenA, config);
+      const tokenBInput = normalizeTokenAlias(args.tokenB, config);
+      const tokenAId = await api.resolveTokenId(tokenAInput);
+      const tokenBId = await api.resolveTokenId(tokenBInput);
+      const tokenA = await api.getTokenByIdOrSymbol(tokenAId);
+      const tokenB = await api.getTokenByIdOrSymbol(tokenBId);
+      if (!tokenA || !tokenB) {
+        return {
+          success: false,
+          error: "Unable to resolve token metadata from SaucerSwap API."
+        };
+      }
+      const amountADesired = parseUnits(args.amountA, tokenA.decimals);
+      const amountBDesired = parseUnits(args.amountB, tokenB.decimals);
+      const amountAMin = applySlippageToAmount(amountADesired, slippageTolerance);
+      const amountBMin = applySlippageToAmount(amountBDesired, slippageTolerance);
+      const routerContractId = resolveRouterContract(config);
+      const deadline = resolveDeadline2(config.deadlineMinutes);
+      const toAddress = accountIdToSolidityAddress(operatorAccountId);
+      const params2 = new ContractFunctionParameters().addAddress(tokenIdToSolidityAddress(requireTokenId(tokenAId))).addAddress(tokenIdToSolidityAddress(requireTokenId(tokenBId))).addUint256(amountADesired).addUint256(amountBDesired).addUint256(amountAMin).addUint256(amountBMin).addAddress(toAddress).addUint256(deadline);
+      const transaction = new ContractExecuteTransaction().setContractId(contractIdFromString(routerContractId)).setGas(config.gasLimit).setFunction("addLiquidity", params2);
+      return await finalizeTransaction(transaction, client, context, {
+        amountADesired,
+        amountBDesired,
+        amountAMin,
+        amountBMin
+      });
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+};
+var removeLiquidityTool = {
+  method: "saucerswap_remove_liquidity",
+  name: "SaucerSwap Remove Liquidity",
+  description: "Remove liquidity from a SaucerSwap pool.",
+  parameters: removeLiquidityInputSchema,
+  execute: async (client, context, params) => {
+    const args = removeLiquidityInputSchema.parse(params);
+    const config = resolveSaucerSwapConfig(context);
+    const operatorAccountId = client?.operatorAccountId?.toString();
+    if (!operatorAccountId) {
+      return {
+        success: false,
+        error: "Hedera client with an operator account is required for liquidity actions."
+      };
+    }
+    try {
+      const api = context.saucerswapClient ?? createSaucerSwapClient(config);
+      const tokenAInput = normalizeTokenAlias(args.tokenA, config);
+      const tokenBInput = normalizeTokenAlias(args.tokenB, config);
+      const tokenAId = await api.resolveTokenId(tokenAInput);
+      const tokenBId = await api.resolveTokenId(tokenBInput);
+      const pool = await api.getPoolByTokens(tokenAId, tokenBId, config.defaultPoolVersion);
+      if (!pool) {
+        return {
+          success: false,
+          error: "Unable to locate pool for the provided token pair."
+        };
+      }
+      const tokenA = await api.getTokenByIdOrSymbol(tokenAId);
+      const tokenB = await api.getTokenByIdOrSymbol(tokenBId);
+      if (!tokenA || !tokenB) {
+        return {
+          success: false,
+          error: "Unable to resolve token metadata from SaucerSwap API."
+        };
+      }
+      const lpAmount = parseUnits(args.lpTokenAmount, pool.lpToken.decimals);
+      const minAmountA = parseUnits(args.minAmountA, tokenA.decimals);
+      const minAmountB = parseUnits(args.minAmountB, tokenB.decimals);
+      const routerContractId = resolveRouterContract(config);
+      const deadline = resolveDeadline2(config.deadlineMinutes);
+      const toAddress = accountIdToSolidityAddress(operatorAccountId);
+      const params2 = new ContractFunctionParameters().addAddress(tokenIdToSolidityAddress(requireTokenId(tokenAId))).addAddress(tokenIdToSolidityAddress(requireTokenId(tokenBId))).addUint256(lpAmount).addUint256(minAmountA).addUint256(minAmountB).addAddress(toAddress).addUint256(deadline);
+      const transaction = new ContractExecuteTransaction().setContractId(contractIdFromString(routerContractId)).setGas(config.gasLimit).setFunction("removeLiquidity", params2);
+      return await finalizeTransaction(transaction, client, context, {
+        lpAmount,
+        minAmountA,
+        minAmountB
+      });
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+};
+var farmsInputSchema = z.object({
+  poolId: z.number().int().positive().optional().describe("Optional pool ID to filter farms")
+});
+var farmsTool = {
+  method: "saucerswap_get_farms",
+  name: "SaucerSwap Get Farms",
+  description: "Get active farming opportunities on SaucerSwap.",
+  parameters: farmsInputSchema,
+  execute: async (_client, context, params) => {
+    const args = farmsInputSchema.parse(params);
+    const config = resolveSaucerSwapConfig(context);
+    const api = context.saucerswapClient ?? createSaucerSwapClient(config);
+    try {
+      const farms = await api.getFarms();
+      const filtered = args.poolId ? farms.filter((farm) => farm.poolId === args.poolId) : farms;
+      return {
+        success: true,
+        farms: filtered
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+};
+
+// src/index.ts
+var saucerswapPlugin = {
+  name: "saucerswap",
+  description: "Integration with SaucerSwap DEX for token swaps, liquidity provision, and yield farming",
+  tools: () => [swapTool, quoteTool, poolsTool, addLiquidityTool, removeLiquidityTool, farmsTool]
+};
+
+export { saucerswapPlugin as default, saucerswapPlugin };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map