@ilalv3/cli 0.1.0

package/dist/commands/status.js

@@ -0,0 +1,164 @@
+/**
+ * status.ts — `ilal status`
+ *
+ * Dashboard: credential validity, hook config, pool policy — all in one view.
+ */
+import { createPublicClient, http, isAddress } from "viem";
+import { base, baseSepolia } from "viem/chains";
+import { fmt, log, header, Spinner, dieOnContract } from "../ui.js";
+import { withConfig } from "../config.js";
+const CHAINS = { "8453": base, "84532": baseSepolia };
+const CNF_ABI = [
+    { name: "isValid", type: "function", stateMutability: "view", inputs: [{ name: "wallet", type: "address" }], outputs: [{ type: "bool" }] },
+    { name: "credentialOf", type: "function", stateMutability: "view", inputs: [{ name: "wallet", type: "address" }], outputs: [{ name: "tokenId", type: "uint256" }] },
+    { name: "getCredential", type: "function", stateMutability: "view", inputs: [{ name: "tokenId", type: "uint256" }], outputs: [{ type: "tuple", components: [{ name: "holder", type: "address" }, { name: "issuer", type: "address" }, { name: "credentialType", type: "bytes32" }, { name: "issuedAt", type: "uint64" }, { name: "expiresAt", type: "uint64" }, { name: "revoked", type: "bool" }] }] },
+    { name: "merkleRoot", type: "function", stateMutability: "view", inputs: [], outputs: [{ type: "uint256" }] },
+    { name: "zkVerifier", type: "function", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] },
+];
+const HOOK_ABI = [
+    { name: "issuer", type: "function", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] },
+];
+const REGISTRY_ABI = [
+    { name: "getPolicy", type: "function", stateMutability: "view", inputs: [{ name: "poolId", type: "bytes32" }], outputs: [{ type: "tuple", components: [{ name: "cnfIssuer", type: "address" }, { name: "requiredCredentialType", type: "bytes32" }, { name: "enabled", type: "bool" }] }] },
+];
+function daysUntil(unixSec) {
+    return Math.floor((unixSec * 1000 - Date.now()) / 86_400_000);
+}
+export async function status(opts) {
+    const cfg = withConfig(opts);
+    const chain = CHAINS[cfg.chain ?? "84532"] ?? baseSepolia;
+    const transport = cfg.rpc ? http(cfg.rpc) : http();
+    const client = createPublicClient({ chain, transport });
+    const poolId = cfg.pool ?? cfg.poolId;
+    header("ILAL Status", chain.name);
+    let credentialReady;
+    let issuerReady;
+    let policyReady;
+    // ── Credential ──────────────────────────────────────────────────────────────
+    if (cfg.wallet && cfg.issuer) {
+        if (!isAddress(cfg.wallet)) {
+            log.warn("Invalid wallet address");
+        }
+        else if (!isAddress(cfg.issuer)) {
+            log.warn("Invalid issuer address");
+        }
+        else {
+            const spin = new Spinner("Fetching credential…").start();
+            try {
+                const [valid, tokenId] = await Promise.all([
+                    client.readContract({ address: cfg.issuer, abi: CNF_ABI, functionName: "isValid", args: [cfg.wallet] }),
+                    client.readContract({ address: cfg.issuer, abi: CNF_ABI, functionName: "credentialOf", args: [cfg.wallet] }),
+                ]);
+                spin.stop();
+                log.section("Credential");
+                log.kv("wallet", fmt.cyan(cfg.wallet));
+                log.kv("issuer", fmt.cyan(cfg.issuer));
+                if (tokenId === 0n) {
+                    log.kv("status", fmt.badge("missing", "red"));
+                    log.command("ilal credential prove --wallet " + cfg.wallet + " --update-root");
+                    credentialReady = false;
+                }
+                else {
+                    const cred = await client.readContract({
+                        address: cfg.issuer, abi: CNF_ABI,
+                        functionName: "getCredential", args: [tokenId],
+                    });
+                    const days = daysUntil(Number(cred.expiresAt));
+                    const expiryStr = new Date(Number(cred.expiresAt) * 1000).toISOString().split("T")[0];
+                    const daysLabel = days > 0
+                        ? fmt.gray(`(${days}d remaining)`)
+                        : fmt.red("(EXPIRED)");
+                    log.kv("token ID", fmt.cyan(`#${tokenId}`));
+                    log.kv("issued", fmt.gray(new Date(Number(cred.issuedAt) * 1000).toISOString().split("T")[0]));
+                    log.kv("expires", `${fmt.cyan(expiryStr)} ${daysLabel}`);
+                    log.kv("revoked", cred.revoked ? fmt.badge("yes", "red") : fmt.badge("no", "gray"));
+                    log.kv("status", valid ? fmt.badge("valid", "green") + " can trade" : fmt.badge("invalid", "red"));
+                    credentialReady = valid;
+                }
+            }
+            catch (e) {
+                spin.stop();
+                dieOnContract(e);
+            }
+            log.line();
+        }
+    }
+    // ── Issuer config ────────────────────────────────────────────────────────────
+    if (cfg.issuer && isAddress(cfg.issuer)) {
+        const spin = new Spinner("Fetching issuer config…").start();
+        try {
+            const [root, verifier] = await Promise.all([
+                client.readContract({ address: cfg.issuer, abi: CNF_ABI, functionName: "merkleRoot" }),
+                client.readContract({ address: cfg.issuer, abi: CNF_ABI, functionName: "zkVerifier" }),
+            ]);
+            spin.stop();
+            log.section("Issuer");
+            log.kv("address", fmt.cyan(cfg.issuer));
+            log.kv("zkVerifier", verifier === "0x0000000000000000000000000000000000000000"
+                ? fmt.badge("not set", "red")
+                : fmt.green(fmt.addr(verifier)));
+            log.kv("merkleRoot", root === 0n
+                ? fmt.badge("not set", "red")
+                : fmt.gray(root.toString().slice(0, 20) + "…"));
+            issuerReady = root !== 0n && verifier !== "0x0000000000000000000000000000000000000000";
+        }
+        catch (e) {
+            spin.stop();
+            log.warn(`Could not fetch issuer config: ${e instanceof Error ? e.message.split("\n")[0] : String(e)}`);
+        }
+        log.line();
+    }
+    // ── Pool policy ──────────────────────────────────────────────────────────────
+    if (cfg.registry && poolId && isAddress(cfg.registry)) {
+        const spin = new Spinner("Fetching pool policy…").start();
+        try {
+            const policy = await client.readContract({
+                address: cfg.registry, abi: REGISTRY_ABI,
+                functionName: "getPolicy", args: [poolId],
+            });
+            spin.stop();
+            const configured = policy.enabled && policy.cnfIssuer !== "0x0000000000000000000000000000000000000000";
+            log.section("Pool Policy");
+            log.kv("pool", fmt.hash(poolId));
+            log.kv("registry", fmt.cyan(cfg.registry));
+            if (configured) {
+                log.kv("issuer", fmt.addr(policy.cnfIssuer));
+                log.kv("schema", fmt.hash(policy.requiredCredentialType));
+                log.kv("status", fmt.badge("configured", "green"));
+            }
+            else {
+                log.kv("status", fmt.badge("missing", "red"));
+                log.command("ilal pool policy set --pool " + poolId);
+            }
+            policyReady = configured;
+        }
+        catch (e) {
+            spin.stop();
+            log.warn(`Could not fetch policy: ${e instanceof Error ? e.message.split("\n")[0] : String(e)}`);
+        }
+        log.line();
+    }
+    // ── Hint if nothing was shown ────────────────────────────────────────────────
+    if (!cfg.wallet && !cfg.issuer && !cfg.registry) {
+        log.info("Pass --wallet and --issuer to check credential status.");
+        log.info(`Or run ${fmt.cyan("ilal init")} to save your config.`);
+        console.log();
+    }
+    else {
+        const checks = [credentialReady, issuerReady, policyReady].filter((v) => v !== undefined);
+        if (checks.length > 0) {
+            const passed = checks.filter(Boolean).length;
+            const readiness = Math.round((passed / checks.length) * 100);
+            const tone = readiness >= 85 ? "green" : readiness >= 60 ? "yellow" : "red";
+            log.section("Access Verdict");
+            log.progress("readiness", readiness, tone);
+            if (readiness >= 85) {
+                log.callout("Wallet can use ILAL", "credential and pool policy are aligned for hook-gated execution", "green");
+            }
+            else {
+                log.callout("Wallet is not ready", "fix the failing credential, issuer, or policy check above", tone);
+            }
+            console.log();
+        }
+    }
+}

