@artblocks/abx-cli 0.1.0-alpha.10 → 0.1.0-alpha.11

package/dist/main.js

@@ -21,6 +21,8 @@
  *   abx remote [<name|url>]  inspect a remote service (descriptor · chains · managed rendering · your projects there)
  *   abx index [<address>]    re-index a project from chain (replay; --remote to nudge a remote resolver)
  *   abx verify <address>     re-hash served bytes vs the on-chain commitment (no server)
+ *   abx tokenuri <address>   read tokenURI(id) from the contract + decode  ·  contracturi: the ERC-7572 collection JSON
+ *                            (the contract holds the URL — never hand-build a resolver path)
  *   abx configure-param <addr> <id> <key> <value>  set a governed PostParam (typed encode; any lane)
  *   abx set-param-hooks <addr>  wire/clear a SeriesCode's configure/augment/transfer param hooks
  *   abx render <addr> [id…]  effect-runner repair lane: render missing stills/traits
@@ -177,6 +179,7 @@ async function main() {
         case 'render': return cmdRender(rest[0], rest.slice(1), flags);
         case 'effects': return cmdEffects(flags);
         case 'tokenuri': return cmdTokenUri(rest[0], flags);
+        case 'contracturi': return cmdContractUri(rest[0], flags);
         case 'serve': return cmdServe(flags);
         // owner operations — write + sign (hot/wallet/cold lane), then re-index
         case 'mint': return cmdMint(rest[0], flags);
@@ -4397,6 +4400,101 @@ async function cmdTokenUri(address, flags) {
         console.log(`    ${uri.slice(0, 240)}${uri.length > 240 ? dim(`… (${uri.length} chars)`) : ''}\n`);
     }
 }
