@artblocks/abx-cli 0.1.0-alpha.0

package/dist/mintpage.js

@@ -0,0 +1,461 @@
+/**
+ * Mint-page scaffolding — a **self-contained** Next.js starter a creator stands up to sell a drop,
+ * compatible with the shared {AbxFixedPriceMinter}. The sibling of `deploy-resolver`: a buildable
+ * artifact the creator OWNS and customizes (with the agent's help), not a service we run.
+ *
+ * SELF-CONTAINED + BACKEND-FREE by design:
+ *   - Reads live sale state (price · sold/allocation · paused · supply) straight from chain, and each
+ *     token's image/name from `tokenURI(id)` — no server, no database. Fully-on-chain collections need
+ *     nothing else; off-chain ones rely on their `tokenURI` resolving (same as any marketplace).
+ *   - Wallet connect + mint use viem + the injected browser wallet (`window.ethereum`) — NO API keys,
+ *     no WalletConnect projectId. The README shows how to swap in RainbowKit for multi-wallet.
+ *   - Reads use a PUBLIC RPC (never the creator's keyed endpoint — that would leak a secret into a
+ *     `NEXT_PUBLIC_` var); the mint tx uses the wallet's own RPC. Config rides `NEXT_PUBLIC_*` env vars,
+ *     prefilled by the CLI into `.env.local`.
+ *
+ * V1 scope (deliberately minimal — customize from here): ETH sales, one mint per click, a paginated
+ * gallery of minted tokens. ERC-20 sales (need an `approve` step) are flagged as a customization.
+ *
+ * Pure module: returns the artifact files + the exact next-step commands. The CLI writes the files and
+ * prints the steps; `vercel` / `next dev` run in the creator's own account/machine — they own that step.
+ */
+/** Public, keyless RPCs safe to embed in a public site. Extend as chains are added. */
+export const PUBLIC_RPC = {
+    1: 'https://ethereum-rpc.publicnode.com',
+    11155111: 'https://ethereum-sepolia-rpc.publicnode.com',
+};
+const slug = (s) => s
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '') || 'abx';
+// ── file contents ─────────────────────────────────────────────────────────────
+// NOTE: emitted TS/TSX below uses single-quote strings + concatenation and avoids backticks and
+// `${}` on purpose — so these Node template literals only interpolate SCAFFOLD-time values, never
+// browser-runtime ones. Keep it that way when editing.
+function packageJson(o) {
+    return JSON.stringify({
+        name: slug(o.collectionName) + '-mint',
+        private: true,
+        version: '0.1.0',
+        scripts: { dev: 'next dev', build: 'next build', start: 'next start' },
+        dependencies: {
+            next: '^15.0.3',
+            react: '^19.0.0',
+            'react-dom': '^19.0.0',
+            viem: '^2.21.0',
+        },
+        devDependencies: {
+            typescript: '^5.6.0',
+            '@types/node': '^22.0.0',
+            '@types/react': '^19.0.0',
+            '@types/react-dom': '^19.0.0',
+        },
+    }, null, 2);
+}
+const NEXT_CONFIG = `/** @type {import('next').NextConfig} */
+// Images render via a plain <img> from data:/http(s) URIs, so the built-in optimizer is off
+// (no per-domain allowlist to maintain). Customize freely.
+const nextConfig = {images: {unoptimized: true}};
+export default nextConfig;
+`;
+const TSCONFIG = JSON.stringify({
+    compilerOptions: {
+        target: 'ES2020',
+        lib: ['dom', 'dom.iterable', 'esnext'],
+        allowJs: true,
+        skipLibCheck: true,
+        strict: true,
+        noEmit: true,
+        esModuleInterop: true,
+        module: 'esnext',
+        moduleResolution: 'bundler',
+        resolveJsonModule: true,
+        isolatedModules: true,
+        jsx: 'preserve',
+        incremental: true,
+        plugins: [{ name: 'next' }],
+        paths: { '@/*': ['./*'] },
+    },
+    include: ['next-env.d.ts', '**/*.ts', '**/*.tsx', '.next/types/**/*.ts'],
+    exclude: ['node_modules'],
+}, null, 2);
+const NEXT_ENV = `/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+// NOTE: This file should not be edited. See https://nextjs.org/docs/basic-features/typescript
+`;
+const GITIGNORE = `/node_modules
+/.next
+/out
+.env.local
+.DS_Store
+*.log
+.vercel
+`;
+function envFile(o) {
+    return ('NEXT_PUBLIC_CHAIN_ID=' +
+        o.chainId +
+        '\nNEXT_PUBLIC_CHAIN_NAME=' +
+        o.chainName +
+        '\n# PUBLIC, keyless RPC (embedded in the public site — never put a keyed endpoint here).\n' +
+        'NEXT_PUBLIC_RPC_URL=' +
+        o.rpcUrl +
+        '\nNEXT_PUBLIC_TOKEN=' +
+        o.token +
+        '\nNEXT_PUBLIC_MINTER=' +
+        o.minter +
+        '\nNEXT_PUBLIC_COLLECTION_NAME=' +
+        o.collectionName +
+        '\nNEXT_PUBLIC_EXPLORER=' +
+        (o.explorer ?? '') +
+        '\n');
+}
+const LIB_CONFIG = `// Config from NEXT_PUBLIC_* env (prefilled by \`abx mint-page\` into .env.local; set the same in Vercel).
+export const CHAIN_ID = Number(process.env.NEXT_PUBLIC_CHAIN_ID || '11155111');
+export const CHAIN_NAME = process.env.NEXT_PUBLIC_CHAIN_NAME || 'Sepolia';
+export const RPC_URL = process.env.NEXT_PUBLIC_RPC_URL || 'https://ethereum-sepolia-rpc.publicnode.com';
+export const TOKEN = (process.env.NEXT_PUBLIC_TOKEN || '') as \`0x\${string}\`;
+export const MINTER = (process.env.NEXT_PUBLIC_MINTER || '') as \`0x\${string}\`;
+export const COLLECTION_NAME = process.env.NEXT_PUBLIC_COLLECTION_NAME || 'ABX Collection';
+export const EXPLORER = process.env.NEXT_PUBLIC_EXPLORER || '';
+export const PAGE_SIZE = 12;
+`;
+const LIB_CHAIN = `import {defineChain} from 'viem';
+import {CHAIN_ID, CHAIN_NAME, RPC_URL} from './config';
+
+// A minimal viem chain built from config — no dependency on viem/chains matching the id.
+export const chain = defineChain({
+  id: CHAIN_ID,
+  name: CHAIN_NAME,
+  nativeCurrency: {name: 'Ether', symbol: 'ETH', decimals: 18},
+  rpcUrls: {default: {http: [RPC_URL]}},
+});
+`;
+const LIB_ABI = `// Minimal ABIs — only what the mint page reads/writes.
+export const minterAbi = [
+  {
+    type: 'function',
+    name: 'sales',
+    stateMutability: 'view',
+    inputs: [{name: 'token', type: 'address'}],
+    outputs: [
+      {name: 'configured', type: 'bool'},
+      {name: 'paymentToken', type: 'address'},
+      {name: 'price', type: 'uint256'},
+      {name: 'allocation', type: 'uint256'},
+      {name: 'sold', type: 'uint256'},
+    ],
+  },
+  {type: 'function', name: 'purchase', stateMutability: 'payable', inputs: [{name: 'token', type: 'address'}], outputs: [{name: 'tokenId', type: 'uint256'}]},
+  {type: 'function', name: 'purchaseTo', stateMutability: 'payable', inputs: [{name: 'token', type: 'address'}, {name: 'to', type: 'address'}], outputs: [{name: 'tokenId', type: 'uint256'}]},
+] as const;
+
+export const tokenAbi = [
+  {type: 'function', name: 'name', stateMutability: 'view', inputs: [], outputs: [{type: 'string'}]},
+  {type: 'function', name: 'totalSupply', stateMutability: 'view', inputs: [], outputs: [{type: 'uint256'}]},
+  {type: 'function', name: 'maxInvocations', stateMutability: 'view', inputs: [], outputs: [{type: 'uint256'}]},
+  {type: 'function', name: 'paused', stateMutability: 'view', inputs: [], outputs: [{type: 'bool'}]},
+  {type: 'function', name: 'tokenURI', stateMutability: 'view', inputs: [{name: 'id', type: 'uint256'}], outputs: [{type: 'string'}]},
+] as const;
+`;
+const LIB_META = `// Read a token's image + name from tokenURI(id), directly from chain. Handles data: URIs
+// (on-chain tokens) and http/ipfs/ar locators (off-chain custody). No backend.
+import {createPublicClient, http} from 'viem';
+import {chain} from './chain';
+import {TOKEN} from './config';
+import {tokenAbi} from './abi';
+
+export const publicClient = createPublicClient({chain, transport: http()});
+
+export function toGateway(u: string): string {
+  if (!u) return '';
+  if (u.startsWith('ipfs://')) return 'https://ipfs.io/ipfs/' + u.slice(7);
+  if (u.startsWith('ar://')) return 'https://arweave.net/' + u.slice(5);
+  return u;
+}
+
+async function fetchJson(uri: string): Promise<any> {
+  if (uri.startsWith('data:')) {
+    const comma = uri.indexOf(',');
+    const header = uri.slice(5, comma);
+    const body = uri.slice(comma + 1);
+    const text = header.includes('base64') ? atob(body) : decodeURIComponent(body);
+    return JSON.parse(text);
+  }
+  const res = await fetch(toGateway(uri));
+  return res.json();
+}
+
+export interface TokenMeta {
+  id: number;
+  name: string;
+  image: string;
+}
+
+export async function readTokenMeta(id: number): Promise<TokenMeta> {
+  const uri = (await publicClient.readContract({address: TOKEN, abi: tokenAbi, functionName: 'tokenURI', args: [BigInt(id)]})) as string;
+  const json = await fetchJson(uri);
+  return {id, name: json.name || '#' + id, image: toGateway(json.image || '')};
+}
+`;
+const APP_LAYOUT = `import './globals.css';
+import type {ReactNode} from 'react';
+import {COLLECTION_NAME} from '../lib/config';
+
+export const metadata = {title: COLLECTION_NAME + ' — Mint', description: 'Mint ' + COLLECTION_NAME};
+
+export default function RootLayout({children}: {children: ReactNode}) {
+  return (
+    <html lang="en">
+      <body>{children}</body>
+    </html>
+  );
+}
+`;
+const APP_GLOBALS = `:root { color-scheme: dark; }
+* { box-sizing: border-box; }
+body {
+  margin: 0;
+  font-family: ui-sans-serif, system-ui, -apple-system, Segoe UI, Roboto, sans-serif;
+  background: #0b0b0f;
+  color: #e8e8ea;
+}
+.wrap { max-width: 960px; margin: 0 auto; padding: 32px 20px 80px; }
+h1 { font-size: 28px; margin: 0 0 4px; }
+.muted { color: #9a9aa2; }
+.card { background: #15151c; border: 1px solid #26262f; border-radius: 14px; padding: 20px; }
+.row { display: flex; flex-wrap: wrap; gap: 16px; align-items: center; justify-content: space-between; }
+button {
+  font: inherit; font-weight: 600; cursor: pointer;
+  background: #6d5efc; color: #fff; border: 0; border-radius: 10px; padding: 12px 20px;
+}
+button:disabled { background: #2a2a35; color: #6b6b75; cursor: not-allowed; }
+button.ghost { background: transparent; border: 1px solid #3a3a46; color: #e8e8ea; }
+.grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(200px, 1fr)); gap: 14px; margin-top: 20px; }
+.tile { background: #15151c; border: 1px solid #26262f; border-radius: 12px; overflow: hidden; }
+.tile img { width: 100%; aspect-ratio: 1; object-fit: cover; display: block; background: #0e0e13; }
+.tile .label { padding: 10px 12px; font-size: 14px; }
+.pager { display: flex; gap: 10px; align-items: center; justify-content: center; margin-top: 24px; }
+a { color: #a99bff; }
+.stat { font-size: 15px; }
+.stat b { color: #fff; }
+.pill { display: inline-block; padding: 3px 10px; border-radius: 999px; font-size: 12px; font-weight: 600; }
+.pill.open { background: #12351f; color: #57d98a; }
+.pill.closed { background: #351212; color: #e88; }
+`;
+const APP_PAGE = `import Mint from './mint-client';
+export default function Page() {
+  return <Mint />;
+}
+`;
+// The whole UI in one client component: live sale state + paginated gallery + connect/mint.
+const APP_MINT_CLIENT = `'use client';
+import {useCallback, useEffect, useState} from 'react';
+import {createWalletClient, custom, formatEther} from 'viem';
+import {chain} from '../lib/chain';
+import {CHAIN_ID, CHAIN_NAME, COLLECTION_NAME, EXPLORER, MINTER, PAGE_SIZE, TOKEN} from '../lib/config';
+import {minterAbi, tokenAbi} from '../lib/abi';
+import {publicClient, readTokenMeta, type TokenMeta} from '../lib/meta';
+
+const ZERO = '0x0000000000000000000000000000000000000000';
+
+interface Sale {
+  configured: boolean;
+  paymentToken: string;
+  price: bigint;
+  allocation: bigint;
+  sold: bigint;
+}
+
+export default function Mint() {
+  const [sale, setSale] = useState<Sale | null>(null);
+  const [supply, setSupply] = useState(0);
+  const [maxInv, setMaxInv] = useState(0);
+  const [paused, setPaused] = useState(false);
+  const [account, setAccount] = useState<string>('');
+  const [page, setPage] = useState(0);
+  const [tiles, setTiles] = useState<TokenMeta[]>([]);
+  const [busy, setBusy] = useState(false);
+  const [msg, setMsg] = useState('');
+
+  const refresh = useCallback(async () => {
+    const s = (await publicClient.readContract({address: MINTER, abi: minterAbi, functionName: 'sales', args: [TOKEN]})) as any;
+    setSale({configured: s[0], paymentToken: s[1], price: s[2], allocation: s[3], sold: s[4]});
+    const [ts, mx, pz] = await Promise.all([
+      publicClient.readContract({address: TOKEN, abi: tokenAbi, functionName: 'totalSupply'}),
+      publicClient.readContract({address: TOKEN, abi: tokenAbi, functionName: 'maxInvocations'}),
+      publicClient.readContract({address: TOKEN, abi: tokenAbi, functionName: 'paused'}),
+    ]);
+    setSupply(Number(ts));
+    setMaxInv(Number(mx));
+    setPaused(Boolean(pz));
+  }, []);
+
+  useEffect(() => {
+    refresh().catch((e) => setMsg(String(e)));
+  }, [refresh]);
+
+  // Load the visible page of minted tokens (newest first). Only this page's tokenURIs are fetched.
+  useEffect(() => {
+    let live = true;
+    (async () => {
+      const ids: number[] = [];
+      const start = page * PAGE_SIZE;
+      for (let i = 0; i < PAGE_SIZE; i++) {
+        const id = supply - 1 - start - i;
+        if (id < 0) break;
+        ids.push(id);
+      }
+      const metas = await Promise.all(ids.map((id) => readTokenMeta(id).catch(() => ({id, name: '#' + id, image: ''}))));
+      if (live) setTiles(metas);
+    })();
+    return () => {
+      live = false;
+    };
+  }, [page, supply]);
+
+  async function connect() {
+    const eth = (window as any).ethereum;
+    if (!eth) {
+      setMsg('No injected wallet found — install MetaMask (or another browser wallet).');
+      return;
+    }
+    const accts = (await eth.request({method: 'eth_requestAccounts'})) as string[];
+    setAccount(accts[0] || '');
+    try {
+      await eth.request({method: 'wallet_switchEthereumChain', params: [{chainId: '0x' + CHAIN_ID.toString(16)}]});
+    } catch (e) {
+      /* user can switch manually; the mint call will surface a wrong-network error */
+    }
+  }
+
+  async function mint() {
+    if (!sale) return;
+    const eth = (window as any).ethereum;
+    if (!eth || !account) return connect();
+    setBusy(true);
+    setMsg('');
+    try {
+      const wallet = createWalletClient({account: account as any, chain, transport: custom(eth)});
+      const hash = await wallet.writeContract({address: MINTER, abi: minterAbi, functionName: 'purchase', args: [TOKEN], value: sale.price, account: account as any, chain});
+      setMsg('Minting… tx ' + hash.slice(0, 10) + '…');
+      await publicClient.waitForTransactionReceipt({hash});
+      setMsg('Minted! ✦');
+      setPage(0);
+      await refresh();
+    } catch (e: any) {
+      setMsg(e && e.shortMessage ? e.shortMessage : String(e && e.message ? e.message : e));
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  const isEth = !sale || sale.paymentToken === ZERO;
+  const soldOut = !!sale && (sale.sold >= sale.allocation || (maxInv > 0 && supply >= maxInv));
+  const pages = Math.max(1, Math.ceil(supply / PAGE_SIZE));
+  const canMint = !!sale && sale.configured && !paused && !soldOut && isEth && !busy;
+
+  return (
+    <main className="wrap">
+      <div className="row" style={{marginBottom: 20}}>
+        <div>
+          <h1>{COLLECTION_NAME}</h1>
+          <div className="muted">
+            {EXPLORER ? <a href={EXPLORER + '/address/' + TOKEN} target="_blank" rel="noreferrer">contract ↗</a> : TOKEN}
+            {' · '}
+            {CHAIN_NAME}
+          </div>
+        </div>
+        {account ? <span className="muted">{account.slice(0, 6) + '…' + account.slice(-4)}</span> : <button className="ghost" onClick={connect}>Connect wallet</button>}
+      </div>
+
+      <div className="card">
+        <div className="row">
+          <div className="stat">
+            {sale ? <>Price <b>{isEth ? formatEther(sale.price) + ' ETH' : sale.price.toString() + ' units'}</b></> : 'Loading…'}
+            {sale ? <> &nbsp;·&nbsp; Sold <b>{sale.sold.toString()}/{sale.allocation.toString()}</b></> : null}
+            {maxInv > 0 ? <> &nbsp;·&nbsp; Supply <b>{supply}/{maxInv}</b></> : null}
+            {' '}
+            <span className={'pill ' + (paused || soldOut ? 'closed' : 'open')}>{soldOut ? 'sold out' : paused ? 'paused' : 'open'}</span>
+          </div>
+          <button onClick={mint} disabled={!canMint}>
+            {busy ? 'Minting…' : soldOut ? 'Sold out' : paused ? 'Paused' : !isEth ? 'ERC-20 — see README' : account ? 'Mint' : 'Connect & mint'}
+          </button>
+        </div>
+        {msg ? <div className="muted" style={{marginTop: 12}}>{msg}</div> : null}
+        {sale && !sale.configured ? <div className="muted" style={{marginTop: 12}}>No sale configured yet for this collection.</div> : null}
+      </div>
+
+      <div className="grid">
+        {tiles.map((t) => (
+          <div className="tile" key={t.id}>
+            {t.image ? <img src={t.image} alt={t.name} /> : <div style={{aspectRatio: '1', background: '#0e0e13'}} />}
+            <div className="label">{t.name}</div>
+          </div>
+        ))}
+      </div>
+      {supply === 0 ? <p className="muted" style={{textAlign: 'center', marginTop: 24}}>No tokens minted yet — be the first.</p> : null}
+
+      {pages > 1 ? (
+        <div className="pager">
+          <button className="ghost" onClick={() => setPage((p) => Math.max(0, p - 1))} disabled={page === 0}>Prev</button>
+          <span className="muted">Page {page + 1} / {pages}</span>
+          <button className="ghost" onClick={() => setPage((p) => Math.min(pages - 1, p + 1))} disabled={page >= pages - 1}>Next</button>
+        </div>
+      ) : null}
+    </main>
+  );
+}
+`;
+function readme(o) {
+    return ('# ' +
+        o.collectionName +
+        ' — mint page\n\n' +
+        'A self-contained Next.js mint site for the ABX collection `' +
+        o.token +
+        '`, wired to the shared fixed-price minter `' +
+        o.minter +
+        '` on ' +
+        o.chainName +
+        '. Generated by `abx mint-page`.\n\n' +
+        '## Run it locally\n\n' +
+        '```bash\nnpm install\nnpm run dev      # http://localhost:3000\n```\n\n' +
+        'Config lives in `.env.local` (already prefilled). It reads sale state + each token\'s image straight from chain — no backend.\n\n' +
+        '## Deploy (Vercel — recommended)\n\n' +
+        '```bash\nnpm i -g vercel\nvercel            # first run links/creates the project\nvercel --prod     # ship it\n```\n\n' +
+        'In the Vercel dashboard set the same `NEXT_PUBLIC_*` vars from `.env.local` (Project → Settings → Environment Variables), then redeploy. Any Next.js host works; Vercel is the least-setup path.\n\n' +
+        '## Customize (this is a starting point)\n\n' +
+        '- **Design** — it is plain React + one `app/globals.css`. Restyle freely; ask your agent for a bespoke layout per drop.\n' +
+        '- **Multi-wallet** — V1 uses the injected wallet (`window.ethereum`) with zero config. For WalletConnect/Coinbase/etc., swap in [RainbowKit](https://rainbowkit.com) + wagmi (needs a WalletConnect projectId).\n' +
+        '- **ERC-20 sales** — the mint button handles ETH. For an ERC-20-priced sale, add an `approve(minter, price)` step before `purchase` (see `lib/abi.ts`).\n' +
+        '- **RPC** — `NEXT_PUBLIC_RPC_URL` is a public endpoint (may rate-limit). Use your own **keyless** endpoint if you like; never put a secret-keyed URL in a `NEXT_PUBLIC_` var — it ships to the browser.\n' +
+        '- **Gallery** — shows minted tokens newest-first, ' +
+        'paginated. It reads `tokenURI(id)`; on-chain collections resolve with no backend, off-chain ones need their resolver/gateway reachable.\n');
+}
+export function mintPageArtifact(o) {
+    return {
+        files: [
+            { path: 'package.json', content: packageJson(o) },
+            { path: 'next.config.mjs', content: NEXT_CONFIG },
+            { path: 'tsconfig.json', content: TSCONFIG },
+            { path: 'next-env.d.ts', content: NEXT_ENV },
+            { path: '.gitignore', content: GITIGNORE },
+            { path: '.env.local', content: envFile(o) },
+            { path: '.env.example', content: envFile({ ...o, token: '0xYourCollection', minter: o.minter }) },
+            { path: 'lib/config.ts', content: LIB_CONFIG },
+            { path: 'lib/chain.ts', content: LIB_CHAIN },
+            { path: 'lib/abi.ts', content: LIB_ABI },
+            { path: 'lib/meta.ts', content: LIB_META },
+            { path: 'app/globals.css', content: APP_GLOBALS },
+            { path: 'app/layout.tsx', content: APP_LAYOUT },
+            { path: 'app/page.tsx', content: APP_PAGE },
+            { path: 'app/mint-client.tsx', content: APP_MINT_CLIENT },
+            { path: 'README.md', content: readme(o) },
+        ],
+        steps: [
+            'npm install',
+            'npm run dev            # preview at http://localhost:3000',
+            'npm i -g vercel && vercel --prod   # deploy (set the NEXT_PUBLIC_* vars in the Vercel dashboard)',
+        ],
+    };
+}
+//# sourceMappingURL=mintpage.js.map

