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

package/dist/ownerops.js

@@ -6,7 +6,7 @@
  * served state reflects the change. The agent picks the lane; the human only
  * approves (wallet lane) or it's the env key (hot lane).
  */
-import { MAX_ROYALTY_BPS, assertChainId, ensureChunkStore as sdkEnsureChunkStore, predictFixedPriceMinter, predictFixedPriceMinter1155, makeHotSender, makePublicClient, makeWalletClient, oneOfOneImageAbi, oneOfOneEditionAbi, seriesImageAbi, deployFixedPriceMinter, deployFixedPriceMinter1155, prepareConfigureSale, prepareConfigureSale1155, preparePurchase, preparePurchase1155, readSaleConfig, readSaleConfig1155, prepareEditionMint, prepareEditionTransfer, prepareSetMaxSupply, preparePingURI, prepareLockContractField, prepareLockContractURI, prepareLockTokenField, prepareLockTokenURI, prepareMint, mintedTokenIds, prepareSeriesMintMany, prepareSetMinter, prepareSetMaxInvocations, prepareSetPrimaryPayee, prepareSetPaused, prepareSetContractField, prepareSetContractURIBase, prepareSetContractURIOverride, prepareSetContractURIRenderer, prepareSetParamHooks, prepareSetParamSchema, prepareRetireParam, readParamSchema, PARAM_TYPES, prepareSetRoyalty, prepareReduceMaxRoyaltyBps, prepareSetTokenField, batchOps, prepareSetTokenURIBase, prepareSetTokenURIOverride, prepareSetTokenURIRenderer, prepareSetTransferValidator, prepareSetSeedSource, probeSeedSource, readSeedSource, predictSeedSource, getDeployment, prepareTransfer, prepareTransferOwnership, probeTransferValidator, readCreatorTokenStatus, resolveRecommendedTransferValidator, RECOMMENDED_TRANSFER_VALIDATOR, KNOWN_CHAIN_KEYS, resolveChain, resolveRpcUrl, redactRpcUrl, encodeTag, METADATA_FIELD as F, METADATA_REPRESENTATION as R, stageFieldContent, planStagedContent, exceedsOnchainSoftLimit, classifyOnchainReadSize, tokenUriGasEstimate, ONCHAIN_IMAGE_SOFT_LIMIT, ONCHAIN_PROJECT_SOFT_LIMIT, ONCHAIN_READ_WARN_BYTES, ONCHAIN_READ_REFUSE_BYTES, } from '@artblocks/abx-sdk';
+import { MAX_ROYALTY_BPS, assertChainId, ensureChunkStore as sdkEnsureChunkStore, predictFixedPriceMinter, predictFixedPriceMinter1155, makeHotSender, makePublicClient, makeWalletClient, oneOfOneImageAbi, oneOfOneEditionAbi, seriesImageAbi, deployFixedPriceMinter, deployFixedPriceMinter1155, prepareConfigureSale, prepareConfigureSale1155, preparePurchase, preparePurchase1155, readSaleConfig, readSaleConfig1155, prepareEditionMint, prepareEditionTransfer, prepareSetMaxSupply, preparePingURI, prepareLockContractField, prepareLockContractURI, prepareLockTokenField, prepareLockTokenURI, prepareMint, mintedTokenIds, prepareSeriesMintMany, prepareSetMinter, prepareSetMaxInvocations, prepareSetPrimaryPayee, prepareSetPaused, prepareSetContractField, prepareSetContractURIBase, prepareSetContractURIOverride, prepareSetContractURIRenderer, prepareSetParamHooks, prepareSetParamSchema, prepareRetireParam, readParamSchema, PARAM_TYPES, prepareSetRoyalty, prepareReduceMaxRoyaltyBps, prepareSetTokenField, batchOps, prepareSetTokenURIBase, prepareSetTokenURIOverride, prepareSetTokenURIRenderer, prepareSetTransferValidator, prepareSetSeedSource, probeSeedSource, readSeedSource, predictSeedSource, getDeployment, prepareTransfer, prepareTransferOwnership, probeTransferValidator, readCreatorTokenStatus, resolveRecommendedTransferValidator, RECOMMENDED_TRANSFER_VALIDATOR, KNOWN_CHAIN_KEYS, resolveChain, resolveRpcUrl, redactRpcUrl, encodeTag, METADATA_FIELD as F, METADATA_REPRESENTATION as R, stageFieldContent, planStagedContent, exceedsOnchainSoftLimit, classifyOnchainReadSize, tokenUriGasEstimate, ONCHAIN_IMAGE_SOFT_LIMIT, ONCHAIN_PROJECT_SOFT_LIMIT, ONCHAIN_READ_WARN_BYTES, ETH_CALL_GAS_FLOOR, readableBytesAtGas, probeBestEthCallGasCap, } from '@artblocks/abx-sdk';
 import { encodeScalarParam, encodeTag as encodeTagSdk, isAccepted, prepareConfigureTokenParam, prepareConfigureTokenParamData, prepareSetContractParam, prepareSetContractParamData, seriesCodeAbi, tryReadContract, } from '@artblocks/abx-sdk';
 import { hasParamEnumeration, GATEWAY_FIELD, GATEWAY_FLOOR, gatewayPrefixFrom, readCollectionPolicy, readEnv } from '@artblocks/abx-sdk';
 import { decodeFieldRenderer, encodeFieldRenderer, resolveGenerator, DEP_RESOLUTION, parseDependencyRef, prepareLockDependencies, prepareLockParamHooks, prepareLockScript, prepareRemoveLastDependency, prepareSetDependency, prepareSetDependencyRegistry, } from '@artblocks/abx-sdk';