+// ── contracturi ──────────────────────────────────────────────────────────────
+/**
+ * `abx contracturi <address>` — the collection-level counterpart of `tokenuri`: read
+ * `contractURI()` (ERC-7572) STRAIGHT FROM THE CONTRACT, then FOLLOW it and decode the JSON.
+ *
+ * Why this exists, and why it follows the URL: the resolver's route grammar is committed
+ * on-chain at deploy (`contractURIBase` = `<baseUrl>/c`), so the contract — not a doc, not a
+ * service descriptor — is the source of truth for where a collection's metadata lives. Without
+ * this command the only way to look was to hand-build the URL from memory of the grammar, and a
+ * guessed path that 404s reads exactly like a broken service. Ask the chain instead.
+ */
+async function cmdContractUri(address, _flags) {
+    if (!address || address.startsWith('--')) {
+        console.error('usage: abx contracturi <address>\n');
+        process.exit(1);
+    }
+    if (!/^0x[0-9a-fA-F]{40}$/.test(address)) {
+        console.error(`abx contracturi: '${address}' isn't a 0x contract address.\n`);
+        process.exit(1);
+    }
+    const publicClient = makePublicClient({ chainKey: CHAIN });
+    let uri;
+    try {
+        uri = (await publicClient.readContract({
+            address,
+            abi: oneOfOneImageAbi,
+            functionName: 'contractURI',
+            args: [],
+        }));
+    }
+    catch {
+        const code = await publicClient.getCode({ address }).catch(() => undefined);
+        if (!code || code === '0x') {
+            // Name the endpoint we actually asked — "no contract here" and "you're pointed at the wrong
+            // node" are indistinguishable otherwise (same reasoning as `tokenuri`).
+            console.error(`abx contracturi: no contract at ${address} on ${CHAIN} (asked ${redactRpcUrl(resolveRpcUrl(CHAIN))}) — ` +
+                `double-check the address, and that this endpoint is the network you deployed to. ` +
+                `If you JUST deployed, give the tx a block or two to mine.\n`);
+        }
+        else {
+            console.error(`abx contracturi: ${address} didn't return a contractURI — it may not be an ABX/ERC-7572 contract, or ` +
+                `— on a large on-chain contractURI — an unauthenticated RPC read hit its gas cap (try a wallet-connected / high-gas RPC).\n`);
+        }
+        process.exit(1);
+    }
+    console.log(`\n  ${bold('contractURI()')} ${dim(`— read directly from ${address} on ${CHAIN}`)}`);
+    if (!uri) {
+        console.error(`\n  ${bold('empty')} — this contract has no contractURI set: no collection-level metadata to resolve. ` +
+            `Set one with ${bold(`abx set-contract-uri ${address} --uri <base>`)}, or point it at the canonical renderer for the on-chain lane.\n`);
+        process.exit(1);
+    }
+    const onChain = decodeOnChainJson(uri);
+    if (onChain) {
+        info('resolution: ON-CHAIN (data: URI from the renderer — no server in the path)');
+        console.log(onChain.split('\n').map((l) => '    ' + l).join('\n') + '\n');
+        return;
+    }
+    console.log(`  ${dim('resolves to')} ${uri}`);
+    if (!/^https?:\/\//i.test(uri)) {
+        // ipfs:// / ar:// — a locator, not something we can fetch without choosing a gateway. Print it
+        // rather than silently picking one; the creator's gateway choice is theirs.
+        info(`not an http(s) URL — a ${uri.split(':')[0]}: locator needs a gateway to fetch. Nothing more to read from here.`);
+        console.log('');
+        return;
+    }
+    let body;
+    try {
+        const res = await fetch(uri, { headers: { accept: 'application/json' } });
+        body = await res.text();
+        if (!res.ok) {
+            // The URL came FROM THE CHAIN, so a bad status here is genuinely about the service (or the
+            // contract pointing somewhere stale) — never a mistyped path. Say which, so nobody re-guesses.
+            console.error(`\n  ${bold(`HTTP ${res.status}`)} from the contract's own contractURI — the URL is correct by construction (it came from ` +
+                `${address} on-chain), so this is the SERVICE, not the path. Likely: the project isn't registered on that resolver ` +
+                `(${bold('abx add ' + address + ' --remote')}), the node serves a different chain, or it's down. ` +
+                `Response: ${body.slice(0, 200)}\n`);
+            process.exit(1);
+        }
+    }
+    catch (e) {
+        console.error(`\n  couldn't reach ${uri} — ${e.message}. The URL is what the contract commits to, so check that the ` +
+            `host is up and publicly reachable (a localhost base URL resolves for no one but this machine).\n`);
+        process.exit(1);
+    }
+    info('resolution: OFF-CHAIN (fetched from the URL the contract commits to)');
+    try {
+        console.log(JSON.stringify(JSON.parse(body), null, 2)
+            .split('\n')
+            .map((l) => '    ' + l)
+            .join('\n') + '\n');
+    }
+    catch {
+        console.log(`    ${dim('(not JSON)')} ${body.slice(0, 400)}\n`);
+    }
+}
 // ── serve ──────────────────────────────────────────────────────────────────--
 async function cmdServe(flags) {
     const port = Number(flags.port ?? process.env.ABX_PORT ?? DEFAULT_PORT);
@@ -5951,7 +6049,14 @@ const COMMAND_HELP = {
     ${dim(`${g('onChainStatus')} (branch · chain-complete · unresolved refs · URL budget) and decodes ${g('tokenURI')} straight from the contract.`)}`,
     tokenuri: `
   ${bold('abx tokenuri')} <address> [--token <id>] ${dim('— read tokenURI(id) straight from the contract on-chain + decode the JSON (read-only; no server).')}
-    ${dim('The proof a fully on-chain token self-resolves: any RPC returns the renderer-assembled metadata. Default token 0.')}`,
+    ${dim('The proof a fully on-chain token self-resolves: any RPC returns the renderer-assembled metadata. Default token 0.')}
+    ${dim('Collection-level (ERC-7572) counterpart:')} ${g('abx contracturi <address>')}`,
+    contracturi: `
+  ${bold('abx contracturi')} <address> ${dim('— read contractURI() (ERC-7572 collection metadata) from the contract, FOLLOW it, and decode (read-only).')}
+    ${dim('The collection-level counterpart of')} ${g('tokenuri')}${dim('. On-chain lane: decodes the data: URI. Off-chain lane: fetches the')}
+    ${dim('URL the contract itself commits to and prints the JSON.')}
+    ${bold('Never hand-build a resolver URL to check this')} ${dim('— the contract holds the answer, so a URL from here is right by')}
+    ${dim('construction. A bad status is then about the SERVICE (unregistered project · wrong chain · down), never a mistyped path.')}`,
     forget: `
   ${bold('abx forget')} <address> ${dim('— drop a project’s local registration + projection. On-chain data is untouched.')}
     ${g('--remote [name|url]')}  deregister on a REMOTE resolver instead (it stops serving the project; re-add any time)`,
@@ -6022,6 +6127,7 @@ function help() {
     ${g('abx index')} [<address>]   re-index from chain (incremental by default; ${g('--full')} forces a replay from deploy)
     ${g('abx verify')} <addr>       re-hash served bytes vs the on-chain commitment (no server needed)
     ${g('abx tokenuri')} <addr>     read tokenURI(0) on-chain + decode the JSON (proof a self-resolving token works)
+    ${g('abx contracturi')} <addr>  read contractURI() (ERC-7572 collection metadata) on-chain, follow it, decode — never hand-build the URL
     ${g('abx state')} <addr>        one-glance on-chain snapshot: owner · supply · paused · minter · payee · royalty · renderer
     ${g('abx serve')} [--port ..]   serve the token API + dashboard — and WATCH the chain: auto-index every registered
                             project + notify the effects layer on change (${g('ABX_WATCH_INTERVAL_MS')}; 0 = off)