@earnforge/cli 0.1.0

package/dist/esm/src-kbE_XVj7.mjs

@@ -0,0 +1,1170 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { MAX_UINT256, buildApprovalTx, checkAllowance, createEarnForge, parseTvl, riskScore } from "@earnforge/sdk";
+import Table from "cli-table3";
+//#region src/helpers.ts
+function fmtPct(n) {
+	return `${n.toFixed(2)}%`;
+}
+function fmtUsd(n) {
+	if (n >= 1e9) return `$${(n / 1e9).toFixed(2)}B`;
+	if (n >= 1e6) return `$${(n / 1e6).toFixed(2)}M`;
+	if (n >= 1e3) return `$${(n / 1e3).toFixed(2)}K`;
+	return `$${n.toFixed(2)}`;
+}
+function riskLabel(score) {
+	if (score >= 7) return chalk.green(`${score}/10 (low)`);
+	if (score >= 4) return chalk.yellow(`${score}/10 (medium)`);
+	return chalk.red(`${score}/10 (high)`);
+}
+function vaultTable(vaults) {
+	const table = new Table({
+		head: [
+			chalk.bold("Name"),
+			chalk.bold("Chain"),
+			chalk.bold("Protocol"),
+			chalk.bold("APY"),
+			chalk.bold("TVL"),
+			chalk.bold("Tags"),
+			chalk.bold("Slug")
+		],
+		colWidths: [
+			30,
+			8,
+			14,
+			10,
+			12,
+			16,
+			20
+		],
+		wordWrap: true
+	});
+	for (const v of vaults) {
+		const tvl = parseTvl(v.analytics.tvl);
+		table.push([
+			v.name,
+			String(v.chainId),
+			v.protocol.name,
+			chalk.green(fmtPct(v.analytics.apy.total)),
+			fmtUsd(tvl.parsed),
+			v.tags.join(", "),
+			v.slug
+		]);
+	}
+	return table.toString();
+}
+function vaultDetail(v) {
+	const tvl = parseTvl(v.analytics.tvl);
+	return [
+		chalk.bold.underline(v.name),
+		"",
+		`  ${chalk.dim("Slug:")}         ${v.slug}`,
+		`  ${chalk.dim("Chain:")}        ${v.chainId} (${v.network})`,
+		`  ${chalk.dim("Address:")}      ${v.address}`,
+		`  ${chalk.dim("Protocol:")}     ${v.protocol.name} (${v.protocol.url})`,
+		`  ${chalk.dim("Provider:")}     ${v.provider}`,
+		`  ${chalk.dim("Tags:")}         ${v.tags.join(", ") || "(none)"}`,
+		"",
+		chalk.bold("Analytics"),
+		`  ${chalk.dim("APY Total:")}    ${chalk.green(fmtPct(v.analytics.apy.total))}`,
+		`  ${chalk.dim("APY Base:")}     ${fmtPct(v.analytics.apy.base)}`,
+		`  ${chalk.dim("APY Reward:")}   ${fmtPct(v.analytics.apy.reward)}`,
+		`  ${chalk.dim("APY 1d:")}       ${v.analytics.apy1d !== null ? fmtPct(v.analytics.apy1d) : "N/A"}`,
+		`  ${chalk.dim("APY 7d:")}       ${v.analytics.apy7d !== null ? fmtPct(v.analytics.apy7d) : "N/A"}`,
+		`  ${chalk.dim("APY 30d:")}      ${v.analytics.apy30d !== null ? fmtPct(v.analytics.apy30d) : "N/A"}`,
+		`  ${chalk.dim("TVL:")}          ${fmtUsd(tvl.parsed)}`,
+		`  ${chalk.dim("Updated:")}      ${v.analytics.updatedAt}`,
+		"",
+		chalk.bold("Deposit & Redeem"),
+		`  ${chalk.dim("Transactional:")} ${v.isTransactional ? chalk.green("Yes") : chalk.red("No")}`,
+		`  ${chalk.dim("Redeemable:")}    ${v.isRedeemable ? chalk.green("Yes") : chalk.red("No")}`,
+		`  ${chalk.dim("Deposit Packs:")} ${v.depositPacks.map((p) => p.name).join(", ") || "(none)"}`,
+		`  ${chalk.dim("Redeem Packs:")}  ${v.redeemPacks.map((p) => p.name).join(", ") || "(none)"}`,
+		"",
+		chalk.bold("Underlying Tokens"),
+		...v.underlyingTokens.map((t) => `  ${t.symbol} (${t.address}) — ${t.decimals} decimals`),
+		...v.underlyingTokens.length === 0 ? ["  (none)"] : [],
+		"",
+		...v.description ? [
+			chalk.bold("Description"),
+			`  ${v.description}`,
+			""
+		] : []
+	].join("\n");
+}
+function chainTable(chains) {
+	const table = new Table({ head: [
+		chalk.bold("Chain ID"),
+		chalk.bold("Name"),
+		chalk.bold("CAIP")
+	] });
+	for (const c of chains) table.push([
+		String(c.chainId),
+		c.name,
+		c.networkCaip
+	]);
+	return table.toString();
+}
+function protocolTable(protocols) {
+	const table = new Table({ head: [chalk.bold("Name"), chalk.bold("URL")] });
+	for (const p of protocols) table.push([p.name, p.url]);
+	return table.toString();
+}
+function portfolioTable(positions) {
+	const table = new Table({ head: [
+		chalk.bold("Chain"),
+		chalk.bold("Protocol"),
+		chalk.bold("Asset"),
+		chalk.bold("Balance (Native)"),
+		chalk.bold("Balance (USD)")
+	] });
+	for (const p of positions) table.push([
+		String(p.chainId),
+		p.protocolName,
+		`${p.asset.symbol} (${p.asset.name})`,
+		p.balanceNative,
+		`$${Number(p.balanceUsd).toFixed(2)}`
+	]);
+	return table.toString();
+}
+function riskTable(risk) {
+	const table = new Table({ head: [chalk.bold("Dimension"), chalk.bold("Score")] });
+	table.push(["TVL Magnitude", `${risk.breakdown.tvl}/10`]);
+	table.push(["APY Stability", `${risk.breakdown.apyStability}/10`]);
+	table.push(["Protocol Maturity", `${risk.breakdown.protocol}/10`]);
+	table.push(["Redeemability", `${risk.breakdown.redeemability}/10`]);
+	table.push(["Asset Type", `${risk.breakdown.assetType}/10`]);
+	table.push([chalk.bold("Composite"), chalk.bold(riskLabel(risk.score))]);
+	return table.toString();
+}
+function suggestTable(allocations) {
+	const table = new Table({ head: [
+		chalk.bold("Vault"),
+		chalk.bold("Chain"),
+		chalk.bold("Protocol"),
+		chalk.bold("APY"),
+		chalk.bold("Risk"),
+		chalk.bold("Allocation"),
+		chalk.bold("Amount")
+	] });
+	for (const a of allocations) table.push([
+		a.vault.name,
+		String(a.vault.chainId),
+		a.vault.protocol.name,
+		chalk.green(fmtPct(a.apy)),
+		riskLabel(a.risk.score),
+		`${a.percentage.toFixed(1)}%`,
+		fmtUsd(a.amount)
+	]);
+	return table.toString();
+}
+function apyHistoryTable(history) {
+	const table = new Table({ head: [
+		chalk.bold("Date"),
+		chalk.bold("APY"),
+		chalk.bold("TVL")
+	] });
+	for (const d of history) {
+		const date = d.timestamp.split("T")[0] ?? d.timestamp;
+		table.push([
+			date,
+			fmtPct(d.apy),
+			fmtUsd(d.tvlUsd)
+		]);
+	}
+	return table.toString();
+}
+function preflightTable(report) {
+	const lines = [];
+	const status = report.ok ? chalk.green("PASS") : chalk.red("FAIL");
+	lines.push(chalk.bold(`Preflight — ${report.vault.name}  ${status}`));
+	lines.push("");
+	if (report.issues.length === 0) lines.push(chalk.green("  All checks passed. Ready to deposit."));
+	else for (const issue of report.issues) {
+		const icon = issue.severity === "error" ? chalk.red("ERROR") : chalk.yellow("WARN");
+		lines.push(`  ${icon}  [${issue.code}] ${issue.message}`);
+	}
+	return lines.join("\n");
+}
+function compareTable(vaults, risks) {
+	const fields = [
+		{
+			label: "Slug",
+			value: (v) => v.slug
+		},
+		{
+			label: "Chain",
+			value: (v) => `${v.network} (${v.chainId})`
+		},
+		{
+			label: "Protocol",
+			value: (v) => v.protocol.name
+		},
+		{
+			label: "APY Total",
+			value: (v) => chalk.green(fmtPct(v.analytics.apy.total))
+		},
+		{
+			label: "APY Base",
+			value: (v) => fmtPct(v.analytics.apy.base)
+		},
+		{
+			label: "APY Reward",
+			value: (v) => fmtPct(v.analytics.apy.reward)
+		},
+		{
+			label: "APY 7d",
+			value: (v) => v.analytics.apy7d !== null ? fmtPct(v.analytics.apy7d) : "N/A"
+		},
+		{
+			label: "APY 30d",
+			value: (v) => v.analytics.apy30d !== null ? fmtPct(v.analytics.apy30d) : "N/A"
+		},
+		{
+			label: "TVL",
+			value: (v) => fmtUsd(parseTvl(v.analytics.tvl).parsed)
+		},
+		{
+			label: "Risk",
+			value: (_, r) => riskLabel(r.score)
+		},
+		{
+			label: "Tags",
+			value: (v) => v.tags.join(", ") || "(none)"
+		},
+		{
+			label: "Transactional",
+			value: (v) => v.isTransactional ? chalk.green("Yes") : chalk.red("No")
+		},
+		{
+			label: "Redeemable",
+			value: (v) => v.isRedeemable ? chalk.green("Yes") : chalk.red("No")
+		},
+		{
+			label: "Underlying",
+			value: (v) => v.underlyingTokens.map((t) => t.symbol).join(", ") || "(none)"
+		}
+	];
+	const table = new Table({
+		head: [chalk.bold(""), ...vaults.map((v) => chalk.bold(v.name))],
+		wordWrap: true
+	});
+	for (const field of fields) table.push([chalk.dim(field.label), ...vaults.map((v, i) => field.value(v, risks[i]))]);
+	return table.toString();
+}
+function outputResult(data, json, humanFn) {
+	if (json) console.log(JSON.stringify(data, null, 2));
+	else console.log(humanFn());
+}
+//#endregion
+//#region src/doctor.ts
+/**
+* Run all 18 pitfall checks on a vault.
+* Each check is based on a real pitfall from the LI.FI Earn API.
+*/
+function runDoctorChecks(vault, opts) {
+	const checks = [];
+	checks.push({
+		id: 1,
+		pitfall: "Base URL split",
+		description: "Earn Data uses earn.li.fi, Composer uses li.quest",
+		passed: true,
+		detail: "SDK uses correct base URLs (earn.li.fi / li.quest)"
+	});
+	checks.push({
+		id: 2,
+		pitfall: "No auth for Earn Data",
+		description: "Earn Data API (earn.li.fi) requires no authentication",
+		passed: true,
+		detail: "SDK sends no auth headers to earn.li.fi"
+	});
+	checks.push({
+		id: 3,
+		pitfall: "Composer API key",
+		description: "Composer (li.quest) requires x-lifi-api-key header",
+		passed: opts.hasApiKey,
+		detail: opts.hasApiKey ? "LIFI_API_KEY is set" : "LIFI_API_KEY is NOT set — quote/deposit commands will fail"
+	});
+	checks.push({
+		id: 4,
+		pitfall: "GET for Composer",
+		description: "Composer quote endpoint uses GET, not POST",
+		passed: true,
+		detail: "SDK uses GET for /v1/quote"
+	});
+	checks.push({
+		id: 5,
+		pitfall: "toToken = vault.address",
+		description: "Deposit toToken must be vault.address, not underlying token",
+		passed: true,
+		detail: `Vault address: ${vault.address}`
+	});
+	checks.push({
+		id: 6,
+		pitfall: "Pagination via nextCursor",
+		description: "Vault list is paginated — must follow nextCursor",
+		passed: true,
+		detail: "SDK auto-paginates via listAllVaults()"
+	});
+	const apyTotal = vault.analytics.apy.total;
+	const apyIsReasonable = apyTotal >= 0 && apyTotal < 500;
+	checks.push({
+		id: 7,
+		pitfall: "APY value is reasonable",
+		description: "apy.total is already a percentage (3.84 = 3.84%), not a fraction",
+		passed: apyIsReasonable,
+		detail: `apy.total = ${apyTotal.toFixed(2)}%`
+	});
+	const tvl = parseTvl(vault.analytics.tvl);
+	const tvlIsString = typeof vault.analytics.tvl.usd === "string";
+	checks.push({
+		id: 8,
+		pitfall: "TVL.usd is a string",
+		description: "tvl.usd comes as a string, must parse to number",
+		passed: tvlIsString,
+		detail: `tvl.usd type=${typeof vault.analytics.tvl.usd}, parsed=${tvl.parsed}`
+	});
+	const hasDecimals = vault.underlyingTokens.length > 0;
+	const decimals = vault.underlyingTokens[0]?.decimals;
+	checks.push({
+		id: 9,
+		pitfall: "Token decimals",
+		description: "Use underlyingTokens[0].decimals for amount conversion (6 for USDC, 18 for ETH)",
+		passed: hasDecimals,
+		detail: hasDecimals ? `Decimals: ${decimals} (${vault.underlyingTokens[0]?.symbol})` : "No underlyingTokens — decimals unknown, must specify fromToken manually"
+	});
+	const chainIdIsNumber = typeof vault.chainId === "number";
+	checks.push({
+		id: 10,
+		pitfall: "chainId is a number",
+		description: "Use numeric chainId (8453), not chain name (\"Base\")",
+		passed: chainIdIsNumber,
+		detail: `chainId = ${vault.chainId} (type: ${typeof vault.chainId})`
+	});
+	checks.push({
+		id: 11,
+		pitfall: "Gas token needed",
+		description: "Wallet must have native gas on the vault chain for tx execution",
+		passed: true,
+		detail: `Vault is on chain ${vault.chainId} — ensure wallet has native gas`
+	});
+	checks.push({
+		id: 12,
+		pitfall: "Chain mismatch",
+		description: "Wallet chain must match vault chain (or use cross-chain route)",
+		passed: true,
+		detail: `Vault on chain ${vault.chainId} — ensure wallet is on same chain or use bridge`
+	});
+	checks.push({
+		id: 13,
+		pitfall: "isTransactional",
+		description: "Vault must be isTransactional=true to deposit via Composer",
+		passed: vault.isTransactional,
+		detail: vault.isTransactional ? "Vault is transactional — deposits supported" : "Vault is NOT transactional — cannot deposit via API"
+	});
+	checks.push({
+		id: 14,
+		pitfall: "isRedeemable",
+		description: "If isRedeemable=false, you may not be able to withdraw",
+		passed: vault.isRedeemable,
+		detail: vault.isRedeemable ? "Vault is redeemable" : "Vault is NOT redeemable — funds may be locked"
+	});
+	const hasUnderlyingTokens = vault.underlyingTokens.length > 0;
+	checks.push({
+		id: 15,
+		pitfall: "underlyingTokens[]",
+		description: "Some vaults have empty underlyingTokens — must specify fromToken manually",
+		passed: hasUnderlyingTokens,
+		detail: hasUnderlyingTokens ? `Underlying: ${vault.underlyingTokens.map((t) => t.symbol).join(", ")}` : "underlyingTokens is EMPTY — you must pass fromToken explicitly"
+	});
+	const hasDescription = vault.description !== void 0 && vault.description !== "";
+	checks.push({
+		id: 16,
+		pitfall: "description optional",
+		description: "~14% of vaults lack a description field — do not assume it exists",
+		passed: true,
+		detail: hasDescription ? `Description present: "${vault.description.slice(0, 60)}..."` : "No description (this is expected for some vaults)"
+	});
+	checks.push({
+		id: 17,
+		pitfall: "apy.reward nullable",
+		description: "apy.reward is null for some protocols (Morpho) — normalize to 0",
+		passed: typeof vault.analytics.apy.reward === "number",
+		detail: `apy.reward = ${vault.analytics.apy.reward} (type: ${typeof vault.analytics.apy.reward})`
+	});
+	const apyFields = {
+		apy1d: vault.analytics.apy1d,
+		apy7d: vault.analytics.apy7d,
+		apy30d: vault.analytics.apy30d
+	};
+	const nullApyFields = Object.entries(apyFields).filter(([, v]) => v === null).map(([k]) => k);
+	checks.push({
+		id: 18,
+		pitfall: "Historical APY nullable",
+		description: "apy1d, apy7d, apy30d can all be null — use fallback chain",
+		passed: true,
+		detail: nullApyFields.length > 0 ? `Null fields: ${nullApyFields.join(", ")} — SDK uses fallback chain` : "All historical APY fields present"
+	});
+	const passed = checks.filter((c) => c.passed).length;
+	const failed = checks.filter((c) => !c.passed).length;
+	const risk = riskScore(vault);
+	return {
+		checks,
+		passed,
+		failed,
+		total: checks.length,
+		riskScore: {
+			score: risk.score,
+			label: risk.label
+		}
+	};
+}
+function formatDoctorReport(report, vaultName) {
+	const lines = [];
+	lines.push(chalk.bold.underline(`EarnForge Doctor${vaultName ? ` — ${vaultName}` : ""}`));
+	lines.push("");
+	for (const check of report.checks) {
+		const icon = check.passed ? chalk.green("OK") : chalk.red("FAIL");
+		const num = `#${String(check.id).padStart(2, "0")}`;
+		lines.push(`  ${icon}  ${chalk.dim(num)} ${chalk.bold(check.pitfall)}`);
+		lines.push(`       ${chalk.dim(check.description)}`);
+		lines.push(`       ${check.detail}`);
+		lines.push("");
+	}
+	lines.push(chalk.bold("Summary"));
+	lines.push(`  ${chalk.green(`${report.passed} passed`)}  ${report.failed > 0 ? chalk.red(`${report.failed} failed`) : chalk.dim("0 failed")}  ${chalk.dim(`${report.total} total`)}`);
+	if (report.riskScore) {
+		lines.push("");
+		lines.push(chalk.bold("Risk Score"));
+		lines.push(`  ${riskLabel(report.riskScore.score)}`);
+	}
+	return lines.join("\n");
+}
+/**
+* Run environment-only doctor checks (no vault needed).
+*/
+function runEnvChecks() {
+	const checks = [];
+	const hasApiKey = !!process.env["LIFI_API_KEY"];
+	checks.push({
+		id: 1,
+		pitfall: "LIFI_API_KEY",
+		description: "Composer API key for quote/deposit operations",
+		passed: hasApiKey,
+		detail: hasApiKey ? "LIFI_API_KEY is set" : "LIFI_API_KEY is NOT set"
+	});
+	const nodeVersion = process.version;
+	const majorVersion = parseInt(nodeVersion.slice(1), 10);
+	checks.push({
+		id: 2,
+		pitfall: "Node.js version",
+		description: "Node.js 18+ required for native fetch",
+		passed: majorVersion >= 18,
+		detail: `Node.js ${nodeVersion} (major: ${majorVersion})`
+	});
+	checks.push({
+		id: 3,
+		pitfall: "Earn Data API",
+		description: "earn.li.fi is the read-only API (no auth needed)",
+		passed: true,
+		detail: "earn.li.fi — public, no API key required"
+	});
+	checks.push({
+		id: 4,
+		pitfall: "Composer API",
+		description: "li.quest is the Composer API (requires API key)",
+		passed: hasApiKey,
+		detail: hasApiKey ? "li.quest will use LIFI_API_KEY for x-lifi-api-key header" : "li.quest requires LIFI_API_KEY — set it to use quote/deposit"
+	});
+	return {
+		checks,
+		passed: checks.filter((c) => c.passed).length,
+		failed: checks.filter((c) => !c.passed).length,
+		total: checks.length
+	};
+}
+function formatEnvReport(report) {
+	const lines = [];
+	lines.push(chalk.bold.underline("EarnForge Doctor — Environment"));
+	lines.push("");
+	for (const check of report.checks) {
+		const icon = check.passed ? chalk.green("OK") : chalk.red("FAIL");
+		lines.push(`  ${icon}  ${chalk.bold(check.pitfall)}`);
+		lines.push(`       ${chalk.dim(check.description)}`);
+		lines.push(`       ${check.detail}`);
+		lines.push("");
+	}
+	lines.push(chalk.bold("Summary"));
+	lines.push(`  ${chalk.green(`${report.passed} passed`)}  ${report.failed > 0 ? chalk.red(`${report.failed} failed`) : chalk.dim("0 failed")}  ${chalk.dim(`${report.total} total`)}`);
+	return lines.join("\n");
+}
+//#endregion
+//#region src/index.ts
+let _forge;
+function getForge() {
+	if (!_forge) _forge = createEarnForge({ composerApiKey: process.env["LIFI_API_KEY"] });
+	return _forge;
+}
+/** Override forge instance (for testing) */
+function setForge(forge) {
+	_forge = forge;
+}
+/** Reset forge instance */
+function resetForge() {
+	_forge = void 0;
+}
+const VALID_STRATEGIES = [
+	"conservative",
+	"max-apy",
+	"diversified",
+	"risk-adjusted"
+];
+function validateStrategy(s) {
+	if (!VALID_STRATEGIES.includes(s)) throw new Error(`Invalid strategy: ${s}. Valid: ${VALID_STRATEGIES.join(", ")}`);
+	return s;
+}
+const program = new Command();
+program.name("earnforge").version("0.1.0").description("EarnForge CLI — Developer toolkit for the LI.FI Earn API");
+program.command("list").description("List vaults with filters").option("--chain <id>", "Filter by chain ID", parseInt).option("--asset <sym>", "Filter by asset symbol").option("--min-apy <n>", "Minimum APY (e.g. 5 = 5%)", parseFloat).option("--min-tvl <n>", "Minimum TVL in USD", parseFloat).option("--sort <field>", "Sort by apy or tvl", "apy").option("--limit <n>", "Max results", parseInt).option("--strategy <preset>", "Strategy preset (conservative, max-apy, diversified, risk-adjusted)").option("--json", "Output as JSON", false).action(async (opts) => {
+	const spinner = ora("Fetching vaults...").start();
+	try {
+		const forge = getForge();
+		const limit = opts.limit ?? 20;
+		const strategy = opts.strategy ? validateStrategy(opts.strategy) : void 0;
+		const vaults = [];
+		for await (const v of forge.vaults.listAll({
+			chainId: opts.chain,
+			asset: opts.asset,
+			minTvl: opts.minTvl,
+			strategy
+		})) {
+			if (opts.minApy !== void 0 && v.analytics.apy.total < opts.minApy) continue;
+			if (opts.minTvl !== void 0 && parseTvl(v.analytics.tvl).parsed < opts.minTvl) continue;
+			vaults.push(v);
+			if (vaults.length >= limit * 3) break;
+		}
+		if (opts.sort === "tvl") vaults.sort((a, b) => parseTvl(b.analytics.tvl).parsed - parseTvl(a.analytics.tvl).parsed);
+		else vaults.sort((a, b) => b.analytics.apy.total - a.analytics.apy.total);
+		const result = vaults.slice(0, limit);
+		spinner.stop();
+		outputResult(result.map((v) => ({
+			slug: v.slug,
+			name: v.name,
+			chainId: v.chainId,
+			protocol: v.protocol.name,
+			apy: v.analytics.apy.total,
+			tvlUsd: parseTvl(v.analytics.tvl).parsed,
+			tags: v.tags,
+			isTransactional: v.isTransactional
+		})), opts.json, () => {
+			if (result.length === 0) return chalk.yellow("No vaults found matching your filters.");
+			return `${vaultTable(result)}\n\n${chalk.dim(`Showing ${result.length} vault${result.length !== 1 ? "s" : ""}`)}`;
+		});
+	} catch (err) {
+		spinner.fail("Failed to fetch vaults");
+		console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+		process.exitCode = 1;
+	}
+});
+program.command("top").description("Show top vaults by APY for a given asset").requiredOption("--asset <sym>", "Asset symbol (e.g. USDC, WETH)").option("--chain <id>", "Filter by chain ID", parseInt).option("--limit <n>", "Max results", parseInt).option("--json", "Output as JSON", false).action(async (opts) => {
+	const spinner = ora("Fetching top vaults...").start();
+	try {
+		const result = await getForge().vaults.top({
+			asset: opts.asset,
+			chainId: opts.chain,
+			limit: opts.limit ?? 10
+		});
+		spinner.stop();
+		outputResult(result.map((v) => ({
+			slug: v.slug,
+			name: v.name,
+			chainId: v.chainId,
+			protocol: v.protocol.name,
+			apy: v.analytics.apy.total,
+			tvlUsd: parseTvl(v.analytics.tvl).parsed,
+			tags: v.tags
+		})), opts.json, () => {
+			if (result.length === 0) return chalk.yellow(`No vaults found for asset: ${opts.asset}`);
+			return `${chalk.bold(`Top ${opts.asset} vaults`)}\n\n${vaultTable(result)}`;
+		});
+	} catch (err) {
+		spinner.fail("Failed to fetch top vaults");
+		console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+		process.exitCode = 1;
+	}
+});
+program.command("vault").description("Get detailed vault info by slug").argument("<slug>", "Vault slug (e.g. 8453-0xbeef...)").option("--json", "Output as JSON", false).action(async (slug, opts) => {
+	const spinner = ora("Fetching vault...").start();
+	try {
+		const vault = await getForge().vaults.get(slug);
+		spinner.stop();
+		outputResult(vault, opts.json, () => vaultDetail(vault));
+	} catch (err) {
+		spinner.fail("Failed to fetch vault");
+		console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+		process.exitCode = 1;
+	}
+});
+program.command("compare").description("Side-by-side comparison of 2 or more vaults").argument("<slugs...>", "Vault slugs to compare (space-separated)").option("--json", "Output as JSON", false).action(async (slugs, opts) => {
+	if (slugs.length < 2) {
+		console.error(chalk.red("Provide at least 2 vault slugs to compare."));
+		process.exitCode = 1;
+		return;
+	}
+	const spinner = ora(`Fetching ${slugs.length} vaults...`).start();
+	try {
+		const forge = getForge();
+		const vaults = await Promise.all(slugs.map((s) => forge.vaults.get(s)));
+		const risks = vaults.map((v) => forge.riskScore(v));
+		spinner.stop();
+		outputResult(vaults.map((v, i) => ({
+			slug: v.slug,
+			name: v.name,
+			chainId: v.chainId,
+			network: v.network,
+			protocol: v.protocol.name,
+			apy: v.analytics.apy,
+			apy7d: v.analytics.apy7d,
+			apy30d: v.analytics.apy30d,
+			tvlUsd: parseTvl(v.analytics.tvl).parsed,
+			risk: risks[i],
+			tags: v.tags,
+			isTransactional: v.isTransactional,
+			isRedeemable: v.isRedeemable,
+			underlyingTokens: v.underlyingTokens.map((t) => t.symbol)
+		})), opts.json, () => {
+			return `${chalk.bold(`Vault Comparison (${vaults.length} vaults)`)}\n\n${compareTable(vaults, risks)}`;
+		});
+	} catch (err) {
+		spinner.fail("Failed to compare vaults");
+		console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+		process.exitCode = 1;
+	}
+});
+program.command("portfolio").description("View portfolio positions for a wallet").argument("<wallet>", "Wallet address").option("--json", "Output as JSON", false).action(async (wallet, opts) => {
+	const spinner = ora("Fetching portfolio...").start();
+	try {
+		const portfolio = await getForge().portfolio.get(wallet);
+		spinner.stop();
+		outputResult(portfolio, opts.json, () => {
+			if (portfolio.positions.length === 0) return chalk.yellow("No positions found.");
+			const totalUsd = portfolio.positions.reduce((sum, p) => sum + Number(p.balanceUsd), 0);
+			return `${chalk.bold("Portfolio")}\n\n${portfolioTable(portfolio.positions)}\n\n${chalk.dim(`Total: ${fmtUsd(totalUsd)}`)}`;
+		});
+	} catch (err) {
+		spinner.fail("Failed to fetch portfolio");
+		console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+		process.exitCode = 1;
+	}
+});
+program.command("quote").description("Build a deposit quote").requiredOption("--vault <slug>", "Vault slug").requiredOption("--amount <human>", "Human-readable deposit amount").requiredOption("--wallet <addr>", "Wallet address").option("--from-token <addr>", "Override from token address").option("--from-chain <id>", "Override source chain", parseInt).option("--optimize-gas", "Compare routes from multiple chains", false).option("--json", "Output as JSON", false).action(async (opts) => {
+	const spinner = ora("Building quote...").start();
+	try {
+		const forge = getForge();
+		const vault = await forge.vaults.get(opts.vault);
+		if (opts.optimizeGas) {
+			spinner.text = "Comparing cross-chain routes...";
+			const routes = await forge.optimizeGasRoutes(vault, {
+				fromAmount: opts.amount,
+				wallet: opts.wallet,
+				fromToken: opts.fromToken,
+				fromChains: opts.fromChain ? [opts.fromChain, vault.chainId] : void 0
+			});
+			spinner.stop();
+			outputResult(routes.map((r) => ({
+				fromChain: r.fromChain,
+				fromChainName: r.fromChainName,
+				totalCostUsd: r.totalCostUsd,
+				gasCostUsd: r.gasCostUsd,
+				feeCostUsd: r.feeCostUsd,
+				executionDuration: r.executionDuration
+			})), opts.json, () => {
+				if (routes.length === 0) return chalk.yellow("No routes found.");
+				const lines = [chalk.bold(`Gas-optimized routes for ${vault.name}`), ""];
+				for (const r of routes) {
+					const best = r === routes[0] ? chalk.green(" << cheapest") : "";
+					lines.push(`  ${r.fromChainName} (${r.fromChain}): gas=${fmtUsd(r.gasCostUsd)} fee=${fmtUsd(r.feeCostUsd)} total=${fmtUsd(r.totalCostUsd)} time=${r.executionDuration}s${best}`);
+				}
+				return lines.join("\n");
+			});
+		} else {
+			const result = await forge.buildDepositQuote(vault, {
+				fromAmount: opts.amount,
+				wallet: opts.wallet,
+				fromToken: opts.fromToken,
+				fromChain: opts.fromChain
+			});
+			spinner.stop();
+			const approvalAddress = result.quote.estimate.approvalAddress;
+			outputResult({
+				vault: vault.slug,
+				humanAmount: result.humanAmount,
+				rawAmount: result.rawAmount,
+				decimals: result.decimals,
+				fromToken: result.quote.action.fromToken.symbol,
+				toToken: result.quote.action.toToken.symbol,
+				estimatedOutput: result.quote.estimate.toAmount,
+				gasCosts: result.quote.estimate.gasCosts,
+				feeCosts: result.quote.estimate.feeCosts,
+				executionDuration: result.quote.estimate.executionDuration,
+				approvalAddress
+			}, opts.json, () => {
+				const lines = [
+					chalk.bold(`Deposit Quote — ${vault.name}`),
+					"",
+					`  ${chalk.dim("Amount:")}      ${result.humanAmount} (${result.rawAmount} raw, ${result.decimals} decimals)`,
+					`  ${chalk.dim("From:")}        ${result.quote.action.fromToken.symbol} on chain ${result.quote.action.fromChainId}`,
+					`  ${chalk.dim("To:")}          ${result.quote.action.toToken.symbol} on chain ${result.quote.action.toChainId}`,
+					`  ${chalk.dim("Est. Output:")} ${result.quote.estimate.toAmount}`,
+					`  ${chalk.dim("Duration:")}    ${result.quote.estimate.executionDuration}s`
+				];
+				const gasCosts = result.quote.estimate.gasCosts ?? [];
+				const feeCosts = result.quote.estimate.feeCosts ?? [];
+				if (gasCosts.length > 0) {
+					const totalGas = gasCosts.reduce((s, g) => s + Number(g.amountUSD), 0);
+					lines.push(`  ${chalk.dim("Gas Cost:")}    ${fmtUsd(totalGas)}`);
+				}
+				if (feeCosts.length > 0) {
+					const totalFee = feeCosts.reduce((s, f) => s + Number(f.amountUSD), 0);
+					lines.push(`  ${chalk.dim("Fee Cost:")}    ${fmtUsd(totalFee)}`);
+				}
+				if (approvalAddress) {
+					lines.push("");
+					lines.push(chalk.yellow(`  Approval needed: approve ${result.quote.action.fromToken.symbol} for spender ${approvalAddress}`));
+					lines.push(chalk.dim(`  Run: earnforge allowance --token ${result.quote.action.fromToken.address} --owner ${opts.wallet} --spender ${approvalAddress} --amount ${result.rawAmount} --chain ${result.quote.action.fromChainId}`));
+				}
+				lines.push("");
+				lines.push(chalk.dim("Transaction ready to sign via quote.transactionRequest"));
+				return lines.join("\n");
+			});
+		}
+	} catch (err) {
+		spinner.fail("Failed to build quote");
+		console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+		process.exitCode = 1;
+	}
+});
+program.command("withdraw").description("Build a withdrawal/redeem quote").requiredOption("--vault <slug>", "Vault slug").requiredOption("--amount <human>", "Amount of vault shares to redeem").requiredOption("--wallet <addr>", "Wallet address").option("--to-token <addr>", "Override destination token address").option("--to-chain <id>", "Override destination chain", parseInt).option("--slippage <n>", "Slippage tolerance (0.03 = 3%)", parseFloat).option("--json", "Output as JSON", false).action(async (opts) => {
+	const spinner = ora("Building redeem quote...").start();
+	try {
+		const forge = getForge();
+		const vault = await forge.vaults.get(opts.vault);
+		const result = await forge.buildRedeemQuote(vault, {
+			fromAmount: opts.amount,
+			wallet: opts.wallet,
+			toToken: opts.toToken,
+			toChain: opts.toChain,
+			slippage: opts.slippage
+		});
+		spinner.stop();
+		outputResult({
+			vault: vault.slug,
+			humanAmount: result.humanAmount,
+			rawAmount: result.rawAmount,
+			fromToken: result.quote.action.fromToken.symbol,
+			toToken: result.quote.action.toToken.symbol,
+			estimatedOutput: result.quote.estimate.toAmount,
+			gasCosts: result.quote.estimate.gasCosts,
+			feeCosts: result.quote.estimate.feeCosts,
+			executionDuration: result.quote.estimate.executionDuration
+		}, opts.json, () => {
+			const lines = [
+				chalk.bold(`Withdraw Quote — ${vault.name}`),
+				"",
+				`  ${chalk.dim("Amount:")}      ${result.humanAmount} vault shares (${result.rawAmount} raw)`,
+				`  ${chalk.dim("From:")}        ${result.quote.action.fromToken.symbol} (vault token) on chain ${result.quote.action.fromChainId}`,
+				`  ${chalk.dim("To:")}          ${result.quote.action.toToken.symbol} on chain ${result.quote.action.toChainId}`,
+				`  ${chalk.dim("Est. Output:")} ${result.quote.estimate.toAmount}`,
+				`  ${chalk.dim("Duration:")}    ${result.quote.estimate.executionDuration}s`
+			];
+			const gasCosts = result.quote.estimate.gasCosts ?? [];
+			const feeCosts = result.quote.estimate.feeCosts ?? [];
+			if (gasCosts.length > 0) {
+				const totalGas = gasCosts.reduce((s, g) => s + Number(g.amountUSD), 0);
+				lines.push(`  ${chalk.dim("Gas Cost:")}    ${fmtUsd(totalGas)}`);
+			}
+			if (feeCosts.length > 0) {
+				const totalFee = feeCosts.reduce((s, f) => s + Number(f.amountUSD), 0);
+				lines.push(`  ${chalk.dim("Fee Cost:")}    ${fmtUsd(totalFee)}`);
+			}
+			lines.push("");
+			lines.push(chalk.dim("Transaction ready to sign via quote.transactionRequest"));
+			return lines.join("\n");
+		});
+	} catch (err) {
+		spinner.fail("Failed to build redeem quote");
+		console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+		process.exitCode = 1;
+	}
+});
+program.command("allowance").description("Check ERC-20 token allowance for a spender").requiredOption("--token <addr>", "ERC-20 token address").requiredOption("--owner <addr>", "Token owner (wallet) address").requiredOption("--spender <addr>", "Spender address (from quote.estimate.approvalAddress)").requiredOption("--amount <raw>", "Required amount in smallest unit").requiredOption("--chain <id>", "Chain ID", parseInt).option("--rpc <url>", "Custom RPC URL").option("--json", "Output as JSON", false).action(async (opts) => {
+	const spinner = ora("Checking allowance...").start();
+	try {
+		const result = await checkAllowance(opts.rpc ?? `https://rpc.li.fi/v1/chain/${opts.chain}`, opts.token, opts.owner, opts.spender, BigInt(opts.amount));
+		spinner.stop();
+		outputResult({
+			token: opts.token,
+			owner: opts.owner,
+			spender: opts.spender,
+			allowance: result.allowance.toString(),
+			requiredAmount: result.requiredAmount.toString(),
+			sufficient: result.sufficient
+		}, opts.json, () => {
+			const status = result.sufficient ? chalk.green("SUFFICIENT — no approval needed") : chalk.red("INSUFFICIENT — approval required");
+			return [
+				chalk.bold("Allowance Check"),
+				"",
+				`  ${chalk.dim("Token:")}     ${opts.token}`,
+				`  ${chalk.dim("Owner:")}     ${opts.owner}`,
+				`  ${chalk.dim("Spender:")}   ${opts.spender}`,
+				`  ${chalk.dim("Allowance:")} ${result.allowance.toString()}`,
+				`  ${chalk.dim("Required:")}  ${result.requiredAmount.toString()}`,
+				`  ${chalk.dim("Status:")}    ${status}`,
+				"",
+				...result.sufficient ? [] : [chalk.dim("To approve, run:"), chalk.dim(`  earnforge approve --token ${opts.token} --spender ${opts.spender} --chain ${opts.chain}`)]
+			].join("\n");
+		});
+	} catch (err) {
+		spinner.fail("Failed to check allowance");
+		console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+		process.exitCode = 1;
+	}
+});
+program.command("approve").description("Build an ERC-20 approval transaction").requiredOption("--token <addr>", "ERC-20 token address").requiredOption("--spender <addr>", "Spender address (from quote.estimate.approvalAddress)").requiredOption("--chain <id>", "Chain ID", parseInt).option("--amount <raw>", "Amount to approve (default: unlimited)").option("--json", "Output as JSON", false).action(async (opts) => {
+	const amount = opts.amount ? BigInt(opts.amount) : MAX_UINT256;
+	const tx = buildApprovalTx(opts.token, opts.spender, amount, opts.chain);
+	outputResult(tx, opts.json, () => {
+		return [
+			chalk.bold("Approval Transaction"),
+			"",
+			`  ${chalk.dim("To:")}      ${tx.to}`,
+			`  ${chalk.dim("Chain:")}   ${tx.chainId}`,
+			`  ${chalk.dim("Amount:")}  ${amount === MAX_UINT256 ? "Unlimited (MaxUint256)" : amount.toString()}`,
+			`  ${chalk.dim("Data:")}    ${tx.data.slice(0, 20)}...`,
+			"",
+			chalk.dim("Sign and send this transaction before the deposit/quote transaction.")
+		].join("\n");
+	});
+});
+program.command("apy-history").description("Fetch 30-day APY history from DeFiLlama").argument("<slug>", "Vault slug").option("--json", "Output as JSON", false).action(async (slug, opts) => {
+	const spinner = ora("Fetching APY history...").start();
+	try {
+		const forge = getForge();
+		const vault = await forge.vaults.get(slug);
+		const history = await forge.getApyHistory(vault);
+		spinner.stop();
+		outputResult({
+			vault: vault.slug,
+			name: vault.name,
+			dataPoints: history.length,
+			history
+		}, opts.json, () => {
+			if (history.length === 0) return chalk.yellow(`No APY history found for ${vault.name}. DeFiLlama may not track this vault.`);
+			return `${chalk.bold(`APY History — ${vault.name} (${history.length} days)`)}\n\n${apyHistoryTable(history)}`;
+		});
+	} catch (err) {
+		spinner.fail("Failed to fetch APY history");
+		console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+		process.exitCode = 1;
+	}
+});
+program.command("preflight").description("Run pre-deposit checks on a vault + wallet").requiredOption("--vault <slug>", "Vault slug").requiredOption("--wallet <addr>", "Wallet address").option("--amount <human>", "Deposit amount (human-readable)").option("--wallet-chain <id>", "Wallet current chain ID", parseInt).option("--cross-chain", "Flag cross-chain deposit intent", false).option("--json", "Output as JSON", false).action(async (opts) => {
+	const spinner = ora("Running preflight checks...").start();
+	try {
+		const forge = getForge();
+		const vault = await forge.vaults.get(opts.vault);
+		const report = forge.preflight(vault, opts.wallet, {
+			walletChainId: opts.walletChain,
+			depositAmount: opts.amount,
+			crossChain: opts.crossChain
+		});
+		spinner.stop();
+		outputResult({
+			ok: report.ok,
+			vault: vault.slug,
+			wallet: opts.wallet,
+			issues: report.issues
+		}, opts.json, () => preflightTable(report));
+	} catch (err) {
+		spinner.fail("Preflight failed");
+		console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+		process.exitCode = 1;
+	}
+});
+program.command("doctor").description("Run 18-pitfall diagnostics on a vault or environment").option("--vault <slug>", "Vault slug to check").option("--env", "Run environment checks only", false).option("--json", "Output as JSON", false).action(async (opts) => {
+	if (opts.env && !opts.vault) {
+		const report = runEnvChecks();
+		outputResult(report, opts.json, () => formatEnvReport(report));
+		return;
+	}
+	if (!opts.vault) {
+		console.error(chalk.red("Provide --vault <slug> or --env"));
+		process.exitCode = 1;
+		return;
+	}
+	const spinner = ora("Running doctor checks...").start();
+	try {
+		const vault = await getForge().vaults.get(opts.vault);
+		const report = runDoctorChecks(vault, { hasApiKey: !!process.env["LIFI_API_KEY"] });
+		spinner.stop();
+		outputResult(report, opts.json, () => formatDoctorReport(report, vault.name));
+	} catch (err) {
+		spinner.fail("Doctor failed");
+		console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+		process.exitCode = 1;
+	}
+});
+program.command("risk").description("Calculate risk score for a vault").argument("<slug>", "Vault slug").option("--json", "Output as JSON", false).action(async (slug, opts) => {
+	const spinner = ora("Calculating risk...").start();
+	try {
+		const forge = getForge();
+		const vault = await forge.vaults.get(slug);
+		const risk = forge.riskScore(vault);
+		spinner.stop();
+		outputResult({
+			slug: vault.slug,
+			name: vault.name,
+			...risk
+		}, opts.json, () => `${chalk.bold(`Risk Score — ${vault.name}`)}\n\n${riskTable(risk)}`);
+	} catch (err) {
+		spinner.fail("Failed to calculate risk");
+		console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+		process.exitCode = 1;
+	}
+});
+program.command("suggest").description("Get portfolio allocation suggestions").requiredOption("--amount <human>", "Total amount to allocate (USD)", parseFloat).requiredOption("--asset <sym>", "Asset symbol (e.g. USDC)").option("--max-chains <n>", "Max number of chains", parseInt).option("--strategy <preset>", "Strategy preset").option("--json", "Output as JSON", false).action(async (opts) => {
+	const spinner = ora("Analyzing vaults and building allocations...").start();
+	try {
+		const forge = getForge();
+		const strategy = opts.strategy ? validateStrategy(opts.strategy) : void 0;
+		const result = await forge.suggest({
+			amount: opts.amount,
+			asset: opts.asset,
+			maxChains: opts.maxChains,
+			strategy
+		});
+		spinner.stop();
+		outputResult({
+			totalAmount: result.totalAmount,
+			expectedApy: result.expectedApy,
+			allocations: result.allocations.map((a) => ({
+				vault: a.vault.slug,
+				vaultName: a.vault.name,
+				chainId: a.vault.chainId,
+				protocol: a.vault.protocol.name,
+				apy: a.apy,
+				risk: a.risk,
+				percentage: a.percentage,
+				amount: a.amount
+			}))
+		}, opts.json, () => {
+			if (result.allocations.length === 0) return chalk.yellow("No suitable vaults found for allocation.");
+			return [
+				chalk.bold(`Allocation Suggestion — ${fmtUsd(result.totalAmount)} in ${opts.asset}`),
+				`  ${chalk.dim("Expected APY:")} ${chalk.green(fmtPct(result.expectedApy))}`,
+				"",
+				suggestTable(result.allocations)
+			].join("\n");
+		});
+	} catch (err) {
+		spinner.fail("Failed to generate suggestions");
+		console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+		process.exitCode = 1;
+	}
+});
+program.command("watch").description("Watch a vault for APY/TVL changes").requiredOption("--vault <slug>", "Vault slug").option("--apy-drop <pct>", "APY drop threshold (%)", parseFloat).option("--tvl-drop <pct>", "TVL drop threshold (%)", parseFloat).option("--interval <ms>", "Poll interval in milliseconds", parseInt).option("--max-iterations <n>", "Max iterations (0 = unlimited)", parseInt).option("--json", "Output events as JSON", false).action(async (opts) => {
+	if (!opts.json) console.log(chalk.dim(`Watching ${opts.vault} (Ctrl+C to stop)...`));
+	try {
+		const forge = getForge();
+		const ac = new AbortController();
+		const onSignal = () => {
+			ac.abort();
+		};
+		process.on("SIGINT", onSignal);
+		process.on("SIGTERM", onSignal);
+		const gen = forge.watch(opts.vault, {
+			apyDropPercent: opts.apyDrop,
+			tvlDropPercent: opts.tvlDrop,
+			interval: opts.interval,
+			maxIterations: opts.maxIterations,
+			signal: ac.signal
+		});
+		for await (const event of gen) if (opts.json) console.log(JSON.stringify({
+			type: event.type,
+			vault: event.vault.slug,
+			previous: event.previous,
+			current: event.current,
+			timestamp: event.timestamp.toISOString()
+		}));
+		else {
+			const typeColor = event.type === "apy-drop" ? chalk.red : event.type === "tvl-drop" ? chalk.yellow : chalk.dim;
+			const prevApy = event.previous ? fmtPct(event.previous.apy) : "N/A";
+			const prevTvl = event.previous ? fmtUsd(event.previous.tvlUsd) : "N/A";
+			console.log(`[${event.timestamp.toISOString()}] ${typeColor(event.type.toUpperCase())} APY: ${fmtPct(event.current.apy)} (prev: ${prevApy}) TVL: ${fmtUsd(event.current.tvlUsd)} (prev: ${prevTvl})`);
+		}
+	} catch (err) {
+		console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+		process.exitCode = 1;
+	}
+});
+program.command("chains").description("List supported chains").option("--json", "Output as JSON", false).action(async (opts) => {
+	const spinner = ora("Fetching chains...").start();
+	try {
+		const chains = await getForge().chains.list();
+		spinner.stop();
+		outputResult(chains, opts.json, () => `${chalk.bold("Supported Chains")}\n\n${chainTable(chains)}`);
+	} catch (err) {
+		spinner.fail("Failed to fetch chains");
+		console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+		process.exitCode = 1;
+	}
+});
+program.command("protocols").description("List supported protocols").option("--json", "Output as JSON", false).action(async (opts) => {
+	const spinner = ora("Fetching protocols...").start();
+	try {
+		const protocols = await getForge().protocols.list();
+		spinner.stop();
+		outputResult(protocols, opts.json, () => `${chalk.bold("Supported Protocols")}\n\n${protocolTable(protocols)}`);
+	} catch (err) {
+		spinner.fail("Failed to fetch protocols");
+		console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+		process.exitCode = 1;
+	}
+});
+program.command("init").argument("<name>", "Project name").description("Scaffold a new Next.js + wagmi + @earnforge/react project").action(async (name) => {
+	const fs = await import("node:fs");
+	const path = await import("node:path");
+	const dir = path.resolve(process.cwd(), name);
+	if (fs.existsSync(dir)) {
+		console.error(chalk.red(`Directory "${name}" already exists.`));
+		process.exitCode = 1;
+		return;
+	}
+	fs.mkdirSync(dir, { recursive: true });
+	fs.mkdirSync(path.join(dir, "src"), { recursive: true });
+	fs.writeFileSync(path.join(dir, "package.json"), JSON.stringify({
+		name,
+		version: "0.1.0",
+		private: true,
+		type: "module",
+		scripts: {
+			dev: "next dev",
+			build: "next build",
+			start: "next start"
+		},
+		dependencies: {
+			"@earnforge/sdk": "^0.1.0",
+			"@earnforge/react": "^0.1.0",
+			"@tanstack/react-query": "^5.90.0",
+			next: "^15.0.0",
+			react: "^19.0.0",
+			"react-dom": "^19.0.0",
+			wagmi: "^2.0.0",
+			viem: "^2.47.0"
+		}
+	}, null, 2));
+	fs.writeFileSync(path.join(dir, ".env.example"), "LIFI_API_KEY=your-api-key-from-portal.li.fi\n");
+	fs.writeFileSync(path.join(dir, "src", "page.tsx"), `// SPDX-License-Identifier: Apache-2.0
+import { createEarnForge } from '@earnforge/sdk';
+
+const forge = createEarnForge({
+  composerApiKey: process.env.LIFI_API_KEY,
+});
+
+export default async function Home() {
+  const top = await forge.vaults.top({ asset: 'USDC', limit: 5 });
+  return (
+    <main>
+      <h1>Top USDC Vaults</h1>
+      <ul>
+        {top.map((v) => (
+          <li key={v.slug}>
+            {v.name} — {v.analytics.apy.total.toFixed(2)}% APY
+          </li>
+        ))}
+      </ul>
+    </main>
+  );
+}
+`);
+	console.log(chalk.green(`\n  Scaffolded ${chalk.bold(name)}!\n`));
+	console.log(`  ${chalk.dim("cd")} ${name}`);
+	console.log(`  ${chalk.dim("cp")} .env.example .env.local`);
+	console.log(`  ${chalk.dim("npm install")}`);
+	console.log(`  ${chalk.dim("npm run dev")}\n`);
+});
+program.command("simulate").description("Dry-run a deposit quote against an anvil fork (requires anvil)").requiredOption("--vault <slug>", "Vault slug").requiredOption("--amount <human>", "Deposit amount (human-readable)").requiredOption("--wallet <addr>", "Wallet address").option("--rpc <url>", "Custom RPC URL (default: auto-detect)").option("--json", "JSON output").action(async (opts) => {
+	const spinner = ora("Running preflight checks...").start();
+	try {
+		const forge = getForge();
+		const vault = await forge.vaults.get(opts.vault);
+		const pre = forge.preflight(vault, opts.wallet, { depositAmount: opts.amount });
+		if (!pre.ok) {
+			spinner.fail("Preflight failed");
+			const errors = pre.issues.filter((i) => i.severity === "error");
+			for (const e of errors) console.error(chalk.red(`  [${e.code}] ${e.message}`));
+			process.exitCode = 1;
+			return;
+		}
+		const warnings = pre.issues.filter((i) => i.severity === "warning");
+		for (const w of warnings) console.warn(chalk.yellow(`  [${w.code}] ${w.message}`));
+		spinner.text = "Building quote for simulation...";
+		const result = await forge.buildDepositQuote(vault, {
+			fromAmount: opts.amount,
+			wallet: opts.wallet
+		});
+		spinner.text = "Simulating on anvil fork...";
+		const txReq = result.quote.transactionRequest;
+		const rpcUrl = opts.rpc ?? `https://rpc.li.fi/v1/chain/${vault.chainId}`;
+		const sim = await (await globalThis.fetch(rpcUrl, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				jsonrpc: "2.0",
+				method: "eth_call",
+				params: [{
+					from: opts.wallet,
+					to: txReq.to,
+					data: txReq.data,
+					value: txReq.value,
+					gas: txReq.gasLimit
+				}, "latest"],
+				id: 1
+			})
+		})).json();
+		spinner.stop();
+		outputResult({
+			vault: vault.slug,
+			amount: opts.amount,
+			decimals: result.decimals,
+			rawAmount: result.rawAmount,
+			gasLimit: txReq.gasLimit,
+			to: txReq.to,
+			chainId: txReq.chainId,
+			simulation: sim.error ? "FAILED" : "SUCCESS",
+			error: sim.error?.message
+		}, opts.json, () => {
+			const status = sim.error ? chalk.red("FAILED: " + sim.error.message) : chalk.green("SUCCESS — transaction would execute");
+			return [
+				chalk.bold("Simulation Result"),
+				"",
+				`  Vault:     ${vault.name} (${vault.slug})`,
+				`  Amount:    ${opts.amount} (${result.rawAmount} raw)`,
+				`  Gas Limit: ${txReq.gasLimit}`,
+				`  Target:    ${txReq.to}`,
+				`  Chain:     ${txReq.chainId}`,
+				"",
+				`  Status:    ${status}`
+			].join("\n");
+		});
+	} catch (err) {
+		spinner.fail("Simulation failed");
+		console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+		process.exitCode = 1;
+	}
+});
+//#endregion
+export { formatEnvReport as a, formatDoctorReport as i, resetForge as n, runDoctorChecks as o, setForge as r, runEnvChecks as s, program as t };
+
+//# sourceMappingURL=src-kbE_XVj7.mjs.map