package/dist/mintpage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mintpage.js","sourceRoot":"","sources":["../src/mintpage.ts"],"names":[],"mappings":"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"}

package/dist/onchain-uri.d.ts

@@ -0,0 +1,97 @@
+import { type Address, type GeneratorReadClient, type GeneratorStatus, type Hex, type ParsedDependencyRef, type ProjectState } from '@artblocks/abx-sdk';
+import type { DepCheck } from './deps.js';
+/** The self-referential key: the CSV lists it too (the resolver's tokenData carries every
+ *  evented param — including `params.keys` itself — so the generator must list it to stay
+ *  byte-aligned; inputsHash parity is load-bearing). */
+export declare const PARAMS_KEYS = "params.keys";
+/** ≤ this many chars rides as a literal readable-ASCII bytes32; longer takes the data path. */
+export declare const PARAMS_KEYS_LITERAL_MAX = 31;
+/**
+ * Compose the `params.keys` CSV: every param key the deploy writes ∪ the `--schema` keys ∪
+ * `params.keys` itself — deduped, sorted lexicographically, comma-joined. Sorted because the
+ * canonical tokenData serialization sorts keys; deterministic composition keeps the value
+ * reproducible from the same flags.
+ */
+export declare function composeParamsKeys(writtenParamKeys: string[], schemaKeys: string[]): string;
+/** Whether a CSV fits the literal bytes32 lane (printable ASCII, ≤ 31 bytes). */
+export declare function paramsKeysIsLiteral(csv: string): boolean;
+/** The `params.keys` write leg: `setContractParam` (literal bytes32) when the CSV fits,
+ *  else `setContractParamData` (one blob; hash evented — the generator reads it back whole). */
+export declare function paramsKeysCall(csv: string): {
+    call: Hex;
+    encoding: 'literal' | 'data';
+};
+/**
+ * The `--onchain-uri` legs of the setup multicall, in order:
+ *   1. collection-scope `animation_url` field → representation `renderer`,
+ *      value `abi.encode(generator)` (the canonical generator computes the live view on-chain);
+ *   2. the `params.keys` contract param (the generator's tokenData enumeration seam);
+ *   3. `setTokenURIRenderer(metadataRenderer)` — tokenURI resolves ON-CHAIN from here on;
+ *   4. `setContractURIRenderer(metadataRenderer)` — contractURI too (parity with the 1/1 lane).
+ * Placed BEFORE the mint legs so every token is born with the on-chain lane fully configured.
+ */
+export declare function onchainUriSetupCalls(args: {
+    generator: Address;
+    metadataRenderer: Address;
+    paramsKeys: string;
+}): {
+    calls: Hex[];
+    paramsKeysEncoding: 'literal' | 'data';
+};
+/** What the deploy can honestly promise about the generator's template branch, derived from
+ *  the selection-time dependency report (never a new RPC): chain-complete iff every registry
+ *  dep has proven ON-CHAIN bytes (OnChain refs read their data contract directly, so they
+ *  count as on-chain; `abx verify` is the from-chain confirmation either way). */
+export declare function expectedChainComplete(deps: ParsedDependencyRef[], checks: DepCheck[]): {
+    expected: boolean | null;
+    detail: string;
+};
+/** The generator this project's on-chain lane actually uses: the collection `animation_url`
+ *  field's `renderer` value when set (that address is what the metadata renderer staticcalls),
+ *  else the chain's canonical generator. Null when neither exists. */
+export declare function generatorFor(state: ProjectState, override?: string): Address | null;
+/** Whether verify should run the on-chain-URI report: the tokenURIRenderer toggle is on, or
+ *  the collection `animation` field points at a field renderer (the generator). */
+export declare function hasOnChainUriLane(state: ProjectState): boolean;
+export interface TokenUriProbe {
+    tokenId: string;
+    /** tokenURI(id) is a `data:application/json;base64,` URI (resolves on-chain, any RPC). */
+    onChainJson: boolean;
+    uriPrefix: string;
+    animation: {
+        form: 'data-html';
+        bytes: number;
+        marker: string | null;
+    } | {
+        form: 'url';
+        url: string;
+    } | {
+        form: 'data-other';
+        prefix: string;
+    } | {
+        form: 'missing';
+    };
+}
+export interface OnChainUriReport {
+    generator: Address;
+    status: GeneratorStatus;
+    /** Null when no token is minted yet (tokenURI would revert). */
+    probe: TokenUriProbe | null;
+}
+/**
+ * The verify-time on-chain-URI report: `generator.onChainStatus(token)` (branch ·
+ * chain-completeness · unresolved refs · URL budget) plus a `tokenURI` probe of the lowest
+ * minted token — decoded, with the `animation_url` form checked against the branch.
+ */
+export declare function onChainUriReport(client: GeneratorReadClient, state: ProjectState, generatorOverride?: string): Promise<OnChainUriReport>;
+/**
+ * After a param write: if the project's `params.keys` CSV exists but doesn't list the
+ * configured key, the on-chain generator's tokenData will silently omit it (breaking byte
+ * parity with the resolver's). Returns the fixed CSV to suggest, or null when no nudge is
+ * warranted (no CSV = not on the on-chain lane; already listed = fine).
+ */
+export declare function paramsKeysNudge(existingCsv: string | null, configuredKey: string): string | null;
+/** Read the project's `params.keys` contract param from chain (literal or data-backed);
+ *  null when unset. Best-effort — callers must treat a throw as "no nudge". */
+export declare function readParamsKeys(client: GeneratorReadClient, contract: Address): Promise<string | null>;
+//# sourceMappingURL=onchain-uri.d.ts.map

