@artblocks/abx-cli 0.1.0-alpha.53 → 0.1.0-alpha.55

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # @artblocks/abx-cli
 
+## 0.1.0-alpha.55
+
+### Patch Changes
+
+- 8ccbede: Enable Robinhood Chain production as beta after canonical deployment, paired-testnet qualification,
+  and managed-service validation. Surface the same real-funds warning and testnet-first gate used for
+  other production beta networks.
+- Updated dependencies [8ccbede]
+  - @artblocks/abx-sdk@0.1.0-alpha.41
+  - @artblocks/abx-indexer@0.1.0-alpha.42
+  - @artblocks/abx-storage@0.1.0-alpha.41
+  - @artblocks/abx-token-api@0.1.0-alpha.44
+
+## 0.1.0-alpha.54
+
+### Patch Changes
+
+- f9d7a44: Clarify fully on-chain image deployment tradeoffs and make static-project verification report
+  `onChainUri.chainComplete` as not applicable instead of false.
+- ee24497: Add machine-readable `--json` output to `contracturi` and `add`. Collection metadata reads now emit
+  the resolved document alone, while registration reports identify the target surface, chain and
+  address, scan floor, lifecycle status, and whether remote catch-up is complete or still backfilling.
+- Updated dependencies [b9197bc]
+  - @artblocks/abx-sdk@0.1.0-alpha.40
+  - @artblocks/abx-indexer@0.1.0-alpha.41
+  - @artblocks/abx-storage@0.1.0-alpha.40
+  - @artblocks/abx-token-api@0.1.0-alpha.43
+
 ## 0.1.0-alpha.53
 
 ### Patch Changes

package/dist/commands/deploy.js