package/dist/commands/swap.d.ts

@@ -0,0 +1,38 @@
+/**
+ * swap.ts — `ilal swap`
+ *
+ * Execute a compliant token swap through the ILAL channel.
+ *
+ * Signs a fresh SessionToken internally, then calls ILALRouter.swap()
+ * on-chain.  The ComplianceHook verifies the session + CNF credential
+ * before the swap is executed.
+ *
+ * Usage:
+ *   ilal swap \
+ *     --amount-in 100 \
+ *     --token-in  0xTOKA \
+ *     --zero-for-one \
+ *     --router    0xROUTER \
+ *     --hook      0xHOOK \
+ *     --issuer    0xISSUER \
+ *     --pool-id   0xPOOLID \
+ *     --chain     84532
+ */
+export declare function swap(opts: {
+    amountIn: string;
+    tokenIn?: string;
+    zeroForOne?: boolean;
+    poolId?: string;
+    router?: string;
+    hook?: string;
+    issuer?: string;
+    tokenA?: string;
+    tokenB?: string;
+    fee?: string;
+    tickSpacing?: string;
+    chain?: string;
+    rpc?: string;
+    privateKey?: string;
+    ttl?: string;
+    simulate?: boolean;
+}): Promise<void>;

package/dist/commands/swap.js

