@ilalv3/cli 0.1.0

package/dist/commands/liquidity.js

@@ -0,0 +1,249 @@
+/**
+ * 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
+ */
+import { createPublicClient, createWalletClient, encodeAbiParameters, http, isAddress, isHex, parseAbiParameters, } 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: "symbol", type: "function", stateMutability: "view", inputs: [], outputs: [{ type: "string" }] },
+    { name: "decimals", type: "function", stateMutability: "view", inputs: [], outputs: [{ type: "uint8" }] },
+    { 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_LIQUIDITY_ABI = [
+    {
+        name: "addLiquidity", 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: "tickLower", type: "int24" },
+                    { name: "tickUpper", type: "int24" },
+                    { name: "liquidityDelta", type: "int256" },
+                    { name: "salt", type: "bytes32" },
+                ] },
+            { name: "hookData", type: "bytes" },
+        ],
+        outputs: [
+            { name: "callerDelta", type: "int256" },
+            { name: "feesAccrued", type: "int256" },
+        ],
+    },
+    {
+        name: "removeLiquidity", type: "function", stateMutability: "nonpayable",
+        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: "tickLower", type: "int24" },
+                    { name: "tickUpper", type: "int24" },
+                    { name: "liquidityDelta", type: "int256" },
+                    { name: "salt", type: "bytes32" },
+                ] },
+            { name: "hookData", type: "bytes" },
+        ],
+        outputs: [
+            { name: "callerDelta", type: "int256" },
+            { name: "feesAccrued", 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",
+]);
+function txUrl(chain, hash) {
+    const baseUrl = chain.blockExplorers?.default?.url;
+    return baseUrl ? `${baseUrl}/tx/${hash}` : undefined;
+}
+// ─── Shared core ──────────────────────────────────────────────────────────────
+async function executeLiquidity(action, 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 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");
+    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 });
+    // Ensure currency0 < currency1
+    const c0 = tokenA.toLowerCase() < tokenB.toLowerCase() ? tokenA : tokenB;
+    const c1 = tokenA.toLowerCase() < tokenB.toLowerCase() ? tokenB : tokenA;
+    const tickLower = parseInt(opts.tickLower);
+    const tickUpper = parseInt(opts.tickUpper);
+    const liquidity = BigInt(opts.liquidity);
+    const fee = parseInt(cfg.fee ?? "3000");
+    const tickSpacing = parseInt(cfg.tickSpacing ?? "60");
+    const salt = (opts.salt ?? "0x0000000000000000000000000000000000000000000000000000000000000000");
+    const verb = action === "add" ? "Add" : "Remove";
+    header(`ILAL ${verb} Liquidity`, 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("tickLower", tickLower.toString());
+    log.kv("tickUpper", tickUpper.toString());
+    log.kv("liquidity", liquidity.toString());
+    log.line();
+    // Approve both tokens if adding liquidity
+    if (action === "add") {
+        const MAX = 2n ** 256n - 1n;
+        for (const token of [c0, c1]) {
+            const sym = await pubClient.readContract({ address: token, abi: ERC20_ABI, functionName: "symbol" });
+            const allowed = await pubClient.readContract({
+                address: token, abi: ERC20_ABI, functionName: "allowance",
+                args: [account.address, cfg.router],
+            });
+            if (allowed < MAX / 2n) {
+                const appSpin = new Spinner(`Approving ${sym}…`).start();
+                const h = await walClient.writeContract({
+                    address: token, abi: ERC20_ABI, functionName: "approve",
+                    args: [cfg.router, MAX],
+                });
+                await pubClient.waitForTransactionReceipt({ hash: h });
+                appSpin.succeed(`Approved ${sym} ${fmt.gray(fmt.hash(h))}`);
+            }
+        }
+    }
+    // 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")}`;
+    // action: 2 = ADD_LIQUIDITY, 3 = REMOVE_LIQUIDITY
+    const actionCode = action === "add" ? 2 : 3;
+    const token = {
+        user: account.address,
+        authorizedCaller: cfg.router,
+        cnfIssuer: cfg.issuer,
+        chainId: BigInt(chain.id),
+        verifyingHook: cfg.hook,
+        poolId: cfg.poolId,
+        action: actionCode,
+        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)`);
+    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.line();
+    // Build PoolKey + params
+    const poolKey = {
+        currency0: c0,
+        currency1: c1,
+        fee,
+        tickSpacing,
+        hooks: cfg.hook,
+    };
+    const liquidityDelta = action === "add" ? liquidity : -liquidity;
+    const liquidityParams = { tickLower, tickUpper, liquidityDelta, salt };
+    const fnName = action === "add" ? "addLiquidity" : "removeLiquidity";
+    // Execute
+    const txSpin = new Spinner(`Sending ${fnName}…`).start();
+    let txHash;
+    try {
+        const baseArgs = [poolKey, liquidityParams, hookData];
+        txHash = await (action === "add"
+            ? walClient.writeContract({ address: cfg.router, abi: ROUTER_LIQUIDITY_ABI, functionName: "addLiquidity", args: baseArgs, value: 0n })
+            : walClient.writeContract({ address: cfg.router, abi: ROUTER_LIQUIDITY_ABI, functionName: "removeLiquidity", args: baseArgs }));
+        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(`Liquidity ${action === "add" ? "added" : "removed"} via ILAL channel ✓`)));
+    }
+    catch (e) {
+        txSpin.fail(`${fnName} failed`);
+        dieOnContract(e);
+    }
+    log.line();
+    log.callout(action === "add" ? "Hook-enforced liquidity add" : "Hook-enforced liquidity removal", "pool policy, credential type, session 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();
+}
+// ─── Public exports ───────────────────────────────────────────────────────────
+export async function addLiquidity(opts) {
+    await executeLiquidity("add", opts);
+}
+export async function removeLiquidity(opts) {
+    await executeLiquidity("remove", opts);
+}

package/dist/commands/mint.d.ts

@@ -0,0 +1,11 @@
+declare function sendMintTx(mode: "mint" | "renew", opts: {
+    attestation: string;
+    issuer: string;
+    chain: string;
+    rpc?: string;
+    privateKey?: string;
+    simulate: boolean;
+}): Promise<void>;
+export declare const mintCredential: (opts: Parameters<typeof sendMintTx>[1]) => Promise<void>;
+export declare const renewCredential: (opts: Parameters<typeof sendMintTx>[1]) => Promise<void>;
+export {};

package/dist/commands/mint.js

@@ -0,0 +1,146 @@
+import { createPublicClient, createWalletClient, http, isAddress, isHex, } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { base, baseSepolia } from "viem/chains";
+import { fmt, log, die } from "../ui.js";
+import { EAS_ADDRESSES, COINBASE_SCHEMA_UID, COINBASE_ATTESTER } from "../constants.js";
+const CHAINS = { "8453": base, "84532": baseSepolia };
+const CNF_ISSUER_ABI = [
+    {
+        name: "mintWithEAS",
+        type: "function",
+        stateMutability: "nonpayable",
+        inputs: [{ name: "attestationUID", type: "bytes32" }],
+        outputs: [{ name: "tokenId", type: "uint256" }],
+    },
+    {
+        name: "renewWithEAS",
+        type: "function",
+        stateMutability: "nonpayable",
+        inputs: [{ name: "attestationUID", type: "bytes32" }],
+        outputs: [],
+    },
+    {
+        name: "isValid",
+        type: "function",
+        stateMutability: "view",
+        inputs: [{ name: "wallet", type: "address" }],
+        outputs: [{ type: "bool" }],
+    },
+];
+async function sendMintTx(mode, opts) {
+    const rawKey = opts.privateKey ?? process.env["PRIVATE_KEY"];
+    if (!rawKey)
+        die("Private key required. Use --private-key or set PRIVATE_KEY env var.");
+    if (!isHex(rawKey) || rawKey.length !== 66)
+        die("Invalid private key (expected 0x + 32 bytes).");
+    if (!isAddress(opts.issuer))
+        die(`Invalid issuer address: ${opts.issuer}`);
+    if (!isHex(opts.attestation) || opts.attestation.length !== 66)
+        die("Attestation UID must be 0x + 32 bytes (64 hex chars).");
+    const chain = CHAINS[opts.chain] ?? baseSepolia;
+    const account = privateKeyToAccount(rawKey);
+    const transport = opts.rpc ? http(opts.rpc) : http();
+    const publicClient = createPublicClient({ chain, transport });
+    const walletClient = createWalletClient({ account, chain, transport });
+    console.log();
+    console.log(fmt.bold(`  ILAL Credential ${mode === "mint" ? "Mint" : "Renew"}`));
+    log.line();
+    log.kv("wallet", account.address);
+    log.kv("issuer", opts.issuer);
+    log.kv("attestation", opts.attestation);
+    log.kv("chain", chain.name);
+    if (opts.simulate)
+        log.kv("mode", fmt.yellow("simulate (no tx sent)"));
+    log.line();
+    // Verify EAS attestation exists on-chain before sending tx
+    log.step("Verifying attestation on EAS…");
+    const easAddress = EAS_ADDRESSES[chain.id];
+    if (!easAddress)
+        die(`No EAS contract known for chain ${chain.id}. Use --rpc with a custom setup.`);
+    const EAS_ABI = [
+        {
+            name: "getAttestation",
+            type: "function",
+            stateMutability: "view",
+            inputs: [{ name: "uid", type: "bytes32" }],
+            outputs: [{
+                    type: "tuple",
+                    components: [
+                        { name: "uid", type: "bytes32" },
+                        { name: "schema", type: "bytes32" },
+                        { name: "time", type: "uint64" },
+                        { name: "expirationTime", type: "uint64" },
+                        { name: "revocationTime", type: "uint64" },
+                        { name: "refUID", type: "bytes32" },
+                        { name: "recipient", type: "address" },
+                        { name: "attester", type: "address" },
+                        { name: "revocable", type: "bool" },
+                        { name: "data", type: "bytes" },
+                    ],
+                }],
+        },
+    ];
+    const attestation = await publicClient.readContract({
+        address: easAddress,
+        abi: EAS_ABI,
+        functionName: "getAttestation",
+        args: [opts.attestation],
+    });
+    if (attestation.uid === "0x" + "0".repeat(64))
+        die("Attestation not found on EAS.");
+    if (attestation.revocationTime !== 0n)
+        die("Attestation has been revoked.");
+    if (attestation.expirationTime !== 0n && attestation.expirationTime < BigInt(Math.floor(Date.now() / 1000)))
+        die("Attestation has expired.");
+    if (attestation.recipient.toLowerCase() !== account.address.toLowerCase())
+        die(`Attestation recipient (${attestation.recipient}) does not match your wallet (${account.address}).`);
+    log.ok(`Attester: ${attestation.attester}`);
+    if (attestation.attester.toLowerCase() === COINBASE_ATTESTER.toLowerCase()) {
+        log.ok("Coinbase Verifications attester confirmed");
+    }
+    else {
+        log.warn(`Unknown attester — not Coinbase Verifications (${COINBASE_ATTESTER})`);
+    }
+    if (attestation.schema.toLowerCase() !== COINBASE_SCHEMA_UID.toLowerCase()) {
+        log.warn(`Schema mismatch — expected Coinbase schema, got ${attestation.schema}`);
+    }
+    else {
+        log.ok("Coinbase Account Verification schema confirmed");
+    }
+    log.line();
+    if (opts.simulate) {
+        log.ok("Simulation complete — attestation valid, tx would succeed");
+        console.log();
+        console.log(`  Run without ${fmt.cyan("--simulate")} to send the transaction.`);
+        console.log();
+        return;
+    }
+    log.step(`Sending ${mode === "mint" ? "mintWithEAS" : "renewWithEAS"} transaction…`);
+    const hash = await walletClient.writeContract({
+        address: opts.issuer,
+        abi: CNF_ISSUER_ABI,
+        functionName: mode === "mint" ? "mintWithEAS" : "renewWithEAS",
+        args: [opts.attestation],
+    });
+    log.step(`Tx sent: ${hash}`);
+    log.step("Waiting for confirmation…");
+    const receipt = await publicClient.waitForTransactionReceipt({ hash });
+    if (receipt.status === "success") {
+        log.ok(fmt.bold(fmt.green(`CNF ${mode === "mint" ? "minted" : "renewed"} successfully`)));
+        log.kv("tx hash", hash);
+        log.kv("block", receipt.blockNumber.toString());
+        const valid = await publicClient.readContract({
+            address: opts.issuer,
+            abi: CNF_ISSUER_ABI,
+            functionName: "isValid",
+            args: [account.address],
+        });
+        log.kv("isValid()", valid ? fmt.green("true ✓") : fmt.red("false"));
+    }
+    else {
+        die(`Transaction reverted. Hash: ${hash}`);
+    }
+    console.log();
+}
+export const mintCredential = (opts) => sendMintTx("mint", opts);
+export const renewCredential = (opts) => sendMintTx("renew", opts);

package/dist/commands/pool.d.ts

@@ -0,0 +1,15 @@
+export declare function poolPolicySet(opts: {
+    pool: string;
+    issuer: string;
+    credType: string;
+    registry: string;
+    chain: string;
+    rpc?: string;
+    privateKey?: string;
+}): Promise<void>;
+export declare function poolPolicyGet(opts: {
+    pool: string;
+    registry: string;
+    chain: string;
+    rpc?: string;
+}): Promise<void>;

package/dist/commands/pool.js

@@ -0,0 +1,115 @@
+import { createPublicClient, createWalletClient, http, isAddress, isHex, } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { base, baseSepolia } from "viem/chains";
+import { fmt, log, header, Spinner, die } from "../ui.js";
+const CHAINS = { "8453": base, "84532": baseSepolia };
+const REGISTRY_ABI = [
+    {
+        name: "setPolicy",
+        type: "function",
+        stateMutability: "nonpayable",
+        inputs: [
+            { name: "poolId", type: "bytes32" },
+            { name: "cnfIssuer", type: "address" },
+            { name: "credentialType", type: "bytes32" },
+        ],
+        outputs: [],
+    },
+    {
+        name: "disablePolicy",
+        type: "function",
+        stateMutability: "nonpayable",
+        inputs: [{ name: "poolId", type: "bytes32" }],
+        outputs: [],
+    },
+    {
+        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" },
+                ],
+            }],
+    },
+];
+export async function poolPolicySet(opts) {
+    const rawKey = opts.privateKey ?? process.env["PRIVATE_KEY"];
+    if (!rawKey)
+        die("Private key required. Use --private-key or set PRIVATE_KEY env var.");
+    if (!isHex(rawKey) || rawKey.length !== 66)
+        die("Invalid private key.");
+    if (!isAddress(opts.issuer))
+        die(`Invalid issuer address: ${opts.issuer}`);
+    if (!isAddress(opts.registry))
+        die(`Invalid registry address: ${opts.registry}`);
+    if (!isHex(opts.pool) || opts.pool.length !== 66)
+        die("poolId must be 0x + 32 bytes.");
+    if (!isHex(opts.credType) || opts.credType.length !== 66)
+        die("credType must be 0x + 32 bytes.");
+    const chain = CHAINS[opts.chain] ?? baseSepolia;
+    const account = privateKeyToAccount(rawKey);
+    const transport = opts.rpc ? http(opts.rpc) : http();
+    const publicClient = createPublicClient({ chain, transport });
+    const walletClient = createWalletClient({ account, chain, transport });
+    header("Pool Policy Set", chain.name);
+    log.section("Request");
+    log.kv("operator", fmt.addr(account.address));
+    log.kv("registry", fmt.addr(opts.registry));
+    log.kv("pool", fmt.hash(opts.pool));
+    log.kv("issuer", fmt.addr(opts.issuer));
+    log.kv("credType", fmt.hash(opts.credType));
+    log.line();
+    const spin = new Spinner("Sending setPolicy transaction…").start();
+    const hash = await walletClient.writeContract({
+        address: opts.registry,
+        abi: REGISTRY_ABI,
+        functionName: "setPolicy",
+        args: [opts.pool, opts.issuer, opts.credType],
+    });
+    spin.update(`Confirming ${fmt.hash(hash)}…`);
+    const receipt = await publicClient.waitForTransactionReceipt({ hash });
+    if (receipt.status !== "success")
+        die(`Transaction reverted. Hash: ${hash}`);
+    spin.succeed("Transaction confirmed");
+    const policy = await publicClient.readContract({
+        address: opts.registry,
+        abi: REGISTRY_ABI,
+        functionName: "getPolicy",
+        args: [opts.pool],
+    });
+    log.section("Registered Policy");
+    log.kv("cnfIssuer", fmt.addr(policy.cnfIssuer));
+    log.kv("credType", fmt.hash(policy.requiredCredentialType));
+    log.kv("enabled", policy.enabled ? fmt.badge("true", "green") : fmt.badge("false", "red"));
+    log.kv("tx", fmt.hash(hash));
+    log.result("Policy registered", "", "green");
+    console.log();
+}
+export async function poolPolicyGet(opts) {
+    if (!isAddress(opts.registry))
+        die(`Invalid registry address: ${opts.registry}`);
+    if (!isHex(opts.pool) || opts.pool.length !== 66)
+        die("poolId must be 0x + 32 bytes.");
+    const chain = CHAINS[opts.chain] ?? baseSepolia;
+    const transport = opts.rpc ? http(opts.rpc) : http();
+    const publicClient = createPublicClient({ chain, transport });
+    header("Pool Policy", chain.name);
+    const policy = await publicClient.readContract({
+        address: opts.registry,
+        abi: REGISTRY_ABI,
+        functionName: "getPolicy",
+        args: [opts.pool],
+    });
+    log.section("Policy");
+    log.kv("pool", fmt.hash(opts.pool));
+    log.kv("registry", fmt.addr(opts.registry));
+    log.kv("cnfIssuer", policy.cnfIssuer === "0x0000000000000000000000000000000000000000" ? fmt.badge("unset", "red") : fmt.addr(policy.cnfIssuer));
+    log.kv("credType", fmt.hash(policy.requiredCredentialType));
+    log.kv("enabled", policy.enabled ? fmt.badge("true", "green") : fmt.badge("false", "red"));
+    console.log();
+}

package/dist/commands/proof.d.ts

@@ -0,0 +1,16 @@
+export declare function proofMint(opts: {
+    proof: string;
+    public: string;
+    issuer: string;
+    chain: string;
+    rpc?: string;
+    privateKey?: string;
+}): Promise<void>;
+export declare function proofRenew(opts: {
+    proof: string;
+    public: string;
+    issuer: string;
+    chain: string;
+    rpc?: string;
+    privateKey?: string;
+}): Promise<void>;