@ilalv3/cli 0.1.0

package/dist/commands/demo.js

@@ -0,0 +1,346 @@
+import { createPublicClient, formatUnits, http, isAddress, isHex, } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { base, baseSepolia } from "viem/chains";
+import { loadConfig } from "../config.js";
+import { fmt, header, log } from "../ui.js";
+const CHAINS = { "8453": base, "84532": baseSepolia };
+const POOL_MANAGER = {
+    "84532": "0x05E73354cFDd6745C338b50BcFDfA3Aa6fA03408",
+    "8453": "0x498581fF718922c3f8e6A244956aF099B2652b2b",
+};
+const SAMPLE = {
+    wallet: "0x1b869CaC69Df23Ad9D727932496AEb3605538c8D",
+    issuer: "0x319c0F1cb46c85B42E051251c4db04BA6BD265a2",
+    hook: "0xdFF2ebBAc963f5Ed0B0EBCf021aB5EA16d57ea94",
+    router: "0x4A1F7E7d9D2D1f2A0c4A2F4A8C1A0B3E9E5d1111",
+    pool: "0x7ef1c0ffee00000000000000000000000000000000000000000000000000bEEF",
+    proof: "0x91f2b8a0c43e902f7f1a8c0d",
+    session: "0x6b84eac5e0db21f8d5d43b7a",
+};
+const ZERO = "0x0000000000000000000000000000000000000000";
+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: [{ type: "uint256" }] },
+    { name: "merkleRoot", type: "function", stateMutability: "view", inputs: [], outputs: [{ type: "uint256" }] },
+    { name: "zkVerifier", 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" }] }] },
+];
+const ROUTER_ABI = [
+    { name: "protocolFeePips", type: "function", stateMutability: "view", inputs: [], outputs: [{ type: "uint24" }] },
+    { name: "treasury", type: "function", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] },
+];
+const ERC20_ABI = [
+    { name: "symbol", type: "function", stateMutability: "view", inputs: [], outputs: [{ type: "string" }] },
+    { name: "decimals", type: "function", stateMutability: "view", inputs: [], outputs: [{ type: "uint8" }] },
+    { 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" }] },
+];
+function stage(n, title, subtitle) {
+    console.log();
+    console.log(`  ${fmt.badge(`step ${n}`, "cyan")} ${fmt.bold(title)}`);
+    console.log(`  ${fmt.gray(subtitle)}`);
+}
+function verdict(label, value, tone) {
+    console.log(`  ${tone === "green" ? fmt.green("●") : tone === "yellow" ? fmt.yellow("●") : tone === "red" ? fmt.red("●") : fmt.cyan("●")} ${fmt.gray(label.padEnd(20))} ${value}`);
+}
+function flowStep(label, value, tone = "cyan") {
+    const color = tone === "green" ? fmt.green : tone === "yellow" ? fmt.yellow : tone === "red" ? fmt.red : fmt.cyan;
+    console.log(`  ${color("●")} ${fmt.gray(label.padEnd(14))} ${value}`);
+}
+function pipsToPercent(pips) {
+    return `${(pips / 10_000).toFixed(4).replace(/0+$/, "").replace(/\.$/, "")}%`;
+}
+export async function demo(opts) {
+    header("Institutional DeFi Demo", "local preview");
+    log.section("Thesis");
+    log.kv("problem", "institutions face a compliance / cost / privacy trilemma");
+    log.kv("answer", "verified eligibility becomes low-cost private trading access");
+    log.kv("native layer", "Uniswap v4 Hook, not a wrapper or critical-path API");
+    log.kv("demo proof", "real Base Sepolia liquidity + swap through PoolManager");
+    log.line();
+    stage(1, "Non-eligible wallet attempts to trade", "The pool rejects access before swap execution.");
+    verdict("wallet", fmt.addr("0x000000000000000000000000000000000000dEaD"), "cyan");
+    verdict("credential", fmt.badge("missing", "red"), "red");
+    verdict("hook check", "beforeSwap -> CredentialInvalid", "red");
+    verdict("result", fmt.badge("reverted", "red") + " no trade, no bypass", "red");
+    stage(2, "Verified trader mints a CNF credential", "Coinbase EAS or ZK proof creates an expiring, non-transferable credential.");
+    verdict("wallet", fmt.addr(SAMPLE.wallet), "cyan");
+    verdict("issuer", fmt.addr(SAMPLE.issuer), "cyan");
+    verdict("proof", fmt.hash(SAMPLE.proof), "cyan");
+    verdict("credential", fmt.badge("valid", "green") + " expires in 90d", "green");
+    stage(3, "Trader signs a local session", "No API call. No gas. Session binds user + authorized caller + pool + action.");
+    verdict("user", fmt.addr(SAMPLE.wallet), "cyan");
+    verdict("caller", fmt.addr(SAMPLE.router), "cyan");
+    verdict("pool", fmt.hash(SAMPLE.pool), "cyan");
+    verdict("session", fmt.hash(SAMPLE.session), "cyan");
+    verdict("cost", fmt.badge("0 gas", "green") + " local EIP-712 signature", "green");
+    stage(4, "Compliant swap executes through the Hook", "The Hook enforces policy, credential type, caller binding, and nonce replay protection.");
+    verdict("hook", fmt.addr(SAMPLE.hook), "cyan");
+    verdict("policy", fmt.badge("configured", "green") + " required CNF type matched", "green");
+    verdict("nonce", fmt.badge("unused", "green") + " consumed on success", "green");
+    verdict("result", fmt.badge("swap allowed", "green") + " institutional liquidity path opened", "green");
+    console.log();
+    log.section("What Changed Since The Prototype");
+    log.kv("before", "API verified proofs and activated sessions");
+    log.kv("now", "CLI/SDK generate locally; contracts enforce on-chain");
+    log.kv("trust path", fmt.badge("no API critical path", "green") + " Hook-native enforcement");
+    log.line();
+    log.result("Pitch line", "ILAL solves the compliance-cost-privacy trilemma for institutional DeFi.", "cyan");
+    if (opts.commands) {
+        console.log();
+        log.section("Live Demo Commands");
+        log.command("ilal status --wallet <wallet>");
+        log.command("ilal credential prove --wallet <wallet> --update-root");
+        log.command("ilal session sign --pool <poolId> --action swap --hook <hook> --issuer <issuer> --caller <router>");
+        log.command("ilal swap --amount-in 100 --token-in <token> --pool-id <poolId>");
+    }
+    console.log();
+}
+function ok(label, value) {
+    console.log(`  ${fmt.green("●")} ${fmt.gray(label.padEnd(20))} ${value}`);
+}
+function warn(label, value) {
+    console.log(`  ${fmt.yellow("●")} ${fmt.gray(label.padEnd(20))} ${value}`);
+}
+function bad(label, value) {
+    console.log(`  ${fmt.red("●")} ${fmt.gray(label.padEnd(20))} ${value}`);
+}
+async function hasCode(client, label, address) {
+    if (!address) {
+        bad(label, fmt.badge("missing", "red"));
+        return false;
+    }
+    if (!isAddress(address)) {
+        bad(label, `invalid address ${address}`);
+        return false;
+    }
+    try {
+        const code = await client.getBytecode({ address: address });
+        if (code && code !== "0x") {
+            ok(label, fmt.addr(address));
+            return true;
+        }
+        bad(label, `${fmt.addr(address)} ${fmt.badge("no code", "red")}`);
+        return false;
+    }
+    catch (e) {
+        bad(label, e instanceof Error ? e.message.split("\n")[0] : String(e));
+        return false;
+    }
+}
+export async function demoCheck(opts) {
+    const cfg = loadConfig();
+    const chain = CHAINS[cfg.chain ?? "84532"] ?? baseSepolia;
+    const client = createPublicClient({ chain, transport: http(cfg.rpc) });
+    const rawKey = opts.privateKey ?? process.env["PRIVATE_KEY"];
+    const wallet = opts.wallet
+        ?? (rawKey && isHex(rawKey) && rawKey.length === 66 ? privateKeyToAccount(rawKey).address : undefined);
+    header("Live Demo Preflight", chain.name);
+    log.deal([
+        { label: "Private proof", value: "ZK/CNF", note: "eligibility without full identity", tone: "cyan" },
+        { label: "Verified LP fee", value: "0.05%", note: "dynamic fee override", tone: "green" },
+        { label: "ILAL protocol fee", value: "0.005%", note: "on-chain verified flow revenue", tone: "cyan" },
+    ]);
+    log.line();
+    let score = 0;
+    let total = 0;
+    const pass = (condition) => {
+        total++;
+        if (condition)
+            score++;
+    };
+    log.section("Network");
+    log.kv("rpc", cfg.rpc ?? "default viem transport");
+    try {
+        const block = await client.getBlockNumber();
+        ok("latest block", block.toString());
+        pass(true);
+    }
+    catch (e) {
+        bad("latest block", e instanceof Error ? e.message.split("\n")[0] : String(e));
+        pass(false);
+    }
+    log.line();
+    log.section("Configuration", "addresses that define the live path");
+    const configItems = [
+        ["issuer", cfg.issuer, "address"],
+        ["hook", cfg.hook, "address"],
+        ["registry", cfg.registry, "address"],
+        ["router", cfg.router, "address"],
+        ["treasury", cfg.treasury, "address"],
+        ["currency0", cfg.tokenA, "address"],
+        ["currency1", cfg.tokenB, "address"],
+        ["poolId", cfg.poolId, "bytes32"],
+        ["fee", cfg.fee ?? "3000", "text"],
+        ["tickSpacing", cfg.tickSpacing ?? "60", "text"],
+    ];
+    for (const [label, value, kind] of configItems) {
+        const valid = !!value && (kind === "address" ? isAddress(value) : kind === "bytes32" ? isHex(value) && value.length === 66 : true);
+        if (valid) {
+            const display = kind === "bytes32"
+                ? fmt.hash(value)
+                : kind === "address"
+                    ? fmt.addr(value)
+                    : label === "fee" && value === "8388608"
+                        ? `${fmt.badge("dynamic", "green")} verified flow 0.05%`
+                        : value;
+            ok(label, display);
+        }
+        else
+            bad(label, fmt.badge("missing", "red"));
+        pass(valid);
+    }
+    log.line();
+    log.section("Contract Code", "must exist on-chain");
+    pass(await hasCode(client, "CNFIssuer", cfg.issuer));
+    pass(await hasCode(client, "ComplianceHook", cfg.hook));
+    pass(await hasCode(client, "PolicyRegistry", cfg.registry));
+    pass(await hasCode(client, "ILALRouter", cfg.router));
+    pass(await hasCode(client, "currency0", cfg.tokenA));
+    pass(await hasCode(client, "currency1", cfg.tokenB));
+    log.line();
+    if (cfg.router && isAddress(cfg.router)) {
+        log.section("Verified Flow Economics");
+        try {
+            const [protocolFeePips, treasury] = await Promise.all([
+                client.readContract({ address: cfg.router, abi: ROUTER_ABI, functionName: "protocolFeePips" }),
+                client.readContract({ address: cfg.router, abi: ROUTER_ABI, functionName: "treasury" }),
+            ]);
+            ok("LP fee", cfg.fee === "8388608" ? `${fmt.badge("dynamic", "green")} verified 0.05%` : "pool fee tier");
+            ok("ILAL fee", protocolFeePips > 0 ? `${fmt.badge("protocol", "cyan")} ${pipsToPercent(protocolFeePips)}` : fmt.badge("off", "yellow"));
+            ok("treasury", fmt.addr(treasury));
+            pass(true);
+        }
+        catch {
+            warn("protocol fee", fmt.badge("legacy router", "yellow"));
+            pass(true);
+        }
+        log.line();
+    }
+    if (cfg.issuer && isAddress(cfg.issuer)) {
+        log.section("Issuer State");
+        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" }),
+            ]);
+            if (root === 0n)
+                warn("merkleRoot", fmt.badge("not set", "yellow"));
+            else
+                ok("merkleRoot", root.toString().slice(0, 24) + "...");
+            if (verifier === ZERO)
+                warn("zkVerifier", fmt.badge("not set", "yellow"));
+            else
+                ok("zkVerifier", fmt.addr(verifier));
+        }
+        catch (e) {
+            bad("issuer reads", e instanceof Error ? e.message.split("\n")[0] : String(e));
+        }
+        if (wallet && isAddress(wallet)) {
+            try {
+                const [valid, tokenId] = await Promise.all([
+                    client.readContract({ address: cfg.issuer, abi: CNF_ABI, functionName: "isValid", args: [wallet] }),
+                    client.readContract({ address: cfg.issuer, abi: CNF_ABI, functionName: "credentialOf", args: [wallet] }),
+                ]);
+                if (valid)
+                    ok("credential", `${fmt.badge("valid", "green")} token #${tokenId}`);
+                else
+                    warn("credential", tokenId === 0n ? fmt.badge("missing", "yellow") : fmt.badge("invalid", "yellow"));
+                pass(valid);
+            }
+            catch (e) {
+                bad("credential", e instanceof Error ? e.message.split("\n")[0] : String(e));
+                pass(false);
+            }
+        }
+        else {
+            warn("wallet", "pass --wallet or set PRIVATE_KEY for credential checks");
+        }
+        log.line();
+    }
+    if (cfg.registry && cfg.poolId && isAddress(cfg.registry) && isHex(cfg.poolId) && cfg.poolId.length === 66) {
+        log.section("Pool Policy");
+        try {
+            const policy = await client.readContract({
+                address: cfg.registry,
+                abi: REGISTRY_ABI,
+                functionName: "getPolicy",
+                args: [cfg.poolId],
+            });
+            const issuerMatches = policy.cnfIssuer.toLowerCase() === (cfg.issuer ?? "").toLowerCase();
+            const ready = policy.enabled && issuerMatches;
+            (ready ? ok : warn)("policy", `${policy.enabled ? fmt.badge("enabled", "green") : fmt.badge("disabled", "yellow")} issuer ${fmt.addr(policy.cnfIssuer)}`);
+            pass(ready);
+        }
+        catch (e) {
+            bad("policy", e instanceof Error ? e.message.split("\n")[0] : String(e));
+            pass(false);
+        }
+        log.line();
+    }
+    if (wallet && cfg.router && cfg.tokenA && cfg.tokenB && isAddress(wallet) && isAddress(cfg.router)) {
+        log.section("Wallet Balances");
+        for (const [label, token] of [["currency0", cfg.tokenA], ["currency1", cfg.tokenB]]) {
+            if (!token || !isAddress(token))
+                continue;
+            try {
+                const [symbol, decimals, balance, allowance] = await Promise.all([
+                    client.readContract({ address: token, abi: ERC20_ABI, functionName: "symbol" }),
+                    client.readContract({ address: token, abi: ERC20_ABI, functionName: "decimals" }),
+                    client.readContract({ address: token, abi: ERC20_ABI, functionName: "balanceOf", args: [wallet] }),
+                    client.readContract({ address: token, abi: ERC20_ABI, functionName: "allowance", args: [wallet, cfg.router] }),
+                ]);
+                const balanceText = `${formatUnits(balance, decimals)} ${symbol}`;
+                const allowanceText = allowance > 0n ? fmt.badge("approved", "green") : fmt.badge("needs approval", "yellow");
+                (balance > 0n ? ok : warn)(label, `${balanceText} ${allowanceText}`);
+                pass(balance > 0n);
+            }
+            catch (e) {
+                bad(label, e instanceof Error ? e.message.split("\n")[0] : String(e));
+                pass(false);
+            }
+        }
+        log.line();
+    }
+    const readiness = total === 0 ? 0 : Math.round((score / total) * 100);
+    log.section("Readiness");
+    const tone = readiness >= 85 ? "green" : readiness >= 60 ? "yellow" : "red";
+    log.progress("score", readiness, tone);
+    log.metrics([
+        { label: "credential", value: wallet ? "ready" : "missing", tone: wallet ? "green" : "yellow" },
+        { label: "policy", value: cfg.poolId ? "enabled" : "missing", tone: cfg.poolId ? "green" : "yellow" },
+        { label: "deal", value: cfg.fee === "8388608" ? "better" : "standard", tone: cfg.fee === "8388608" ? "green" : "gray" },
+    ]);
+    if (readiness >= 85) {
+        log.callout("Live demo ready", "credential, policy, hook, router, pool, and balances are aligned", "green");
+    }
+    else {
+        log.callout("Live demo not ready", "fill the missing config/state first", tone);
+    }
+    log.line();
+    log.section("Live Path", readiness >= 85 ? "what the judge is about to see" : "target flow");
+    flowStep("credential", wallet ? `${fmt.addr(wallet)} holds a valid CNF` : "wallet not selected", wallet ? "green" : "yellow");
+    flowStep("session", `local EIP-712 binds user + router + pool + action`, "green");
+    flowStep("hook", `${cfg.hook ? fmt.addr(cfg.hook) : fmt.badge("missing", "red")} gates swap/liquidity`, cfg.hook ? "green" : "red");
+    flowStep("pool", cfg.poolId ? `${fmt.hash(cfg.poolId)} policy enabled` : fmt.badge("missing", "red"), cfg.poolId ? "green" : "red");
+    flowStep("result", readiness >= 85 ? fmt.badge("ready for real tx", "green") : fmt.badge("preflight incomplete", "yellow"), readiness >= 85 ? "green" : "yellow");
+    log.line();
+    log.section("Next Commands");
+    if (!cfg.router || !cfg.tokenA || !cfg.tokenB || !cfg.poolId) {
+        const poolManager = POOL_MANAGER[cfg.chain ?? "84532"] ?? POOL_MANAGER["84532"];
+        log.command(`POOL_MANAGER=${poolManager} CNF_ISSUER=${cfg.issuer ?? "<issuer>"} HOOK_ADDR=${cfg.hook ?? "<hook>"} REGISTRY_ADDR=${cfg.registry ?? "<registry>"} forge script contracts/script/DeployDemo.s.sol --rpc-url ${cfg.rpc ?? "https://sepolia.base.org"} --broadcast`);
+        log.info("Then copy router/tokenA/tokenB/poolId into .ilal.json");
+    }
+    if (wallet) {
+        log.command(`ilal status --wallet ${wallet}`);
+        log.command(`ilal session sign --pool ${cfg.poolId ?? "<poolId>"} --action swap --hook ${cfg.hook ?? "<hook>"} --issuer ${cfg.issuer ?? "<issuer>"} --caller ${cfg.router ?? "<router>"}`);
+    }
+    else {
+        log.command("ilal demo check --wallet <wallet>");
+    }
+    const suggestedTokenIn = cfg.tokenB ?? "<token>";
+    log.command(`ilal swap --amount-in 0.001 --token-in ${suggestedTokenIn}`);
+    console.log();
+}

