@artblocks/abx-cli 0.1.0-alpha.20 → 0.1.0-alpha.22

package/dist/commands/project.d.ts

@@ -115,6 +115,14 @@ export declare const STATE_ABI: readonly [{
     readonly outputs: readonly [{
         readonly type: "address";
     }];
+}, {
+    readonly type: "function";
+    readonly name: "seedSource";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
 }];
 /** The edition twin of {@link STATE_ABI} — `owner`/`maxInvocations`/`paused`/`minter`/
  *  `primaryPayee`/`tokenURIRenderer`/`royaltyInfo` are shared, unchanged, function names (see
@@ -222,6 +230,14 @@ export declare const EDITION_STATE_ABI: readonly [{
     readonly outputs: readonly [{
         readonly type: "address";
     }];
+}, {
+    readonly type: "function";
+    readonly name: "seedSource";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
 }];
 export declare function cmdState(address: Address | undefined, flags: Flags): Promise<void>;
 export declare function cmdStateBody(address: Address, flags: Flags, emit: (p: Record<string, unknown>) => void): Promise<void>;

package/dist/commands/project.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../src/commands/project.ts"],"names":[],"mappings":"AAQA,OAAO,EAEL,KAAK,OAAO,EA0Bb,MAAM,oBAAoB,CAAC;AAgB5B,OAAO,EAAC,KAAK,KAAK,EAA0B,MAAM,aAAa,CAAC;AAKhE,OAAO,EACL,KAAK,YAAY,EAalB,MAAM,cAAc,CAAC;AAQtB,wBAAsB,UAAU,CAAC,KAAK,EAAE,KAAK,iBA8E5C;AAMD,wBAAsB,MAAM,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,EAAE,KAAK,EAAE,KAAK,iBA2FtE;AAED,wBAAsB,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,EAAE,KAAK,EAAE,KAAK,iBAoCxE;AAMD,wBAAsB,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,EAAE,KAAK,EAAE,KAAK,iBAazE;AAED,wBAAsB,aAAa,CACjC,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,GACzC,OAAO,CAAC,IAAI,CAAC,CA0Mf;AAMD,wBAAsB,eAAe,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,iBA+F3E;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,yBAAyB,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA6CnH;AAKD,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAaZ,CAAC;AAEX;;;;;oGAKoG;AACpG,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAapB,CAAC;AAEX,wBAAsB,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,EAAE,KAAK,EAAE,KAAK,iBASxE;AAED,wBAAsB,YAAY,CAChC,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,GACzC,OAAO,CAAC,IAAI,CAAC,CA+Hf;AAgFD;;;;;;;GAOG;AACH,wBAAsB,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,EAAE,KAAK,EAAE,KAAK,iBAqDzE;AAED;0EAC0E;AAC1E,wBAAsB,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,KAAK,iBAgErG;AAKD,wBAAsB,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,EAAE,KAAK,EAAE,KAAK,iBA2BzE"}
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../src/commands/project.ts"],"names":[],"mappings":"AAQA,OAAO,EAEL,KAAK,OAAO,EA4Bb,MAAM,oBAAoB,CAAC;AAgB5B,OAAO,EAAC,KAAK,KAAK,EAA0B,MAAM,aAAa,CAAC;AAMhE,OAAO,EACL,KAAK,YAAY,EAalB,MAAM,cAAc,CAAC;AAQtB,wBAAsB,UAAU,CAAC,KAAK,EAAE,KAAK,iBA+E5C;AAMD,wBAAsB,MAAM,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,EAAE,KAAK,EAAE,KAAK,iBA2FtE;AAED,wBAAsB,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,EAAE,KAAK,EAAE,KAAK,iBAoCxE;AAMD,wBAAsB,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,EAAE,KAAK,EAAE,KAAK,iBAazE;AAED,wBAAsB,aAAa,CACjC,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,GACzC,OAAO,CAAC,IAAI,CAAC,CAmQf;AAMD,wBAAsB,eAAe,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,iBA+F3E;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,yBAAyB,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA6CnH;AAqBD,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBZ,CAAC;AAEX;;;;;oGAKoG;AACpG,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAepB,CAAC;AAEX,wBAAsB,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,EAAE,KAAK,EAAE,KAAK,iBASxE;AAED,wBAAsB,YAAY,CAChC,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,GACzC,OAAO,CAAC,IAAI,CAAC,CAqKf;AAgHD;;;;;;;GAOG;AACH,wBAAsB,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,EAAE,KAAK,EAAE,KAAK,iBAqDzE;AAED;0EAC0E;AAC1E,wBAAsB,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,KAAK,iBAgErG;AAKD,wBAAsB,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,EAAE,KAAK,EAAE,KAAK,iBA2BzE"}

package/dist/commands/project.js

@@ -6,7 +6,7 @@
  */
 import { readFileSync } from 'node:fs';
 import { resolve as resolvePath } from 'node:path';
