hak-saucerswap-plugin 1.0.0 → 2.0.0

package/dist/index.js

@@ -1,9 +1,9 @@
+import { BaseTool, handleTransaction } from '@hashgraph/hedera-agent-kit';
 import { z } from 'zod';
-import { ContractFunctionParameters, ContractExecuteTransaction, AccountId, TokenId, ContractId } from '@hashgraph/sdk';
 import axios from 'axios';
-import { AgentMode } from 'hedera-agent-kit';
+import { ContractFunctionParameters, ContractExecuteTransaction, AccountId, TokenId, ContractId } from '@hiero-ledger/sdk';
 
-// src/tools/swap.ts
+// src/tools/farms.ts
 
 // src/api/endpoints.ts
 var SAUCER_ENDPOINTS = {
@@ -34,7 +34,8 @@ var SaucerSwapClient = class {
     this.retries = options.retries ?? 2;
     this.http = options.http ?? axios.create({
       baseURL: options.baseUrl ?? "https://api.saucerswap.finance",
-      timeout: options.timeoutMs ?? 1e4
+      timeout: options.timeoutMs ?? 1e4,
+      headers: options.apiKey ? { "x-api-key": options.apiKey } : void 0
     });
   }
   async request(path, params) {
@@ -176,6 +177,7 @@ var resolveSaucerSwapConfig = (context) => {
     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),
+    apiKey: ctxConfig.apiKey ?? process.env.SAUCERSWAP_API_KEY,
     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,
@@ -189,6 +191,47 @@ var resolveSaucerSwapConfig = (context) => {
   };
 };
 
+// src/tools/farms.ts
+var farmsInputSchema = z.object({
+  poolId: z.number().int().positive().optional().describe("Optional pool ID to filter farms")
+});
+var FarmsTool = class extends BaseTool {
+  constructor() {
+    super(...arguments);
+    this.method = "saucerswap_get_farms";
+    this.name = "SaucerSwap Get Farms";
+    this.description = "Get active farming opportunities on SaucerSwap.";
+    this.parameters = farmsInputSchema;
+  }
+  async normalizeParams(params, _context, _client) {
+    return farmsInputSchema.parse(params);
+  }
+  async coreAction(args, context, _client) {
+    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"
+      };
+    }
+  }
+  async shouldSecondaryAction(_coreActionResult, _context) {
+    return false;
+  }
+  async secondaryAction(_request, _client, _context) {
+    return null;
+  }
+};
+var farmsTool = new FarmsTool();
+
 // src/utils/amm.ts
 var calculatePriceImpact = (inputAmount, outputAmount, poolReserveIn, poolReserveOut) => {
   const inAmount = Number(inputAmount);
@@ -210,53 +253,6 @@ var applySlippageToAmount = (amount, slippageTolerance) => {
   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)) {
@@ -284,115 +280,106 @@ var accountIdToSolidityAddress = (accountId) => {
 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;
+// src/utils/units.ts
+var parseUnits = (amount, decimals) => {
+  if (!amount || typeof amount !== "string") {
+    throw new Error("Amount must be a non-empty string.");
   }
-  if (deadlineInput > now + 60) {
-    return Math.floor(deadlineInput);
+  if (decimals < 0) {
+    throw new Error("Decimals must be non-negative.");
   }
-  return now + Math.round(deadlineInput) * 60;
+  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 amountToSmallest = (amount, decimals) => {
-  return parseUnits(amount, decimals);
+
+// src/tools/liquidity.ts
+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 isLiquidityCorePayload = (value) => typeof value === "object" && value !== null && "transaction" in value;
+var addLiquidityPostProcess = (response) => `SaucerSwap add liquidity submitted. Status: ${response.status}. Transaction ID: ${response.transactionId}`;
+var removeLiquidityPostProcess = (response) => `SaucerSwap remove liquidity submitted. Status: ${response.status}. Transaction ID: ${response.transactionId}`;
+var resolveDeadline = (defaultMinutes) => {
+  return Math.floor(Date.now() / 1e3) + defaultMinutes * 60;
 };
-var expectedToSmallest = (amount, decimals) => {
-  return amount.includes(".") ? parseUnits(amount, decimals) : amount;
+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 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);
+var AddLiquidityTool = class extends BaseTool {
+  constructor() {
+    super(...arguments);
+    this.method = "saucerswap_add_liquidity";
+    this.name = "SaucerSwap Add Liquidity";
+    this.description = "Add liquidity to a SaucerSwap pool.";
+    this.parameters = addLiquidityInputSchema;
+  }
+  async normalizeParams(params, _context, _client) {
+    return addLiquidityInputSchema.parse(params);
+  }
+  async coreAction(args, context, client) {
     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."
+        error: "Hedera client with an operator account is required for liquidity actions."
       };
     }
     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) {
+      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 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 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 = resolveDeadline(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
-      });
+      const params = 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", params);
+      const payload = {
+        transaction,
+        extras: { amountADesired, amountBDesired, amountAMin, amountBMin }
+      };
+      return payload;
     } catch (error) {
       return {
         success: false,
@@ -400,61 +387,73 @@ var swapTool = {
       };
     }
   }
+  async shouldSecondaryAction(coreActionResult, _context) {
+    return isLiquidityCorePayload(coreActionResult);
+  }
+  async secondaryAction(payload, client, context) {
+    const result = await handleTransaction(
+      payload.transaction,
+      client,
+      context,
+      addLiquidityPostProcess
+    );
+    return { ...result, ...payload.extras };
+  }
 };
-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);
+var RemoveLiquidityTool = class extends BaseTool {
+  constructor() {
+    super(...arguments);
+    this.method = "saucerswap_remove_liquidity";
+    this.name = "SaucerSwap Remove Liquidity";
+    this.description = "Remove liquidity from a SaucerSwap pool.";
+    this.parameters = removeLiquidityInputSchema;
+  }
+  async normalizeParams(params, _context, _client) {
+    return removeLiquidityInputSchema.parse(params);
+  }
+  async coreAction(args, context, client) {
     const config = resolveSaucerSwapConfig(context);
-    const client = context.saucerswapClient;
-    const api = client ?? createSaucerSwapClient(config);
-    const slippageTolerance = args.slippageTolerance ?? 0.5;
+    const operatorAccountId = client?.operatorAccountId?.toString();
+    if (!operatorAccountId) {
+      return {
+        success: false,
+        error: "Hedera client with an operator account is required for liquidity actions."
+      };
+    }
     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
-          );
-        }
+      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."
+        };
       }