@@ -23,12 +23,12 @@ import { openWalletSession } from './signer.js';
 import { gatedSend, laneFromFlags } from './riskgate.js';
 import { withJson } from './jsonout.js';
 import { resolveRemote, serviceClient } from './remote.js';
-import { allowUnreadableOnchain, isDryRun, positionalArgs, unknownFlags, warnStrayFlags } from './flags.js';
+import { isDryRun, positionalArgs, unknownFlags, warnStrayFlags } from './flags.js';
 import { parseSchemaSpecs, describeSchema } from './schema.js';
 // Re-exported for main.ts (the on-chain-vs-off-chain cost model + the compression-mode type now
 // live in the SDK's staging.ts, layered on planChunks/planContentTxs — see the comment at their
 // definition below).
-export { ONCHAIN_PROJECT_SOFT_LIMIT, ONCHAIN_READ_WARN_BYTES, ONCHAIN_READ_REFUSE_BYTES, tokenUriGasEstimate };
+export { ONCHAIN_PROJECT_SOFT_LIMIT, ONCHAIN_READ_WARN_BYTES, ETH_CALL_GAS_FLOOR, tokenUriGasEstimate, readableBytesAtGas };
 // ── ANSI (local) ─────────────────────────────────────────────────────────────
 const C = { reset: '\x1b[0m', dim: '\x1b[2m', bold: '\x1b[1m', green: '\x1b[38;5;115m', yellow: '\x1b[38;5;221m' };
 const dim = (s) => `${C.dim}${s}${C.reset}`;