-import { AUTH_OPTIONS, CREATOR_TOKEN_INTERFACE_ID, PARAM_TYPES, hasOnChainUriLane, isCodeProject, isCurrentFactory, isCurrentOneOfOneEditionFactory, makePublicClient, makeWalletClient, normalizeAttributes, onChainUriReport, parseTraitPairs, predictClone, readParamSchema, readParamSchemaKeys, readSetParamKeys, resolveChain, resolveSeriesCodeFactory, saltFor, saltGuard, sleep, tryReadContract, } from '@artblocks/abx-sdk';
+import { AUTH_OPTIONS, CREATOR_TOKEN_INTERFACE_ID, PARAM_TYPES, hasOnChainUriLane, isCodeProject, isCurrentFactory, isCurrentOneOfOneEditionFactory, makePublicClient, makeWalletClient, normalizeAttributes, onChainUriReport, parseTraitPairs, predictClone, readParamHooks, readParamHooksLocked, readParamSchema, readParamSchemaKeys, readSetParamKeys, resolveChain, resolveSeriesCodeFactory, saltFor, saltGuard, sleep, tryReadContract, } from '@artblocks/abx-sdk';
 import { resolveBackend } from '@artblocks/abx-storage';
 import { currentRenderArtifact, verifyProject } from '@artblocks/abx-token-api';
 import { zeroAddress } from 'viem';
@@ -15,6 +15,7 @@ import { isDryRun, parseSaltFlag } from '../flags.js';
 import { jsonSafe, withJson } from '../jsonout.js';
 import { allowLargeScan, bold, c, detectCanonicalFactory, dim, g, info, ok, registerAndIndexLocally, resolveScanFloor, warn } from '../output.js';
 import { parseCopies } from './deploy.js';
+import { canonicalSeedSource } from '../ownerops.js';
 import { detectTokenKind, describeKind } from '../kind.js';
 import { canonicalLabel, describeRemoteError, indexErrorAction, remoteFlag, reportRemoteIndexing, requireRemoteToken, rollUp, serviceClient, statusLabel, statusLine, statusRow, tokenSourceLabel, } from '../remote.js';
 import { describeSchema } from '../schema.js';
@@ -66,9 +67,10 @@ export async function cmdPredict(flags) {
     }
     // The current-factory guard is the 1/1 impl-version check (721 or its edition twin); the Series/
     // Series-edition/code/code-edition lanes verify their own factory at deploy time instead —