-      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);
+      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."
+        };
       }
-      return {
-        success: true,
-        quote: normalized,
-        minOutput
+      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 = resolveDeadline(config.deadlineMinutes);
+      const toAddress = accountIdToSolidityAddress(operatorAccountId);
+      const params = 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", params);
+      const payload = {
+        transaction,
+        extras: { lpAmount, minAmountA, minAmountB }
       };
+      return payload;
     } catch (error) {
       return {
         success: false,
@@ -462,20 +461,39 @@ var quoteTool = {
       };
     }
   }
+  async shouldSecondaryAction(coreActionResult, _context) {
+    return isLiquidityCorePayload(coreActionResult);
+  }
+  async secondaryAction(payload, client, context) {
+    const result = await handleTransaction(
+      payload.transaction,
+      client,
+      context,
+      removeLiquidityPostProcess
+    );
+    return { ...result, ...payload.extras };
+  }
 };
+var addLiquidityTool = new AddLiquidityTool();
+var removeLiquidityTool = new RemoveLiquidityTool();
 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);
+var PoolsTool = class extends BaseTool {
+  constructor() {
+    super(...arguments);
+    this.method = "saucerswap_get_pools";
+    this.name = "SaucerSwap Get Pools";
+    this.description = "Query SaucerSwap liquidity pools and reserves.";
+    this.parameters = poolsInputSchema;
+  }
+  async normalizeParams(params, _context, _client) {
+    return poolsInputSchema.parse(params);
+  }
+  async coreAction(args, context, _client) {
     const config = resolveSaucerSwapConfig(context);
     const api = context.saucerswapClient ?? createSaucerSwapClient(config);
     try {
@@ -508,76 +526,100 @@ var poolsTool = {
       };
     }
   }
+  async shouldSecondaryAction(_coreActionResult, _context) {
+    return false;
+  }
+  async secondaryAction(_request, _client, _context) {
+    return null;
+  }
 };
-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 poolsTool = new PoolsTool();
+
+// 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 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.");
+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 routerContractId;
+  return {
+    amountIn,
+    expectedOutput,
+    priceImpact: typeof quote.priceImpact === "number" ? quote.priceImpact : null,
+    route: Array.isArray(quote.route) ? quote.route : [],
+    raw: quote
+  };
 };