package/dist/onchain-uri.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onchain-uri.d.ts","sourceRoot":"","sources":["../src/onchain-uri.ts"],"names":[],"mappings":"AAaA,OAAO,EAUL,KAAK,OAAO,EACZ,KAAK,mBAAmB,EACxB,KAAK,eAAe,EACpB,KAAK,GAAG,EACR,KAAK,mBAAmB,EACxB,KAAK,YAAY,EAElB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,WAAW,CAAC;AAExC;;wDAEwD;AACxD,eAAO,MAAM,WAAW,gBAAgB,CAAC;AAEzC,+FAA+F;AAC/F,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAE1C;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,gBAAgB,EAAE,MAAM,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,MAAM,CAQ1F;AAED,iFAAiF;AACjF,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAExD;AAED;gGACgG;AAChG,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG;IAAC,IAAI,EAAE,GAAG,CAAC;IAAC,QAAQ,EAAE,SAAS,GAAG,MAAM,CAAA;CAAC,CAmBrF;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE;IACzC,SAAS,EAAE,OAAO,CAAC;IACnB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;CACpB,GAAG;IAAC,KAAK,EAAE,GAAG,EAAE,CAAC;IAAC,kBAAkB,EAAE,SAAS,GAAG,MAAM,CAAA;CAAC,CAuBzD;AAID;;;kFAGkF;AAClF,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,mBAAmB,EAAE,EAC3B,MAAM,EAAE,QAAQ,EAAE,GACjB;IAAC,QAAQ,EAAE,OAAO,GAAG,IAAI,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,CAoB5C;AAID;;sEAEsE;AACtE,wBAAgB,YAAY,CAAC,KAAK,EAAE,YAAY,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAUnF;AAED;mFACmF;AACnF,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAM9D;AAYD,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,0FAA0F;IAC1F,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EACL;QAAC,IAAI,EAAE,WAAW,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;KAAC,GACzD;QAAC,IAAI,EAAE,KAAK,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAC,GAC1B;QAAC,IAAI,EAAE,YAAY,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,GACpC;QAAC,IAAI,EAAE,SAAS,CAAA;KAAC,CAAC;CACvB;AAED,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,eAAe,CAAC;IACxB,gEAAgE;IAChE,KAAK,EAAE,aAAa,GAAG,IAAI,CAAC;CAC7B;AAmBD;;;;GAIG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,mBAAmB,EAC3B,KAAK,EAAE,YAAY,EACnB,iBAAiB,CAAC,EAAE,MAAM,GACzB,OAAO,CAAC,gBAAgB,CAAC,CAgC3B;AAID;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAKhG;AAED;+EAC+E;AAC/E,wBAAsB,cAAc,CAAC,MAAM,EAAE,mBAAmB,EAAE,QAAQ,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAgB3G"}