@@ -0,0 +1,284 @@
+/**
+ * swap.ts — `ilal swap`
+ *
+ * Execute a compliant token swap through the ILAL channel.
+ *
+ * Signs a fresh SessionToken internally, then calls ILALRouter.swap()
+ * on-chain.  The ComplianceHook verifies the session + CNF credential
+ * before the swap is executed.
+ *
+ * Usage:
+ *   ilal swap \
+ *     --amount-in 100 \
+ *     --token-in  0xTOKA \
+ *     --zero-for-one \
+ *     --router    0xROUTER \
+ *     --hook      0xHOOK \
+ *     --issuer    0xISSUER \
+ *     --pool-id   0xPOOLID \
+ *     --chain     84532
+ */
+import { createPublicClient, createWalletClient, encodeAbiParameters, http, isAddress, isHex, parseAbiParameters, parseUnits, } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { base, baseSepolia } from "viem/chains";
+import { fmt, log, header, Spinner, die, dieOnContract } from "../ui.js";
+import { withConfig } from "../config.js";
+const CHAINS = { "8453": base, "84532": baseSepolia };
+// ─── ABIs ─────────────────────────────────────────────────────────────────────
+const ERC20_ABI = [
+    { name: "decimals", type: "function", stateMutability: "view", inputs: [], outputs: [{ type: "uint8" }] },
+    { name: "symbol", type: "function", stateMutability: "view", inputs: [], outputs: [{ type: "string" }] },
+    { name: "balanceOf", type: "function", stateMutability: "view", inputs: [{ name: "owner", type: "address" }], outputs: [{ type: "uint256" }] },
+    { name: "allowance", type: "function", stateMutability: "view", inputs: [{ name: "owner", type: "address" }, { name: "spender", type: "address" }], outputs: [{ type: "uint256" }] },
+    { name: "approve", type: "function", stateMutability: "nonpayable", inputs: [{ name: "spender", type: "address" }, { name: "amount", type: "uint256" }], outputs: [{ type: "bool" }] },
+];
+const ROUTER_ABI = [
+    { name: "protocolFeePips", type: "function", stateMutability: "view", inputs: [], outputs: [{ type: "uint24" }] },
+    { name: "treasury", type: "function", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] },
+    {
+        name: "swap", type: "function", stateMutability: "payable",
+        inputs: [
+            { name: "key", type: "tuple", components: [
+                    { name: "currency0", type: "address" },
+                    { name: "currency1", type: "address" },
+                    { name: "fee", type: "uint24" },
+                    { name: "tickSpacing", type: "int24" },
+                    { name: "hooks", type: "address" },
+                ] },
+            { name: "params", type: "tuple", components: [
+                    { name: "zeroForOne", type: "bool" },
+                    { name: "amountSpecified", type: "int256" },
+                    { name: "sqrtPriceLimitX96", type: "uint160" },
+                ] },
+            { name: "hookData", type: "bytes" },
+        ],
+        outputs: [{ name: "delta", type: "int256" }],
+    },
+];
+// ─── Session helpers ──────────────────────────────────────────────────────────
+const SESSION_TOKEN_TYPE = [
+    { name: "user", type: "address" },
+    { name: "authorizedCaller", type: "address" },
+    { name: "cnfIssuer", type: "address" },
+    { name: "chainId", type: "uint256" },
+    { name: "verifyingHook", type: "address" },
+    { name: "poolId", type: "bytes32" },
+    { name: "action", type: "uint8" },
+    { name: "deadline", type: "uint64" },
+    { name: "nonce", type: "bytes32" },
+];
+const HOOK_DATA_ABI = parseAbiParameters([
+    "(address user, address authorizedCaller, address cnfIssuer, uint256 chainId, address verifyingHook, bytes32 poolId, uint8 action, uint64 deadline, bytes32 nonce) token",
+    "bytes signature",
+]);
+// sqrtPriceLimitX96 — use min/max to let the swap fill fully
+const MIN_SQRT_PRICE = 4295128740n; // TickMath.MIN_SQRT_PRICE + 1
+const MAX_SQRT_PRICE = 1461446703485210103287273052203988822378723970341n; // MAX - 1
+const DYNAMIC_FEE_FLAG = 8388608;
+const PIPS_DENOMINATOR = 1000000n;
+function txUrl(chain, hash) {
+    const baseUrl = chain.blockExplorers?.default?.url;
+    return baseUrl ? `${baseUrl}/tx/${hash}` : undefined;
+}
+function feeLabel(fee) {
+    if (fee === DYNAMIC_FEE_FLAG)
+        return `${fmt.badge("fair flow", "green")} verified swap fee 0.05%`;
+    return `${fmt.badge("static", "gray")} ${(fee / 10_000).toFixed(4).replace(/0+$/, "").replace(/\.$/, "")}%`;
+}
+function pipsToPercent(pips) {
+    return `${(pips / 10_000).toFixed(4).replace(/0+$/, "").replace(/\.$/, "")}%`;
+}
+function poolFeePercent(fee) {
+    return fee === DYNAMIC_FEE_FLAG
+        ? "0.05%"
+        : `${(fee / 10_000).toFixed(4).replace(/0+$/, "").replace(/\.$/, "")}%`;
+}
+// ─── Main export ──────────────────────────────────────────────────────────────
+export async function swap(opts) {
+    const cfg = withConfig(opts);
+    const rawKey = cfg.privateKey ?? process.env["PRIVATE_KEY"];
+    if (!rawKey)
+        die("Private key required. Use --private-key or set PRIVATE_KEY env var.");
+    if (!cfg.router)
+        die("ILALRouter address required. Use --router or set in .ilal.json");
+    if (!cfg.hook)
+        die("ComplianceHook address required. Use --hook or set in .ilal.json");
+    if (!cfg.issuer)
+        die("CNFIssuer address required. Use --issuer or set in .ilal.json");
+    if (!cfg.poolId)
+        die("Pool ID required. Use --pool-id or set in .ilal.json");
+    if (!isAddress(cfg.router))
+        die(`Invalid router address: ${cfg.router}`);
+    if (!isAddress(cfg.hook))
+        die(`Invalid hook address: ${cfg.hook}`);
+    if (!isAddress(cfg.issuer))
+        die(`Invalid issuer address: ${cfg.issuer}`);
+    if (!isHex(cfg.poolId) || cfg.poolId.length !== 66)
+        die("poolId must be 0x + 64 hex chars");
+    const chain = CHAINS[cfg.chain ?? "84532"] ?? baseSepolia;
+    const account = privateKeyToAccount(rawKey);
+    const transport = cfg.rpc ? http(cfg.rpc) : http();
+    const pubClient = createPublicClient({ chain, transport });
+    const walClient = createWalletClient({ account, chain, transport });
+    // Determine token order
+    const tokenA = (cfg.tokenA ?? opts.tokenA);
+    const tokenB = (cfg.tokenB ?? opts.tokenB);
+    if (!tokenA || !tokenB)
+        die("Token addresses required. Use --token-a/--token-b or set in .ilal.json");
+    // currency0 < currency1
+    const c0 = tokenA.toLowerCase() < tokenB.toLowerCase() ? tokenA : tokenB;
+    const c1 = tokenA.toLowerCase() < tokenB.toLowerCase() ? tokenB : tokenA;
+    const tokenIn = (opts.tokenIn ?? tokenA);
+    if (!isAddress(tokenIn))
+        die(`Invalid token-in address: ${tokenIn}`);
+    const zeroForOne = tokenIn.toLowerCase() === c0.toLowerCase();
+    header("ILAL Swap", chain.name);
+    log.kv("router", fmt.cyan(cfg.router));
+    log.kv("hook", fmt.cyan(cfg.hook));
+    log.kv("pool", fmt.gray(cfg.poolId.slice(0, 18) + "…"));
+    log.kv("tokenIn", fmt.cyan(tokenIn));
+    log.kv("direction", zeroForOne ? "currency0 → currency1" : "currency1 → currency0");
+    log.line();
+    // Fetch token decimals + symbol
+    const spin = new Spinner("Fetching token info…").start();
+    const [decimals, symbol] = await Promise.all([
+        pubClient.readContract({ address: tokenIn, abi: ERC20_ABI, functionName: "decimals" }),
+        pubClient.readContract({ address: tokenIn, abi: ERC20_ABI, functionName: "symbol" }),
+    ]);
+    spin.stop();
+    const amountIn = parseUnits(opts.amountIn, decimals);
+    log.kv("amount", `${opts.amountIn} ${fmt.cyan(symbol)} (${amountIn.toString()} wei)`);
+    let protocolFeePips = 0;
+    let treasury;
+    try {
+        [protocolFeePips, treasury] = await Promise.all([
+            pubClient.readContract({ address: cfg.router, abi: ROUTER_ABI, functionName: "protocolFeePips" }),
+            pubClient.readContract({ address: cfg.router, abi: ROUTER_ABI, functionName: "treasury" }),
+        ]);
+    }
+    catch {
+        protocolFeePips = 0;
+    }
+    const protocolFeeAmount = amountIn * BigInt(protocolFeePips) / PIPS_DENOMINATOR;
+    const totalDebit = amountIn + protocolFeeAmount;
+    log.deal([
+        { label: "verified input", value: `${opts.amountIn} ${symbol}`, note: "exact-in swap", tone: "cyan" },
+        { label: "LP fee", value: poolFeePercent(parseInt(cfg.fee ?? "3000")), note: "hook-priced flow", tone: "green" },
+        { label: "ILAL fee", value: protocolFeePips > 0 ? pipsToPercent(protocolFeePips) : "off", note: protocolFeePips > 0 ? "protocol revenue" : "legacy router", tone: protocolFeePips > 0 ? "cyan" : "gray" },
+    ]);
+    log.line();
+    // Check allowance — approve if needed
+    const approveSpin = new Spinner("Checking allowance…").start();
+    const allowed = await pubClient.readContract({
+        address: tokenIn,
+        abi: ERC20_ABI,
+        functionName: "allowance",
+        args: [account.address, cfg.router],
+    });
+    if (allowed < totalDebit) {
+        approveSpin.update(`Approving ${symbol} for ILALRouter…`);
+        const approveHash = await walClient.writeContract({
+            address: tokenIn,
+            abi: ERC20_ABI,
+            functionName: "approve",
+            args: [cfg.router, totalDebit * 10n], // approve 10× for future swaps
+        });
+        await pubClient.waitForTransactionReceipt({ hash: approveHash });
+        approveSpin.succeed(`Approved ${symbol} ${fmt.gray(fmt.hash(approveHash))}`);
+    }
+    else {
+        approveSpin.succeed(`Allowance ok (${fmt.gray(allowed.toString())} wei)`);
+    }
+    // Sign session token
+    const signSpin = new Spinner("Signing session token…").start();
+    const ttl = parseInt(opts.ttl ?? "600");
+    const deadline = BigInt(Math.floor(Date.now() / 1000) + ttl);
+    const nonce = `0x${Buffer.from(crypto.getRandomValues(new Uint8Array(32))).toString("hex")}`;
+    const token = {
+        user: account.address,
+        authorizedCaller: cfg.router,
+        cnfIssuer: cfg.issuer,
+        chainId: BigInt(chain.id),
+        verifyingHook: cfg.hook,
+        poolId: cfg.poolId,
+        action: 1, // ACTION_SWAP
+        deadline,
+        nonce,
+    };
+    const signature = await walClient.signTypedData({
+        account,
+        domain: {
+            name: "ILAL ComplianceHook",
+            version: "1",
+            chainId: BigInt(chain.id),
+            verifyingContract: cfg.hook,
+        },
+        types: { SessionToken: SESSION_TOKEN_TYPE },
+        primaryType: "SessionToken",
+        message: token,
+    });
+    const hookData = encodeAbiParameters(HOOK_DATA_ABI, [token, signature]);
+    signSpin.succeed(`Session signed (expires in ${ttl}s)`);
+    const fee = parseInt(cfg.fee ?? "3000");
+    const tickSpacing = parseInt(cfg.tickSpacing ?? "60");
+    log.section("Gate Checks");
+    log.kv("credential", `${fmt.badge("required", "cyan")} issuer ${fmt.addr(cfg.issuer)}`);
+    log.kv("caller", `${fmt.badge("bound", "green")} ${fmt.addr(cfg.router)}`);
+    log.kv("nonce", `${fmt.badge("fresh", "green")} ${fmt.hash(nonce)}`);
+    log.kv("fee", feeLabel(fee));
+    if (protocolFeePips > 0) {
+        log.kv("protocol fee", `${fmt.badge("ILAL", "cyan")} ${pipsToPercent(protocolFeePips)} to ${treasury ? fmt.addr(treasury) : "treasury"}`);
+        log.kv("total debit", `${totalDebit.toString()} wei (${symbol} input + ILAL fee)`);
+    }
+    log.line();
+    if (opts.simulate) {
+        log.ok("Simulation mode — skipping on-chain tx");
+        log.kv("hookData", hookData.slice(0, 22) + "…");
+        console.log();
+        return;
+    }
+    // Build PoolKey
+    const poolKey = {
+        currency0: c0,
+        currency1: c1,
+        fee,
+        tickSpacing,
+        hooks: cfg.hook,
+    };
+    const swapParams = {
+        zeroForOne,
+        amountSpecified: -amountIn, // negative = exactIn
+        sqrtPriceLimitX96: zeroForOne ? MIN_SQRT_PRICE : MAX_SQRT_PRICE,
+    };
+    // Execute swap
+    const txSpin = new Spinner("Sending swap tx…").start();
+    let txHash;
+    try {
+        txHash = await walClient.writeContract({
+            address: cfg.router,
+            abi: ROUTER_ABI,
+            functionName: "swap",
+            args: [poolKey, swapParams, hookData],
+            value: 0n,
+        });
+        txSpin.update(`Confirming ${fmt.gray(fmt.hash(txHash))}…`);
+        const receipt = await pubClient.waitForTransactionReceipt({ hash: txHash });
+        if (receipt.status !== "success") {
+            txSpin.fail("Transaction reverted");
+            die(`Tx failed: ${txHash}`);
+        }
+        txSpin.succeed(fmt.bold(fmt.green(`Swap executed via ILAL channel ✓`)));
+    }
+    catch (e) {
+        txSpin.fail("Swap failed");
+        dieOnContract(e);
+    }
+    log.line();
+    log.callout("Hook-enforced swap", "credential, session, caller binding, and nonce all passed on-chain", "green");
+    log.kv("tx", fmt.gray(txHash));
+    log.kv("block", fmt.gray((await pubClient.getTransactionReceipt({ hash: txHash })).blockNumber.toString()));
+    const explorer = txUrl(chain, txHash);
+    if (explorer)
+        log.kv("explorer", fmt.cyan(explorer));
+    console.log();
+}

