saucer-swap-plugin 0.1.0

package/dist/saucer-swap-v2-parameter-normaliser.js

@@ -0,0 +1,102 @@
+import { AccountResolver } from "hedera-agent-kit";
+import { getSwapQuoteV2Parameters, swapV2Parameters } from './saucer-swap.zod';
+import { ethers } from "ethers";
+import z from 'zod';
+import { getHederaTokenAddress, getHederaTokenEVMAddress, getTokenDecimals, toBaseUnit } from "./utils";
+import SwapRouterAbi from './abi/SwapRouter.json' assert { type: 'json' };
+import { buildEncodedPath } from "./utils/swap-path";
+import { SAUCER_SWAP_CONFIG } from "./constants";
+import { PoolFinderService } from "./service/pool-finder-service";
+import { InvalidAmountError } from "./errors";
+export default class SaucerSwapV2ParameterNormaliser {
+    static parseParamsWithSchema(params, schema, context = {}) {
+        let parsedParams;
+        try {
+            parsedParams = schema(context).parse(params);
+        }
+        catch (e) {
+            if (e instanceof z.ZodError) {
+                const issues = this.formatZodIssues(e);
+                throw new Error(`Invalid parameters: ${issues}`);
+            }
+            throw e;
+        }
+        return parsedParams;
+    }
+    static formatZodIssues(error) {
+        return error.errors.map(err => `Field "${err.path.join('.')}" - ${err.message}`).join('; ');
+    }
+    static async normaliseGetSwapQuoteV2Params(params, context, saucerSwapApiService) {
+        const parsedParams = this.parseParamsWithSchema(params, getSwapQuoteV2Parameters, context);
+        // Validate amount
+        if (parsedParams.amountIn <= 0) {
+            throw new InvalidAmountError(parsedParams.amountIn);
+        }
+        const tokenInEVM = getHederaTokenEVMAddress(parsedParams.tokenIn);
+        const inputTokenHedera = getHederaTokenAddress(parsedParams.tokenIn);
+        const tokenOutEVM = getHederaTokenEVMAddress(parsedParams.tokenOut);
+        const outputTokenHedera = getHederaTokenAddress(parsedParams.tokenOut);
+        // Use PoolFinderService to find the pool
+        const pool = await PoolFinderService.findPoolForTokens(inputTokenHedera, outputTokenHedera, saucerSwapApiService);
+        const poolFees = pool.fee;
+        const poolFeesInHexFormat = `0x${poolFees?.toString(16).padStart(6, '0')}`;
+        const decimals = getTokenDecimals(pool, inputTokenHedera);
+        const amountIn = toBaseUnit(parsedParams.amountIn, decimals).toNumber();
+        return {
+            tokenIn: tokenInEVM,
+            tokenOut: tokenOutEVM,
+            amountIn,
+            poolFeesInHexFormat: poolFeesInHexFormat
+        };
+    }
+    static async normaliseSwapV2Params(params, context, saucerSwapV2ConfigService, saucerSwapApiService, mirrorNode, client) {
+        const parsedParams = this.parseParamsWithSchema(params, swapV2Parameters, context);
+        // Validate amount is positive
+        if (parsedParams.amountIn <= 0) {
+            throw new InvalidAmountError(parsedParams.amountIn);
+        }
+        const inputTokenEVM = getHederaTokenEVMAddress(parsedParams.tokenIn);
+        const inputTokenHedera = getHederaTokenAddress(parsedParams.tokenIn);
+        const outputTokenEVM = getHederaTokenEVMAddress(parsedParams.tokenOut);
+        const outputTokenHedera = getHederaTokenAddress(parsedParams.tokenOut);
+        const recipient = AccountResolver.resolveAccount(parsedParams.recipientAddress, context, client);
+        const recipientAddress = await AccountResolver.getHederaEVMAddress(recipient, mirrorNode);
+        // Use PoolFinderService to find the pool
+        const pool = await PoolFinderService.findPoolForTokens(inputTokenHedera, outputTokenHedera, saucerSwapApiService);
+        const poolFees = pool.fee;
+        const decimals = getTokenDecimals(pool, inputTokenHedera);
+        const amountIn = toBaseUnit(parsedParams.amountIn, decimals).toNumber();
+        const poolFeesInHexFormat = `0x${poolFees?.toString(16).padStart(6, '0')}`;
+        const routeDataWithFee = buildEncodedPath(inputTokenEVM, poolFeesInHexFormat.toLowerCase(), outputTokenEVM);
+        const abiSwapRouterInterface = new ethers.Interface(SwapRouterAbi);
+        const swapRouterContractId = saucerSwapV2ConfigService.getSwapRouterContractId();
+        const wrappedHBarEvmAddress = saucerSwapV2ConfigService.getWrappedHBarEvmAddress();
+        //ExactInputParams
+        const exactInputParams = {
+            path: routeDataWithFee, //'0x...'
+            recipient: recipientAddress, //'0x...' - user's recipient address
+            deadline: Math.floor(Date.now() / 1000) + SAUCER_SWAP_CONFIG.DEFAULT_DEADLINE_SECONDS, // Unix seconds from now
+            amountIn: amountIn, //in Tinybar
+            amountOutMinimum: 0 //in token's smallest unit
+        };
+        //encode each function individually
+        const swapEncoded = abiSwapRouterInterface.encodeFunctionData('exactInput', [exactInputParams]);
+        const refundHBAREncoded = abiSwapRouterInterface.encodeFunctionData('refundETH');
+        //multi-call parameter: bytes[]
+        const multiCallParam = [swapEncoded, refundHBAREncoded];
+        //get encoded data for the multicall involving both functions
+        const encodedData = abiSwapRouterInterface.encodeFunctionData('multicall', [multiCallParam]);
+        //get encoded data as Uint8Array
+        const functionParameters = ethers.getBytes(encodedData);
+        let response = {
+            contractId: swapRouterContractId.toString(),
+            functionParameters,
+            gas: SAUCER_SWAP_CONFIG.SWAP_GAS_LIMIT,
+            payableAmount: undefined,
+        };
+        if (inputTokenEVM === wrappedHBarEvmAddress) {
+            response.payableAmount = amountIn;
+        }
+        return response;
+    }
+}

