keyring-agent-core 0.2.0 → 0.2.2

package/dist/tools/builtin/pool/OpenAddLiquidityFormTool.d.ts

@@ -1,128 +0,0 @@
-import { BaseTool } from '../../BaseTool';
-import type { AddLiquidityFormProps, ToolKind, ToolParameter, ToolResult, UIPayload, UserContext } from '../../../types';
-import { type UniswapServiceConfig } from '../../../services/UniswapService';
-import { type PoolServiceConfig } from '../../../services/PoolService';
-export interface OpenAddLiquidityFormToolConfig extends UniswapServiceConfig {
-    pool?: PoolServiceConfig;
-    /** Min USD value the user must supply. Default 10. */
-    minProvideUsd?: number;
-}
-/**
- * Tool: open-add-liquidity-form
- *
- * Resolves a pool from token symbols + fee tier, reads the pool's on-chain
- * state, checks the user's native balance on that chain, and returns a UI
- * payload telling the FE to render the AddLiquidityForm component.
- *
- * Native-only: this gateway flow ALWAYS swaps the chain's native coin into
- * both pool tokens via deBridge — there is no token-in selector. The form
- * props expose only the native token; the FE must enforce the same.
- *
- * The tool DOES NOT build a transaction — it just sets up the form. The
- * user picks a strategy + amount, then the agent calls
- * `build-add-liquidity-tx` for the actual unsigned mint.
- */
-export declare class OpenAddLiquidityFormTool extends BaseTool {
-    name: string;
-    kind: ToolKind;
-    category: string;
-    noSuggestions: boolean;
-    description: string;
-    parameters: ToolParameter[];
-    private uniswap;
-    private pool;
-    private minProvideUsd;
-    constructor(config?: OpenAddLiquidityFormToolConfig);
-    /**
-     * Override execute to forward our `ui` payload from `run()` into the
-     * ToolResult envelope (BaseTool only copies `data`).
-     */
-    execute(args: Record<string, unknown>, userContext?: UserContext): Promise<ToolResult>;
-    protected run(args: Record<string, unknown>, userContext?: UserContext): Promise<{
-        error: string;
-        _instructions: string;
-        chain?: undefined;
-        requestedToken?: undefined;
-        nativeSymbol?: undefined;
-        chainName?: undefined;
-        candidates?: undefined;
-        ui?: undefined;
-        summary?: undefined;
-    } | {
-        error: string;
-        chain: string;
-        _instructions: string;
-        requestedToken?: undefined;
-        nativeSymbol?: undefined;
-        chainName?: undefined;
-        candidates?: undefined;
-        ui?: undefined;
-        summary?: undefined;
-    } | {
-        error: string;
-        requestedToken: string;
-        nativeSymbol: string;
-        chainName: string;
-        _instructions: string;
-        chain?: undefined;
-        candidates?: undefined;
-        ui?: undefined;
-        summary?: undefined;
-    } | {
-        error: string;
-        _instructions?: undefined;
-        chain?: undefined;
-        requestedToken?: undefined;
-        nativeSymbol?: undefined;
-        chainName?: undefined;
-        candidates?: undefined;
-        ui?: undefined;
-        summary?: undefined;
-    } | {
-        candidates: {
-            apr?: number | undefined;
-            address: string | undefined;
-            token0Symbol: string | undefined;
-            token1Symbol: string | undefined;
-            feeTier: number | undefined;
-            feeTierPercent: number | undefined;
-            volume24hUsd: number | undefined;
-            tvlUsd: number | undefined;
-        }[];
-        _instructions: string;
-        error?: undefined;
-        chain?: undefined;
-        requestedToken?: undefined;
-        nativeSymbol?: undefined;
-        chainName?: undefined;
-        ui?: undefined;
-        summary?: undefined;
-    } | {
-        ui: UIPayload<AddLiquidityFormProps>;
-        summary: string;
-        _instructions: string;
-        error?: undefined;
-        chain?: undefined;
-        requestedToken?: undefined;
-        nativeSymbol?: undefined;
-        chainName?: undefined;
-        candidates?: undefined;
-    }>;
-    private matchesPairExact;
-    private matchesPair;
-    private symMatch;
-    private parseRangeStrategy;
-    /**
-     * Decide which (minPrice, maxPrice) to prefill in the form. Order:
-     *  1. Explicit minPrice + maxPrice (user-supplied numbers) — clamp to priceBounds.
-     *  2. rangeStrategy = "stable" → buildRangePresets() stable preset.
-     *  3. rangeStrategy = "wide"   → buildRangePresets() wide preset.
-     *  4. rangeStrategy = "full"   → priceBounds.min / priceBounds.max.
-     *  5. nothing → null (FE shows empty inputs + preset chips like before).
-     *
-     * The FE keeps the inputs editable in all cases — this is just a pre-fill.
-     */
-    private computePrefillRange;
-    private buildSummary;
-}
-//# sourceMappingURL=OpenAddLiquidityFormTool.d.ts.map