-    // EditionCodeFactory mirrors SeriesCodeFactory's stance here (no version probe: a link-time-linked
-    // factory has no CREATE2-deterministic address to self-heal to, so there's nothing this check would
-    // catch that the real deploy doesn't already). predictDeterministicAddress works on any factory ABI.
+    // EditionCodeFactory mirrors SeriesCodeFactory's stance here (no version probe: a configured code
+    // factory with code is always accepted, and one found at its CREATE2 address is bytecode-bound to
+    // this build anyway, so there's nothing this check would catch that the real deploy doesn't
+    // already). predictDeterministicAddress works on any factory ABI.
     if (lane.cmd === 'deploy') {
         const current = isEdition ? await isCurrentOneOfOneEditionFactory(publicClient, factory) : await isCurrentFactory(publicClient, factory);
         if (!current) {
@@ -338,6 +340,27 @@ export async function cmdVerifyBody(address, flags, emit) {
         info(state.paramHooks?.augmentHook
             ? `live data: augment hook ${state.paramHooks.augmentHook} — live view reads chain per view; stills snapshot settled state`
             : 'live data: none (settled params only — the live view makes zero extra chain reads)');
+        // Immutability of the WORK itself — the on-chain program (script chunks) and its library set.
+        // This is the gap `lock-field`/`lock-uri` don't cover: those freeze metadata, but the owner can
+        // still call `setScriptChunk`/`removeLastScriptChunk` until `lock-script` is sent. Report it so a
+        // "locked" drop isn't quietly still-mutable in the one place that carries the work.
+        verifyReport.script = state.script ? { locked: !!state.script.locked } : null;
+        verifyReport.dependencies = state.dependencies
+            ? { count: state.dependencies.list.length, locked: !!state.dependencies.locked }
+            : null;
+        emit(verifyReport);
+        if (state.script) {
+            if (state.script.locked)
+                ok('script: locked — the program bytes are frozen permanently (setScriptChunk reverts)');
+            else
+                console.log(`    ${c.orange}⚠${c.reset} script: UNLOCKED — the owner can still change the program. Freeze the work with ${bold(`abx lock-script ${address}`)} ${dim("(lock-field/lock-uri don't cover the script)")}`);
+        }
+        if (state.dependencies && state.dependencies.list.length > 0) {
+            if (state.dependencies.locked)
+                ok('dependencies: locked — the library set is frozen');
+            else
+                info(`dependencies: unlocked — freeze the list + registry pointer with \`abx lock-dependencies ${address}\` (that pins WHICH library each ref means; a Registry ref's bytes still live in the registry)`);
+        }
         // The other two param hooks (if wired) — surfaced here since this is where hooks show. Quiet when
         // unset (the common case). Manage all three with `abx set-param-hooks`.
         if (state.paramHooks?.configureHook || state.paramHooks?.transferHook) {
@@ -346,7 +369,26 @@ export async function cmdVerifyBody(address, flags, emit) {
                 parts.push(`configure ${state.paramHooks.configureHook}`);
             if (state.paramHooks.transferHook)
                 parts.push(`transfer ${state.paramHooks.transferHook}`);
-            info(`param hooks: ${parts.join(' · ')} ${dim('(configure = write-time veto · transfer = ownership-change lifecycle; manage with `abx set-param-hooks`)')}`);
+            info(`param hooks: ${parts.join(' · ')} ${dim('(configure = write-time veto · transfer = a VETO over transfers AND mints; manage with `abx set-param-hooks`)')}`);
+        }
+        // The hook lock is reported for every project with the surface, set hooks or not: a frozen empty
+        // trio is a real guarantee ("this project can never add a transfer veto"), and an unfrozen one is
+        // a live power even when no hook is set today. Folded from `ParamHooksFrozen`.
+        if (state.paramHooks) {
+            verifyReport.paramHooks = {
+                configureHook: state.paramHooks.configureHook,
+                augmentHook: state.paramHooks.augmentHook,
+                transferHook: state.paramHooks.transferHook,
+                locked: state.paramHooks.locked,
+            };
+            if (state.paramHooks.locked)
+                ok('param hooks: frozen — no hook address can change again (no transfer veto can ever be armed)');
+            else if (state.paramHooks.transferHook) {
+                console.log(`    ${c.orange}⚠${c.reset} param hooks: UNLOCKED, and a transfer hook is armed — it can block transfers and mints, and the owner can re-point it. Freeze the set with ${bold(`abx lock-param-hooks ${address}`)}`);
+            }
+            else {
+                info(`param hooks: unlocked — no hook is set, but the owner can still add one (a transfer hook can block transfers/mints). Freeze with \`abx lock-param-hooks ${address}\``);
+            }
         }
         // This checks THIS machine's store. A render PUBLISHED to a hosted resolver (locator bridge) lives
         // on that resolver, NOT here — so a "not found" below can be a false negative for a hosted drop.
@@ -391,6 +433,14 @@ export async function cmdVerifyBody(address, flags, emit) {
     // what the animation_url actually is. All eth_calls; no server, no local store involved.
     if (hasOnChainUriLane(state)) {
         const client = makePublicClient({ chainKey: CHAIN });
+        // Is this actually a PROGRAM, or a static image that merely resolves on-chain? `hasOnChainUriLane`
+        // is true whenever a tokenURI renderer is set — which it is for EVERY fully-on-chain project,
+        // image or code. So an image drop ran the code-project checks and ended in two ⚠ ("generator
+        // reports NO code", "no animation_url") that are the DESIGN for a static image, not a defect.
+        // Two cold agents in one sweep flagged those warnings as the worst thing about `verify`: the
+        // command the skill points at to answer "did my on-chain drop work?" was ending in warnings on a
+        // drop that is completely fine, which teaches people to discount its warnings generally.
+        const isCodeProject = state.contractType === 'code' || state.contractType === 'edition-code';
         try {
             const report = await onChainUriReport(client, state, flags.generator);
             const { status, probe } = report;
@@ -409,8 +459,15 @@ export async function cmdVerifyBody(address, flags, emit) {
             info(`on-chain URI lane: generator ${report.generator}${state.tokenURIRenderer ? ` · tokenURI renderer ${state.tokenURIRenderer}` : ' · tokenURIRenderer NOT set (animation field only — tokenURI still resolves off-chain)'}`);
             if (status.branchName === 'template') {
                 ok(`generator branch: template — the document assembles from the on-chain script chunks`);
-                if (status.chainComplete)
-                    ok('chain-complete — every dependency resolves to proven on-chain bytes; no server, gateway, or CDN in the graph');
+                if (status.chainComplete) {
+                    ok('chain-complete — every dependency resolves to on-chain bytes; no server, gateway, or CDN in the graph');
+                    // chainComplete is a SERVING claim, not an immutability one. A `Registry` dependency is
+                    // fetched live from the registry contract on every read, so its bytes can change after
+                    // `lock-dependencies` froze the pointer — and this flag reported `true` on both sides of
+                    // exactly that swap during the audit. Say what it means rather than letting "complete" read
+                    // as "finished".
+                    info(dim('  chain-complete describes WHERE the bytes come from, not that they are frozen: a Registry dependency is re-fetched from the registry on every read, so its bytes can change even with lock-dependencies set. Locks freeze this contract; they cannot freeze another one.'));
+                }
                 else
                     info('not chain-complete — CDN-served or unresolved dependencies (CDN entries serve fine; on-chain bytes are the durability floor)');
                 for (const ref of status.unresolvedRefs) {
@@ -424,17 +481,21 @@ export async function cmdVerifyBody(address, flags, emit) {
                 else
                     info('URL within the 8KB budget');
             }
-            else {
+            else if (isCodeProject) {
                 console.log(`    ${c.orange}⚠${c.reset} generator reports NO code (neither script chunks nor a code field) — animation_url degrades to an <!-- abx:no-code --> marker`);
             }
+            else {
+                // A static image drop has no program by design — stating that is fine, warning about it is not.
+                info('no program on this project — a static image drop, so the metadata carries no animation_url (expected, not a gap)');
+            }
             if (!probe) {
                 info('tokenURI probe skipped — no token minted yet (mint token #0, then re-run)');
             }
             else if (!probe.onChainJson) {
-                console.log(`    ${c.red}✗${c.reset} tokenURI(${probe.tokenId}) is NOT an on-chain data:application/json;base64 URI — got "${probe.uriPrefix}…"`);
+                console.log(`    ${c.red}✗${c.reset} ${probe.accessor}(${probe.tokenId}) is NOT an on-chain data:application/json;base64 URI — got "${probe.uriPrefix}…"`);
             }
             else {
-                ok(`tokenURI(${probe.tokenId}) resolves ON-CHAIN: data:application/json;base64 — decoded from the contract, no server`);
+                ok(`${probe.accessor}(${probe.tokenId}) resolves ON-CHAIN: data:application/json;base64 — decoded from the contract, no server`);
                 const a = probe.animation;
                 if (a.form === 'data-html') {
                     if (a.marker)
@@ -448,9 +509,10 @@ export async function cmdVerifyBody(address, flags, emit) {
                 else if (a.form === 'data-other') {
                     console.log(`    ${c.orange}⚠${c.reset} animation_url is a data: URI but not text/html — got "${a.prefix}…"`);
                 }
-                else {
+                else if (isCodeProject) {
                     console.log(`    ${c.orange}⚠${c.reset} no animation_url in the on-chain JSON — the generator field may be missing or unrenderable`);
                 }
+                // else: a static image has no animation_url and is not supposed to — say nothing.
             }
             // The READ-side envelope. Params enumerate on-chain, so the write side is unbounded — but
             // tokenURI and tokenData assemble EVERY enumerated param per call, and that is what grows.
@@ -466,7 +528,10 @@ export async function cmdVerifyBody(address, flags, emit) {
             }
         }
         catch (e) {
-            console.log(`    ${c.orange}⚠${c.reset} on-chain URI check unavailable: ${e.message}`);
+            // First line only. A viem read error carries a multi-line dump (Contract Call / args / Docs /
+            // Version) that is meaningless to a creator and buried the actual sentence when this fired.
+            const first = String(e.message ?? e).split('\n')[0].trim();
+            console.log(`    ${c.orange}⚠${c.reset} on-chain URI check unavailable: ${first}`);
         }
     }
     if (renderGap)
@@ -641,6 +706,22 @@ export async function reportRemoteByteIntegrity(address, remote, base) {
 // ── state: a one-glance operational snapshot of a deployed contract, read straight from chain ──
 // Read-only (no tx, no local index). Series-only getters revert on a 1/1, so each read is defensive
 // → the same command works for both. The agent-friendly "what's the state before/after an op" call.
+/**
+ * The `seed source` readout — three states, and the distinction between them is the whole reason the
+ * line exists. `0x0` is a code project that deliberately draws no mint seed; the canonical address is
+ * the shared pseudorandom `AbxSeedSource` (whose properties are documented and NOT lottery-grade);
+ * anything else is the creator's own contract, about which ABX knows and claims nothing. A buyer or an
+ * agent reading this needs to be able to tell "the standard one" from "someone's custom randomness"
+ * at a glance — flattening them to a bare address hides exactly the fact worth surfacing.
+ */
+function describeSeedSource(source) {
+    if (source === zeroAddress)
+        return dim('none (0x0 — no mint-time seed drawn at mint)');
+    if (source.toLowerCase() === canonicalSeedSource(resolveChain(CHAIN).id).toLowerCase()) {
+        return `${source} ${dim('(canonical AbxSeedSource — pseudorandom, not lottery-grade)')}`;
+    }
+    return `${source} ${dim('— CUSTOM IAbxSeedSource (not the canonical one; its randomness properties are the project’s to state)')}`;
+}
 export const STATE_ABI = [
     { type: 'function', name: 'owner', stateMutability: 'view', inputs: [], outputs: [{ type: 'address' }] },
     { type: 'function', name: 'totalSupply', stateMutability: 'view', inputs: [], outputs: [{ type: 'uint256' }] },
@@ -654,6 +735,10 @@ export const STATE_ABI = [
     // ERC-721C (creator token) — ERC-165 advertises ICreatorToken ONLY when enrolled at deploy.
     { type: 'function', name: 'supportsInterface', stateMutability: 'view', inputs: [{ type: 'bytes4' }], outputs: [{ type: 'bool' }] },
     { type: 'function', name: 'getTransferValidator', stateMutability: 'view', inputs: [], outputs: [{ type: 'address' }] },
+    // Seed Source extension — composed by CODE projects only, so absent (undefined) on an image token.
+    // Shown because it is the one setting an owner can re-point mid-sale that changes what a LATER
+    // buyer receives; `SeedSourceSet` puts it on the spine, and this makes it readable in one command.
+    { type: 'function', name: 'seedSource', stateMutability: 'view', inputs: [], outputs: [{ type: 'address' }] },
 ];
 /** The edition twin of {@link STATE_ABI} — `owner`/`maxInvocations`/`paused`/`minter`/
  *  `primaryPayee`/`tokenURIRenderer`/`royaltyInfo` are shared, unchanged, function names (see
@@ -674,6 +759,8 @@ export const EDITION_STATE_ABI = [
     // ERC-1155C (creator token) — identical ERC-165 id + getter as 721C; advertised only when enrolled.
     { type: 'function', name: 'supportsInterface', stateMutability: 'view', inputs: [{ type: 'bytes4' }], outputs: [{ type: 'bool' }] },
     { type: 'function', name: 'getTransferValidator', stateMutability: 'view', inputs: [], outputs: [{ type: 'address' }] },
+    // Seed Source extension — EditionCode composes it; the image editions don't. See STATE_ABI's note.
+    { type: 'function', name: 'seedSource', stateMutability: 'view', inputs: [], outputs: [{ type: 'address' }] },
 ];
 export async function cmdState(address, flags) {
     if (!address || address.startsWith('--')) {
@@ -694,7 +781,7 @@ export async function cmdStateBody(address, flags, emit) {
         return cmdStateEditionBody(address, publicClient, kind, emit);
     // getter absent (extension not composed) or contract has no code → undefined, never a throw.
     const read = (functionName, args = []) => tryReadContract(publicClient, { address, abi: STATE_ABI, functionName, args });
-    const [owner, totalSupply, nextTokenId, maxInvocations, paused, minter, primaryPayee, renderer, royalty, creatorToken, transferValidator] = await Promise.all([
+    const [owner, totalSupply, nextTokenId, maxInvocations, paused, minter, primaryPayee, renderer, royalty, creatorToken, transferValidator, seedSource] = await Promise.all([
         read('owner'),
         read('totalSupply'),
         read('nextTokenId'),
@@ -706,6 +793,7 @@ export async function cmdStateBody(address, flags, emit) {
         read('royaltyInfo', [0n, 10000n]),
         read('supportsInterface', [CREATOR_TOKEN_INTERFACE_ID]),
         read('getTransferValidator'),
+        read('seedSource'),
     ]);
     if (owner === undefined && totalSupply === undefined) {
         throw new Error(`no ABX contract state at ${address} on ${CHAIN} (no code, or not an ABX token).`);
@@ -732,6 +820,10 @@ export async function cmdStateBody(address, flags, emit) {
         royalty: royalty ? { receiver: royalty[0], bps: Number(royalty[1]) } : null,
         creatorToken: !!creatorToken,
         transferValidator: creatorToken ? zeroToNull(transferValidator) : null,
+        // `undefined` (no extension — an image token) and `0x0` (a code project that opted out) are
+        // different facts; the JSON keeps them apart the same way every other getter here does.
+        seedSource: zeroToNull(seedSource),
+        hasSeedSource: seedSource !== undefined,
         params: { governed: [], contractScopeSet: [] },
     });
     emit(payload);
@@ -758,6 +850,8 @@ export async function cmdStateBody(address, flags, emit) {
     if (creatorToken) {
         info(`721C validator ${transferValidator && transferValidator !== zeroAddress ? transferValidator : `${c.orange}suspended${c.reset} ${dim('(zero — enforcement off; re-enable with `abx set-transfer-validator`)')}`}`);
     }
+    if (seedSource !== undefined)
+        info(`seed source    ${describeSeedSource(seedSource)}`);
     // The PostParam surface, read straight from chain: `paramSchemaKeys()` is the DECLARED (governed)
     // set — append-only, and it includes keys declared but never yet written, which nothing off-chain
     // could otherwise discover — and `contractParamKeys()` is the collection-scope set values. Both
@@ -786,7 +880,7 @@ export async function cmdStateBody(address, flags, emit) {
         })));
         emit(payload);
         if (governed.length) {
-            console.log(`\n  ${bold('PostParams')}  ${dim(`${governed.length} governed · collectors/artist set these; the generator injects them`)}`);
+            console.log(`\n  ${bold('PostParams')}  ${dim(`${governed.length} governed · collectors/creator set these; the generator injects them`)}`);
             for (const { key, s } of governed) {
                 const retired = s.lockAfter !== 0 && s.lockAfter < now;
                 const locks = s.lockAfter !== 0 && !retired ? dim(`  locks ${new Date(s.lockAfter * 1000).toISOString().slice(0, 10)}`) : '';
@@ -802,6 +896,36 @@ export async function cmdStateBody(address, flags, emit) {
             emit(payload);
             info(`${dim('contract-scope params set:')} ${[...set.contract].sort().join(', ')} ${dim('(apply to every token)')}`);
         }
+        // The hooks, and whether they can still change. This is a BUYER's read, which is why it lives in
+        // `state` next to the validator rather than only in `verify`: the transfer hook is a veto over
+        // transfers and mints, so "which hooks, and are they frozen" is exactly the pair someone needs
+        // before buying. Printed whenever the surface exists — including with all three unset, because
+        // "none, and frozen" is the strongest thing this line can say and it must be visible.
+        const hooks = await readParamHooks(publicClient, address);
+        if (hooks) {
+            const locked = await readParamHooksLocked(publicClient, address);
+            const shown = [['configure', hooks.configureHook], ['augment', hooks.augmentHook], ['transfer', hooks.transferHook]]
+                .filter(([, a]) => a !== zeroAddress)
+                .map(([role, a]) => `${role} ${a}`);
+            payload.params.hooks = jsonSafe({
+                configureHook: hooks.configureHook === zeroAddress ? null : hooks.configureHook,
+                augmentHook: hooks.augmentHook === zeroAddress ? null : hooks.augmentHook,
+                transferHook: hooks.transferHook === zeroAddress ? null : hooks.transferHook,
+                // `null` = could not be established (see readParamHooksLocked). Never collapse it to false:
+                // "unknown" and "the owner can still arm a transfer veto" are different answers.
+                locked: locked ?? null,
+            });
+            emit(payload);
+            const lockNote = locked === true
+                ? `${c.green}frozen${c.reset} ${dim('— no hook address can ever change again')}`
+                : locked === false
+                    ? `${c.orange}not frozen${c.reset} ${dim('— the owner can re-point these (`abx lock-param-hooks` freezes them forever)')}`
+                    : dim('freeze state unknown (the node refused the check)');
+            info(`param hooks    ${shown.length ? shown.join(' · ') : dim('none set')}   ${lockNote}`);
+            if (hooks.transferHook !== zeroAddress) {
+                info(dim(`               the transfer hook is a VETO: if it reverts, the transfer fails — and mints too (mint = transfer from 0x0).`));
+            }
+        }
     }
     catch {
         /* best-effort — a non-code project has no params surface to read */
@@ -817,7 +941,7 @@ export async function cmdStateBody(address, flags, emit) {
  */
 async function cmdStateEditionBody(address, publicClient, kind, emit) {
     const read = (functionName, args = []) => tryReadContract(publicClient, { address, abi: EDITION_STATE_ABI, functionName, args });
-    const [owner, maxInvocations, paused, minter, primaryPayee, renderer, royalty, creatorToken, transferValidator] = await Promise.all([
+    const [owner, maxInvocations, paused, minter, primaryPayee, renderer, royalty, creatorToken, transferValidator, seedSource] = await Promise.all([
         read('owner'),
         read('maxInvocations'), // absent on a 1/1-edition — its id space is fixed to {0}
         read('paused'),
@@ -827,6 +951,7 @@ async function cmdStateEditionBody(address, publicClient, kind, emit) {
         read('royaltyInfo', [0n, 10000n]),
         read('supportsInterface', [CREATOR_TOKEN_INTERFACE_ID]),
         read('getTransferValidator'),
+        read('seedSource'),
     ]);
     if (owner === undefined)
         throw new Error(`no ABX contract state at ${address} on ${CHAIN} (no code, or not an ABX token).`);
@@ -853,6 +978,8 @@ async function cmdStateEditionBody(address, publicClient, kind, emit) {
         royalty: royalty ? { receiver: royalty[0], bps: Number(royalty[1]) } : null,
         creatorToken: !!creatorToken,
         transferValidator: creatorToken ? zeroToNull(transferValidator) : null,
+        seedSource: zeroToNull(seedSource),
+        hasSeedSource: seedSource !== undefined,
     });
     emit(payload);
     console.log(bold(`\n  ${describeKind(kind)} state`) + dim(`  ${address} · ${CHAIN}`));
@@ -875,6 +1002,35 @@ async function cmdStateEditionBody(address, publicClient, kind, emit) {
     if (creatorToken) {
         info(`1155C validator ${transferValidator && transferValidator !== zeroAddress ? transferValidator : `${c.orange}suspended${c.reset} ${dim('(zero — enforcement off; re-enable with `abx set-transfer-validator`)')}`}`);
     }
+    if (seedSource !== undefined)
+        info(`seed source    ${describeSeedSource(seedSource)}`);
+    // EditionCode composes ConfigurableParams exactly like SeriesCode, so an edition has hooks too —
+    // and the transfer hook's veto reaches a mint, which on this lane is a buyer picking an id. Report
+    // the same pair as the 721 body (which hooks, and whether they can still change); silent for the
+    // image/1-of-1 edition twins, which have no params surface at all.
+    const hooks = await readParamHooks(publicClient, address);
+    if (hooks) {
+        const locked = await readParamHooksLocked(publicClient, address);
+        const shown = [['configure', hooks.configureHook], ['augment', hooks.augmentHook], ['transfer', hooks.transferHook]]
+            .filter(([, a]) => a !== zeroAddress)
+            .map(([role, a]) => `${role} ${a}`);
+        payload.paramHooks = jsonSafe({
+            configureHook: hooks.configureHook === zeroAddress ? null : hooks.configureHook,
+            augmentHook: hooks.augmentHook === zeroAddress ? null : hooks.augmentHook,
+            transferHook: hooks.transferHook === zeroAddress ? null : hooks.transferHook,
+            locked: locked ?? null, // null = unknown; never collapse it to false
+        });
+        emit(payload);
+        const lockNote = locked === true
+            ? `${c.green}frozen${c.reset} ${dim('— no hook address can ever change again')}`
+            : locked === false
+                ? `${c.orange}not frozen${c.reset} ${dim('— the owner can re-point these (`abx lock-param-hooks` freezes them forever)')}`
+                : dim('freeze state unknown (the node refused the check)');
+        info(`param hooks    ${shown.length ? shown.join(' · ') : dim('none set')}   ${lockNote}`);
+        if (hooks.transferHook !== zeroAddress) {
+            info(dim(`               the transfer hook is a VETO: if it reverts, the transfer fails — and mints too (mint = transfer from 0x0).`));
+        }
+    }
     console.log('');
 }
 /**