package/dist/saucer-swap.zod.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+export const getSwapQuoteV2Parameters = () => z.object({
+    tokenIn: z.string().describe("Input token address"),
+    tokenOut: z.string().describe("Output token address"),
+    amountIn: z.number().describe("Amount of input tokens to swap"),
+});
+export const getSwapQuoteV2ParametersNormalised = () => z.object({
+    tokenIn: z.string().describe("Input token address"),
+    tokenOut: z.string().describe("Output token address"),
+    amountIn: z.number().describe("Amount of input tokens to swap"),
+    poolFeesInHexFormat: z.string().describe("Pool fees in hex format"),
+});
+export const swapV2Parameters = () => z.object({
+    tokenIn: z.string().describe("Input token address"),
+    tokenOut: z.string().describe("Output token address"),
+    amountIn: z.number().describe("Amount of input tokens to swap"),
+    recipientAddress: z.string().optional().describe("Recipient address"),
+});

package/dist/service/pool-finder-service.js

@@ -0,0 +1,24 @@
+import { PoolNotFoundError } from "../errors";
+/**
+ * Service for finding pools by token pairs
+ */
+export class PoolFinderService {
+    /**
+     * Finds a pool for the given token pair
+     *
+     * @param tokenA - Hedera token address (e.g., "0.0.123456")
+     * @param tokenB - Hedera token address (e.g., "0.0.789012")
+     * @param apiService - SaucerSwap API service instance
+     * @returns The pool matching the token pair
+     * @throws {PoolNotFoundError} If no pool exists for the token pair
+     */
+    static async findPoolForTokens(tokenA, tokenB, apiService) {
+        const pools = await apiService.getAllPoolsCompact();
+        const pool = pools.find(p => (p.tokenA.id === tokenA && p.tokenB.id === tokenB) ||
+            (p.tokenA.id === tokenB && p.tokenB.id === tokenA));
+        if (!pool) {
+            throw new PoolNotFoundError(tokenA, tokenB);
+        }
+        return pool;
+    }
+}

package/dist/service/saucer-swap-rest-pools-service.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/service/saucer-swap-rest-pools-service.js