@@ -947,7 +947,7 @@ export async function cmdDeployBody(flags, serveAfter, emit) {
         })()
         : 1;
     if (dryRun && onchainImage && imageEndsUpOnChain(flags, false)) {
-        info(`${bold('one-transaction alternative:')} this SVG can be inlined with bare ${bold('--onchain-uri')} instead of staged with ` +
+        warn(`${bold('one-transaction alternative:')} this SVG can be inlined with bare ${bold('--onchain-uri')} instead of staged with ` +
             `${bold('--onchain-image')} (${approvals} transactions here). Dry-run that form before changing lanes.`);
     }
     // Mint-on-deploy is the default; --no-mint defers it so you can stand up + warm

package/dist/commands/project.d.ts

@@ -2,6 +2,29 @@ import { type Address, type PublicClient, type MetadataField } from '@artblocks/
 import { type Flags } from '../flags.js';
 import { type RemoteTarget } from '../remote.js';
 export declare function cmdPredict(flags: Flags): Promise<void>;
+export interface AddJsonResult extends Record<string, unknown> {
+    target: {
+        surface: 'local' | 'remote';
+        name: string | null;
+        url: string | null;
+    };
+    chainId: number;
+    address: Address;
+    status: string;
+    scanFloor: string;
+    completed: boolean;
+    backfilling: boolean;
+    eventCount?: number;
+    tokenCount?: number;
+}
+/** Keep the local lane's machine contract independent of the indexer's larger state object. */
+export declare function localAddJsonResult(input: {
+    chainId: number;
+    address: Address;
+    scanFloor: string;
+    eventCount: number;
+    tokenCount: number;
+}): AddJsonResult;
 export declare function cmdAdd(address: Address | undefined, flags: Flags): Promise<void>;
 export declare function cmdIndex(address: Address | undefined, flags: Flags): Promise<void>;
 export declare function cmdVerify(address: Address | undefined, flags: Flags): Promise<void>;
@@ -42,6 +65,10 @@ export declare function onChainImageSource(fields: MetadataField[]): string | nu
  * "no commitment", a different fact from "an unrecomputable one".
  */
 export declare function pointerOnlyImageCheck(fields: MetadataField[]): string | null;
+/** `chainComplete` describes a code template's dependency graph. Static projects have no code
+ * graph to classify, so their structured verification result must say "not applicable" instead
+ * of reporting a confident `false` that reads like a failed durability check. */
+export declare function verifyChainComplete(isCodeProject: boolean, chainComplete: boolean): boolean | null;
 export declare function cmdVerifyBody(address: Address, flags: Flags, emit: (p: Record<string, unknown>) => void): Promise<void>;
 export declare function cmdVerifyRemote(address: Address, remote: RemoteTarget, emit: (p: Record<string, unknown>) => void): Promise<void>;
 /** What {@link reportRemoteByteIntegrity} found, structured for the JSON payload as well as its own

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

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

package/dist/commands/project.js

@@ -99,10 +99,20 @@ export async function cmdPredict(flags) {
         info(dim('(this is the 1/1 lane; a Series/code drop uses a different factory → a different address — pass --dir / --script to predict those, or use that command\'s --dry-run)'));
     console.log('');
 }
-// ── add ──────────────────────────────────────────────────────────────────────
-// Register + index a project this node didn't deploy. LOCAL by default (this
-// machine's store); `--remote [url]` instead tells a HOSTED resolver to index it —
-// the bridge a local deploy can't make on its own (separate projection stores).
+/** Keep the local lane's machine contract independent of the indexer's larger state object. */
+export function localAddJsonResult(input) {
+    return {
+        target: { surface: 'local', name: null, url: null },
+        chainId: input.chainId,
+        address: input.address,
+        status: input.eventCount > 0 ? 'live' : 'empty',
+        scanFloor: input.scanFloor,
+        completed: true,
+        backfilling: false,
+        eventCount: input.eventCount,
+        tokenCount: input.tokenCount,
+    };
+}
 export async function cmdAdd(address, flags) {
     if (!address || address.startsWith('--')) {
         console.error('usage: abx add <address> [--from-block N] [--factory 0x..] [--label "..."] [--remote [name|url]]\n');
@@ -118,103 +128,123 @@ export async function cmdAdd(address, flags) {
             'Nothing here touches the chain, but it does write. To look before acting: `abx state <address>` (on-chain snapshot) ' +
             'or `abx status <address> [--remote <name>]` (what a node already has). Re-run without --dry-run when you mean it.');
     }
-    // `--attributes` is lane-aware here exactly as at deploy: a PER-TOKEN payload edits a Series'
-    // per-token off-chain traits; a flat payload (+ `--traits`) edits the collection/1-of-1 `attributes`.
-    // Ambiguity defaults to flat (see looksPerTokenAttributes), so a 1/1 add is never mis-read.
-    const attrRaw = flags.attributes ? readFileSync(resolvePath(process.cwd(), String(flags.attributes)), 'utf8') : undefined;
-    const perTokenEdit = attrRaw != null && looksPerTokenAttributes(attrRaw);
-    const flagTraits = [];
-    if (attrRaw != null && !perTokenEdit)
-        flagTraits.push(...normalizeAttributes(JSON.parse(attrRaw)));
-    if (flags.traits)
-        flagTraits.push(...parseTraitPairs(flags.traits));
-    const editedTokenAttributes = perTokenEdit ? parseSeriesTraitsById(attrRaw) : undefined;
-    const remote = remoteFlag(flags);
-    if (remote) {
-        requireRemoteToken(remote);
-        // Bridge what a remote resolver can't derive itself: the off-chain traits and the durable
-        // content locators (ipfs://…). Prefer flags; otherwise forward what the LOCAL deploy stored
-        // (the local registration), and compute locators from this machine's content index if needed.
-        const localReg = localIndexer().store.getRegistration(address);
-        const attributes = flagTraits.length
-            ? flagTraits
-            : localReg?.attributes
-                ? normalizeAttributes(JSON.parse(localReg.attributes))
-                : undefined;
-        // Bridge a Series' per-token off-chain traits to the remote resolver (the resolver has no other
-        // way to derive them — they're operator metadata, not chain state). A fresh per-token `--attributes`
-        // EDITS them; otherwise forward what the LOCAL deploy stored. Best-effort parse.
-        let tokenAttributes;
-        if (editedTokenAttributes && Object.keys(editedTokenAttributes).length) {
-            tokenAttributes = editedTokenAttributes;
-        }
-        else if (localReg?.tokenAttributes) {
-            try {
-                const obj = JSON.parse(localReg.tokenAttributes);
-                const norm = {};
-                for (const [id, v] of Object.entries(obj)) {
-                    const a = normalizeAttributes(v);
-                    if (a.length)
-                        norm[id] = a;
+    return withJson(flags, async (emit) => {
+        // `--attributes` is lane-aware here exactly as at deploy: a PER-TOKEN payload edits a Series'
+        // per-token off-chain traits; a flat payload (+ `--traits`) edits the collection/1-of-1 `attributes`.
+        // Ambiguity defaults to flat (see looksPerTokenAttributes), so a 1/1 add is never mis-read.
+        const attrRaw = flags.attributes ? readFileSync(resolvePath(process.cwd(), String(flags.attributes)), 'utf8') : undefined;
+        const perTokenEdit = attrRaw != null && looksPerTokenAttributes(attrRaw);
+        const flagTraits = [];
+        if (attrRaw != null && !perTokenEdit)
+            flagTraits.push(...normalizeAttributes(JSON.parse(attrRaw)));
+        if (flags.traits)
+            flagTraits.push(...parseTraitPairs(flags.traits));
+        const editedTokenAttributes = perTokenEdit ? parseSeriesTraitsById(attrRaw) : undefined;
+        const remote = remoteFlag(flags);
+        if (remote) {
+            requireRemoteToken(remote);
+            // Bridge what a remote resolver can't derive itself: the off-chain traits and the durable
+            // content locators (ipfs://…). Prefer flags; otherwise forward what the LOCAL deploy stored
+            // (the local registration), and compute locators from this machine's content index if needed.
+            const localReg = localIndexer().store.getRegistration(address);
+            const attributes = flagTraits.length
+                ? flagTraits
+                : localReg?.attributes
+                    ? normalizeAttributes(JSON.parse(localReg.attributes))
+                    : undefined;
+            // Bridge a Series' per-token off-chain traits to the remote resolver (the resolver has no other
+            // way to derive them — they're operator metadata, not chain state). A fresh per-token `--attributes`
+            // EDITS them; otherwise forward what the LOCAL deploy stored. Best-effort parse.
+            let tokenAttributes;
+            if (editedTokenAttributes && Object.keys(editedTokenAttributes).length) {
+                tokenAttributes = editedTokenAttributes;
+            }
+            else if (localReg?.tokenAttributes) {
+                try {
+                    const obj = JSON.parse(localReg.tokenAttributes);
+                    const norm = {};
+                    for (const [id, v] of Object.entries(obj)) {
+                        const a = normalizeAttributes(v);
+                        if (a.length)
+                            norm[id] = a;
+                    }
+                    if (Object.keys(norm).length)
+                        tokenAttributes = norm;
                 }
-                if (Object.keys(norm).length)
-                    tokenAttributes = norm;
+                catch { /* skip a malformed local column */ }
             }
-            catch { /* skip a malformed local column */ }
-        }
-        const contentLocators = await remoteLocators(address, localReg?.contentLocators, flags);
-        // Forward the deploy block, like every other field falls back to the local registration.
-        // (Its ABSENCE here was the bug: a hosted resolver defaulted to genesis and scanned the whole
-        // chain.) Re-sending the same floor stays incremental server-side, so a nudge ≠ a re-scan.
-        const body = {
-            chainId: resolveChain(CHAIN).id,
-            address,
-            fromBlock: await resolveScanFloor(address, localReg?.fromBlock, flags),
-            factory: await detectCanonicalFactory(address, flags.factory, localReg?.factory),
-            label: flags.label,
-            description: flags.description ?? localReg?.description,
-            externalUrl: flags['external-url'] ?? localReg?.externalUrl,
-            attributes,
-            tokenAttributes,
-            contentLocators: Object.keys(contentLocators).length ? contentLocators : undefined,
-            full: flags.full ? true : undefined,
-        };
-        info(`${bold('REMOTE')} → ${remote.url}  ${dim('(registering with the remote resolver — NOT this machine)')}`);
-        if (body.contentLocators)
-            info(`bridging image locator → ${Object.values(body.contentLocators)[0]} ${dim('(so the resolver points at IPFS, not its own localhost)')}`);
-        let r;
-        try {
-            r = await serviceClient(remote).registerProject(body);
-        }
-        catch (err) {
-            throw describeRemoteError(err, remote, 'remote add');
+            const contentLocators = await remoteLocators(address, localReg?.contentLocators, flags);
+            // Forward the deploy block, like every other field falls back to the local registration.
+            // (Its ABSENCE here was the bug: a hosted resolver defaulted to genesis and scanned the whole
+            // chain.) Re-sending the same floor stays incremental server-side, so a nudge ≠ a re-scan.
+            const body = {
+                chainId: resolveChain(CHAIN).id,
+                address,
+                fromBlock: await resolveScanFloor(address, localReg?.fromBlock, flags),
+                factory: await detectCanonicalFactory(address, flags.factory, localReg?.factory),
+                label: flags.label,
+                description: flags.description ?? localReg?.description,
+                externalUrl: flags['external-url'] ?? localReg?.externalUrl,
+                attributes,
+                tokenAttributes,
+                contentLocators: Object.keys(contentLocators).length ? contentLocators : undefined,
+                full: flags.full ? true : undefined,
+            };
+            info(`${bold('REMOTE')} → ${remote.url}  ${dim('(registering with the remote resolver — NOT this machine)')}`);
+            if (body.contentLocators)
+                info(`bridging image locator → ${Object.values(body.contentLocators)[0]} ${dim('(so the resolver points at IPFS, not its own localhost)')}`);
+            let r;
+            try {
+                r = await serviceClient(remote).registerProject(body);
+            }
+            catch (err) {
+                throw describeRemoteError(err, remote, 'remote add');
+            }
+            const outcome = await reportRemoteIndexing(remote, body.chainId, address, r, flags, 'indexed');
+            info(`it now serves ${remote.url}/t/${body.chainId}/${address.toLowerCase()}/0`);
+            // "Indexed" is not "correct". This line proves the service replayed the chain and will answer at
+            // that URL; it says nothing about whether the bytes it serves match the on-chain commitment.
+            // Name the step that checks.
+            info(`confirm what it actually serves (bytes vs. the on-chain hash): ${bold(`abx verify ${address} --remote ${remote.name?.toLowerCase() ?? remote.url}`)}`);
+            // Say what this registration did NOT buy. A project whose `tokenURIRenderer` is set answers
+            // `tokenURI` from the chain, so marketplaces and wallets read THAT document and never touch this
+            // service — the register is still useful (indexing, the live view, managed rendering for a code
+            // drop) but it changes nothing a collector sees. Without this line the readout is a list of
+            // successes that reads like a win, and a creator who was told "put it on a hosted service so it
+            // shows up properly" concludes their problem is solved when nothing about it moved.
+            const onChainRenderer = await tryReadContract(makePublicClient({ chainKey: CHAIN }), {
+                address,
+                abi: STATE_ABI,
+                functionName: 'tokenURIRenderer',
+            });
+            if (onChainRenderer && onChainRenderer !== zeroAddress) {
+                info(`${dim('note:')} this project resolves ${bold('tokenURI from the chain')} (renderer ${onChainRenderer}) — marketplaces read that, not this service. ` +
+                    `Registering still gives you indexing, the live view and managed rendering, but it does not change the metadata a collector sees.`);
+            }
+            emit({
+                target: { surface: 'remote', name: remote.name ?? null, url: remote.url },
+                chainId: body.chainId,
+                address,
+                status: outcome.status,
+                scanFloor: body.fromBlock ?? '0',
+                completed: outcome.completed,
+                backfilling: outcome.backfilling,
+                ...(outcome.eventCount === undefined ? {} : { eventCount: outcome.eventCount }),
+                ...(outcome.tokenCount === undefined ? {} : { tokenCount: outcome.tokenCount }),
+            });
+            return;
         }
-        await reportRemoteIndexing(remote, body.chainId, address, r, flags, 'indexed');
-        info(`it now serves ${remote.url}/t/${body.chainId}/${address.toLowerCase()}/0`);
-        // "Indexed" is not "correct". This line proves the service replayed the chain and will answer at
-        // that URL; it says nothing about whether the bytes it serves match the on-chain commitment.
-        // Name the step that checks.
-        info(`confirm what it actually serves (bytes vs. the on-chain hash): ${bold(`abx verify ${address} --remote ${remote.name?.toLowerCase() ?? remote.url}`)}`);
-        // Say what this registration did NOT buy. A project whose `tokenURIRenderer` is set answers
-        // `tokenURI` from the chain, so marketplaces and wallets read THAT document and never touch this
-        // service — the register is still useful (indexing, the live view, managed rendering for a code
-        // drop) but it changes nothing a collector sees. Without this line the readout is a list of
-        // successes that reads like a win, and a creator who was told "put it on a hosted service so it
-        // shows up properly" concludes their problem is solved when nothing about it moved.
-        const onChainRenderer = await tryReadContract(makePublicClient({ chainKey: CHAIN }), {
+        // The local (non-`--remote`) path is shared with the deploy family's post-setup registration —
+        // see registerAndIndexLocally's doc comment (output.ts).
+        const outcome = await registerAndIndexLocally(address, flags);
+        emit(localAddJsonResult({
+            chainId: outcome.state.chainId,
             address,
-            abi: STATE_ABI,
-            functionName: 'tokenURIRenderer',
-        });
-        if (onChainRenderer && onChainRenderer !== zeroAddress) {
-            info(`${dim('note:')} this project resolves ${bold('tokenURI from the chain')} (renderer ${onChainRenderer}) — marketplaces read that, not this service. ` +
-                `Registering still gives you indexing, the live view and managed rendering, but it does not change the metadata a collector sees.`);
-        }
-        return;
-    }
-    // The local (non-`--remote`) path is shared with the deploy family's post-setup registration —
-    // see registerAndIndexLocally's doc comment (output.ts).
-    return registerAndIndexLocally(address, flags);
+            scanFloor: outcome.scanFloor,
+            eventCount: outcome.state.eventCount,
+            tokenCount: outcome.state.tokens.length,
+        }));
+    });
 }
 export async function cmdIndex(address, flags) {
     const remote = remoteFlag(flags);
@@ -366,6 +396,12 @@ export function pointerOnlyImageCheck(fields) {
         return image.representation;
     return null;
 }
+/** `chainComplete` describes a code template's dependency graph. Static projects have no code
+ * graph to classify, so their structured verification result must say "not applicable" instead
+ * of reporting a confident `false` that reads like a failed durability check. */
+export function verifyChainComplete(isCodeProject, chainComplete) {
+    return isCodeProject ? chainComplete : null;
+}
 export async function cmdVerifyBody(address, flags, emit) {
     const indexer = localIndexer();
     let state = indexer.getProject(address);
@@ -641,7 +677,7 @@ export async function cmdVerifyBody(address, flags, emit) {
                 // renderer — the underlying probe cannot tell those apart, so neither can this field.
                 tokenURIRendererCurrent: rendererCurrent,
                 branch: status.branchName,
-                chainComplete: !!status.chainComplete,
+                chainComplete: verifyChainComplete(isCodeProject, !!status.chainComplete),
                 unresolvedRefs: [...status.unresolvedRefs],
                 urlOverBudget: !!status.urlOverBudget,
                 probe: probe