package/dist/commands/deploy.d.ts

@@ -0,0 +1,10 @@
+export declare function deploy(opts: {
+    chain: string;
+    rpc?: string;
+    privateKey?: string;
+    broadcast: boolean;
+    verify: boolean;
+    mock: boolean;
+    walletToSeed?: string;
+    contractsDir?: string;
+}): Promise<void>;

package/dist/commands/deploy.js

@@ -0,0 +1,94 @@
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { resolve } from "path";
+import { fmt, log, die } from "../ui.js";
+import { EAS_ADDRESSES, COINBASE_ATTESTER, COINBASE_SCHEMA_UID } from "../constants.js";
+const POOL_MANAGERS = {
+    "8453": "0x498581ff718922c3f8e6a244956af099b2652b2b", // Base mainnet
+    "84532": "0x05E73354cFDd6745C338b50BcFDfA3Aa6fA03408", // Base Sepolia
+};
+const RPC_URLS = {
+    "8453": "https://mainnet.base.org",
+    "84532": "https://sepolia.base.org",
+};
+export async function deploy(opts) {
+    const privateKey = opts.privateKey ?? process.env["PRIVATE_KEY"];
+    if (!privateKey)
+        die("Private key required. Use --private-key or set PRIVATE_KEY env var.");
+    const chainId = opts.chain;
+    const poolManager = POOL_MANAGERS[chainId];
+    if (!poolManager)
+        die(`Unsupported chain: ${chainId}. Supported: 8453 (Base), 84532 (Base Sepolia).`);
+    const easAddress = EAS_ADDRESSES[parseInt(chainId)];
+    if (!easAddress)
+        die(`No EAS address for chain ${chainId}.`);
+    const rpc = opts.rpc ?? RPC_URLS[chainId] ?? die(`No default RPC for chain ${chainId}. Use --rpc.`);
+    // Find contracts directory
+    const contractsDir = opts.contractsDir
+        ? resolve(opts.contractsDir)
+        : resolve(process.cwd(), "../contracts");
+    if (!existsSync(resolve(contractsDir, "foundry.toml"))) {
+        die(`Contracts directory not found at ${contractsDir}.\nUse --contracts-dir or run from the ilal project root.`);
+    }
+    const isMock = opts.mock;
+    if (isMock && chainId === "8453")
+        die("--mock is for testnets only. Use --chain 84532.");
+    if (isMock && !opts.walletToSeed)
+        die("--mock requires --wallet-to-seed <address>.");
+    console.log();
+    console.log(fmt.bold(`  ILAL Protocol Deploy${isMock ? fmt.yellow(" [MOCK / TESTNET]") : ""}`));
+    log.line();
+    log.kv("chain", chainId === "8453" ? "Base mainnet" : "Base Sepolia");
+    log.kv("poolManager", poolManager);
+    if (isMock) {
+        log.kv("eas", fmt.yellow("MockEAS (testnet only)"));
+        log.kv("walletToSeed", opts.walletToSeed);
+    }
+    else {
+        log.kv("eas", easAddress);
+        log.kv("attester", COINBASE_ATTESTER);
+        log.kv("schemaUID", COINBASE_SCHEMA_UID.slice(0, 20) + "...");
+    }
+    log.kv("broadcast", opts.broadcast ? fmt.yellow("yes - tx will be sent") : "no (dry run)");
+    log.line();
+    const env = {
+        ...process.env,
+        PRIVATE_KEY: privateKey,
+        POOL_MANAGER: poolManager,
+    };
+    if (isMock) {
+        env["WALLET_TO_SEED"] = opts.walletToSeed;
+    }
+    else {
+        env["EAS_ADDRESS"] = easAddress;
+        env["SCHEMA_UID"] = COINBASE_SCHEMA_UID;
+        env["TRUSTED_ATTESTER"] = COINBASE_ATTESTER;
+    }
+    const script = isMock ? "script/DeployMock.s.sol" : "script/Deploy.s.sol";
+    const flags = [
+        `--rpc-url ${rpc}`,
+        opts.broadcast ? "--broadcast" : "",
+        opts.verify ? "--verify" : "",
+        "--slow",
+    ].filter(Boolean).join(" ");
+    const cmd = `forge script ${script} ${flags}`;
+    log.step(`Running: ${fmt.gray(cmd)}`);
+    console.log();
+    try {
+        execSync(cmd, {
+            cwd: contractsDir,
+            env,
+            stdio: "inherit",
+        });
+        console.log();
+        log.ok(fmt.bold(fmt.green("Deployment complete")));
+        if (opts.broadcast) {
+            log.step("Update your CLI commands with the deployed addresses:");
+            console.log(`  ${fmt.gray("ilal pool policy set --registry <PolicyRegistry> --issuer <CNFIssuer> ...")}`);
+        }
+    }
+    catch {
+        die("forge script failed. Check output above.");
+    }
+    console.log();
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,22 @@
+/**
+ * init.ts — `ilal init`
+ *
+ * Creates a .ilal.json config file in the current directory so you never
+ * have to pass --issuer, --chain, etc. on every command.
+ */
+export declare function init(opts: {
+    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;
+    force: boolean;
+}): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,88 @@
+/**
+ * init.ts — `ilal init`
+ *
+ * Creates a .ilal.json config file in the current directory so you never
+ * have to pass --issuer, --chain, etc. on every command.
+ */
+import { isAddress } from "viem";
+import { writeConfig, configFilePath } from "../config.js";
+import { fmt, log, header, die } from "../ui.js";
+// Known testnet / mainnet addresses for quick init
+const PRESETS = {
+    "84532": {
+        issuer: "0x319c0F1cb46c85B42E051251c4db04BA6BD265a2",
+        hook: "0xdFF2ebBAc963f5Ed0B0EBCf021aB5EA16d57ea94",
+        registry: "0x72A425672c1D0FA95C75F5073e6DAf72194A1E0F",
+        rpc: "https://sepolia.base.org",
+    },
+    "8453": {
+        rpc: "https://mainnet.base.org",
+    },
+};
+export async function init(opts) {
+    header("ILAL Init", "Creating .ilal.json in current directory");
+    const existing = configFilePath();
+    if (existing && !opts.force) {
+        log.warn(`Config already exists: ${fmt.cyan(existing)}`);
+        log.info(`Use ${fmt.cyan("--force")} to overwrite.`);
+        console.log();
+        return;
+    }
+    // Start with preset for the chain
+    const preset = PRESETS[opts.chain] ?? {};
+    const config = {
+        chain: opts.chain,
+        issuer: opts.issuer ?? preset["issuer"],
+        hook: opts.hook ?? preset["hook"],
+        registry: opts.registry ?? preset["registry"],
+        router: opts.router,
+        treasury: opts.treasury,
+        tokenA: opts.tokenA,
+        tokenB: opts.tokenB,
+        poolId: opts.poolId,
+        fee: opts.fee,
+        tickSpacing: opts.tickSpacing,
+        rpc: opts.rpc ?? preset["rpc"],
+        ...(opts.circuitDir ? { circuitDir: opts.circuitDir } : {}),
+    };
+    // Validate addresses
+    for (const [key, val] of Object.entries(config)) {
+        if (val && (key === "issuer" || key === "hook" || key === "registry" || key === "router" || key === "treasury" || key === "tokenA" || key === "tokenB")) {
+            if (!isAddress(val))
+                die(`Invalid ${key} address: ${val}`);
+        }
+    }
+    const path = writeConfig(config);
+    log.ok(`Created ${fmt.cyan(path)}`);
+    log.line();
+    if (config.chain)
+        log.kv("chain", config.chain === "84532" ? "Base Sepolia" : "Base");
+    if (config.issuer)
+        log.kv("issuer", fmt.cyan(config.issuer));
+    if (config.hook)
+        log.kv("hook", fmt.cyan(config.hook));
+    if (config.registry)
+        log.kv("registry", fmt.cyan(config.registry));
+    if (config.router)
+        log.kv("router", fmt.cyan(config.router));
+    if (config.treasury)
+        log.kv("treasury", fmt.cyan(config.treasury));
+    if (config.tokenA)
+        log.kv("tokenA", fmt.cyan(config.tokenA));
+    if (config.tokenB)
+        log.kv("tokenB", fmt.cyan(config.tokenB));
+    if (config.poolId)
+        log.kv("poolId", fmt.hash(config.poolId));
+    if (config.fee)
+        log.kv("fee", config.fee === "8388608" ? "dynamic" : config.fee);
+    if (config.tickSpacing)
+        log.kv("tickSpacing", config.tickSpacing);
+    if (config.rpc)
+        log.kv("rpc", config.rpc);
+    log.line();
+    console.log(`  ${fmt.gray("You can now run commands without --issuer and --chain flags:")}`);
+    console.log();
+    console.log(`  ${fmt.cyan("ilal credential prove --wallet 0x...")}`);
+    console.log(`  ${fmt.cyan("ilal status --wallet 0x...")}`);
+    console.log();
+}

package/dist/commands/liquidity.d.ts

@@ -0,0 +1,51 @@
+/**
+ * liquidity.ts — `ilal pool add-liquidity` / `ilal pool remove-liquidity`
+ *
+ * Add or remove liquidity from an ILAL-compliant Uniswap v4 pool.
+ *
+ * Signs a fresh SessionToken internally, calls ILALRouter.addLiquidity()
+ * or removeLiquidity().  The ComplianceHook verifies session + CNF.
+ *
+ * Usage:
+ *   ilal pool add-liquidity \
+ *     --tick-lower -600 --tick-upper 600 \
+ *     --liquidity  1000000000000000000 \
+ *     --router 0xROUTER --hook 0xHOOK --issuer 0xISSUER \
+ *     --pool-id 0xPOOLID --token-a 0xTOKA --token-b 0xTOKB
+ */
+export declare function addLiquidity(opts: {
+    tickLower: string;
+    tickUpper: string;
+    liquidity: string;
+    salt?: string;
+    poolId?: string;
+    router?: string;
+    hook?: string;
+    issuer?: string;
+    tokenA?: string;
+    tokenB?: string;
+    fee?: string;
+    tickSpacing?: string;
+    chain?: string;
+    rpc?: string;
+    privateKey?: string;
+    ttl?: string;
+}): Promise<void>;
+export declare function removeLiquidity(opts: {
+    tickLower: string;
+    tickUpper: string;
+    liquidity: string;
+    salt?: string;
+    poolId?: string;
+    router?: string;
+    hook?: string;
+    issuer?: string;
+    tokenA?: string;
+    tokenB?: string;
+    fee?: string;
+    tickSpacing?: string;
+    chain?: string;
+    rpc?: string;
+    privateKey?: string;
+    ttl?: string;
+}): Promise<void>;