@@ -0,0 +1,52 @@
+import { LedgerId } from "@hashgraph/sdk";
+const SAUCERSWAP_REST_BASE_URLS = {
+    MAINNET: "https://api.saucerswap.finance",
+    TESTNET: "https://test-api.saucerswap.finance",
+};
+/**
+ * Service to access SaucerSwap REST API V2 pools endpoint:
+ * GET /v2/pools – "Get compact data for all SaucerSwap V2 pools".
+ *
+ * Docs: https://docs.saucerswap.finance/v/developer/rest-api/pools-v2/pools
+ */
+export class SaucerSwapApiServiceImpl {
+    baseUrl;
+    apiKey;
+    constructor(ledgerId, apiKey) {
+        const network = this.mapLedgerToNetwork(ledgerId);
+        this.baseUrl = SAUCERSWAP_REST_BASE_URLS[network];
+        // The docs provide a demo key that is globally rate limited and not for production use:
+        // default: 875e1017-87b8-4b12-8301-6aa1f1aa073b
+        // See: https://docs.saucerswap.finance/v/developer/rest-api/pools-v1/pools
+        this.apiKey = apiKey;
+    }
+    /**
+     * Calls SaucerSwap V2 "Get compact data for all SaucerSwap V2 pools" endpoint.
+     * GET {baseUrl}/v2/pools
+     */
+    async getAllPoolsCompact() {
+        const url = `${this.baseUrl}/v2/pools`;
+        const response = await fetch(url, {
+            method: "GET",
+            headers: {
+                "x-api-key": this.apiKey,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`SaucerSwap REST "GET /pools" failed with status ${response.status}`);
+        }
+        const pools = (await response.json());
+        return pools;
+    }
+    mapLedgerToNetwork(ledgerId) {
+        switch (ledgerId.toString()) {
+            case LedgerId.MAINNET.toString():
+                return "MAINNET";
+            case LedgerId.TESTNET.toString():
+                return "TESTNET";
+            default:
+                // Fallback to MAINNET base URL if an unsupported ledger is used.
+                return "MAINNET";
+        }
+    }
+}

package/dist/service/saucer-swap-v2-config-service.js

@@ -0,0 +1,36 @@
+// write a config service to get the config from the config file
+import { saucerSwapConfig } from "../config";
+import { ContractId, TokenId } from "@hashgraph/sdk";
+export class SaucerSwapV2ConfigService {
+    saucerSwapConfig;
+    ledgerId;
+    constructor(ledgerId) {
+        this.saucerSwapConfig = saucerSwapConfig;
+        this.ledgerId = ledgerId;
+    }
+    //get router address
+    getRouterAddress() {
+        return this.saucerSwapConfig.networks[this.ledgerId.toString()]?.router ?? '';
+    }
+    getSwapRouterContractId() {
+        return ContractId.fromEvmAddress(0, 0, this.saucerSwapConfig.networks[this.ledgerId.toString()]?.router ?? '');
+    }
+    getWrappedHBARTokenId() {
+        return TokenId.fromEvmAddress(0, 0, this.saucerSwapConfig.networks[this.ledgerId.toString()]?.wrappedHBAR ?? '');
+    }
+    getWrappedHBarEvmAddress() {
+        return this.saucerSwapConfig.networks[this.ledgerId.toString()]?.wrappedHBAR ?? '';
+    }
+    getSaucerSwapApiKey() {
+        //get the api key from environment variable
+        const apiKey = process.env.SAUCERSWAP_API_KEY;
+        if (!apiKey) {
+            throw new Error('SAUCERSWAP_API_KEY is not set');
+        }
+        return apiKey;
+    }
+    //get quoter address
+    getQuoterAddress() {
+        return this.saucerSwapConfig.networks[this.ledgerId.toString()]?.quoter ?? '';
+    }
+}

package/dist/service/saucer-swap-v2-query-service-impl.js

@@ -0,0 +1,96 @@
+import { ethers } from 'ethers';
+import QuoterV2Abi from '../abi/QuoterV2.json' assert { type: 'json' };
+import ERC20Abi from '../abi/ERC20.json' assert { type: 'json' };
+import { SAUCER_SWAP_CONFIG } from '../constants';
+import { MirrorNodeError, InvalidAmountError } from '../errors';
+export class SaucerSwapV2QueryServiceImpl {
+    abiQuoterInterface;
+    abiERC20Interface;
+    quoterEvmAddress;
+    mirrorNodeService;
+    saucerSwapV2ConfigService;
+    constructor(ledgerId, mirrorNodeService, saucerSwapV2ConfigService) {
+        this.mirrorNodeService = mirrorNodeService;
+        this.saucerSwapV2ConfigService = saucerSwapV2ConfigService;
+        this.abiQuoterInterface = new ethers.Interface(QuoterV2Abi);
+        this.abiERC20Interface = new ethers.Interface(ERC20Abi);
+        this.quoterEvmAddress = this.saucerSwapV2ConfigService.getQuoterAddress();
+    }
+    /**
+     * Gets a swap quote for the specified token pair
+ken - The EVM address        const poolFeesInHexFormat = this.saucerSwapV2ConfigService.getPoolFeesInHexFormat(inputToken, outputToken);
+ of the input token
+     * @param outputToken - The EVM address of the output token
+     * @param amountIn - The amount of input tokens in base units
+     * @param poolFeesInHexFormat - The pool fee in hex format (e.g., "0x001e" for 30 bps)
+     * @returns The amount of output tokens that would be received
+     * @throws {MirrorNodeError} If the mirror node call fails
+     */
+    async getSwapQuote(inputToken, outputToken, amountIn, poolFeesInHexFormat) {
+        // Validate inputs
+        if (amountIn <= 0) {
+            throw new InvalidAmountError(amountIn);
+        }
+        const encodedData = this.abiQuoterInterface.encodeFunctionData(this.abiQuoterInterface.getFunction('quoteExactInputSingle'), [{
+                tokenIn: inputToken,
+                tokenOut: outputToken,
+                amountIn: amountIn,
+                fee: poolFeesInHexFormat,
+                sqrtPriceLimitX96: 0
+            }]);
+        const url = `${this.mirrorNodeService.getBaseUrl()}/contracts/call`;
+        const body = {
+            data: encodedData,
+            from: SAUCER_SWAP_CONFIG.MIRROR_NODE_FROM_ADDRESS,
+            to: this.quoterEvmAddress,
+            block: "latest",
+            estimate: false,
+            gas: SAUCER_SWAP_CONFIG.QUOTE_GAS_LIMIT,
+            gasPrice: SAUCER_SWAP_CONFIG.DEFAULT_GAS_PRICE,
+            value: 0,
+        };
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            throw new MirrorNodeError(`Call failed with status ${response.status}`, response.status);
+        }
+        const json = await response.json();
+        const decoded = this.abiQuoterInterface.decodeFunctionResult('quoteExactInputSingle', json.result);
+        return Number(decoded.amountOut);
+    }
+    /**
+     * Gets the decimals for a token
+     *
+     * @param tokenEvmAddress - The EVM address of the token
+     * @returns The number of decimals for the token
+     * @throws {MirrorNodeError} If the mirror node call fails
+     */
+    async getDecimals(tokenEvmAddress) {
+        const encodedData = this.abiERC20Interface.encodeFunctionData(this.abiERC20Interface.getFunction('decimals'), []);
+        const url = `${this.mirrorNodeService.getBaseUrl()}/contracts/call`;
+        const body = {
+            data: encodedData,
+            from: SAUCER_SWAP_CONFIG.MIRROR_NODE_FROM_ADDRESS,
+            to: tokenEvmAddress,
+            block: "latest",
+            estimate: false,
+            gas: SAUCER_SWAP_CONFIG.DECIMALS_GAS_LIMIT,
+            gasPrice: SAUCER_SWAP_CONFIG.DEFAULT_GAS_PRICE,
+            value: 0,
+        };
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            throw new MirrorNodeError(`Call failed with status ${response.status}`, response.status);
+        }
+        const json = await response.json();
+        const decoded = this.abiERC20Interface.decodeFunctionResult('decimals', json.result);
+        return decoded[0];
+    }
+}