package/dist/tools/builtin/pool/OpenAddLiquidityFormTool.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"OpenAddLiquidityFormTool.d.ts","sourceRoot":"","sources":["../../../../src/tools/builtin/pool/OpenAddLiquidityFormTool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,OAAO,KAAK,EACV,qBAAqB,EAKrB,QAAQ,EACR,aAAa,EACb,UAAU,EACV,SAAS,EACT,WAAW,EACZ,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAyC,KAAK,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AACpH,OAAO,EAOL,KAAK,iBAAiB,EACvB,MAAM,+BAA+B,CAAC;AAKvC,MAAM,WAAW,8BAA+B,SAAQ,oBAAoB;IAC1E,IAAI,CAAC,EAAE,iBAAiB,CAAC;IACzB,sDAAsD;IACtD,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAID;;;;;;;;;;;;;;GAcG;AACH,qBAAa,wBAAyB,SAAQ,QAAQ;IACpD,IAAI,SAA6B;IACjC,IAAI,EAAE,QAAQ,CAAQ;IACtB,QAAQ,SAAiB;IACzB,aAAa,UAAQ;IACrB,WAAW,SAakE;IAE7E,UAAU,EAAE,aAAa,EAAE,CAqGzB;IAEF,OAAO,CAAC,OAAO,CAAiB;IAChC,OAAO,CAAC,IAAI,CAAc;IAC1B,OAAO,CAAC,aAAa,CAAS;gBAElB,MAAM,CAAC,EAAE,8BAA8B;IAOnD;;;OAGG;IACG,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;cA2B5E,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAuS5E,OAAO,CAAC,gBAAgB;IAUxB,OAAO,CAAC,WAAW;IAWnB,OAAO,CAAC,QAAQ;IAKhB,OAAO,CAAC,kBAAkB;IAO1B;;;;;;;;;OASG;IACH,OAAO,CAAC,mBAAmB;IAwC3B,OAAO,CAAC,YAAY;CAgBrB"}

package/dist/tools/builtin/pool/OpenAddLiquidityFormTool.js