-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);
+
+// src/tools/quote.ts
+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 = class extends BaseTool {
+  constructor() {
+    super(...arguments);
+    this.method = "saucerswap_get_swap_quote";
+    this.name = "SaucerSwap Get Swap Quote";
+    this.description = "Get a price quote for swapping tokens on SaucerSwap.";
+    this.parameters = quoteInputSchema;
+  }
+  async normalizeParams(params, _context, _client) {
+    return quoteInputSchema.parse(params);
+  }
+  async coreAction(args, context, _client) {
     const config = resolveSaucerSwapConfig(context);
-    const operatorAccountId = client?.operatorAccountId?.toString();
+    const cachedApi = context.saucerswapClient;
+    const api = cachedApi ?? createSaucerSwapClient(config);
     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
+      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,
@@ -585,83 +627,110 @@ var addLiquidityTool = {
       };
     }
   }
+  async shouldSecondaryAction(_coreActionResult, _context) {
+    return false;
+  }
+  async secondaryAction(_request, _client, _context) {
+    return null;
+  }
+};
+var quoteTool = new QuoteTool();
+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 isSwapCorePayload = (value) => typeof value === "object" && value !== null && "transaction" in value;
+var swapPostProcess = (response) => `SaucerSwap swap submitted. Status: ${response.status}. Transaction ID: ${response.transactionId}`;
+var resolveDeadline2 = (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 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);
+var amountToSmallest = (amount, decimals) => {
+  return parseUnits(amount, decimals);
+};
+var expectedToSmallest = (amount, decimals) => {
+  return amount.includes(".") ? parseUnits(amount, decimals) : amount;
+};
+var SwapTool = class extends BaseTool {
+  constructor() {
+    super(...arguments);
+    this.method = "saucerswap_swap_tokens";
+    this.name = "SaucerSwap Swap Tokens";
+    this.description = "Execute a token swap on SaucerSwap DEX.";
+    this.parameters = swapInputSchema;
+  }
+  async normalizeParams(params, _context, _client) {
+    return swapInputSchema.parse(params);
+  }
+  async coreAction(args, context, client) {
     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."
+        error: "Hedera client with an operator account is required for swaps."
       };
     }
     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) {
+      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 locate pool for the provided token pair."
+          error: "Unable to resolve token metadata from SaucerSwap API."
         };
       }
-      const tokenA = await api.getTokenByIdOrSymbol(tokenAId);
-      const tokenB = await api.getTokenByIdOrSymbol(tokenBId);
-      if (!tokenA || !tokenB) {
+      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: "Unable to resolve token metadata from SaucerSwap API."
+          error: "Missing SaucerSwap router contract ID configuration."
         };
       }
-      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 deadline = resolveDeadline2(args.deadline, 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
+      const path = [
+        tokenIdToSolidityAddress(requireTokenId(fromTokenId)),
+        tokenIdToSolidityAddress(requireTokenId(toTokenId))
+      ];
+      const params = new ContractFunctionParameters().addUint256(amountInSmallest).addUint256(minOutSmallest).addAddressArray(path).addAddress(toAddress).addUint256(deadline);
+      const transaction = new ContractExecuteTransaction().setContractId(contractIdFromString(routerContractId)).setGas(config.gasLimit).setFunction("swapExactTokensForTokens", params);
+      const payload = {
+        transaction,
+        extras: {
+          estimatedOutput: quote.expectedOutput,
+          minOutput: minOutSmallest,
+          priceImpact: quote.priceImpact,
+          route: quote.route
+        }
       };
+      return payload;
     } catch (error) {
       return {
         success: false,
@@ -669,15 +738,36 @@ var farmsTool = {
       };
     }
   }
+  async shouldSecondaryAction(coreActionResult, _context) {
+    return isSwapCorePayload(coreActionResult);
+  }
+  async secondaryAction(payload, client, context) {
+    const result = await handleTransaction(
+      payload.transaction,
+      client,
+      context,
+      swapPostProcess
+    );
+    return { ...result, ...payload.extras };
+  }
 };
+var swapTool = new SwapTool();
 
 // src/index.ts
+var saucerswapPluginToolNames = {
+  SAUCERSWAP_GET_SWAP_QUOTE_TOOL: "saucerswap_get_swap_quote",
+  SAUCERSWAP_SWAP_TOKENS_TOOL: "saucerswap_swap_tokens",
+  SAUCERSWAP_GET_POOLS_TOOL: "saucerswap_get_pools",
+  SAUCERSWAP_ADD_LIQUIDITY_TOOL: "saucerswap_add_liquidity",
+  SAUCERSWAP_REMOVE_LIQUIDITY_TOOL: "saucerswap_remove_liquidity",
+  SAUCERSWAP_GET_FARMS_TOOL: "saucerswap_get_farms"
+};
 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 };
+export { saucerswapPlugin as default, saucerswapPlugin, saucerswapPluginToolNames };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map