package/dist/service/saucer-swap-v2-query-service.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/service/type.js

@@ -0,0 +1 @@
+export {};

package/dist/service/utils.js

@@ -0,0 +1,19 @@
+export function hexToUint8Array(hex) {
+    const cleanHex = hex.startsWith('0x') ? hex.slice(2) : hex;
+    if (cleanHex.length % 2 !== 0) {
+        throw new Error('Invalid hex string length');
+    }
+    const array = new Uint8Array(cleanHex.length / 2);
+    for (let i = 0; i < array.length; i++) {
+        array[i] = parseInt(cleanHex.substr(i * 2, 2), 16);
+    }
+    return array;
+}
+export function buildEncodedPath(inputToken, hexFee, outputToken) {
+    const clean = (s) => s.startsWith('0x') ? s.slice(2) : s;
+    const pathParts = [];
+    pathParts.push(clean(inputToken));
+    pathParts.push(clean(hexFee));
+    pathParts.push(clean(outputToken));
+    return hexToUint8Array(pathParts.join(''));
+}

package/dist/tools/get-swap-quote-v2.js

@@ -0,0 +1,72 @@
+import { PromptGenerator, getMirrornodeService } from "hedera-agent-kit";
+import { getSwapQuoteV2Parameters } from "../saucer-swap.zod";
+import { SaucerSwapV2QueryServiceImpl } from "../service/saucer-swap-v2-query-service-impl";
+import SaucerSwapV2ParameterNormaliser from "../saucer-swap-v2-parameter-normaliser";
+import { SaucerSwapV2ConfigService } from "../service/saucer-swap-v2-config-service";
+import { SaucerSwapApiServiceImpl } from "../service/saucer-swap-rest-pools-service";
+import { SaucerSwapError } from "../errors";
+const getSwapQuoteV2Prompt = (context = {}) => {
+    const contextSnippet = PromptGenerator.getContextSnippet(context);
+    const usageInstructions = PromptGenerator.getParameterUsageInstructions();
+    return `
+  ${contextSnippet}
+  
+  This tool will get a quote for swapping from tokenIn to tokenOut. Provide either optional.amountIn (exact-in) or optional.amountOut (exact-out).
+  
+  Parameters:
+  - tokenIn (str, required): The input token address.
+  - tokenOut (str, required): The output token address.
+  - amountIn (number, required): The amount of input tokens to swap.
+  ${usageInstructions}
+  
+  Example: "Get quote for swapping 1000000000000000000 amountIn from 0x1234567890abcdef1234567890abcdef12345678 tokenIn to 0xabcdef1234567890abcdef1234567890abcdef12345678 tokenOut"
+  `;
+};
+const postProcess = (quote, tokenAmountInBaseUnit, params) => {
+    return `Swapping ${tokenAmountInBaseUnit} token: ${params.tokenIn} to token: ${params.tokenOut} will result in ${quote} token: ${params.tokenOut}, the rate used is ${quote / tokenAmountInBaseUnit}`;
+};
+const getSwapQuoteV2 = async (client, context, params) => {
+    const mirrorNode = getMirrornodeService(context.mirrornodeService, client.ledgerId);
+    const saucerSwapV2ConfigService = new SaucerSwapV2ConfigService(client.ledgerId);
+    const saucerSwapV2QueryService = new SaucerSwapV2QueryServiceImpl(client.ledgerId, mirrorNode, saucerSwapV2ConfigService);
+    const saucerSwapApiService = new SaucerSwapApiServiceImpl(client.ledgerId, saucerSwapV2ConfigService.getSaucerSwapApiKey());
+    try {
+        const normalisedParams = await SaucerSwapV2ParameterNormaliser.normaliseGetSwapQuoteV2Params(params, context, saucerSwapApiService);
+        const quote = await saucerSwapV2QueryService.getSwapQuote(normalisedParams.tokenIn, normalisedParams.tokenOut, normalisedParams.amountIn, normalisedParams.poolFeesInHexFormat.toLowerCase());
+        return {
+            raw: { quote },
+            humanMessage: postProcess(quote, normalisedParams.amountIn, normalisedParams),
+        };
+    }
+    catch (error) {
+        const desc = 'Failed to get quote';
+        let message;
+        if (error instanceof SaucerSwapError) {
+            message = `${desc}: ${error.message} (code: ${error.code})`;
+        }
+        else if (error instanceof Error) {
+            message = `${desc}: ${error.message}`;
+        }
+        else {
+            message = `${desc}: Unknown error occurred`;
+        }
+        console.error('[get_quote_tool]', message, error);
+        return { raw: { error: message }, humanMessage: message };
+    }
+};
+export const GET_SWAP_QUOTE_V2_TOOL = "get_swap_quote_v2_tool";
+const tool = (context) => ({
+    method: GET_SWAP_QUOTE_V2_TOOL,
+    name: "Get Quote (SaucerSwap V2)",
+    description: getSwapQuoteV2Prompt(context),
+    parameters: getSwapQuoteV2Parameters(),
+    execute: getSwapQuoteV2,
+    outputParser: (rawOutput) => {
+        const json = JSON.parse(rawOutput);
+        return {
+            raw: json,
+            humanMessage: json.quote,
+        };
+    },
+});
+export default tool;

