@artblocks/abx-cli 0.1.0-alpha.31 → 0.1.0-alpha.33

package/dist/commands/deploy.js

@@ -21,7 +21,7 @@ import { DEFAULT_PORT, contentHash, generateContent, resolveBaseUrl, startTokenA
 import { encodeFunctionData, getAddress, toHex, zeroAddress } from 'viem';
 import { CHAIN, explorerBase, assertTurboFundsForUpload, backendResolution, collectContentLocators, ensureArweaveIdentityForUpload, factoryAddress, faucetHint, localIndexer, loopbackBaseUrl, noteArweavePlan, noteStorageReadiness, rendererAddress, seriesFactoryAddress, oneOfOneEditionFactoryAddress, editionFactoryAddress, editionCodeFactoryAddress, storageOptions, storageOverrides, storageSignerChoice, } from '../config.js';
 import { parseDepFlag } from '../deps.js';
-import { allowUnreadableOnchain, isDryRun, parseSaltFlag, refuseStrayFlags, warnSignWithoutFor } from '../flags.js';
+import { isDryRun, parseSaltFlag, refuseStrayFlags, warnSignWithoutFor } from '../flags.js';
 import { isEditionContract } from '../kind.js';
 import { jsonSafe, withJson } from '../jsonout.js';
 import { planOnChainScript } from '../script-chunks.js';
@@ -886,12 +886,12 @@ export async function cmdDeployBody(flags, serveAfter, emit) {
         }
         step('Stage on-chain image');
         if (dryRun) {
-            info(previewImageStaging(flags.image, parseCompress(flags.compress), allowUnreadableOnchain(flags)));
+            info(await previewImageStaging(flags.image, parseCompress(flags.compress)));
         }
         else if (lane === 'send') {
             // hot lane: the env key stages now (deployer-independent — the manifest doesn't depend
             // on the clone address), then the deploy below bakes in the reader field.
-            const { field, note } = await stageImageField(flags.image, parseCompress(flags.compress), envStagingSender(), allowUnreadableOnchain(flags));
+            const { field, note } = await stageImageField(flags.image, parseCompress(flags.compress), envStagingSender());
             bakedImage = field;
             info(note);
         }
@@ -1082,7 +1082,7 @@ export async function cmdDeployBody(flags, serveAfter, emit) {
         try {
             const signer = await session.connect();
             // Stage on-chain through the session (sets bakedImage, which buildForDeployer reads below).
-            const { field, note } = await stageImageField(flags.image, parseCompress(flags.compress), sessionStagingSender(session), allowUnreadableOnchain(flags));
+            const { field, note } = await stageImageField(flags.image, parseCompress(flags.compress), sessionStagingSender(session));
             bakedImage = field;
             info(note);
             const { clone: predicted, params, salt, contentNote } = await buildForDeployer(signer);
@@ -1276,10 +1276,9 @@ export async function cmdDeployBody(flags, serveAfter, emit) {
 // own function rather than threaded into `cmdDeployBody` with `if (copies)` branches throughout —
 // so the 721 lane, above, stays provably byte-identical whether or not editions exist.
 //
-// v1 scope (reported, not hidden): `--onchain-image` (chunk-store staging) is wired for the hot
-// lane only — the wallet-lane session dance `cmdDeployBody` uses for it is a bigger lift than this
-// pass covers; staging + a wallet-signed deploy in two SEPARATE steps isn't offered here rather than
-// half-build it. Every other custody/signing combination the 1/1 lane supports works identically.
+// `--onchain-image` (chunk-store staging) works in the hot and wallet lanes. The cold/unsigned lane
+// is refused because each staged chunk transaction feeds the next; it cannot produce one independent
+// offline bundle. Every other custody/signing combination the 1/1 lane supports works identically.
 // (`DEPLOY_EDITION_FLAGS` — the allowlist this function's `refuseStrayFlags` checks against — is
 // declared further down, alongside `DEPLOY_FLAGS`/`DEPLOY_SERIES_FLAGS`/`DEPLOY_CODE_FLAGS`: it
 // spreads `DEPLOY_FLAGS`, so it must come AFTER that declaration at module scope, same reason
@@ -1410,7 +1409,7 @@ export async function cmdDeployOneOfOneEditionBody(flags, emit) {
     // connect, so the connecting wallet pays for and owns every chunk write. `stageNow` is the hot-lane
     // (and dry-run) path; the session branch below calls the same helper with a session-backed sender.
     const stageOnChainImage = async (sender) => {
-        const { field, note } = await stageImageField(flags.image, parseCompress(flags.compress), sender, allowUnreadableOnchain(flags));
+        const { field, note } = await stageImageField(flags.image, parseCompress(flags.compress), sender);
         bakedImage = field;
         info(note);
     };
@@ -1419,7 +1418,7 @@ export async function cmdDeployOneOfOneEditionBody(flags, emit) {
             throw new Error('--onchain-image needs --image <path> (the bytes to put on-chain)');
         step('Stage on-chain image');
         if (dryRun)
-            info(previewImageStaging(flags.image, parseCompress(flags.compress), allowUnreadableOnchain(flags)));
+            info(await previewImageStaging(flags.image, parseCompress(flags.compress)));
         else if (lane === 'send')
             await stageOnChainImage(envStagingSender());
         // lane === 'sign' → staged inside the wallet session further down.
@@ -1868,7 +1867,7 @@ export async function cmdDeploySeriesBody(flags, emit) {
     const buildImageFields = async (stage) => {
         // --onchain-image: stage every token's bytes into ONE shared chunk store, each a `reader` field.
         if (onchainImage) {
-            const { fields } = await stageImageFieldsBatch(tokenPaths.map((s) => s.path), compress, stage, flags['chunk-store'], allowUnreadableOnchain(flags));
+            const { fields } = await stageImageFieldsBatch(tokenPaths.map((s) => s.path), compress, stage, flags['chunk-store']);
             tokenFields = tokenPaths.map(({ tokenId }, i) => tokenFieldOf(tokenId, fields[i]));
             return;
         }
@@ -2053,7 +2052,7 @@ export async function cmdDeploySeriesBody(flags, emit) {
         }
         if (onchainImage) {
             for (const { tokenId, name: fname, path } of tokenPaths) {
-                info(`token ${tokenId} ← ${fname}: ${previewImageStaging(path, compress, allowUnreadableOnchain(flags))}`);
+                info(`token ${tokenId} ← ${fname}: ${await previewImageStaging(path, compress)}`);
             }
         }
         info(`approvals   ${approvals} wallet approval(s)`); // B2 — TX signatures only
@@ -2238,11 +2237,10 @@ export async function cmdDeploySeriesBody(flags, emit) {
 // `cmdDeploySeriesBody`, kept as its OWN function for the same reason `cmdDeployOneOfOneEditionBody`
 // is (byte-identical 721 lane — see that function's module note).
 //
-// v1 scope (reported, not hidden): custody is off-chain (keccak + optional backend upload, ONE
-// `backend.put` per file) or `--onchain-uri` (inline SVG). `cmdDeploySeriesBody`'s O(1) uniform-
-// extension directory upload and `--onchain-image` chunk staging are NOT ported here — both are
-// real engineering (a shared chunk store / a shared directory manifest across N ids), and a per-file
-// fallback already works correctly, just at O(N) upload calls instead of O(1). Tracked as a follow-up.
+// Custody matches the 721 Series lane: off-chain per-file uploads, O(1) uniform-extension directory
+// templates under `--onchain-uri`, inline SVG, hosted resolution, and `--onchain-image` chunk staging.
+// The last uses hot or wallet signing; cold/unsigned staging is refused because each chunk feeds the
+// next transaction.
 // (`DEPLOY_SERIES_EDITION_FLAGS` is declared further down, beside `DEPLOY_EDITION_FLAGS` — see that
 // const's own note on why.)
 export async function cmdDeployEditionImageBody(flags, emit) {
@@ -2390,7 +2388,7 @@ export async function cmdDeployEditionImageBody(flags, emit) {
     // already deployed. Same per-id predicate either way (`guardOnChainSize` runs again during staging).
     if (onchainImage && dryRun) {
         for (const { name, path } of tokenPaths)
-            guardOnChainSize(statSync(path).size, name, allowUnreadableOnchain(flags));
+            await guardOnChainSize(statSync(path).size, name);
     }
     // Say WHICH backend holds the bytes, exactly as the 1/1 lane does. Both Series lanes resolved a
     // backend and never named it, so a creator asking for "images on IPFS" had no way to confirm from
@@ -2426,7 +2424,7 @@ export async function cmdDeployEditionImageBody(flags, emit) {
         // field pointing at its manifest. Ported from the 721 Series twin — the edition lane refused this
         // outright before (B28), though nothing on-chain prevented it.
         if (onchainImage) {
-            const { fields } = await stageImageFieldsBatch(tokenPaths.map((s) => s.path), compress, stage, flags['chunk-store'], allowUnreadableOnchain(flags));
+            const { fields } = await stageImageFieldsBatch(tokenPaths.map((s) => s.path), compress, stage, flags['chunk-store']);
             tokenPaths.forEach(({ tokenId }, i) => tokenFields.push(tokenFieldOf(tokenId, fields[i])));
             if (seriesTraitsOnchain)
                 for (const [tokenId, attrs] of seriesTraits)
@@ -2947,7 +2945,7 @@ export const SHARED_DEPLOY_FLAGS = [
 // A 1/1 `abx deploy` accepts these (see `abx help deploy`). Anything else warns (typo'd/unsupported).
 export const DEPLOY_FLAGS = new Set([
     'image', 'name', 'symbol', 'type', 'description', 'description-onchain', 'external-url', 'traits', 'traits-onchain', 'attributes',
-    'onchain-uri', 'onchain-image', 'compress', 'allow-unreadable-onchain', 'royalty-bps', 'royalty-cap', 'burnable', 'no-mint',
+    'onchain-uri', 'onchain-image', 'compress', 'royalty-bps', 'royalty-cap', 'burnable', 'no-mint',
     ...AUTHORSHIP_DEPLOY_FIELDS.map(([flag]) => flag),
     ...SHARED_DEPLOY_FLAGS,
 ]);
@@ -2955,7 +2953,7 @@ export const DEPLOY_FLAGS = new Set([
 export const DEPLOY_SERIES_FLAGS = new Set([
     'dir', 'count', 'name', 'symbol', 'description', 'external-url', 'royalty-bps', 'royalty-cap', 'burnable', 'attributes', 'traits-onchain',
     'no-mint', 'mint-all', 'mint-count', 'unpaused', 'minter', 'primary-payee',
-    'onchain-uri', 'onchain-image', 'compress', 'allow-unreadable-onchain', 'chunk-store',
+    'onchain-uri', 'onchain-image', 'compress', 'chunk-store',
     ...AUTHORSHIP_DEPLOY_FIELDS.map(([flag]) => flag),
     ...SHARED_DEPLOY_FLAGS,
 ]);
@@ -4151,21 +4149,19 @@ export async function cmdDeployCodeBody(flags, emit) {
 }
 // ── deploy-code --copies: EditionCode ─────────────────────────────────────────────────────────────
 // A generative/code drop as copies — the full generative stack (on-chain script, PostParams, a
-// mint-time seed) minus the parts this pass deliberately did not port (see below). Kept as its own
+// mint-time seed), plus renderer-only and script+renderer projects. Kept as its own
 // function for the same byte-identical-721-lane reason as the other two edition bodies.
 //
-// v1 scope (reported, not hidden), each refused in code rather than silently ignored:
+// Current limits, each refused in code rather than silently ignored:
 //   • `--code-dir` (directory-build code drops) — not ported; use `--script`.
-//   • `--dep` / `--dep-registry` (declared code dependencies) — not ported; ship a self-contained
-//     script (the skill already recommends zero-dependency vanilla JS as the cleanest option).
-//   • `--image-renderer` / `--attributes-renderer` / `--image-base` (the in-chain-Solidity-renderer and
-//     deterministic-off-chain-thumbnail lanes) — not ported.
+//   • `--image-base` (deterministic off-chain thumbnails) — not ported because the effects runner
+//     does not yet publish a still per edition id. Solidity image/attributes renderers DO work.
 //   • `--no-delegation` — refused outright: EditionCode has no TokenOwner-leg delegation to opt out
 //     of (its auth leg generalizes to "any holder", per the parity plan's ConfigurableParams note).
 //   • `--resume` — refused (see the `isEditionContract` guard in `cmdDeployCodeBody`'s own --resume
 //     handling): the SDK's resume.ts assumes the 721 mint/supply shape throughout.
-// Every other combination `--script` + `--onchain-uri`/`--public-base-url` supports on the 721 lane
-// (schemas, seed opt-out, mint timing, royalty, identity fields, --721c→1155C) works here too.
+// Dependencies, renderer-only projects, schemas, seed controls, mint timing, royalties, identity
+// fields, and --721c→1155C work here too.
 export const DEPLOY_CODE_EDITION_FLAGS = new Set([
     'script', 'name', 'symbol', 'description', 'external-url', 'description-onchain',
     ...AUTHORSHIP_DEPLOY_FIELDS.map(([flag]) => flag),