@@ -382,11 +382,11 @@ export function parseHookAddress(role, v) {
 }
 /**
  * `abx set-param-hooks <address> [--configure 0x|none] [--augment 0x|none] [--transfer 0x|none] [--clear]`
- * — wire (or clear) a SeriesCode project's three param-lifecycle hooks. The contract has NO per-hook
+ * — wire (or clear) a SeriesCode/EditionCode project's three param-lifecycle hooks. The contract has NO per-hook
  * setter (`setParamHooks` writes all three at once), so this READS the current trio (`paramHooks()`)
  * and re-sends it with your changes applied: omit a role to KEEP it, pass an address to set it, or
- * `none` to clear it (`--clear` clears all three). Owner-only, any lane, guards `--dry-run`. SeriesCode
- * only — a 1/1 or plain Series has no configurable params to hook. Bare (no flags) prints the current
+ * `none` to clear it (`--clear` clears all three). Owner-only, any lane, guards `--dry-run`. Code kinds
+ * only — static 1/1, Series, and edition kinds have no configurable params to hook. Bare (no flags) prints the current
  * hooks and does nothing.
  */
 export async function cmdSetParamHooks(address, flags) {
@@ -398,8 +398,8 @@ export async function cmdSetParamHooks(address, flags) {
         // Refuse the contradictory combo rather than silently pick one (enforce, don't warn).
         throw new Error(`--clear clears ALL three hooks; don't combine it with --${roleFlags.join('/--')}. Use either --clear, or per-role flags.`);
     }
-    // Read the current trio FIRST — this doubles as the SeriesCode guard (paramHooks() exists only on
-    // the ConfigurableParams extension; a 1/1 / plain Series reverts "no data").
+    // Read the current trio FIRST — this doubles as the SeriesCode/EditionCode guard (paramHooks()
+    // exists only on the ConfigurableParams extension; a static kind reverts "no data").
     const publicClient = makePublicClient({ chainKey: CHAIN });
     let current;
     try {
@@ -1485,51 +1485,81 @@ export function sessionStagingSender(session) {
 }
 const kb = (n) => `${n < 10 * 1024 ? (n / 1024).toFixed(1) : Math.round(n / 1024)}KB`;
 const mgas = (n) => `~${(n / 1_000_000).toFixed(0)}M gas`;
-/** The flag that overrides {@link guardOnChainSize}'s refusal — a creator who genuinely wants a
- *  project no default RPC can read. Named for what accepting it means, not for the check it skips. */
-export const ALLOW_UNREADABLE_FLAG = 'allow-unreadable-onchain';
 /**
- * The size gate for content going on-chain, on the axis that actually binds: **render gas**, not
- * storage cost. `tokenURI` reassembles the whole document per call — measured at ~360,000-405,000 gas
- * per KB of on-chain content across 10-100 KB and climbing above that (the cost is superlinear: memory
- * expansion is quadratic), within ~1% for `inline` and `reader` up to 75 KB (it's the renderer's string
- * building, not the storage mechanism) — so the readable envelope is much tighter than the cost-sane one.
+ * The measured `eth_call` gas allowance of the best configured endpoint, cached for the process.
+ * `null` = could not be measured (an endpoint that rejects state overrides, or is unreachable),
+ * which is a normal outcome and never blocks anything — the report degrades to the conservative
+ * {@link ETH_CALL_GAS_FLOOR} instead.
  *
- * - under ~40 KB: quiet, plus the cost note if it's past the point where off-chain is simply cheaper.
- * - from ~40 KB: **warn** — the read needs a deliberately high-gas RPC.
- * - past ~100 KB (~40M gas): **refuse** — a deliberate margin, not the wall. geth's own 50M
- *   `--rpc.gascap` default holds to ~120 KB, but hosted providers commonly cap well below it, so past
- *   100 KB the token reads as a revert to marketplaces and indexers on ordinary RPCs.
- *   `--allow-unreadable-onchain` ships it anyway.
+ * Measured once per run because it is a property of the endpoint, not of the content: a 40-file
+ * Series should not fire 40 probes.
+ */
+let cachedGasCap;
+/** Measure (once) what the configured RPCs will actually serve an `eth_call`. Never throws. */
+export async function ensureRpcGasCap() {
+    if (cachedGasCap === undefined) {
+        try {
+            cachedGasCap = await probeBestEthCallGasCap();
+        }
+        catch {
+            cachedGasCap = { gasCap: null, label: null };
+        }
+    }
+    return cachedGasCap;
+}
+/** Test seam: force the cached cap (or clear it with `undefined`). */
+export function __setRpcGasCapForTest(v) {
+    cachedGasCap = v;
+}
+/**
+ * Report what putting `bytesLen` of content on-chain costs, on both axes that matter — and REFUSE
+ * NOTHING at any size.
+ *
+ * This used to throw past 100 KB. The threshold was reasoned from geth's `--rpc.gascap` default of
+ * 50M minus a margin, on the theory that hosted providers commonly cap lower. Measured 2026-08-24,
+ * they do not: 50M is the floor (publicnode, drpc), and `sepolia.base.org` — the default endpoint of
+ * our default chain — serves 600M, good for ~729 KB. The refusal sat below every endpoint we could
+ * find, so it blocked content all of them could read, on the chain we ship as the default.
  *
- * Deliberately a toolkit gate and not an on-chain one: bricking a contract over a read budget is
- * worse than needing a capable RPC, and this is the moment where the creator can still choose
- * differently. Returns true if it said anything.
+ * Two axes, and they fail differently:
+ *   • WRITE is chunked (22,000-byte SSTORE2 chunks across separate transactions), so no block gas
+ *     limit ever binds it. It is purely a money question at ~200 gas/byte.
+ *   • READ is one `eth_call`, and whether it succeeds is a property of WHOSE endpoint is asking.
+ *     Ours is measurable; a marketplace's is not, and that distinction survives into the output.
+ *
+ * Returns true if it printed anything.
  */
-export function guardOnChainSize(bytesLen, label, allowUnreadable = false) {
-    const verdict = classifyOnchainReadSize(bytesLen);
-    const gas = mgas(tokenUriGasEstimate(bytesLen));
-    if (verdict === 'refuse' && !allowUnreadable) {
-        throw new CliError(`${label} is ${kb(bytesLen)} of on-chain content — reading tokenURI would cost ${gas}, past what a default node will serve ` +
-            `(geth's --rpc.gascap defaults to 50M; hosted providers commonly cap lower). Marketplaces, indexers, and other contracts ` +
-            `would see a REVERT rather than your token, so this is refused by default.\n` +
-            `    Three ways forward:\n` +
-            `      • Off-chain custody: --backend arweave (pay-once, permanent) or ipfs|cloud — the bytes live off-chain, the JSON still resolves on-chain, and the read stays small.\n` +
-            `      • Smaller SOURCE content: a leaner SVG rather than a raster. Note --compress fastlz does not help here — it cuts the write cost, and the renderer rebuilds the full uncompressed bytes on every read.\n` +
-            `      • Ship it unreadable on purpose: re-run with --${ALLOW_UNREADABLE_FLAG}. That is a real choice (maximum durability, nothing to run, ever) — and what you accept is that rendering needs a deliberately high-gas endpoint, and most marketplaces and indexers will show nothing at all.`);
-    }
-    if (verdict === 'refuse') {
-        console.log(yellow(`  ⚠ ${label} is ${kb(bytesLen)} on-chain — tokenURI costs ${gas} to read, past a default node's eth_call cap. Shipping anyway (--${ALLOW_UNREADABLE_FLAG}).`));
-        console.log(dim(`    What you're accepting: marketplaces and indexers on ordinary RPCs will see a revert, not your token; rendering needs a deliberately high-gas endpoint. Assemble from the generator's piecewise getters (\`document\`, \`tokenDataJson\`, \`dependencyTag\`) when one eth_call won't fit.`));
+export async function guardOnChainSize(bytesLen, label) {
+    const { gasCap, label: rpcLabel } = await ensureRpcGasCap();
+    const verdict = classifyOnchainReadSize(bytesLen, gasCap);
+    const readGas = tokenUriGasEstimate(bytesLen);
+    const writeGas = bytesLen * 200;
+    const floorKb = kb(readableBytesAtGas(ETH_CALL_GAS_FLOOR));
+    const uncapped = gasCap === Number.POSITIVE_INFINITY;
+    const capText = uncapped ? 'no eth_call cap at all' : `${mgas(gasCap ?? 0)}`;
+    const servesText = uncapped ? 'any size this toolkit can write' : `~${kb(readableBytesAtGas(gasCap ?? 0))}`;
+    // The route that dissolves the reach problem entirely, and the reason none of this is a refusal:
+    // a resolver reads the on-chain bytes with ITS rpc and serves them as ordinary HTTP, so the
+    // marketplace never makes the big eth_call. The bytes stay on-chain and permanent either way.
+    const resolverRoute = ' Reach is fixable after the fact and the bytes are permanent regardless: a resolver reads on-chain content and serves it over plain HTTP' +
+        ' (abx deploy-resolver, or a hosted one), so marketplaces fetch a URL instead of making this call — point tokenURI at it with `abx set-renderer <addr> --off`.' +
+        ' On-chain storage is preservation; serving is a separate, swappable choice.';
+    if (verdict === 'beyond-local-rpc') {
+        console.log(yellow(`  ⚠ ${label} is ${kb(bytesLen)} on-chain — reading tokenURI in ONE call costs ${mgas(readGas)}, past what your own RPC serves (${capText}${rpcLabel ? `, ${rpcLabel}` : ''}).`));
+        console.log(dim(`    Writing is unaffected — ${mgas(writeGas)}, chunked, and the bytes are permanent the moment they land.${resolverRoute}`));
+        return true;
+    }
+    if (verdict === 'endpoint-dependent') {
+        console.log(yellow(`  ⚠ ${label} is ${kb(bytesLen)} on-chain — reading tokenURI in ONE call costs ${mgas(readGas)}, past the ${mgas(ETH_CALL_GAS_FLOOR)} floor every endpoint serves.`));
+        console.log(dim(`    ${gasCap != null ? `Measured just now, your RPC allows ${capText}${rpcLabel ? ` (${rpcLabel})` : ''} — it serves ${servesText}.` : `Your RPC's cap could not be measured, so the floor below is the reference.`} We can measure yours; we CANNOT know a marketplace's or an indexer's, and those are the ones that decide whether your token displays. On a 50M-capped provider the ceiling is ~${floorKb}, and past it they see a revert. Writing is unaffected: ${mgas(writeGas)}, chunked.${resolverRoute}`));
         return true;
     }
-    if (verdict === 'warn') {
-        console.log(yellow(`  ⚠ ${label} is ${kb(bytesLen)} on-chain — reading tokenURI costs ${gas} (~360-405k gas per KB of content and climbing, whatever the representation).`));
-        console.log(dim(`    That is served by a high-gas RPC but not by every hosted one, and it is past what another contract can spend inside a transaction. Under ~${kb(ONCHAIN_READ_WARN_BYTES)} of on-chain content per token is the routinely-readable range; off-chain custody (--backend arweave|ipfs|cloud) keeps the JSON on-chain and the read small.`));
+    if (bytesLen >= ONCHAIN_READ_WARN_BYTES) {
+        console.log(dim(`  ${label} is ${kb(bytesLen)} on-chain — ${mgas(writeGas)} to write (chunked), ${mgas(readGas)} to read. Under the ${mgas(ETH_CALL_GAS_FLOOR)} every endpoint serves, so it renders anywhere.`));
         return true;
     }
     if (exceedsOnchainSoftLimit(bytesLen)) {
-        console.log(dim(`  ${label} is ${kb(bytesLen)} — past ~${kb(ONCHAIN_IMAGE_SOFT_LIMIT)}/file on-chain costs more to write than off-chain (~200 gas/byte), so pick it for self-resolution, not for price. Reading tokenURI: ${gas}.`));
+        console.log(dim(`  ${label} is ${kb(bytesLen)} — past ~${kb(ONCHAIN_IMAGE_SOFT_LIMIT)}/file on-chain costs more to write than off-chain (~200 gas/byte), so pick it for self-resolution, not for price. Reading tokenURI: ${mgas(readGas)}.`));
         return true;
     }
     return false;
@@ -1579,9 +1609,8 @@ function planTxLine(p, finalLabel) {
  * These store writes use the env key (the data contracts are ownerless); the owner only
  * signs the field set that references the manifest.
  */
-async function putContentOnChain(bytes, compress, field, send, finalLabel = '1 owner field-set', store, // pre-resolved store (batch staging reuses one); else resolve/deploy here
-allowUnreadable = false) {
-    guardOnChainSize(bytes.length, `'${field}'`, allowUnreadable);
+async function putContentOnChain(bytes, compress, field, send, finalLabel = '1 owner field-set', store) {
+    await guardOnChainSize(bytes.length, `'${field}'`);
     const content = compress === 'gzip' ? new Uint8Array(gzipSync(bytes)) : new Uint8Array(bytes);
     const publicClient = makePublicClient({ chainKey: CHAIN });
     return stageFieldContent({
@@ -1618,13 +1647,13 @@ export function refusePrewrappedImage(bytes, label) {
  * true count instead of leaving the agent to guess). The final tx here is the deploy that
  * bakes in the reader field, so the count is staging tx(s) + the deploy.
  */
-export function previewImageStaging(imagePath, compress, allowUnreadable = false) {
+export async function previewImageStaging(imagePath, compress) {
     const bytes = readFileSync(resolvePath(imagePath));
     refusePrewrappedImage(bytes, basename(resolvePath(imagePath)));
     const p = computeContentPlan(bytes, compress);
     // The gate runs on the dry-run too: a refusal a creator only meets after the first staging tx has
     // landed is a refusal that already cost them gas.
-    guardOnChainSize(bytes.length, basename(resolvePath(imagePath)), allowUnreadable);
+    await guardOnChainSize(bytes.length, basename(resolvePath(imagePath)));
     return (`would stage ${basename(resolvePath(imagePath))} on-chain (chunk store): ` +
         `${planSizeLine(bytes.length, p, compress)} as ${p.representation}; ` +
         `${planTxLine(p, '1 deploy (bakes the reader field + mints)')}`);
@@ -1636,10 +1665,10 @@ export function previewImageStaging(imagePath, compress, allowUnreadable = false
  * image" is just those staging tx(s) + the single deploy — no post-deploy `set-field`.
  * The manifest is deployer-independent, so this is computed once and reused for any signer.
  */
-export async function stageImageField(imagePath, compress, send, allowUnreadable = false) {
+export async function stageImageField(imagePath, compress, send) {
     const bytes = readFileSync(resolvePath(imagePath));
     refusePrewrappedImage(bytes, basename(resolvePath(imagePath)));
-    const { value, representation } = await putContentOnChain(bytes, compress, 'image', send, '1 deploy (bakes the reader field + mints)', undefined, allowUnreadable);
+    const { value, representation } = await putContentOnChain(bytes, compress, 'image', send, '1 deploy (bakes the reader field + mints)');
     return {
         field: { field: encodeTag(F.image), representation: encodeTag(representation), value },
         note: `image: ${bytes.length}B staged ON-CHAIN via reader (${representation}) — baked into the deploy`,
@@ -1652,12 +1681,12 @@ export async function stageImageField(imagePath, compress, send, allowUnreadable
  * Each field still points at its own manifest, so each token's work is independent; they just
  * share the store contract. Returns the fields in input order (token order).
  */
-export async function stageImageFieldsBatch(imagePaths, compress, send, storeOverride, allowUnreadable = false) {
+export async function stageImageFieldsBatch(imagePaths, compress, send, storeOverride) {
     const store = await ensureChunkStore(send, storeOverride);
     const fields = [];
     for (const imagePath of imagePaths) {
         const bytes = readFileSync(resolvePath(imagePath));
-        const { value, representation } = await putContentOnChain(bytes, compress, 'image', send, '1 deploy (bakes the reader fields + mints)', store, allowUnreadable);
+        const { value, representation } = await putContentOnChain(bytes, compress, 'image', send, '1 deploy (bakes the reader fields + mints)', store);
         fields.push({ field: encodeTag(F.image), representation: encodeTag(representation), value });
     }
     return { fields, store };
@@ -1831,7 +1860,7 @@ export async function cmdSetField(address, flags) {
         const bytes = readFileSync(resolvePath(flags.file));
         const p = computeContentPlan(bytes, parseCompress(flags.compress));
         // Same render-gas gate the real path applies, so a refusal costs a dry run rather than gas.
-        guardOnChainSize(bytes.length, `'${field}'`, allowUnreadableOnchain(flags));
+        await guardOnChainSize(bytes.length, `'${field}'`);
         console.log(`\n  ${bold('◆ set-field ' + field)} ${dim('(dry run — nothing staged or sent)')}`);
         console.log(`    ${dim('scope'.padEnd(12))} ${collection ? 'collection' : `token #${flags.token ?? '0'}`}`);
         console.log(`    ${planSizeLine(bytes.length, p, parseCompress(flags.compress))}`);
@@ -1863,7 +1892,7 @@ export async function cmdSetField(address, flags) {
         });
         try {
             await session.connect();
-            const { value, representation } = await putContentOnChain(bytes, compress, field, sessionStagingSender(session), undefined, undefined, allowUnreadableOnchain(flags));
+            const { value, representation } = await putContentOnChain(bytes, compress, field, sessionStagingSender(session));
             await session.send(buildTx(value, representation));
         }
         finally {
@@ -1877,7 +1906,7 @@ export async function cmdSetField(address, flags) {
     let representation;
     if (staging) {
         const compress = parseCompress(flags.compress);
-        ({ value, representation } = await putContentOnChain(readFileSync(resolvePath(flags.file)), compress, field, envStagingSender(), undefined, undefined, allowUnreadableOnchain(flags)));
+        ({ value, representation } = await putContentOnChain(readFileSync(resolvePath(flags.file)), compress, field, envStagingSender()));
     }
     else if (flags.text && flags.text !== 'true') {
         if (field === 'image')