package/dist/tools/swap-v2.js

@@ -0,0 +1,79 @@
+import SaucerSwapV2ParameterNormaliser from "../saucer-swap-v2-parameter-normaliser";
+import { swapV2Parameters } from "../saucer-swap.zod";
+import { getMirrornodeService, handleTransaction, HederaBuilder, PromptGenerator } from "hedera-agent-kit";
+import { Status } from "@hashgraph/sdk";
+import { SaucerSwapV2ConfigService } from "../service/saucer-swap-v2-config-service";
+import { SaucerSwapApiServiceImpl } from "../service/saucer-swap-rest-pools-service";
+import { SaucerSwapError } from "../errors";
+const swapV2Prompt = (context = {}) => {
+    return `
+    ${PromptGenerator.getContextSnippet(context)}
+
+    This tool will swap tokens using the SaucerSwap V2 protocol.
+
+    Parameters:
+    - tokenIn (str, required): The input token address
+    - tokenOut (str, required): The output token address
+    - amountIn (number, required): The amount of input tokens to swap
+    - recipientAddress (str, required): The address to receive the output tokens
+    `;
+};
+const postProcess = (response) => {
+    return `
+    Swap successful.
+    Transaction ID: ${response.transactionId}
+    `;
+};
+const swapV2 = async (client, context, params) => {
+    try {
+        const mirrorNode = getMirrornodeService(context.mirrornodeService, client.ledgerId);
+        const saucerSwapV2ConfigService = new SaucerSwapV2ConfigService(client.ledgerId);
+        const saucerSwapApiService = new SaucerSwapApiServiceImpl(client.ledgerId, saucerSwapV2ConfigService.getSaucerSwapApiKey());
+        const normalisedParams = await SaucerSwapV2ParameterNormaliser.normaliseSwapV2Params(params, context, saucerSwapV2ConfigService, saucerSwapApiService, mirrorNode, client);
+        const modifiedParams = { ...normalisedParams, gas: normalisedParams.gas };
+        const tx = HederaBuilder.executeTransaction(modifiedParams);
+        return handleTransaction(tx, client, context, postProcess);
+    }
+    catch (error) {
+        const desc = 'Failed to swap tokens';
+        let message;
+        if (error instanceof SaucerSwapError) {
+            message = `${desc}: ${error.message} (code: ${error.code})`;
+        }
+        else if (error instanceof Error) {
+            message = `${desc}: ${error.message}`;
+        }
+        else {
+            message = `${desc}: Unknown error occurred`;
+        }
+        console.error('[swap_v2_tool]', message, error);
+        return {
+            raw: {
+                status: Status.InvalidTransaction.toString(),
+                accountId: null,
+                tokenId: null,
+                transactionId: '',
+                topicId: null,
+                scheduleId: null,
+                error: message
+            },
+            humanMessage: message
+        };
+    }
+};
+export const SWAP_V2_TOOL = 'swap_v2_tool';
+const tool = (context) => ({
+    method: SWAP_V2_TOOL,
+    name: 'Swap V2',
+    description: swapV2Prompt(context),
+    parameters: swapV2Parameters(),
+    execute: swapV2,
+    outputParser: (rawOutput) => {
+        const json = JSON.parse(rawOutput);
+        return {
+            raw: json,
+            humanMessage: json.transactionId,
+        };
+    },
+});
+export default tool;

