@parabolicfamily/mcp 0.1.0

package/dist/parabolic.js

@@ -0,0 +1,710 @@
+import { randomBytes } from "node:crypto";
+import { encodeFunctionData, toHex } from "viem";
+import { curveAbi, factoryAbi, tokenAbi } from "./abi.js";
+import { mapLimit, viemRpc } from "./chain.js";
+import { isNative, progressPct, sortCoins, summaryFromGql } from "./coins.js";
+import { NATIVE_QUOTE, chainName, explorerUrl } from "./config.js";
+import { applySlippage, graduationMarketCap, graduationSplit, marketCap, passesPriceBound, poolIdOf, priceImpact, quoteBuy, quoteSell, reservedTokensFor, spotPrice, toNumber } from "./curve.js";
+import { docsText } from "./docs.js";
+import { addrOf, amount, big, bool, num, parseAddress, parseAmount, str } from "./format.js";
+import { Subgraph } from "./subgraph.js";
+import { encodeApprove, encodeBuy, encodeLaunch, encodeLaunchAndBuy, encodeMemoBuy, encodeSell } from "./tx.js";
+export const PHASES = ["NotGraduated", "Swept", "PoolCreated", "Rescued"];
+export const DEFAULT_SLIPPAGE_BPS = 100;
+export const DEV_BUY_SLIPPAGE_BPS = 200n;
+/** ParabolicLaunchDeployer metadata caps, in bytes. */
+export const METADATA_LIMITS = { name: 64, symbol: 16, logo: 512, description: 2048, social: 256 };
+/** Newest launches the TokenLaunched log scan considers when no subgraph is configured. */
+export const CHAIN_LIST_MAX = 50;
+const LAUNCHED_FIELDS = ["token", "curve", "deployer", "creatorFeeRecipient", "pairToken", "graduationThreshold", "poolFee", "tickSpacing", "creatorTaxBps", "buybackEnabled", "phase", "sweptQuote", "sweptTokens", "sweptAt", "exists"];
+const CONFIG_FIELDS = ["supply", "curveFeeBps", "phantomQuote", "graduationThreshold", "poolFee", "tickSpacing", "enabled"];
+/** viem returns a tuple whose components are all named as an object; accept a positional array as well. */
+function asStruct(raw, fields) {
+    if (Array.isArray(raw))
+        return Object.fromEntries(fields.map((f, i) => [f, raw[i]]));
+    if (raw && typeof raw === "object")
+        return raw;
+    throw new Error("Unexpected struct encoding from the RPC");
+}
+const slippageOf = (bps) => {
+    const v = bps ?? DEFAULT_SLIPPAGE_BPS;
+    if (!Number.isInteger(v) || v < 0 || v >= 10_000)
+        throw new Error("slippageBps must be an integer between 0 and 9999");
+    return BigInt(v);
+};
+const bytesOf = (s) => new TextEncoder().encode(s).length;
+/**
+ * Read-only view of Parabolic plus unsigned-transaction builders. Holds no keys; every method either reads
+ * (RPC and/or subgraph) or encodes calldata for the caller's wallet to sign.
+ */
+export class Parabolic {
+    config;
+    rpc;
+    subgraph;
+    hookPromise;
+    constructor(config, deps = {}) {
+        this.config = config;
+        this.rpc = deps.rpc ?? viemRpc(config.rpcUrl, config.chainId);
+        this.subgraph = config.subgraphUrl ? new Subgraph(config.subgraphUrl, deps.fetch) : undefined;
+    }
+    // ---- reads --------------------------------------------------------------------------------------------------
+    read(address, abi, functionName, args) {
+        return this.rpc.read({ address, abi, functionName, args });
+    }
+    async readMany(address, abi, names) {
+        const values = await Promise.all(names.map((n) => this.read(address, abi, n)));
+        return Object.fromEntries(names.map((n, i) => [n, values[i]]));
+    }
+    requireFactory() {
+        if (!this.config.factory)
+            throw new Error("PARABOLIC_FACTORY is not set: needed for this operation");
+        return this.config.factory;
+    }
+    hookAddress() {
+        if (this.config.hook)
+            return Promise.resolve(this.config.hook);
+        if (!this.config.factory)
+            return Promise.resolve(undefined);
+        this.hookPromise ??= this.read(this.config.factory, factoryAbi, "memeHook").then((v) => {
+            const a = addrOf(v);
+            return a === NATIVE_QUOTE ? undefined : a;
+        }, () => undefined);
+        return this.hookPromise;
+    }
+    async launchFromFactory(factory, token) {
+        const s = asStruct(await this.read(factory, factoryAbi, "getLaunchedToken", [token]), LAUNCHED_FIELDS);
+        if (!s.exists)
+            return undefined;
+        return {
+            token: addrOf(s.token), curve: addrOf(s.curve), deployer: addrOf(s.deployer), creatorFeeRecipient: addrOf(s.creatorFeeRecipient), pairToken: addrOf(s.pairToken),
+            graduationThreshold: big(s.graduationThreshold), poolFee: num(s.poolFee), tickSpacing: num(s.tickSpacing), creatorTaxBps: num(s.creatorTaxBps),
+            buybackEnabled: bool(s.buybackEnabled), phase: num(s.phase), source: "factory",
+        };
+    }
+    launchFromGql(g) {
+        return { token: addrOf(g.id), curve: addrOf(g.curve), deployer: addrOf(g.deployer), pairToken: addrOf(g.pairToken), graduationThreshold: BigInt(g.graduationThreshold), phase: g.status === "CLIMBING" ? 0 : g.status === "SWEPT" ? 1 : g.status === "RESCUED" ? 3 : 2, source: "subgraph" };
+    }
+    /** Finds a launch by token address (or curve address) through the factory, falling back to the subgraph. */
+    async resolveLaunch(input) {
+        const address = parseAddress(input, "address");
+        if (this.config.factory) {
+            const direct = await this.launchFromFactory(this.config.factory, address);
+            if (direct)
+                return direct;
+            const token = await this.read(address, curveAbi, "token").then((v) => (addrOf(v) === NATIVE_QUOTE ? undefined : addrOf(v)), () => undefined);
+            if (token) {
+                const viaCurve = await this.launchFromFactory(this.config.factory, token);
+                if (viaCurve)
+                    return viaCurve;
+            }
+        }
+        if (this.subgraph) {
+            const g = (await this.subgraph.coin(address)) ?? (await this.subgraph.coinByCurve(address));
+            if (g)
+                return this.launchFromGql(g);
+        }
+        const hint = this.config.factory || this.subgraph ? "" : " (set PARABOLIC_FACTORY and/or PARABOLIC_SUBGRAPH_URL)";
+        throw new Error(`No Parabolic coin at ${address} on ${chainName(this.config.chainId)}${hint}`);
+    }
+    async liveTerms(curve) {
+        const c = await this.readMany(curve, curveAbi, ["getReserves", "feeBps", "creatorTaxBps", "currentSnipeTaxBps", "sellableTokens", "graduated", "isNativeQuote", "readyToGraduate"]);
+        const reserves = c.getReserves;
+        const native = bool(c.isNativeQuote);
+        return {
+            quoteReserve: big(reserves[0]), tokenReserve: big(reserves[1]), feeBps: big(c.feeBps), creatorTaxBps: big(c.creatorTaxBps), snipeBps: big(c.currentSnipeTaxBps),
+            sellableTokens: big(c.sellableTokens), graduated: bool(c.graduated), readyToGraduate: bool(c.readyToGraduate), native, quoteDecimals: native ? 18 : 6,
+        };
+    }
+    assertOpen(t, side) {
+        if (t.graduated)
+            throw new Error("This coin has graduated: the curve is closed, trade it on its Uniswap v4 pool");
+        if (side === "sell" && t.readyToGraduate)
+            throw new Error("The curve is ready to graduate and no longer accepts sells; anyone can call factory.graduate(token), then trade on Uniswap v4");
+        if (side === "buy" && t.sellableTokens <= 0n)
+            throw new Error("The curve's sellable allocation is exhausted; it is waiting for factory.graduate(token)");
+    }
+    // ---- listing ------------------------------------------------------------------------------------------------
+    async listCoins(input = {}) {
+        const sort = input.sort ?? "trending";
+        const limit = Math.min(100, Math.max(1, Math.floor(input.limit ?? 20)));
+        let coins;
+        let source;
+        if (this.subgraph) {
+            const where = input.status === "climbing" ? { status: "CLIMBING" } : input.status === "graduated" ? { status_not: "CLIMBING" } : undefined;
+            coins = (await this.subgraph.coins(where, 200)).map((g) => summaryFromGql(g));
+            source = "subgraph";
+        }
+        else if (this.config.factory) {
+            coins = await this.chainCoins(this.config.factory);
+            source = `factory TokenLaunched log scan of recent blocks (newest ${CHAIN_LIST_MAX} launches at most; public Arc RPCs cap the range, so older coins are not in this list. Set PARABOLIC_SUBGRAPH_URL for the full list with holders and volume, or read https://www.parabolic.family/api/v1/coins)`;
+        }
+        else {
+            throw new Error("Listing coins needs PARABOLIC_SUBGRAPH_URL (recommended) or PARABOLIC_FACTORY (TokenLaunched log-scan fallback): the factory ABI exposes getLaunchedToken(address) but no enumeration function");
+        }
+        if (input.status)
+            coins = coins.filter((c) => c.status === input.status);
+        const sorted = sortCoins(coins, sort).slice(0, limit);
+        return { source, sort, status: input.status ?? "all", count: sorted.length, coins: sorted };
+    }
+    /**
+     * Newest TokenLaunched logs, walked backwards from head in bounded windows.
+     *
+     * A single scan from the deployment block is refused by every public Arc RPC: they cap eth_getLogs
+     * at about 10,000 blocks and answer `requested range too large`, so the old unbounded scan made
+     * list_coins fail outright on a default install. Walking back a window at a time returns the newest
+     * launches, which is what this listing promises, and stops as soon as it has enough. A rate-limited
+     * or refused window ends the walk with what has been collected rather than failing the call.
+     *
+     * This covers recent history only. PARABOLIC_SUBGRAPH_URL is the full list, and carries holders and
+     * volume with it.
+     */
+    async recentLaunchLogs(factory) {
+        const WINDOW = 9000n;
+        const MAX_WINDOWS = 20;
+        const floor = this.config.factoryStartBlock;
+        const collected = [];
+        let to;
+        try {
+            to = await this.rpc.blockNumber();
+        }
+        catch {
+            // No block number, no windowing: fall back to one scan from the configured floor.
+            return this.rpc.logs({ address: factory, abi: factoryAbi, eventName: "TokenLaunched", fromBlock: floor });
+        }
+        for (let i = 0; i < MAX_WINDOWS && to >= floor; i++) {
+            const from = to - WINDOW + 1n > floor ? to - WINDOW + 1n : floor;
+            try {
+                const batch = await this.rpc.logs({ address: factory, abi: factoryAbi, eventName: "TokenLaunched", fromBlock: from, toBlock: to });
+                collected.unshift(...batch);
+            }
+            catch {
+                break;
+            }
+            if (collected.length >= CHAIN_LIST_MAX || from === floor)
+                break;
+            to = from - 1n;
+        }
+        return collected;
+    }
+    async chainCoins(factory) {
+        const logs = await this.recentLaunchLogs(factory);
+        const newest = logs.slice(-CHAIN_LIST_MAX).reverse();
+        return mapLimit(newest, 8, async (log) => {
+            const a = log.args;
+            const token = addrOf(a.token);
+            const curve = addrOf(a.curve);
+            const pairToken = addrOf(a.pairToken);
+            const threshold = big(a.graduationThreshold);
+            const [tk, c] = await Promise.all([
+                this.readMany(token, tokenAbi, ["name", "symbol", "totalSupply"]),
+                this.readMany(curve, curveAbi, ["getReserves", "realQuoteReserve", "graduated", "launchedAt", "phantomQuote", "reservedTokens"]),
+            ]);
+            const native = isNative(pairToken);
+            const qd = native ? 18 : 6;
+            const reserves = c.getReserves;
+            const qR = big(reserves[0]);
+            const tR = big(reserves[1]);
+            const supply = big(tk.totalSupply);
+            const graduated = bool(c.graduated);
+            const real = big(c.realQuoteReserve);
+            const mcap = graduated ? graduationMarketCap(big(c.phantomQuote), threshold, big(c.reservedTokens), supply, qd) : marketCap(qR, tR, supply, qd);
+            const raised = graduated ? threshold : real;
+            return {
+                address: token, curve, name: str(tk.name), ticker: str(tk.symbol), creator: addrOf(a.deployer), pair: native ? "USDC" : "EURC", pairToken, quoteDecimals: qd,
+                status: graduated ? "graduated" : "climbing", raised: amount(raised, qd).amount, raisedRaw: raised, threshold: amount(threshold, qd).amount, thresholdRaw: threshold,
+                progressPct: graduated ? 100 : progressPct(real, threshold), price: graduated ? (supply > 0n ? mcap / toNumber(supply) : 0) : spotPrice(qR, tR, qd), marketCap: mcap,
+                createdAt: num(c.launchedAt), launchConfigId: num(a.launchConfigId), source: "chain",
+            };
+        });
+    }
+    // ---- coin detail --------------------------------------------------------------------------------------------
+    async getCoin(address) {
+        const launch = await this.resolveLaunch(address);
+        const [chain, gql] = await Promise.all([this.chainDetail(launch), this.subgraph ? this.subgraph.coin(launch.token).catch(() => null) : Promise.resolve(null)]);
+        const indexed = gql ? summaryFromGql(gql) : undefined;
+        return {
+            ...chain,
+            holders: indexed?.holders ?? null,
+            volume24h: indexed?.volume24h ?? null,
+            change24h: indexed?.change24h ?? null,
+            tradeCount: indexed?.tradeCount ?? null,
+            lastTradeAt: indexed?.lastTradeAt ?? null,
+            pool: { ...chain.pool, poolId: chain.pool.poolId ?? indexed?.poolId ?? null, positionId: gql?.positionId ?? null },
+            logo: chain.logo || indexed?.logo || "",
+            description: chain.description || indexed?.description || "",
+            indexed: gql ? { status: gql.status, graduatedAt: indexed?.graduatedAt ?? null, volumeQuote: amount(BigInt(gql.volumeQuote), chain.quoteDecimals), buyCount: Number(gql.buyCount), sellCount: Number(gql.sellCount) } : null,
+            sources: { chain: chain.source, subgraph: gql ? "coin entity" : this.subgraph ? "not indexed yet" : "not configured" },
+        };
+    }
+    async chainDetail(l) {
+        const [tk, c, hook] = await Promise.all([
+            this.readMany(l.token, tokenAbi, ["name", "symbol", "totalSupply", "getTokenInfo"]),
+            this.readMany(l.curve, curveAbi, ["getReserves", "realQuoteReserve", "graduated", "readyToGraduate", "launchedAt", "currentSnipeTaxBps", "snipeTaxStartBps", "snipeTaxSeconds", "feeBps", "creatorTaxBps", "phantomQuote", "reservedTokens", "sellableTokens", "protocolFeeShareBps", "buybackBurnBps", "isNativeQuote"]),
+            this.hookAddress(),
+        ]);
+        const native = bool(c.isNativeQuote);
+        const qd = native ? 18 : 6;
+        const reserves = c.getReserves;
+        const qR = big(reserves[0]);
+        const tR = big(reserves[1]);
+        const supply = big(tk.totalSupply);
+        const info = (Array.isArray(tk.getTokenInfo) ? tk.getTokenInfo : []);
+        const socials = (info[3] ?? {});
+        const graduated = bool(c.graduated) || (l.phase ?? 0) > 0;
+        const threshold = l.graduationThreshold;
+        const phantom = big(c.phantomQuote);
+        const reserved = big(c.reservedTokens);
+        const real = big(c.realQuoteReserve);
+        const raised = graduated ? threshold : real;
+        const mcap = graduated ? graduationMarketCap(phantom, threshold, reserved, supply, qd) : marketCap(qR, tR, supply, qd);
+        const launchedAt = num(c.launchedAt);
+        const windowSeconds = num(c.snipeTaxSeconds);
+        const now = Math.floor(Date.now() / 1000);
+        const currentSnipeBps = num(c.currentSnipeTaxBps);
+        const protocolShareBps = num(c.protocolFeeShareBps);
+        const buybackBurnBps = num(c.buybackBurnBps);
+        const buybackOfFeeBps = Math.round(((10_000 - protocolShareBps) * buybackBurnBps) / 10_000);
+        const poolId = l.poolFee !== undefined && l.tickSpacing !== undefined && hook ? poolIdOf(l.token, l.pairToken, l.poolFee, l.tickSpacing, hook) : undefined;
+        const chainId = this.config.chainId;
+        return {
+            address: l.token,
+            curve: l.curve,
+            name: str(tk.name),
+            ticker: str(tk.symbol),
+            creator: l.deployer,
+            creatorFeeRecipient: l.creatorFeeRecipient ?? null,
+            pair: native ? "USDC" : "EURC",
+            pairToken: l.pairToken,
+            quoteDecimals: qd,
+            status: graduated ? "graduated" : "climbing",
+            phase: PHASES[l.phase ?? (graduated ? 1 : 0)] ?? "Unknown",
+            readyToGraduate: bool(c.readyToGraduate),
+            raised: amount(raised, qd),
+            threshold: amount(threshold, qd),
+            progressPct: graduated ? 100 : progressPct(real, threshold),
+            price: graduated ? (supply > 0n ? mcap / toNumber(supply) : 0) : spotPrice(qR, tR, qd),
+            marketCap: mcap,
+            marketCapSource: graduated ? "pool seeding price: (phantomQuote + graduationThreshold) / reservedTokens" : "curve reserves",
+            supply: amount(supply, 18),
+            reserves: { quote: amount(qR, qd), tokens: amount(tR, 18), realQuote: amount(real, qd), phantomQuote: amount(phantom, qd), reservedTokens: amount(reserved, 18), sellableTokens: amount(big(c.sellableTokens), 18) },
+            fees: {
+                feeBps: num(c.feeBps),
+                creatorTaxBps: num(c.creatorTaxBps),
+                split: { protocolBps: protocolShareBps, buybackBps: buybackOfFeeBps, creatorBps: 10_000 - protocolShareBps - buybackOfFeeBps, note: "shares of the base fee (and of snipe-tax revenue); the creator tax goes entirely to the creator" },
+                policy: { protocolFeeShareBps: protocolShareBps, buybackBurnBps },
+            },
+            snipeTax: {
+                currentBps: currentSnipeBps,
+                startBps: num(c.snipeTaxStartBps),
+                windowSeconds,
+                launchedAt,
+                windowEndsAt: launchedAt + windowSeconds,
+                windowOpen: currentSnipeBps > 0,
+                secondsRemaining: Math.max(0, launchedAt + windowSeconds - now),
+                exempt: "the creator only, for the buy in their own launch; there is no other exemption pathway. Check curve.snipeTaxExempt(address) or pass `buyer` to quote_buy",
+            },
+            pool: { poolId: poolId ?? null, poolFee: l.poolFee ?? null, tickSpacing: l.tickSpacing ?? null, hook: hook ?? null },
+            createdAt: launchedAt || null,
+            logo: str(info[1]),
+            description: str(info[2]),
+            socials: { twitter: str(socials.twitter), telegram: str(socials.telegram), discord: str(socials.discord), website: str(socials.website), farcaster: str(socials.farcaster) },
+            links: { app: `https://parabolic.family/coin/${l.token}`, token: explorerUrl(chainId, "address", l.token) ?? null, curve: explorerUrl(chainId, "address", l.curve) ?? null, creator: explorerUrl(chainId, "address", l.deployer) ?? null },
+            source: l.source === "factory" ? "factory.getLaunchedToken + curve + token reads" : "subgraph lookup + curve + token reads",
+        };
+    }
+    // ---- quotes -------------------------------------------------------------------------------------------------
+    async buyerSnipeBps(curve, t, buyer) {
+        if (buyer === undefined)
+            return { snipeBps: t.snipeBps, exempt: false };
+        const exempt = bool(await this.read(curve, curveAbi, "snipeTaxExempt", [parseAddress(buyer, "buyer")]));
+        return { snipeBps: exempt ? 0n : t.snipeBps, exempt };
+    }
+    async quoteBuy(input) {
+        const launch = await this.resolveLaunch(input.address);
+        const t = await this.liveTerms(launch.curve);
+        this.assertOpen(t, "buy");
+        const qd = t.quoteDecimals;
+        const quoteIn = parseAmount(input.quoteIn, qd, "quoteIn");
+        const { snipeBps, exempt } = await this.buyerSnipeBps(launch.curve, t, input.buyer);
+        const q = quoteBuy(quoteIn, { ...t, snipeBps });
+        const slippage = slippageOf(input.slippageBps);
+        const minTokensOut = applySlippage(q.tokensOut, slippage);
+        return {
+            side: "buy",
+            coin: launch.token,
+            curve: launch.curve,
+            pair: t.native ? "USDC" : "EURC",
+            quoteIn: amount(quoteIn, qd),
+            tokensOut: amount(q.tokensOut, 18),
+            minTokensOut: { ...amount(minTokensOut, 18), slippageBps: Number(slippage) },
+            spent: amount(q.spent, qd),
+            refund: amount(q.refund, qd),
+            fees: {
+                totalBps: Number(t.feeBps + t.creatorTaxBps + snipeBps),
+                fee: { bps: Number(t.feeBps), ...amount(q.fee, qd) },
+                creatorTax: { bps: Number(t.creatorTaxBps), ...amount(q.creatorTax, qd) },
+                snipeTax: { bps: Number(snipeBps), ...amount(q.snipeTax, qd), windowOpen: t.snipeBps > 0n, buyerExempt: exempt },
+                netToCurve: amount(q.netToCurve, qd),
+            },
+            spotPrice: spotPrice(t.quoteReserve, t.tokenReserve, qd),
+            effectivePrice: q.tokensOut > 0n ? toNumber(q.spent, qd) / toNumber(q.tokensOut) : 0,
+            priceImpactPct: priceImpact(q.spent, q.tokensOut, t.quoteReserve, t.tokenReserve),
+            graduatesCoin: q.crossing,
+            reserves: { quote: amount(t.quoteReserve, qd), tokens: amount(t.tokenReserve, 18), sellableTokens: amount(t.sellableTokens, 18) },
+            notes: [
+                ...(q.crossing ? ["This buy takes the curve's last sellable tokens: it fills to the threshold, refunds the rest, and graduates the coin in the same transaction. Send extra gas (the web adds 300,000 plus 25% headroom)."] : []),
+                ...(t.snipeBps > 0n && !exempt ? ["The launch snipe-tax window is open; the tax decays every second, so a quote taken now overstates the tax a later block charges."] : []),
+                "minTokensOut is enforced as a price bound: spent × minTokensOut ≤ received × tokensOut.",
+            ],
+        };
+    }
+    async quoteSell(input) {
+        const launch = await this.resolveLaunch(input.address);
+        const t = await this.liveTerms(launch.curve);
+        this.assertOpen(t, "sell");
+        const qd = t.quoteDecimals;
+        const tokensIn = parseAmount(input.tokensIn, 18, "tokensIn");
+        const q = quoteSell(tokensIn, t);
+        const slippage = slippageOf(input.slippageBps);
+        const minQuoteOut = applySlippage(q.quoteOut, slippage);
+        return {
+            side: "sell",
+            coin: launch.token,
+            curve: launch.curve,
+            pair: t.native ? "USDC" : "EURC",
+            tokensIn: amount(tokensIn, 18),
+            quoteOut: amount(q.quoteOut, qd),
+            minQuoteOut: { ...amount(minQuoteOut, qd), slippageBps: Number(slippage) },
+            fees: {
+                totalBps: Number(t.feeBps + t.creatorTaxBps),
+                fee: { bps: Number(t.feeBps), ...amount(q.fee, qd) },
+                creatorTax: { bps: Number(t.creatorTaxBps), ...amount(q.creatorTax, qd) },
+                gross: amount(q.gross, qd),
+                snipeTax: { bps: 0, note: "sells carry no snipe tax" },
+            },
+            spotPrice: spotPrice(t.quoteReserve, t.tokenReserve, qd),
+            effectivePrice: tokensIn > 0n ? toNumber(q.quoteOut, qd) / toNumber(tokensIn) : 0,
+            priceImpactPct: priceImpact(tokensIn, q.quoteOut, t.tokenReserve, t.quoteReserve),
+            reserves: { quote: amount(t.quoteReserve, qd), tokens: amount(t.tokenReserve, 18) },
+            notes: ["The curve pulls the tokens with transferFrom: approve the curve for tokensIn first (build_sell_tx returns the approval)."],
+        };
+    }
+    // ---- unsigned transactions ----------------------------------------------------------------------------------
+    async buildBuyTx(input) {
+        const launch = await this.resolveLaunch(input.address);
+        const t = await this.liveTerms(launch.curve);
+        this.assertOpen(t, "buy");
+        const qd = t.quoteDecimals;
+        const chainId = this.config.chainId;
+        const quoteIn = parseAmount(input.quoteIn, qd, "quoteIn");
+        const recipient = parseAddress(input.recipient, "recipient");
+        const { snipeBps, exempt } = await this.buyerSnipeBps(launch.curve, t, input.buyer);
+        const q = quoteBuy(quoteIn, { ...t, snipeBps });
+        const slippage = slippageOf(input.slippageBps);
+        const minTokensOut = input.minTokensOut !== undefined ? parseAmount(input.minTokensOut, 18, "minTokensOut") : applySlippage(q.tokensOut, slippage);
+        const warnings = [];
+        if (!passesPriceBound(quoteIn, q, minTokensOut))
+            warnings.push("minTokensOut is above the current quote: the transaction would revert with SlippageExceeded unless the price improves before it lands");
+        if (t.snipeBps > 0n && !exempt)
+            warnings.push(`The snipe-tax window is open (${t.snipeBps} bps now, decaying to 0 at the end of the window); consider waiting or expect fewer tokens`);
+        const quote = {
+            quoteIn: amount(quoteIn, qd), expectedTokensOut: amount(q.tokensOut, 18), minTokensOut: amount(minTokensOut, 18), slippageBps: input.minTokensOut !== undefined ? null : Number(slippage),
+            fees: { feeBps: Number(t.feeBps), creatorTaxBps: Number(t.creatorTaxBps), snipeTaxBps: Number(snipeBps), buyerExempt: exempt }, priceImpactPct: priceImpact(q.spent, q.tokensOut, t.quoteReserve, t.tokenReserve), graduatesCoin: q.crossing, refund: amount(q.refund, qd),
+        };
+        const gas = { note: q.crossing ? "estimate, add 300,000 for the graduation the buy triggers, then multiply by 1.25 (web/lib/gas.ts)" : "estimate then multiply by 1.25: the snipe tax is priced per block, so a buy quoted in one block runs a slightly different path in the next (web/lib/gas.ts)" };
+        if (input.memo) {
+            if (!this.config.memoRouter)
+                throw new Error("Memo-routed buys need PARABOLIC_MEMO_ROUTER");
+            if (!t.native)
+                throw new Error("Memo-routed buys are only available for native-USDC curves");
+            const m = encodeMemoBuy({ arcMemo: this.config.arcMemo, router: this.config.memoRouter, curve: launch.curve, quoteIn, minTokensOut, recipient, referral: input.memo.referral, note: input.memo.note, chainId });
+            return {
+                kind: "memo_buy",
+                coin: launch.token, curve: launch.curve,
+                eoaOnly: true,
+                steps: ["1. approval (skip if the router's allowance on the USDC ERC-20 view already covers usdcUnits)", "2. tx"],
+                approval: m.approval,
+                tx: m.tx,
+                usdcUnits: m.usdcUnits,
+                memo: { id: m.memoId, payload: m.payload, referral: input.memo.referral ?? null, note: input.memo.note ?? "" },
+                quote, gas, warnings,
+                notes: ["Arc's Memo contract only accepts calls from an EOA (its caller must be tx.origin) and forwards no value, so the router pulls whole 6-decimal USDC units through the ERC-20 view. Smart-account wallets must use the direct curve buy instead (omit `memo`)."],
+            };
+        }
+        const tx = encodeBuy(launch.curve, quoteIn, minTokensOut, recipient, t.native, chainId);
+        const approval = t.native ? null : encodeApprove(launch.pairToken, launch.curve, quoteIn, chainId, "pair token");
+        return {
+            kind: "buy",
+            coin: launch.token, curve: launch.curve,
+            steps: t.native ? ["1. tx (quote rides as msg.value)"] : ["1. approval (skip if the curve's allowance already covers quoteIn)", "2. tx"],
+            approval,
+            tx,
+            quote, gas, warnings,
+            notes: [
+                "Unsigned. Sign and send from the wallet that owns the funds; recipient receives the tokens.",
+                "A memo-routed variant (ParabolicMemoRouter through Arc's Memo contract, carrying a referral code) exists: pass `memo: { referral }`. It is EOA-only.",
+            ],
+        };
+    }
+    async buildSellTx(input) {
+        const launch = await this.resolveLaunch(input.address);
+        const t = await this.liveTerms(launch.curve);
+        this.assertOpen(t, "sell");
+        const qd = t.quoteDecimals;
+        const chainId = this.config.chainId;
+        const tokensIn = parseAmount(input.tokensIn, 18, "tokensIn");
+        const recipient = parseAddress(input.recipient, "recipient");
+        const q = quoteSell(tokensIn, t);
+        const slippage = slippageOf(input.slippageBps);
+        const minQuoteOut = input.minQuoteOut !== undefined ? parseAmount(input.minQuoteOut, qd, "minQuoteOut") : applySlippage(q.quoteOut, slippage);
+        const warnings = [];
+        if (minQuoteOut > q.quoteOut)
+            warnings.push("minQuoteOut is above the current quote: the transaction would revert with SlippageExceeded unless the price improves before it lands");
+        return {
+            kind: "sell",
+            coin: launch.token, curve: launch.curve,
+            steps: ["1. approval (skip if the curve's allowance already covers tokensIn)", "2. tx"],
+            approval: encodeApprove(launch.token, launch.curve, tokensIn, chainId, "coin"),
+            tx: encodeSell(launch.curve, tokensIn, minQuoteOut, recipient, chainId),
+            quote: { tokensIn: amount(tokensIn, 18), expectedQuoteOut: amount(q.quoteOut, qd), minQuoteOut: amount(minQuoteOut, qd), slippageBps: input.minQuoteOut !== undefined ? null : Number(slippage), fees: { feeBps: Number(t.feeBps), creatorTaxBps: Number(t.creatorTaxBps) }, priceImpactPct: priceImpact(tokensIn, q.quoteOut, t.tokenReserve, t.quoteReserve) },
+            warnings,
+            notes: ["Unsigned. The seller signs both; the curve pays the quote to recipient.", "Sells close once the curve is ready to graduate; after graduation sell on the Uniswap v4 pool."],
+        };
+    }
+    async buildLaunchTx(input) {
+        const factory = this.requireFactory();
+        const chainId = this.config.chainId;
+        const creator = parseAddress(input.creator, "creator");
+        const pair = input.pair ?? "USDC";
+        let pairToken = NATIVE_QUOTE;
+        if (pair === "EURC") {
+            if (!this.config.eurc)
+                throw new Error("EURC launches need PARABOLIC_EURC");
+            pairToken = this.config.eurc;
+        }
+        const name = input.name.trim();
+        const symbol = input.ticker.trim();
+        const logo = (input.image ?? "").trim();
+        const description = (input.description ?? "").trim();
+        if (name.length === 0 || bytesOf(name) > METADATA_LIMITS.name)
+            throw new Error(`name must be 1–${METADATA_LIMITS.name} bytes`);
+        if (!/^[A-Za-z0-9]{1,16}$/.test(symbol))
+            throw new Error(`ticker must be 1–${METADATA_LIMITS.symbol} letters or digits (the app shows it upper-case)`);
+        if (bytesOf(logo) > METADATA_LIMITS.logo)
+            throw new Error(`image must be at most ${METADATA_LIMITS.logo} bytes (URL or ipfs:// pointer)`);
+        if (bytesOf(description) > METADATA_LIMITS.description)
+            throw new Error(`description must be at most ${METADATA_LIMITS.description} bytes`);
+        const socials = { twitter: "", telegram: "", discord: "", website: "", farcaster: "" };
+        for (const k of Object.keys(socials)) {
+            const v = (input.socials?.[k] ?? "").trim();
+            if (bytesOf(v) > METADATA_LIMITS.social)
+                throw new Error(`socials.${k} must be at most ${METADATA_LIMITS.social} bytes`);
+            socials[k] = v;
+        }
+        const creatorTaxBps = input.creatorTaxBps ?? 0;
+        if (!Number.isInteger(creatorTaxBps) || creatorTaxBps < 0)
+            throw new Error("creatorTaxBps must be a non-negative integer (100 = 1%)");
+        const configId = this.config.launchConfigId;
+        const [f, economics, canLaunch, cfgRaw, pairEconRaw, pairApproved] = await Promise.all([
+            this.readMany(factory, factoryAbi, ["launchFee", "launchEnabled", "maxCreatorTaxBps", "snipeTaxStartBps", "snipeTaxSeconds", "launchForwarder"]),
+            this.read(factory, factoryAbi, "previewLaunchEconomics", [configId, pairToken]),
+            this.read(factory, factoryAbi, "canLaunch", [creator]),
+            this.read(factory, factoryAbi, "getLaunchConfig", [configId]),
+            pair === "EURC" ? this.read(factory, factoryAbi, "pairTokenEconomics", [pairToken]) : Promise.resolve(undefined),
+            pair === "EURC" ? this.read(factory, factoryAbi, "approvedPairTokens", [pairToken]) : Promise.resolve(true),
+        ]);
+        const cfg = asStruct(cfgRaw, CONFIG_FIELDS);
+        const maxTax = num(f.maxCreatorTaxBps);
+        if (creatorTaxBps > maxTax)
+            throw new Error(`creatorTaxBps ${creatorTaxBps} exceeds the factory's maxCreatorTaxBps (${maxTax})`);
+        const launchFee = big(f.launchFee);
+        const warnings = [];
+        if (!bool(f.launchEnabled))
+            warnings.push("launchEnabled() is false on the factory: the transaction would revert until launching is re-enabled");
+        if (!bool(canLaunch))
+            warnings.push("canLaunch(creator) is false: the launcher allowlist is on and this wallet is not on it (NotWhitelisted)");
+        if (!bool(cfg.enabled))
+            warnings.push(`launch config ${configId} is disabled (LaunchConfigDisabled)`);
+        if (!bool(pairApproved))
+            warnings.push("the EURC pair token is not approved on the factory (PairTokenNotApproved)");
+        // Pair-specific economics override the config's phantom / threshold for ERC-20 pairs.
+        const pairEcon = Array.isArray(pairEconRaw) ? pairEconRaw : undefined;
+        const qd = pair === "USDC" ? 18 : 6;
+        const phantom = pairEcon && big(pairEcon[0]) > 0n ? big(pairEcon[0]) : big(cfg.phantomQuote);
+        const threshold = pairEcon && big(pairEcon[1]) > 0n ? big(pairEcon[1]) : big(cfg.graduationThreshold);
+        const supply = big(cfg.supply);
+        const reserved = reservedTokensFor(supply, phantom, threshold);
+        const salt = toHex(randomBytes(32));
+        const expectedEconomics = (typeof economics === "string" ? economics : "0x");
+        const router = this.config.memoRouter;
+        const devIn = input.devBuy !== undefined ? parseAmount(input.devBuy, qd, "devBuy") : undefined;
+        // Fair launch: with the router configured, the opening buy rides inside the launch transaction.
+        const atomic = devIn !== undefined && router !== undefined;
+        const forwarder = addrOf(f.launchForwarder);
+        if (atomic && forwarder !== router)
+            warnings.push(`factory.launchForwarder() is ${forwarder}, not PARABOLIC_MEMO_ROUTER ${router}: the router's launch would revert (NotLaunchForwarder)`);
+        // A routed launch must leave creatorFeeRecipient zero (the factory then uses the creator) or equal to the signer.
+        const params = { name, symbol, logo, description, socials, creatorFeeRecipient: atomic ? NATIVE_QUOTE : creator, creatorTaxBps, buybackEnabled: input.buybackEnabled ?? true, expectedEconomics, salt };
+        // The opening buy is quoted on the fresh curve; the creator is snipe-tax exempt, so it carries no snipe leg.
+        const devTerms = { quoteReserve: phantom, tokenReserve: supply, feeBps: big(cfg.curveFeeBps), creatorTaxBps: BigInt(creatorTaxBps), snipeBps: 0n, sellableTokens: supply - reserved };
+        const devQuote = devIn !== undefined ? quoteBuy(devIn, devTerms) : undefined;
+        const devMin = devQuote ? applySlippage(devQuote.tokensOut, DEV_BUY_SLIPPAGE_BPS) : 0n;
+        const devSummary = devIn !== undefined && devQuote
+            ? { quoteIn: amount(devIn, qd), expectedTokensOut: amount(devQuote.tokensOut, 18), minTokensOut: { ...amount(devMin, 18), slippageBps: Number(DEV_BUY_SLIPPAGE_BPS) }, fees: { feeBps: Number(cfg.curveFeeBps), creatorTaxBps, snipeTaxBps: 0 }, graduatesCoin: devQuote.crossing, refund: amount(devQuote.refund, qd) }
+            : undefined;
+        const split = graduationSplit(reserved, phantom, threshold);
+        const pctOf = (v) => (supply > 0n ? Number((v * 1000000n) / supply) / 10_000 : 0);
+        const common = {
+            params,
+            launchConfigId: configId.toString(),
+            pair,
+            pairToken,
+            launchFee: amount(launchFee, 18),
+            terms: {
+                supply: amount(supply, 18),
+                curveFeeBps: Number(cfg.curveFeeBps),
+                creatorTaxBps,
+                phantomQuote: amount(phantom, qd),
+                graduationThreshold: amount(threshold, qd),
+                reservedTokens: { ...amount(reserved, 18), pct: pctOf(reserved) },
+                poolSeedTokens: { ...amount(split.poolSeed, 18), pct: pctOf(split.poolSeed) },
+                lockedTokens: { ...amount(split.locked, 18), pct: pctOf(split.locked) },
+                openingMarketCap: marketCap(phantom, supply, supply, qd),
+                graduationMarketCap: graduationMarketCap(phantom, threshold, reserved, supply, qd),
+                snipeTax: { startBps: num(f.snipeTaxStartBps), windowSeconds: num(f.snipeTaxSeconds) },
+                poolFee: num(cfg.poolFee),
+                tickSpacing: num(cfg.tickSpacing),
+            },
+            event: "TokenLaunched(address indexed token, address indexed curve, address indexed deployer, address pairToken, uint256 launchConfigId, uint256 graduationThreshold)",
+            warnings,
+        };
+        const economicsNote = "expectedEconomics pins the curve terms read now; if the factory's config changes before the transaction lands it reverts with LaunchEconomicsMismatch instead of launching on different terms.";
+        if (atomic && router !== undefined && devIn !== undefined && devSummary) {
+            const native = pair === "USDC";
+            const { tx, approval } = encodeLaunchAndBuy(router, params, configId, pairToken, devIn, devMin, launchFee, native, chainId);
+            return {
+                kind: "launch_and_buy",
+                tx,
+                approval,
+                steps: approval ? ["1. approval (the router pulls devBuy of the pair token once the launch has succeeded)", "2. tx (launch fee as value)"] : ["1. tx (launch fee + opening buy as value)"],
+                ...common,
+                snipeTaxExemptions: [],
+                devBuy: { atomic: true, ...devSummary },
+                events: ["RoutedLaunch(user, token, curve, launchConfigId, pairToken)", "RoutedBuy(user, curve, recipient, quoteSpent, tokensOut, refund)", common.event],
+                notes: [
+                    `Unsigned single transaction to ParabolicMemoRouter.${native ? "launchAndBuy" : "launchAndBuyWithToken"}: the launch and the creator's opening buy settle together, before anyone else can trade. Any wallet can call it directly (the memo-wrapped form is EOA-only and cannot carry value).`,
+                    "The router forwards the signer as deployer (factory.launchTokenFor) and places the buy through curve.buyFor(signer, …), so it is snipe-tax exempt; unspent quote (rounding, or a fill capped at graduation) is refunded to the signer. creatorFeeRecipient is left zero: the router rejects any value other than zero or the signer (FeeRecipientMustBeCreator), and the factory then uses the creator.",
+                    native ? "value must equal launchFee + devBuy exactly (ValueMismatch otherwise)." : "value must equal launchFee exactly; devBuy is pulled in the pair token after the approval.",
+                    economicsNote,
+                ],
+            };
+        }
+        const tx = encodeLaunch(factory, params, configId, pairToken, launchFee, chainId);
+        const devBuy = devIn !== undefined && devSummary
+            ? {
+                atomic: false,
+                how: "Second transaction from the creator wallet after the launch is mined: read `curve` from the TokenLaunched event (or parabolic.get_coin), then send this calldata to it. The deployer is snipe-tax exempt, so the quote carries no snipe tax. Set PARABOLIC_MEMO_ROUTER to get this as one launchAndBuy transaction instead.",
+                // Null, not prose: this object has the same shape as the unsigned transactions the other
+                // tools return, and an agent that sends to every `to` it sees must fail here rather than
+                // resolve a sentence into an address.
+                to: null,
+                toHint: "the curve address from the TokenLaunched event, or parabolic.get_coin on the new token",
+                data: encodeFunctionData({ abi: curveAbi, functionName: "buy", args: [devIn, devMin, creator] }),
+                value: pair === "USDC" ? toHex(devIn) : "0x0",
+                valueWei: pair === "USDC" ? devIn.toString() : "0",
+                chainId,
+                ...devSummary,
+                approvalNeeded: pair === "EURC" ? "approve the curve to spend devBuy EURC first" : null,
+            }
+            : null;
+        return {
+            kind: "launch",
+            tx,
+            steps: ["1. tx (launch fee rides as msg.value)", ...(devBuy ? ["2. devBuy after the receipt (see devBuy.how)"] : [])],
+            ...common,
+            devBuy,
+            notes: [
+                "Unsigned. The creator wallet signs; it becomes the deployer (snipe-tax exempt, creator-fee claimant through the fee escrow).",
+                economicsNote,
+                "ParabolicMemoRouter.launch / launchAndBuy exist for routed launches (the opening buy inside the launch transaction; a memo-wrapped call also carries a referral code but is EOA-only). Set PARABOLIC_MEMO_ROUTER and pass devBuy to get launchAndBuy.",
+            ],
+        };
+    }
+    // ---- protocol -----------------------------------------------------------------------------------------------
+    async protocolStats() {
+        const [indexed, factory] = await Promise.all([
+            this.subgraph ? this.subgraph.protocol().then(mapProtocol).catch((e) => ({ error: e instanceof Error ? e.message : String(e) })) : Promise.resolve(null),
+            this.config.factory ? this.factoryStats(this.config.factory).catch((e) => ({ error: e instanceof Error ? e.message : String(e) })) : Promise.resolve(null),
+        ]);
+        return {
+            chain: { id: this.config.chainId, name: chainName(this.config.chainId), rpc: this.config.rpcUrl },
+            indexed,
+            factory,
+            notes: [
+                ...(indexed ? [] : ["Set PARABOLIC_SUBGRAPH_URL for launches, graduations, volume and fees."]),
+                ...(factory ? [] : ["Set PARABOLIC_FACTORY for the live launch fee, curve preset and snipe-tax terms."]),
+            ],
+        };
+    }
+    async factoryStats(factory) {
+        const names = ["launchFee", "launchEnabled", "maxCreatorTaxBps", "snipeTaxStartBps", "snipeTaxSeconds", "launchConfigCount", "feeEscrow", "buybackVault", "locker", "memeHook", "poolManager", "positionManager", "launchDeployer", "graduationExecutor", "launchForwarder", "owner"];
+        const [f, cfgRaw] = await Promise.all([this.readMany(factory, factoryAbi, names), this.read(factory, factoryAbi, "getLaunchConfig", [this.config.launchConfigId])]);
+        const cfg = asStruct(cfgRaw, CONFIG_FIELDS);
+        const supply = big(cfg.supply);
+        const phantom = big(cfg.phantomQuote);
+        const threshold = big(cfg.graduationThreshold);
+        const reserved = reservedTokensFor(supply, phantom, threshold);
+        const split = graduationSplit(reserved, phantom, threshold);
+        const pctOf = (v) => (supply > 0n ? Number((v * 1000000n) / supply) / 10_000 : 0);
+        return {
+            address: factory,
+            launchFee: amount(big(f.launchFee), 18),
+            launchEnabled: bool(f.launchEnabled),
+            maxCreatorTaxBps: num(f.maxCreatorTaxBps),
+            snipeTax: { startBps: num(f.snipeTaxStartBps), windowSeconds: num(f.snipeTaxSeconds) },
+            launchConfigCount: num(f.launchConfigCount),
+            launchConfig: {
+                id: this.config.launchConfigId.toString(),
+                enabled: bool(cfg.enabled),
+                supply: amount(supply, 18),
+                curveFeeBps: num(cfg.curveFeeBps),
+                phantomQuote: amount(phantom, 18),
+                graduationThreshold: amount(threshold, 18),
+                reservedTokens: amount(reserved, 18),
+                reservedPct: pctOf(reserved),
+                poolSeedTokens: amount(split.poolSeed, 18),
+                poolSeedPct: pctOf(split.poolSeed),
+                lockedTokens: amount(split.locked, 18),
+                lockedPct: pctOf(split.locked),
+                openingMarketCap: marketCap(phantom, supply, supply, 18),
+                graduationMarketCap: graduationMarketCap(phantom, threshold, reserved, supply, 18),
+                poolFee: num(cfg.poolFee),
+                tickSpacing: num(cfg.tickSpacing),
+            },
+            contracts: { feeEscrow: addrOf(f.feeEscrow), buybackVault: addrOf(f.buybackVault), locker: addrOf(f.locker), hook: addrOf(f.memeHook), poolManager: addrOf(f.poolManager), positionManager: addrOf(f.positionManager), launchDeployer: addrOf(f.launchDeployer), graduationExecutor: addrOf(f.graduationExecutor), launchForwarder: addrOf(f.launchForwarder), owner: addrOf(f.owner) },
+        };
+    }
+    docs() {
+        return docsText(this.config);
+    }
+}
+function mapProtocol(d) {
+    const p = d.protocol;
+    const today = Math.floor(Date.now() / 1000 / 86_400);
+    const day = (x) => ({ day: x.day, date: new Date(x.day * 86_400_000).toISOString().slice(0, 10), coinsLaunched: Number(x.coinsLaunched), coinsGraduated: Number(x.coinsGraduated), tradeCount: Number(x.tradeCount), volume: amount(BigInt(x.volumeQuote), 18), fees: amount(BigInt(x.feesQuote), 18) });
+    const launched = p ? Number(p.coinsLaunched) : 0;
+    const graduated = p ? Number(p.coinsGraduated) : 0;
+    const todayStat = d.dailyStats.find((x) => x.day === today);
+    return {
+        coinsLaunched: launched,
+        coinsGraduated: graduated,
+        graduationRatePct: launched > 0 ? Math.round((graduated / launched) * 10_000) / 100 : 0,
+        tradeCount: p ? Number(p.tradeCount) : 0,
+        volume: p ? amount(BigInt(p.volumeQuote), 18) : amount(0n, 18),
+        fees: p ? amount(BigInt(p.feesQuote), 18) : amount(0n, 18),
+        today: todayStat ? day(todayStat) : null,
+        daily: d.dailyStats.map(day),
+        units: "native USDC, whole units; EURC-quoted volume is mixed in at its raw 6-decimal scale by the indexer",
+    };
+}
+//# sourceMappingURL=parabolic.js.map