@@ -1,520 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpenAddLiquidityFormTool = void 0;
-const BaseTool_1 = require("../../BaseTool");
-const chainResolver_1 = require("../../chainResolver");
-const UniswapService_1 = require("../../../services/UniswapService");
-const PoolService_1 = require("../../../services/PoolService");
-const pool_1 = require("../../../functions/pool");
-const EVM_ADDRESS_RE = /^0x[a-fA-F0-9]{40}$/;
-/**
- * Tool: open-add-liquidity-form
- *
- * Resolves a pool from token symbols + fee tier, reads the pool's on-chain
- * state, checks the user's native balance on that chain, and returns a UI
- * payload telling the FE to render the AddLiquidityForm component.
- *
- * Native-only: this gateway flow ALWAYS swaps the chain's native coin into
- * both pool tokens via deBridge — there is no token-in selector. The form
- * props expose only the native token; the FE must enforce the same.
- *
- * The tool DOES NOT build a transaction — it just sets up the form. The
- * user picks a strategy + amount, then the agent calls
- * `build-add-liquidity-tx` for the actual unsigned mint.
- */
-class OpenAddLiquidityFormTool extends BaseTool_1.BaseTool {
-    name = 'open-add-liquidity-form';
-    kind = 'ui';
-    category = 'pool-action';
-    noSuggestions = true;
-    description = 'Open the Add-Liquidity form for a specific Uniswap V3 pool. Use this when the user wants to ' +
-        'provide liquidity / add LP / farm / stake / deposit into a pool — natural-language verbs in ' +
-        'any language all map here. Resolves the pool by token symbols (and optional fee tier), reads ' +
-        "on-chain state, checks the connected wallet's NATIVE balance, then returns a UI payload that " +
-        'the FE renders as the form (with two preset ranges: Stable ±3 ticks and Wide -50%/+100%). ' +
-        "CONSTRAINT: the gateway only accepts the chain's NATIVE coin as input (ETH on Ethereum/Base/" +
-        'Arbitrum/Optimism/Linea, BNB on BSC, MATIC on Polygon, AVAX on Avalanche). The native amount ' +
-        'is auto-split via deBridge into both pool tokens — the user never selects a different input. ' +
-        'If the user asks to add liquidity using a NON-NATIVE token amount (e.g. "add pool with 5 USDT", ' +
-        '"thêm 100 USDC"), pass that symbol via `requestedNonNativeToken` so the tool can return ' +
-        'error="unsupported_input_token" — never silently convert their non-native amount into native or USD. ' +
-        'PRECONDITION: a connected wallet (userContext.walletAddress). If absent, the tool returns ' +
-        'error="wallet_not_connected" and the agent must ask the user to connect.';
-    parameters = [
-        {
-            name: 'token0Symbol',
-            type: 'string',
-            description: 'Symbol of one of the pool\'s tokens (e.g. "USDC"). Pair order does not matter.',
-            required: true,
-        },
-        {
-            name: 'token1Symbol',
-            type: 'string',
-            description: 'Symbol of the other pool token (e.g. "WETH"). Required to uniquely identify the pool.',
-            required: true,
-        },
-        {
-            name: 'feeTier',
-            type: 'number',
-            description: 'Fee tier in basis points: 100 = 0.01%, 500 = 0.05%, 3000 = 0.30%, 10000 = 1.00%. ' +
-                'Omit when unknown — the tool will resolve the best match automatically.',
-            required: false,
-        },
-        {
-            name: 'chain',
-            type: 'string',
-            description: 'Hex chain ID: "0x1" Ethereum, "0xa" Optimism, "0x38" BSC, "0x89" Polygon, "0x2105" Base, ' +
-                '"0xa4b1" Arbitrum, "0xa86a" Avalanche, "0xe708" Linea. ONLY set this when the user EXPLICITLY names a chain; otherwise OMIT it so the connected wallet chain is used.',
-            required: false,
-        },
-        {
-            name: 'prefillNativeAmount',
-            type: 'number',
-            description: "Optional NATIVE-COIN amount (human-readable) to pre-fill the form's input field. " +
-                "ONLY pass this when the user named an amount in the chain's native coin itself — ETH on Ethereum/Base/Arbitrum/Optimism/Linea, " +
-                'BNB on BSC, MATIC on Polygon, AVAX on Avalanche. Example: "add 0.1 ETH to USDC/WETH on Base". ' +
-                'Pass the plain decimal number (e.g. 0.1 for 0.1 ETH). ' +
-                'DO NOT convert a non-native amount (USDC, USDT, DAI, WBTC, …) into native here — pass `requestedNonNativeToken` instead so the tool can reject. ' +
-                'Mutually exclusive with prefillUsdAmount — pass one or neither.',
-            required: false,
-        },
-        {
-            name: 'prefillUsdAmount',
-            type: 'number',
-            description: "Optional USD amount to pre-fill the form's input field. " +
-                'Use this ONLY when the user explicitly speaks in USD/dollars — e.g. "add $10 to this pool", "10 dollars", "10 đô". ' +
-                'The tool converts the USD value to native amount automatically using the current native-token price. ' +
-                'DO NOT use this as a workaround for non-native token amounts (e.g. "5 USDT" is NOT $5 — USDT may de-peg, and even if 1:1 the user asked for a token, not USD). ' +
-                'For non-native token amounts pass `requestedNonNativeToken` instead. ' +
-                'Mutually exclusive with prefillNativeAmount — pass one or neither.',
-            required: false,
-        },
-        {
-            name: 'requestedNonNativeToken',
-            type: 'string',
-            description: 'Set this ONLY when the user named an AMOUNT in a non-native token — e.g. "add pool with 5 USDT", ' +
-                '"add 100 USDC to USDC/WETH", "thêm 5 USDT vào pool". The trigger is "<number> <non-native-symbol>" in the user\'s message, ' +
-                'NOT the mere appearance of the symbol. Pass the symbol the user attached the amount to (e.g. "USDT", "USDC", "DAI"). ' +
-                'CRITICAL: If the user also names a NATIVE amount in the same message (e.g. "add USDC/WETH with 0.1 ETH", ' +
-                '"thêm pool USDC/WETH 0.3% với 0.000005 ETH"), the native amount is the input — leave this EMPTY and use prefillNativeAmount. ' +
-                'The pool pair symbols (the two tokens after "pool" / "to") are NEVER the input token by themselves — they only identify which pool. ' +
-                'The tool will return error="unsupported_input_token" so the agent can tell the user that only the chain\'s native coin ' +
-                "is accepted as input. DO NOT silently convert the user's non-native amount into a native amount or USD amount — " +
-                'the user explicitly named a different asset and must be informed, not auto-corrected. ' +
-                'Leave empty when the user did name a native amount, a USD amount, or no amount at all.',
-            required: false,
-        },
-        {
-            name: 'rangeStrategy',
-            type: 'string',
-            description: 'Optional preset that pre-fills the min/max price inputs (FE keeps them editable). One of: ' +
-                '"stable" — ±3 tickSpacing around the current price (narrow, higher yield, higher out-of-range risk; pick for stablecoin / low-volatility pairs and when the user says "safe", "tight", "high yield", "tập trung"); ' +
-                '"wide" — currentPrice × [0.5, 2.0] (broad, lower yield, less rebalancing; pick when the user says "wide", "set and forget", "rộng"); ' +
-                '"full" — full V3 tick range (V2-style, lowest yield, never goes out of range; pick when the user says "full range", "v2-style", "không lo out of range"). ' +
-                'Omit when the user did not signal a preference AND did not provide explicit minPrice/maxPrice. ' +
-                'Mutually exclusive with minPrice/maxPrice — if both are passed, explicit prices win.',
-            required: false,
-        },
-        {
-            name: 'minPrice',
-            type: 'number',
-            description: 'Optional explicit lower bound for the price range, in token1-per-token0 units ' +
-                '(same unit as pool.currentPrice — decimal-adjusted). ' +
-                'Pass when the user named a concrete number, e.g. "range 1800 to 2200" → minPrice=1800. ' +
-                'Must be paired with maxPrice. When set, overrides rangeStrategy.',
-            required: false,
-        },
-        {
-            name: 'maxPrice',
-            type: 'number',
-            description: 'Optional explicit upper bound for the price range, in token1-per-token0 units ' +
-                '(same unit as pool.currentPrice — decimal-adjusted). ' +
-                'Pass when the user named a concrete number, e.g. "range 1800 to 2200" → maxPrice=2200. ' +
-                'Must be paired with minPrice. When set, overrides rangeStrategy.',
-            required: false,
-        },
-    ];
-    uniswap;
-    pool;
-    minProvideUsd;
-    constructor(config) {
-        super();
-        this.uniswap = new UniswapService_1.UniswapService(config);
-        this.pool = new PoolService_1.PoolService(config?.pool);
-        this.minProvideUsd = config?.minProvideUsd ?? 0.01;
-    }
-    /**
-     * Override execute to forward our `ui` payload from `run()` into the
-     * ToolResult envelope (BaseTool only copies `data`).
-     */
-    async execute(args, userContext) {
-        const callId = `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-        const start = Date.now();
-        try {
-            const out = (await this.run(args, userContext));
-            const result = {
-                toolName: this.name,
-                callId,
-                success: true,
-                data: out,
-                duration: Date.now() - start,
-            };
-            if (out && typeof out === 'object' && out.ui) {
-                result.ui = out.ui;
-            }
-            return result;
-        }
-        catch (err) {
-            return {
-                toolName: this.name,
-                callId,
-                success: false,
-                error: err instanceof Error ? err.message : String(err),
-                duration: Date.now() - start,
-            };
-        }
-    }
-    async run(args, userContext) {
-        const chain = (0, chainResolver_1.resolveChain)(args.chain, userContext);
-        const token0Symbol = typeof args.token0Symbol === 'string' ? args.token0Symbol.trim() : '';
-        const token1Symbol = typeof args.token1Symbol === 'string' ? args.token1Symbol.trim() : '';
-        const feeTier = typeof args.feeTier === 'number' && Number.isFinite(args.feeTier) ? Math.floor(args.feeTier) : undefined;
-        const prefillNativeAmountInput = typeof args.prefillNativeAmount === 'number' &&
-            Number.isFinite(args.prefillNativeAmount) &&
-            args.prefillNativeAmount > 0
-            ? args.prefillNativeAmount
-            : null;
-        const prefillUsdAmount = typeof args.prefillUsdAmount === 'number' && Number.isFinite(args.prefillUsdAmount) && args.prefillUsdAmount > 0
-            ? args.prefillUsdAmount
-            : null;
-        const requestedNonNativeTokenRaw = typeof args.requestedNonNativeToken === 'string' && args.requestedNonNativeToken.trim()
-            ? args.requestedNonNativeToken.trim()
-            : null;
-        // Guard: when the LLM sets requestedNonNativeToken to one of the pair
-        // symbols AND the user also named a native amount (prefillNativeAmount),
-        // it's almost certainly a misfire — the symbol came from the pool name,
-        // not from an input amount. Drop it so the flow proceeds normally.
-        const requestedNonNativeToken = requestedNonNativeTokenRaw &&
-            prefillNativeAmountInput != null &&
-            (requestedNonNativeTokenRaw.toLowerCase() === token0Symbol.toLowerCase() ||
-                requestedNonNativeTokenRaw.toLowerCase() === token1Symbol.toLowerCase())
-            ? null
-            : requestedNonNativeTokenRaw;
-        const rangeStrategy = this.parseRangeStrategy(args.rangeStrategy);
-        const explicitMinPrice = typeof args.minPrice === 'number' && Number.isFinite(args.minPrice) && args.minPrice > 0 ? args.minPrice : null;
-        const explicitMaxPrice = typeof args.maxPrice === 'number' && Number.isFinite(args.maxPrice) && args.maxPrice > 0 ? args.maxPrice : null;
-        if (!token0Symbol || !token1Symbol) {
-            return {
-                error: 'missing_pool_identifier',
-                _instructions: 'token0Symbol and token1Symbol are required. Ask the user for the missing token symbol.',
-            };
-        }
-        const meta = (0, PoolService_1.getChainMeta)(chain);
-        if (!meta) {
-            return {
-                error: 'unsupported_chain',
-                chain,
-                _instructions: `Chain ${chain} is not supported by the add-liquidity flow.`,
-            };
-        }
-        const nativeMeta = (0, PoolService_1.getNativeTokenInfo)(chain);
-        if (requestedNonNativeToken &&
-            nativeMeta &&
-            requestedNonNativeToken.toLowerCase() !== nativeMeta.symbol.toLowerCase()) {
-            return {
-                error: 'unsupported_input_token',
-                requestedToken: requestedNonNativeToken,
-                nativeSymbol: nativeMeta.symbol,
-                chainName: meta.name,
-                _instructions: `The user asked to add liquidity using ${requestedNonNativeToken}, but this app only supports the chain's native coin ` +
-                    `(${nativeMeta.symbol} on ${meta.name}) as the input. Tell the user this in their language and ask them to either ` +
-                    `restate the amount in ${nativeMeta.symbol} or in USD. DO NOT silently convert their ${requestedNonNativeToken} amount, ` +
-                    `do NOT pre-fill the form, and do NOT call this tool again until the user provides a native or USD amount.`,
-            };
-        }
-        const gateway = await this.pool.getGatewayAddress(chain);
-        if (!gateway) {
-            return {
-                error: 'no_gateway_configured',
-                chain,
-                _instructions: `No gateway contract is configured for chain ${chain} (${meta.name}). ` +
-                    'Tell the user this chain is not yet supported for add-liquidity in this app.',
-            };
-        }
-        const walletAddress = userContext?.walletAddress;
-        if (!walletAddress) {
-            return {
-                error: 'wallet_not_connected',
-                _instructions: 'The user is not connected. Ask them to connect their wallet before adding liquidity. Do NOT render the form.',
-            };
-        }
-        // ---- Step 1: resolve pool address via search ----
-        const search = await this.uniswap.searchPools({
-            query: `${token0Symbol} ${token1Symbol}`,
-            chain,
-            page: 1,
-            size: 100,
-            protocolVersion: 'V3',
-            feeTier,
-        });
-        if (!search.success) {
-            return { error: search.error || 'pool_search_failed' };
-        }
-        const all = search.data ?? [];
-        // ---- Step 2: resolve a single pool from the results ----
-        // Priority: exact symbol match → single fuzzy match → ask user to pick.
-        const exactMatch = all.find((p) => this.matchesPairExact(p, token0Symbol, token1Symbol, feeTier));
-        const fuzzyMatches = exactMatch ? [] : all.filter((p) => this.matchesPair(p, token0Symbol, token1Symbol, feeTier));
-        if (!exactMatch && fuzzyMatches.length === 0) {
-            return {
-                error: 'pool_not_found',
-                _instructions: `No V3 pool found for ${token0Symbol}/${token1Symbol}${feeTier != null ? ` at ${feeTier}bps` : ''} on ${meta.name}. Verify the inputs with the user.`,
-            };
-        }
-        if (!exactMatch && fuzzyMatches.length > 1) {
-            return {
-                candidates: fuzzyMatches.map((p) => ({
-                    address: p.id,
-                    token0Symbol: p.token0?.symbol,
-                    token1Symbol: p.token1?.symbol,
-                    feeTier: p.feeTier,
-                    feeTierPercent: p.feeTier != null ? p.feeTier / 10_000 : undefined,
-                    volume24hUsd: p.volume1DayUsd ?? p.volumeUsd24hr,
-                    tvlUsd: p.tvlUsd,
-                    ...(p.apr ? { apr: p.apr } : undefined),
-                })),
-                _instructions: 'Multiple pools matched. Present them as a numbered list (pair, fee %, TVL, 24h volume, address, apr) ' +
-                    "and ask the user to pick one. Then re-call this tool with the chosen pool's exact token0Symbol, token1Symbol, and feeTier.",
-            };
-        }
-        // Exactly one match (exact or single fuzzy) — proceed.
-        const candidate = exactMatch ?? fuzzyMatches[0];
-        if (!candidate.id || !EVM_ADDRESS_RE.test(candidate.id)) {
-            return { error: 'invalid_pool_address' };
-        }
-        // ---- Step 2: read on-chain state ----
-        const onchain = await this.pool.readPoolOnchain(chain, candidate.id);
-        // ---- Step 3: balance + gas + price ----
-        const [balanceWei, gasReserveWei, nativePriceUsd] = await Promise.all([
-            this.pool.getNativeBalance(chain, walletAddress),
-            this.pool.estimateGasReserveWei(chain),
-            this.pool.getNativePriceUsd(chain),
-        ]);
-        const spendableWei = balanceWei > gasReserveWei ? balanceWei - gasReserveWei : 0n;
-        const native = (0, PoolService_1.getNativeTokenInfo)(chain);
-        const spendable = Number(spendableWei) / 10 ** native.decimals;
-        const balance = Number(balanceWei) / 10 ** native.decimals;
-        const spendableUsd = nativePriceUsd != null ? spendable * nativePriceUsd : null;
-        // ---- Step 4: token decimals + price-input bounds ----
-        // The form lets the user TYPE a min/max price (token1 per token0). Compute
-        // the absolute decimal-adjusted window that maps to the V3 valid tick range,
-        // so the FE can clamp inputs and show a sane upper limit.
-        const [token0Decimals, token1Decimals] = await Promise.all([
-            this.pool.readErc20Decimals(chain, onchain.token0),
-            this.pool.readErc20Decimals(chain, onchain.token1),
-        ]);
-        const priceBounds = {
-            min: (0, PoolService_1.tickToPrice)(pool_1.MIN_TICK, token0Decimals, token1Decimals),
-            max: (0, PoolService_1.tickToPrice)(pool_1.MAX_TICK, token0Decimals, token1Decimals),
-        };
-        // ---- Step 5: warning ----
-        let warning = null;
-        if (balanceWei === 0n) {
-            warning = 'no_balance';
-        }
-        else if (spendableUsd != null && spendableUsd < this.minProvideUsd) {
-            warning = 'insufficient_balance';
-        }
-        // ---- Step 6: candidate token info from search payload (icons/symbols) ----
-        const t0Info = candidate.token0;
-        const t1Info = candidate.token1;
-        // ---- Step 7: input-token block — self-contained for the FE input field ----
-        // Everything the FE needs to render the "amount in" input lives here:
-        // identity, decimals, price, balance, gas reserve, spendable, quick-pick
-        // rates (25/50/75/100% of spendable), USD value, warning, and an optional
-        // pre-fill amount (when the user named an amount before picking the pool).
-        const quickRates = [25, 50, 75, 100].map((pct) => ({
-            percent: pct,
-            amountWei: ((spendableWei * BigInt(pct)) / 100n).toString(),
-            amount: spendable * (pct / 100),
-        }));
-        let prefillAmountWei = null;
-        let prefillAmount = null;
-        if (prefillNativeAmountInput != null) {
-            prefillAmount = prefillNativeAmountInput;
-            const weiBig = BigInt(Math.floor(prefillAmount * 10 ** native.decimals));
-            if (weiBig > 0n)
-                prefillAmountWei = weiBig.toString();
-        }
-        else if (prefillUsdAmount != null && nativePriceUsd != null && nativePriceUsd > 0) {
-            prefillAmount = prefillUsdAmount / nativePriceUsd;
-            const weiBig = BigInt(Math.floor(prefillAmount * 10 ** native.decimals));
-            if (weiBig > 0n)
-                prefillAmountWei = weiBig.toString();
-        }
-        const inputToken = {
-            address: PoolService_1.ZERO_ADDRESS,
-            isNative: true,
-            symbol: native.symbol,
-            name: native.name,
-            decimals: native.decimals,
-            priceUsd: nativePriceUsd,
-            balanceWei: balanceWei.toString(),
-            balance,
-            gasReserveWei: gasReserveWei.toString(),
-            spendableWei: spendableWei.toString(),
-            spendable,
-            spendableUsd,
-            quickRates,
-            minProvideUsd: this.minProvideUsd,
-            warning,
-            warningMessage: warning === 'no_balance'
-                ? `You have no ${native.symbol} on ${meta.name}. Top up to add liquidity.`
-                : warning === 'insufficient_balance'
-                    ? `Spendable ${native.symbol} is below the $${this.minProvideUsd} minimum.`
-                    : null,
-            prefillAmount,
-            prefillAmountWei,
-        };
-        // ---- Step 8: price-range prefill — explicit prices win over strategy presets ----
-        const prefillRange = this.computePrefillRange({
-            explicitMinPrice,
-            explicitMaxPrice,
-            rangeStrategy,
-            currentTick: onchain.currentTick,
-            tickSpacing: onchain.tickSpacing,
-            token0Decimals,
-            token1Decimals,
-            priceBounds,
-        });
-        const props = {
-            chain: { hexId: chain, name: meta.name },
-            pool: {
-                address: onchain.poolAddress,
-                fee: onchain.fee,
-                feePercent: onchain.fee / 10_000,
-                tickSpacing: onchain.tickSpacing,
-                currentTick: onchain.currentTick,
-                currentPrice: onchain.currentPrice,
-                sqrtPriceX96: onchain.sqrtPriceX96.toString(),
-                token0: {
-                    address: onchain.token0,
-                    symbol: t0Info?.symbol,
-                    name: t0Info?.name,
-                    logo: t0Info?.logo,
-                },
-                token1: {
-                    address: onchain.token1,
-                    symbol: t1Info?.symbol,
-                    name: t1Info?.name,
-                    logo: t1Info?.logo,
-                },
-            },
-            inputToken,
-            priceBounds,
-            prefillRange,
-            gatewayAddress: gateway,
-        };
-        const ui = { component: 'AddLiquidityForm', props };
-        return {
-            ui,
-            summary: this.buildSummary({
-                chainName: meta.name,
-                pair: `${t0Info?.symbol ?? token0Symbol}/${t1Info?.symbol ?? token1Symbol}`,
-                feePercent: onchain.fee / 10_000,
-                warning,
-                minProvideUsd: this.minProvideUsd,
-                nativeSymbol: native.symbol,
-            }),
-            _instructions: "The add-liquidity action is ready. In the user's language, invite them to enter the amount and price range to add liquidity, " +
-                'naming the pool + chain (e.g. "Enter the amount and price range to add liquidity to <pool> on <chain>"). ' +
-                'If warning="no_balance" tell them they need to top up. ' +
-                'If warning="insufficient_balance" tell them the balance is below the minimum. ' +
-                'Do NOT mention balance amounts, deBridge, native coin mechanics, UI, forms, or internal tool names. ' +
-                'Wait for the user to fill in amount + price range before proceeding.',
-        };
-    }
-    matchesPairExact(p, sym0, sym1, fee) {
-        if (!fee)
-            return false;
-        if (fee != null && p.feeTier !== fee)
-            return false;
-        const a = (p.token0?.symbol ?? '').toLowerCase();
-        const b = (p.token1?.symbol ?? '').toLowerCase();
-        const x = sym0.toLowerCase();
-        const y = sym1.toLowerCase();
-        return (a === x && b === y) || (a === y && b === x);
-    }
-    matchesPair(p, sym0, sym1, fee) {
-        if (fee != null && p.feeTier !== fee)
-            return false;
-        const a = (p.token0?.symbol ?? '').toLowerCase();
-        const b = (p.token1?.symbol ?? '').toLowerCase();
-        const x = sym0.toLowerCase();
-        const y = sym1.toLowerCase();
-        const ordered = this.symMatch(a, x) && this.symMatch(b, y);
-        const reversed = this.symMatch(a, y) && this.symMatch(b, x);
-        return ordered || reversed;
-    }
-    symMatch(poolSym, userSym) {
-        if (!poolSym || !userSym)
-            return false;
-        return poolSym.includes(userSym) || userSym.includes(poolSym);
-    }
-    parseRangeStrategy(value) {
-        if (typeof value !== 'string')
-            return null;
-        const v = value.trim().toLowerCase();
-        if (v === 'stable' || v === 'wide' || v === 'full')
-            return v;
-        return null;
-    }
-    /**
-     * Decide which (minPrice, maxPrice) to prefill in the form. Order:
-     *  1. Explicit minPrice + maxPrice (user-supplied numbers) — clamp to priceBounds.
-     *  2. rangeStrategy = "stable" → buildRangePresets() stable preset.
-     *  3. rangeStrategy = "wide"   → buildRangePresets() wide preset.
-     *  4. rangeStrategy = "full"   → priceBounds.min / priceBounds.max.
-     *  5. nothing → null (FE shows empty inputs + preset chips like before).
-     *
-     * The FE keeps the inputs editable in all cases — this is just a pre-fill.
-     */
-    computePrefillRange(input) {
-        const { explicitMinPrice, explicitMaxPrice, rangeStrategy, priceBounds } = input;
-        if (explicitMinPrice != null && explicitMaxPrice != null && explicitMaxPrice > explicitMinPrice) {
-            return {
-                strategy: 'user',
-                minPrice: Math.max(explicitMinPrice, priceBounds.min),
-                maxPrice: Math.min(explicitMaxPrice, priceBounds.max),
-            };
-        }
-        if (rangeStrategy === 'full') {
-            return { strategy: 'full', minPrice: priceBounds.min, maxPrice: priceBounds.max };
-        }
-        if (rangeStrategy === 'stable' || rangeStrategy === 'wide') {
-            const presets = (0, PoolService_1.buildRangePresets)({
-                currentTick: input.currentTick,
-                tickSpacing: input.tickSpacing,
-                token0Decimals: input.token0Decimals,
-                token1Decimals: input.token1Decimals,
-            });
-            const preset = presets.find((p) => p.id === rangeStrategy);
-            if (preset) {
-                return { strategy: rangeStrategy, minPrice: preset.minPrice, maxPrice: preset.maxPrice };
-            }
-        }
-        return null;
-    }
-    buildSummary(args) {
-        const parts = [`Add-liquidity form opened for ${args.pair} ${args.feePercent}% on ${args.chainName}.`];
-        if (args.warning === 'no_balance') {
-            parts.push(`No ${args.nativeSymbol} balance — top up the wallet to add liquidity.`);
-        }
-        else if (args.warning === 'insufficient_balance') {
-            parts.push(`Balance is below the $${args.minProvideUsd} minimum — top up before submitting.`);
-        }
-        return parts.join(' ');
-    }
-}
-exports.OpenAddLiquidityFormTool = OpenAddLiquidityFormTool;
-//# sourceMappingURL=OpenAddLiquidityFormTool.js.map