package/dist/utils/hedera-mirrornode-utils.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/swap-path.js

@@ -0,0 +1,25 @@
+export function hexToUint8Array(hex) {
+    const cleanHex = hex.startsWith('0x') ? hex.slice(2) : hex;
+    if (cleanHex.length % 2 !== 0) {
+        throw new Error('Invalid hex string length');
+    }
+    const array = new Uint8Array(cleanHex.length / 2);
+    for (let i = 0; i < array.length; i++) {
+        array[i] = parseInt(cleanHex.substr(i * 2, 2), 16);
+    }
+    return array;
+}
+export function buildEncodedPath(inputToken, hexFee, outputToken) {
+    const clean = (s) => s.toLowerCase().replace(/^0x/, '');
+    const inHex = clean(inputToken);
+    const feeHex = clean(hexFee).padStart(6, '0'); // ensure 3 bytes
+    const outHex = clean(outputToken);
+    if (inHex.length !== 40)
+        throw new Error(`tokenIn must be 20 bytes (40 hex), got ${inHex.length}`);
+    if (feeHex.length !== 6)
+        throw new Error(`fee must be 3 bytes (6 hex), got ${feeHex.length}`);
+    if (outHex.length !== 40)
+        throw new Error(`tokenOut must be 20 bytes (40 hex), got ${outHex.length}`);
+    const joined = inHex + feeHex + outHex; // total 86 hex chars (43 bytes)
+    return hexToUint8Array(joined);
+}