package/dist/config.d.ts

@@ -0,0 +1,29 @@
+/**
+ * config.ts — ILAL CLI project configuration.
+ *
+ * Loads from (highest priority first):
+ *   1. CLI flags (handled by Commander, passed directly)
+ *   2. Environment variables (ILAL_ISSUER, ILAL_CHAIN, etc.)
+ *   3. .ilal.json in current dir or any parent dir
+ */
+export interface ILALConfig {
+    issuer?: string;
+    hook?: string;
+    registry?: string;
+    router?: string;
+    treasury?: string;
+    tokenA?: string;
+    tokenB?: string;
+    poolId?: string;
+    fee?: string;
+    tickSpacing?: string;
+    chain?: string;
+    rpc?: string;
+    circuitDir?: string;
+    outDir?: string;
+}
+export declare function loadConfig(): ILALConfig;
+/** Merge CLI flags over config (undefined flags don't override) */
+export declare function withConfig<T extends Partial<ILALConfig>>(flags: T): T & ILALConfig;
+export declare function writeConfig(config: ILALConfig, dir?: string): string;
+export declare function configFilePath(): string | null;

package/dist/config.js

@@ -0,0 +1,75 @@
+/**
+ * config.ts — ILAL CLI project configuration.
+ *
+ * Loads from (highest priority first):
+ *   1. CLI flags (handled by Commander, passed directly)
+ *   2. Environment variables (ILAL_ISSUER, ILAL_CHAIN, etc.)
+ *   3. .ilal.json in current dir or any parent dir
+ */
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { resolve, dirname } from "path";
+const CONFIG_FILE = ".ilal.json";
+// ─── Find config file ─────────────────────────────────────────────────────────
+function findConfigFile(startDir = process.cwd()) {
+    let dir = startDir;
+    for (let i = 0; i < 6; i++) {
+        const candidate = resolve(dir, CONFIG_FILE);
+        if (existsSync(candidate))
+            return candidate;
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+// ─── Load config ──────────────────────────────────────────────────────────────
+let _config = null;
+export function loadConfig() {
+    if (_config)
+        return _config;
+    // Start with file config
+    const filePath = findConfigFile();
+    let fileConfig = {};
+    if (filePath) {
+        try {
+            fileConfig = JSON.parse(readFileSync(filePath, "utf8"));
+        }
+        catch { /* malformed, ignore */ }
+    }
+    // Overlay env vars
+    _config = {
+        issuer: process.env["ILAL_ISSUER"] ?? fileConfig.issuer,
+        hook: process.env["ILAL_HOOK"] ?? fileConfig.hook,
+        registry: process.env["ILAL_REGISTRY"] ?? fileConfig.registry,
+        router: process.env["ILAL_ROUTER"] ?? fileConfig.router,
+        treasury: process.env["ILAL_TREASURY"] ?? fileConfig.treasury,
+        tokenA: process.env["ILAL_TOKEN_A"] ?? fileConfig.tokenA,
+        tokenB: process.env["ILAL_TOKEN_B"] ?? fileConfig.tokenB,
+        poolId: process.env["ILAL_POOL_ID"] ?? fileConfig.poolId,
+        fee: process.env["ILAL_FEE"] ?? fileConfig.fee,
+        tickSpacing: process.env["ILAL_TICK_SPACING"] ?? fileConfig.tickSpacing,
+        chain: process.env["ILAL_CHAIN"] ?? fileConfig.chain,
+        rpc: process.env["ILAL_RPC"] ?? fileConfig.rpc,
+        circuitDir: process.env["ILAL_CIRCUIT_DIR"] ?? fileConfig.circuitDir,
+        outDir: process.env["ILAL_OUT_DIR"] ?? fileConfig.outDir,
+    };
+    return _config;
+}
+/** Merge CLI flags over config (undefined flags don't override) */
+export function withConfig(flags) {
+    const cfg = loadConfig();
+    return {
+        ...cfg,
+        ...Object.fromEntries(Object.entries(flags).filter(([, v]) => v !== undefined)),
+    };
+}
+// ─── Write config ─────────────────────────────────────────────────────────────
+export function writeConfig(config, dir = process.cwd()) {
+    const path = resolve(dir, CONFIG_FILE);
+    writeFileSync(path, JSON.stringify(config, null, 2) + "\n");
+    return path;
+}
+export function configFilePath() {
+    return findConfigFile();
+}

package/dist/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const EAS_ADDRESSES: Record<number, `0x${string}`>;
+export declare const COINBASE_ATTESTER: "0x357458739F90461b99789350868CD7CF330Dd7EE";
+export declare const COINBASE_SCHEMA_UID: "0xf8b05c79f090979bf4a80270aba232dff11a10d9ca55c4f88de95317970f0de9";
+export declare const COINBASE_COUNTRY_SCHEMA: "0x1801901fabd0e6189356b4fb52bb0ab855276d84f7ec140839fbd1f6801ca065";
+export declare const DEFAULT_LIFETIME_DAYS = 90;

package/dist/constants.js

@@ -0,0 +1,14 @@
+// EAS is an OP Stack predeploy — same address on Base mainnet and Base Sepolia
+// Source: github.com/coinbase/verifications, docs.attest.org/docs/quick--start/contracts
+export const EAS_ADDRESSES = {
+    8453: "0x4200000000000000000000000000000000000021", // Base mainnet
+    84532: "0x4200000000000000000000000000000000000021", // Base Sepolia
+};
+// Coinbase Verifications — Base mainnet only (no Sepolia equivalent)
+// Source: github.com/coinbase/verifications
+export const COINBASE_ATTESTER = "0x357458739F90461b99789350868CD7CF330Dd7EE";
+// Verified Account (primary KYC schema)
+export const COINBASE_SCHEMA_UID = "0xf8b05c79f090979bf4a80270aba232dff11a10d9ca55c4f88de95317970f0de9";
+// Verified Country (jurisdiction schema — for Phase 3 policy extensions)
+export const COINBASE_COUNTRY_SCHEMA = "0x1801901fabd0e6189356b4fb52bb0ab855276d84f7ec140839fbd1f6801ca065";
+export const DEFAULT_LIFETIME_DAYS = 90;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};