package/dist/utils.js

@@ -0,0 +1,98 @@
+import { TokenId } from "@hashgraph/sdk";
+import BigNumber from 'bignumber.js';
+import { AccountResolver } from "hedera-agent-kit";
+/**
+ * Handles response formatting for both autonomous and manual modes
+ */
+export const handleResponse = (data, message) => {
+    return {
+        success: true,
+        data,
+        message,
+    };
+};
+/**
+ * Converts decimal amount to tiny units (wei)
+ */
+export const toTiny = (amount) => {
+    const amountBigInt = typeof amount === "string" ? BigInt(amount) : BigInt(amount);
+    return amountBigInt.toString();
+};
+/**
+ * Validates token addresses
+ */
+export const isValidAddress = (address) => {
+    return /^0x[a-fA-F0-9]{40}$/.test(address);
+};
+/**
+ * Normalizes token addresses to lowercase
+ */
+export const normalizeAddress = (address) => {
+    if (!isValidAddress(address)) {
+        throw new Error(`Invalid address: ${address}`);
+    }
+    return address.toLowerCase();
+};
+/**
+ * Sorts token addresses for consistent pair ordering
+ */
+export const sortTokens = (tokenA, tokenB) => {
+    const normalizedA = normalizeAddress(tokenA);
+    const normalizedB = normalizeAddress(tokenB);
+    if (normalizedA === normalizedB) {
+        throw new Error("Cannot create pool with same token");
+    }
+    return normalizedA < normalizedB ? [normalizedA, normalizedB] : [normalizedB, normalizedA];
+};
+/**
+ * Calculates slippage bounds
+ */
+export const calculateSlippageBounds = (amount, slippageBps) => {
+    const slippageMultiplier = BigInt(10000 - slippageBps);
+    const min = (amount * slippageMultiplier) / 10000n;
+    const maxMultiplier = BigInt(10000 + slippageBps);
+    const max = (amount * maxMultiplier) / 10000n;
+    return { min, max };
+};
+/**
+ * Formats amount with decimals
+ */
+export const formatAmount = (amount, decimals) => {
+    const divisor = BigInt(10 ** decimals);
+    const whole = amount / divisor;
+    const fractional = amount % divisor;
+    if (fractional === 0n) {
+        return whole.toString();
+    }
+    const fractionalStr = fractional.toString().padStart(decimals, '0');
+    const trimmed = fractionalStr.replace(/0+$/, '');
+    if (trimmed === '') {
+        return whole.toString();
+    }
+    return `${whole}.${trimmed}`;
+};
+export const getHederaTokenEVMAddress = (address) => {
+    if (!AccountResolver.isHederaAddress(address)) {
+        return address;
+    }
+    const token = TokenId.fromString(address);
+    return '0x' + token.toEvmAddress();
+};
+export const getHederaTokenAddress = (address) => {
+    if (AccountResolver.isHederaAddress(address)) {
+        return address;
+    }
+    const token = TokenId.fromEvmAddress(0, 0, address);
+    return token.toString();
+};
+export function toBaseUnit(amount, decimals) {
+    const amountBN = new BigNumber(amount);
+    const multiplier = new BigNumber(10).pow(decimals);
+    return amountBN.multipliedBy(multiplier).integerValue(BigNumber.ROUND_FLOOR);
+}
+export const getTokenDecimals = (pool, hederaTokenAddress) => {
+    if (pool.tokenA.id === hederaTokenAddress) {
+        return pool.tokenA.decimals;
+    }
+    return pool.tokenB.decimals;
+};