@artblocks/abx-cli 0.1.0-alpha.17 → 0.1.0-alpha.19

package/CHANGELOG.md

@@ -1,5 +1,223 @@
 # @artblocks/abx-cli
 
+## 0.1.0-alpha.19
+
+### Minor Changes
+
+- d40caf4: `abx remote <name|url> --conformance` — self-certify a resolver from the published CLI
+
+  The self-verify fixture that used to live only as a repo-local script
+  (`scripts/conformance-remote-service.mjs`, `pnpm conformance`) is now a mode on the existing `remote`
+  command rather than a new one (command-count discipline): `abx remote <name|url> --conformance
+[--remote-token <t>] [--chain-id <n>] [--address <a>] [--from-block <n>]`.
+
+  This is what lets a third party self-certify a hosted resolver — or CI-gate on one — with nothing but
+  `npm i -g @artblocks/abx-cli` and a base URL: no repo checkout, and a bare URL + `--remote-token`
+  needs no `.env` setup. It reuses the same `--remote` name/URL/token resolution as every other remote
+  command, prints one ✓/✗/· line per assertion (descriptor shape, unauthenticated writes refused, the
+  read-plane's error taxonomy, every declared interface's routes, and — with `--chain-id` + `--address`
+  naming a contract you own — the full register → poll-to-live → status → reindex → deregister loop),
+  and sets a non-zero exit code on any failure.
+
+  The assertions themselves moved to `packages/cli/src/conformance.ts`, importable by both the CLI
+  command and the (now much thinner) root script, so `pnpm conformance` and
+  `scripts/e2e-remote-resolver.sh` keep working unchanged against the same logic.
+
+### Patch Changes
+
+- d40caf4: Two first-party consumers adopt the backoff/gateway/data-URI helpers hoisted into `@artblocks/abx-sdk`
+  last round, and `mint-page` refuses a 1/1 target instead of scaffolding a page that hangs. Drop-in for
+  everyone — no behavior change in the adoption itself, and the mint-page refusal only fires for a
+  contract type the page never worked against.
+
+  **`token-api`'s chain watcher now calls `exponentialBackoffDelay`/`linearBackoffDelay` instead of
+  re-deriving them inline.** `dueForRetry`'s failed-project retry and the tick loop's repeated-failure
+  delay were the sdk helpers reimplemented by hand; both now call the shared functions, with the exact
+  index mapping (`min(attempts, 8) + 1` into the 1-indexed exponential helper) that reproduces identical
+  delays for every `attempts`/`failures` value — proved by an old-formula-vs-sdk-helper equality table
+  in `packages/token-api/test/watcher-backoff.test.ts` (attempts/failures 0..12, several `baseMs`
+  values, and the cap boundary explicitly).
+
+  **The `mint-page` template's generated app now reads gateway URLs and `data:` URIs through the sdk**
+  (`gatewayUrlFor`/`resolveGatewayBase`/`parseDataUri`) instead of a hand-rolled `ipfs://`-slicing
+  `toGateway` and a hand-parsed comma-split in `fetchJson`. Same output for every input (plain
+  `https://`, empty string, `ipfs://`, `ar://`, base64 and percent-encoded `data:` bodies) — verified
+  byte-for-byte before the swap, and pinned by a new mintpage.test.ts assertion that the emitted
+  `lib/meta.ts` imports the sdk helpers and no longer contains the old hand-rolled body.
+
+  **`mint-page` now refuses a non-Series target.** The generated page reads `maxInvocations`/`paused`
+  and mints through the shared fixed-price minter — a 1/1 (`OneOfOneImage`) has none of that, so pointing
+  `mint-page` at one silently wrote a page that sat on "Loading…" forever with no diagnostic. `cmdMintPage`
+  now probes the same ERC-165 `supportsInterface(IAbxSequentialMint)` `sdk/anchors.ts`'s
+  `isCurrentSeriesFactory` uses, and refuses with a `CliError` pointing at `abx deploy-series --dir
+<folder> --count 1` (matching the existing guidance in `sales.mdx`). A probe that can't run at all (RPC
+  unreachable) is left undecided and does NOT refuse — scaffolding stays usable offline, same tolerance
+  the existing best-effort `name()` read already has.
+
+  Also folded in: `PUBLIC_RPC` (the mint-page template's keyless-RPC table) gains `base` and
+  `base-sepolia` — the toolkit's own default chain was missing from it, so every default-chain deploy
+  needed a manual `--rpc` just to scaffold its own mint page.
+
+- Updated dependencies [d40caf4]
+- Updated dependencies [d40caf4]
+- Updated dependencies [d40caf4]
+  - @artblocks/abx-sdk@0.1.0-alpha.11
+  - @artblocks/abx-token-api@0.1.0-alpha.14
+  - @artblocks/abx-storage@0.1.0-alpha.11
+  - @artblocks/abx-indexer@0.1.0-alpha.12
+
+## 0.1.0-alpha.18
+
+### Minor Changes
+
+- 11fa933: Phase 5 interface unifications: the self resolver becomes a named remote, doctor absorbs the
+  version/install/provenance ladder, deploy previews stop showing addresses they can't keep,
+  approvals are counted honestly, render×storage combos are validated once, and storage config gets
+  a real probe.
+
+  - **Self resolver is a named remote (breaking, client-side only)**: the CLIENT credential for the
+    local/self resolver moves from `ABX_RESOLVER_ADMIN_TOKEN` to the named-remote grammar
+    (`ABX_REMOTE_SELF_URL` / `ABX_REMOTE_SELF_TOKEN` — "self" is just a conventional remote name, zero
+    special-casing). The SERVER side (token-api control-plane auth, `provision.ts`, the Fly.io secret)
+    keeps its old name — it's the service's own config, not a client credential, so deployed resolvers
+    need no change. The old client var, if still set, is now a pointed `CliError` naming both new vars
+    (no silent fallback); `abx doctor` flags it too, and the near-miss `_KEY`-vs-`_TOKEN` detector keeps
+    working under the unified grammar.
+  - **`abx doctor` absorbs the version/install/provenance ladder** the skill used to only teach in
+    prose: one new ✓/✗ block for binary provenance (source checkout / npm install / npx — the silent-
+    stale-npx-cache trap), npm currency (reuses the existing cached update check), and skill↔CLI
+    version match (reuses `abx skill`'s own discovery). Each row names the exact fix.
+  - **Deploy previews stop showing addresses they can't keep**: `--dry-run` (`deploy` /
+    `deploy-series` / `deploy-code`) **without `--salt`** no longer prints a "deterministic address" —
+    that salt was just freshly, randomly reserved, so the address was real for that one preview and
+    never reproducible by a plain re-run. It now prints the salt itself, prominently, plus how to pin
+    it: re-run with `--salt <shown>` (guaranteed same address), or `abx predict --salt <shown> --for
+<signer>`. **With `--salt`, the address prints exactly as before** (it IS stable) — `abx predict`
+    is unchanged. The same rule applies to `--json`: without `--salt`, `address` reports `null` rather
+    than a value the real deploy won't land at (`saltPinned` still says why).
+  - **`approvals` — a labeled, honest signature count**: every deploy-family `--dry-run` preview and
+    `--confirm` summary now carries one uniform `approvals N wallet approval(s)` line/clause — the
+    number of **wallet TX signatures** the real run will ask for (a connected-wallet storage upload,
+    e.g. Arweave via `--storage-signer eth`, is a message signature, not a transaction, and stays
+    listed separately, as it already was). It's derived from the exact same staging/setup-multicall
+    math that sizes the wallet-lane session's own `total`, so the two can never disagree — this caught
+    (and fixed) `deploy-code`'s wallet-lane session `total` being hardcoded to `2` even on the 1-tx path
+    (no chunks/schema/deps/on-chain-uri legs/setup-carried mints), which would have shown "transaction
+    1 of 2" and then silently never asked for a second.
+  - **One validator for render×storage combos**: `@artblocks/abx-storage` gains
+    `validateRenderStorageCombo()` (`content-plan.ts`) — the single source of truth for two known-bad
+    configurations, each checked against the ACTUAL fact that makes it bad (not against an unrelated
+    flag): (1) `--image-base` needs a backend that can overwrite a stable per-token key in place; an
+    ipfs/arweave-_shaped URL_ is refused regardless of this deploy's own `--backend`, because those are
+    content-addressed — a re-upload gets a new address, so no fixed URL can point at it. (2) publishing
+    a render to a resolver that doesn't share this machine's disk needs a backend that can hand back a
+    public URL at all — `fs` (or `cloud` with no public base) can't. `deploy-code` wires this into BOTH
+    its real-run refusal (`--image-base`) and a new `render/storage ✓|✗ <reason>` dry-run row;
+    `requirePublishableBackend` (the existing `abx render --remote` / `abx effects` guard) now consults
+    the same validator for its ok/not-ok decision, so the two surfaces can't drift apart.
+  - **`abx storage show --check`**: a real read/write against the resolved storage config, not just
+    "is it configured." `cloud` PUTs a tiny object through the signed API and GETs it back over the
+    PUBLIC base with a plain unsigned fetch — the only check that catches the R2/S3
+    endpoint-vs-public-base trap (`health()` alone only proves the API credentials work); on failure
+    both URLs print, so the mismatch is visible. `ipfs`/`fs` reuse their existing `health()` verbatim
+    (gateway/API reachability, dir writability — no upload, no pin — reused, not reimplemented).
+    `arweave` adds an identity+balance READ, never a paid upload. Exit code is meaningful (0 ok / 1 any
+    ✗) so a script can gate a launch on it. `abx doctor`'s storage row now runs the same fuller probe
+    (bounded to 1.5s, matching its other fast network checks) instead of a bare `health()` call.
+
+### Patch Changes
+
+- 11fa933: The remaining phases of the simplification refactor that hadn't yet gotten a changeset: the CLI's
+  internal module split, the token-api/effects/mint-page convergence on the SDK, the shipped skill's
+  rewrite for the simplified surface, and a new SDK README.
+
+  - **`abx`'s `main.ts` split into domain command modules** (`commands/{deploy,project,reads,service,
+scaffold,storage}.ts`, shared `output.ts`/`errors.ts`), with one exit-discipline rule
+    (`process.exitCode` + return, or a typed `CliError`, everywhere — bare `process.exit` only at the
+    entry guard, the top-level catch, and the keep-alive SIGINT handler). Purely internal: a 207-fixture
+    byte-diff matrix (every help text, dry-run, error path, and exit code) confirmed identical output
+    before and after.
+  - **token-api / effects / mint-page converge on the SDK**: `@artblocks/abx-storage` gains one
+    `resolveGatewayBase` (`readiness.ts`), replacing three near-identical copies (two in token-api, one
+    inline in storage itself); token-api exports `buildGeneratorDocument` so the CLI's `abx preview`
+    consumes the real generator-document assembler instead of a hand-kept duplicate; the effects runner
+    now resolves its config via the SDK's `readEnv` and gets a `makePublicClient` fallback transport, so
+    `ABX_RPC_URL` accepts a comma-separated failover list like every other RPC var; the scaffolded
+    mint-page app now imports ABIs from `@artblocks/abx-sdk/abi` and a browser-safe `makePublicClient` +
+    typed `readSaleConfig` instead of hand-rolled fetch/decode, and pins its generated `package.json` to
+    the SDK's _resolved_ version via a new `@artblocks/abx-sdk/package.json` export (alpha version
+    counters diverge per package under changesets, so pinning the CLI's own number could produce an
+    unsatisfiable range).
+  - **The shipped skill (`.claude/skills/abx-self-host/`) is rewritten for the surface phases 0–5
+    actually shipped**: every warning made obsolete by an enforcement is deleted rather than softened —
+    predict-only deploy-preview addresses, the `approvals N` line, the single `ABX_REMOTE_SELF_*`
+    credential grammar, `doctor`'s version/provenance ladder, `storage show --check`, the render/storage
+    combo validator's dry-run row, and `ABX_DEPLOYER_PK` as the only key name. Retired names swept from
+    `dev-loop-test`, the agent-eval scenarios, and spec prose. The skill ships bundled inside this CLI
+    package (co-versioned via `SKILL.md` frontmatter), so it rides this same patch.
+  - **New `packages/sdk/README.md`**: what the SDK is, the send-injection model (`PreparedTx` +
+    `SendTx`, `makeHotSender` for a hot key, bring-your-own for a wallet/multisig), a complete
+    deploy → upload → mint → read walkthrough against real exports, and browser-use notes (explicit
+    `rpcUrls`, no env, the `/node` subpath is Node-only). Included in the npm tarball automatically
+    (README is one of the files npm always packs, regardless of the `files` allowlist).
+
+- 11fa933: Two ripouts, no functional loss: the retired `params.keys` read fallback in `abx state`, and the `abx changelog` command.
+
+  **`abx state`'s legacy `params.keys` fallback.** On-chain param enumeration (`contractParamKeys` /
+  `tokenParamKeys` / `paramSchemaKeys`) shipped a while back and every project deployed since enumerates
+  its own param surface — nothing writes the old `params.keys` CSV any more. The only thing still reading
+  it was `abx state`, so it could keep describing the handful of pre-enumeration testnet projects that
+  predate the switch. That reader (`readLegacyParamsKeys`) and its `legacy`-branching in `cmdStateBody`
+  are gone; `abx state` now shows exactly what it reads from on-chain enumeration, an empty PostParams
+  list for a pre-enumeration contract included. (The repoint guard that refuses to point a legacy token's
+  field renderer at the canonical generator is a separate, still-live safeguard — untouched.)
+
+  **`abx changelog`.** A `CHANGELOG.md`-reading command that duplicated what any agent or human can do by
+  reading the file that already ships with the package (`package.json` `files`) — one more command to
+  document and maintain for a read `cat` already covers. `CHANGELOG.md` keeps shipping; the update-nag
+  banner and the docs now point at the file and at npm's version list
+  (`https://www.npmjs.com/package/@artblocks/abx-cli?activeTab=versions`) instead of a command.
+
+- 11fa933: The extraction phase of the simplification refactor: business logic that lived only inside the CLI
+  is now importable — the CLI calls the same functions you can.
+
+  **Into the SDK:** the five trust-anchor bootstraps (`ensureFactory`, `ensureSeriesFactory`,
+  `ensureSeriesCodeFactory`, `ensureRenderer`, `ensureSeedSource` — `anchors.ts`, on the same
+  injected-`send` + `onEvent` pattern as `ensureChunkStore`, with a typed `AnchorUnavailableError`),
+  `detectCanonicalFactory`/`resolveScanFloor`, the on-chain-URI setup composer (`onchain-uri.ts`),
+  interrupted-deploy resume planning (`resume.ts`), migration plan/parity reconciliation
+  (`migrate.ts`), the `abx.js` static analyzer (`inspect.ts`), dependency setup legs (`deps.ts`),
+  content-staging plans (`staging.ts` — `planStagedContent`, `stageFieldContent` with `StagingEvent`),
+  `mintedTokenIds`, and a typed `readSaleConfig` for the fixed-price minter.
+
+  **Into storage:** `uploadAndLocate`, `repinNodeCustody` (the byte-custody half of migration),
+  `decideImageContentLane`, `assessStorageReadiness`/`assessTurboFunds` (the Arweave/Turbo funding
+  math), and `awaitLocatorReady` (poll a locator until it serves).
+
+  **CLI hardening that fell out of the dedup:** one risk gate (`gatedSend`) now guards every write —
+  `--dry-run` and `--confirm` mean the same thing on every command, all owner-ops gain `--confirm`,
+  and a write reaching the send lane under `--dry-run` is structurally impossible (grep-enforced by
+  test). One `CHAIN` source of truth; one memoized local-indexer accessor.
+
+- 11fa933: Phase 1 of the simplification refactor: one transaction shape with one send-injection point, and an SDK that never touches `.env` or a Node-only global on its own. Two related passes, same release.
+
+  **One transaction shape, one executor.** `StagingTx`/`SendStagingTx` are gone — everything is a `PreparedTx` sent through a single `SendTx`. New `execute.ts` carries `makeHotSender` (pins the nonce once, detects an under-estimated gas limit against a just-deployed target, throws a typed `TxRevertedError` instead of reporting a reverted tx as confirmed) plus `pinGas`/`waitForCodeAt`, moved from the CLI (`gas.ts` is gone) with their design comments intact. Every `deployX` is now `prepareDeployX` (pure) + `deployX(send, ...)`; the CLI's hot lane and `abx deploy-code --resume` both delegate to the same sender instead of hand-rolling their own nonce/gas loop — the class of bug that reported a burned, reverted transaction as a successful deploy can't recur in a second call site because there is no longer a second implementation.
+
+  **The SDK never loads `.env` implicitly.** `loadDotEnv`/`parseEnvContent` moved to a new `@artblocks/abx-sdk/node` subpath — the only module that touches `node:fs`/`node:path`. The package's main entry is now browser-bundle-safe (a permanent esbuild smoke test guards it); a host calls `loadDotEnv()` once at startup (the CLI's `main()`, the effects runner's `main()`) and the SDK core reads whatever's already in `process.env` through a tiny `readEnv` that no-ops outside Node. `ClientOptions` gained `rpcUrls?: string[]` and `makeWalletClient`/`envSigningKey` gained a `privateKey`/`override` escape — explicit config now wins outright over env resolution, following the same override → env → manifest precedence `deployments.ts` already used for contract addresses.
+
+  **Single signing-key name.** `ABX_DEPLOYER_PK` is the only env var the SDK reads for a hot key — `SEPOLIA_FUNDED_PK` and `SEPOLIA_WALLET_PK` (earlier-alpha names) are no longer consulted. A caller with one of the old names set now gets a `MissingSigningKeyError` that names the new one explicitly and says the old ones are retired, rather than a plain "no key found" that leaves an upgrader hunting for why a key that's clearly _there_ isn't being read. Sandbox/e2e scripts and test fixtures move to the new name too.
+
+  **Shared, environment-neutral utilities.** New `sdk/src/util.ts`: `sleep`, a `linearBackoffDelay` helper (service.ts's retry ladder and the effects runner's resolver poll both use it now instead of hand-rolled backoff math), `parseDataUri` (replaces three near-identical `data:` URI regexes across the CLI and the tokenURI probe with one permissive parser), and `tryReadContract` (replaces three near-identical try/read-return-undefined helpers; the CLI's "no contract at this address" diagnostic still wraps it where that mattered). `Buffer` is gone from the SDK core (chunk hex-encoding and param base64-encoding now use viem's `bytesToHex` and a ~12-line dependency-free base64 codec) — nothing in the SDK's main import graph is Node-only any more.
+
+- Updated dependencies [11fa933]
+- Updated dependencies [11fa933]
+- Updated dependencies [11fa933]
+- Updated dependencies [11fa933]
+  - @artblocks/abx-sdk@0.1.0-alpha.10
+  - @artblocks/abx-storage@0.1.0-alpha.10
+  - @artblocks/abx-token-api@0.1.0-alpha.13
+  - @artblocks/abx-indexer@0.1.0-alpha.11
+
 ## 0.1.0-alpha.17
 
 ### Patch Changes

package/dist/commands/deploy.d.ts

@@ -0,0 +1,181 @@
+import { SelfHostIndexer } from '@artblocks/abx-indexer';
+import { type Address, type OnChainFieldInput, type OpenSeaAttribute, type ProjectState, type PublicClient, type SeriesTokenFieldInput } from '@artblocks/abx-sdk';
+import { type Hex } from 'viem';
+import { type StorageOverrides } from '../config.js';
+import { type Flags } from '../flags.js';
+export declare const DIMENSIONS: Record<string, {
+    label: string;
+    aliases: string[];
+}>;
+export declare function resolveDimension(type: string): string;
+/**
+ * A `--dry-run` computes the deterministic deploy address, which is a pure function of
+ * (factory, salt, deployer) — so it needs a deployer even though it signs nothing. Resolve it the
+ * same way the preview will (`--for`, else an env key) and fail EARLY with the fix if neither
+ * exists, rather than after the preview has printed several steps of work.
+ */
+/**
+ * A dry run only checks whether a factory address is CONFIGURED, not whether it has code on this
+ * chain — and the manifest always has an address, so a chain where the trust anchor isn't deployed
+ * (a private/local chain, or a wrong-network RPC) sailed past this and died inside
+ * `predictDeterministicAddress` with a raw `returned no data ("0x")` and a list of ABI hypotheses.
+ * The real deploy and `abx predict` both explain that case; a preview of the same deploy must too.
+ * Returns false when the caller should stop (message already printed).
+ */
+export declare function previewFactoryLive(client: PublicClient, factory: Address, label: string): Promise<boolean>;
+/**
+ * Placeholder-identity guard, shared by ALL THREE deploy commands. `name`/`symbol` are written
+ * on-chain as the public collection identity and are effectively permanent, so a real deploy must
+ * never bake a tool default silently: warn in a preview, HARD-STOP a real send unless `--yes`.
+ *
+ * It was duplicated per command, and `deploy-series` simply never got a copy — its default
+ * "ABX Series"/"ABXS" went on-chain with at most a warning, while the skill promises the CLI
+ * refuses demo defaults. (deploy-code's copy even said "mirror deploy/deploy-series", which made
+ * the gap look closed.) One predicate now, like `loopbackBaseUrl()`, so a fourth command can't drift.
+ */
+export declare function assertRealIdentity(flags: Flags, o: {
+    name: string;
+    symbol: string;
+    dryRun: boolean;
+}): void;
+export declare function assertPreviewDeployer(flags: Flags): void;
+export declare function warnUnfunded(publicClient: PublicClient, address: Address): Promise<void>;
+export declare function shArg(v: string): string;
+export declare function deployCommandLine(flags: Flags, salt: string): string;
+export declare function deploySeriesCommandLine(flags: Flags, salt: string): string;
+export declare function deployCodeCommandLine(flags: Flags, salt: string): string;
+export declare const imageKeccakField: (value: Hex) => OnChainFieldInput;
+export declare const imageInlineField: (svg: string) => OnChainFieldInput;
+/** An `image` field pointing at an off-chain URL (the renderer emits it verbatim). */
+export declare const imageUrlField: (url: string) => OnChainFieldInput;
+/** An `image` field as a `url-template` — `{id}` is substituted with the tokenId at render, so ONE
+ *  (collection-scope) field addresses a whole pinned directory / Arweave manifest. */
+export declare const imageUrlTemplateField: (template: string) => OnChainFieldInput;
+export declare const looksLikeSvg: (s: string) => boolean;
+/**
+ * Does the IMAGE itself end up on-chain for this deploy? Two ways it can:
+ *   • `--onchain-image` — the bytes are staged in the chunk store and read back via a `reader` field.
+ *   • `--onchain-uri` with an SVG — v1 inlines SVG directly as a data: URI (raster cannot be).
+ * Anything else falls through to keccak256 custody, and the on-chain renderer serves its PLACEHOLDER
+ * image. This distinction is the difference between a token that is durable and one that only looks
+ * durable, so it must be computed from the actual file — never inferred from the flag alone (the
+ * success banner used to claim "fully on-chain, no hosting needed" for a keccak-anchored raster).
+ */
+/**
+ * Will `tokenURI` resolve to the creator's REAL image, with nothing to keep running?
+ *
+ * Three ways yes, and they are not the same promise: the bytes are on-chain
+ * ({@link imageEndsUpOnChain}), or they sit at a durable public URL that the on-chain JSON points at
+ * (a direct-URL backend — the "no server" pattern). Only `fs` custody under `--onchain-uri` fails,
+ * because the renderer then holds a hash and nothing can serve it. Keep this separate from
+ * "fully on-chain": conflating them is what let a keccak-anchored raster ship under a permanence
+ * banner it did not earn.
+ */
+export declare function imageResolvesWithoutServer(flags: Flags, onchainImage: boolean): boolean;
+export declare function imageEndsUpOnChain(flags: Flags, onchainImage: boolean): boolean;
+/** A browser wallet reached through an open sign session, used as the Turbo (Arweave) upload
+ *  identity so the wallet's own credits pay — `signMessage` returns the `0x` EIP-191 signature. */
+export type RemoteEthUpload = {
+    address: Address;
+    signMessage: (message: Uint8Array) => Promise<string>;
+};
+export declare function prepareContent(imagePath: string | undefined, clone: Address, overrides: StorageOverrides, store?: boolean, // false for --dry-run: compute the hash but don't custody bytes
+onChain?: boolean, // true (--onchain-uri): put the image ON-CHAIN (inline SVG) so it self-resolves
+remoteEth?: RemoteEthUpload, // wallet-lane Turbo uploads: sign+pay with the connected browser wallet
+walletAddr?: string): Promise<{
+    tokenFields: OnChainFieldInput[];
+    contentNote: string;
+}>;
+/**
+ * Real OpenSea traits supplied by the creator, from `--attributes <file.json>` (canonical array or
+ * `{name: value}` map) and/or `--traits "Background=Blue; Edition=3"` (quick inline form). These are
+ * the marketplace trait array — NOT a place for protocol facts. Empty when neither flag is given.
+ */
+export declare function parseDeployTraits(flags: Flags): OpenSeaAttribute[];
+/** Encode creator traits as the on-chain `attributes` field (inline JSON bytes) — for `--traits-onchain`. */
+export declare const attributesInlineField: (attrs: OpenSeaAttribute[]) => OnChainFieldInput;
+/** Warn when IPFS/Arweave custody is pointed at a LOCAL gateway: the served image URL
+ *  (`<gateway>/ipfs/<cid>`) would resolve only on this machine, so marketplaces/wallets can't
+ *  load it — a pinning service + a PUBLIC gateway is part of operating off-chain custody. */
+export declare function localGatewayWarning(flags: Flags): string | null;
+/** A readout line for an optional creator text field — states exactly what's written (and where),
+ *  or that NOTHING is, so the deploy never silently invents one. */
+export declare function describeDeployField(label: string, value: string | undefined, onchain: boolean): string;
+/** Readout lines for whichever authorship/rights fields a deploy will write (always on-chain,
+ *  inline collection fields). Empty when none are set — so the readout stays quiet by default. */
+export declare function authorshipReadout(flags: Flags): string[];
+/** A readout line for creator traits — the exact traits written (and where), or that none are. */
+export declare function describeTraits(traits: OpenSeaAttribute[], onchain: boolean): string;
+export declare function cmdDeploy(flags: Flags, serveAfter: boolean): Promise<void>;
+export declare function cmdDeployBody(flags: Flags, serveAfter: boolean, emit: (p: Record<string, unknown>) => void): Promise<void>;
+export declare const tokenFieldOf: (tokenId: number, f: OnChainFieldInput) => SeriesTokenFieldInput;
+export declare function cmdDeploySeries(flags: Flags): Promise<void>;
+export declare function cmdDeploySeriesBody(flags: Flags, emit: (p: Record<string, unknown>) => void): Promise<void>;
+/**
+ * `abx deploy-code` — deploy a code project ({SeriesCode}) end to end, hot lane:
+ * the canonical factory + seed source from the manifest, fat initialize (the `code`
+ * field rides it in directory mode), then ONE post-deploy multicall for the script
+ * chunks (template mode) + any PostParam schemas, optional reserve mints, and local
+ * register + index. Grown directly from the Sepolia drop rehearsal
+ * (`packages/cli/scripts/code-drop-rehearsal.ts`).
+ *
+ * Modes (exactly one):
+ *   --script <file>    template mode — the program stored on-chain in chunks
+ *   --code-dir <dir>   directory mode — the build uploaded via the storage backend
+ *                      (`putDirectory`; ipfs/arweave), its root as the `code` field
+ *
+ * Schemas: --schema key:Type:Auth[,key:Type:Auth…] (e.g. palette:HexColor:TokenOwner).
+ * Seeds: canonical randomizer by default; --no-seed opts out.
+ */
+/**
+ * The deterministic part of a projection: everything that is a pure function of the chain.
+ * Deliberately EXCLUDES `reconstructedAt`, `rpcUrl` and `toBlock` — a timestamp, the endpoint that
+ * happened to answer, and the head at scan time all legitimately differ between two replays, so
+ * folding them in would make the rebuild proof fail for reasons that aren't about correctness.
+ */
+export declare function projectionFingerprint(s: ProjectState): string;
+/**
+ * Print the reconstructed spine — the point being that this list IS the database. Rendered inside
+ * the index step (no header of its own: "Index it — replay the event spine" immediately followed by
+ * a separate "The event spine" step read as a stutter).
+ */
+export declare function walkthroughSpine(state: ProjectState): void;
+/**
+ * [4] The claim, demonstrated: delete the local projection and rebuild it from the chain.
+ *
+ * This is the one step that can't be faked by good output — it drops the projection for real
+ * (registration kept), confirms it's gone, replays from the deploy block, and compares a
+ * fingerprint of everything chain-derived. If ABX's premise is wrong, this step fails loudly.
+ */
+export declare function walkthroughRebuild(indexer: SelfHostIndexer, address: Address, before: ProjectState): Promise<void>;
+/**
+ * [5] Read the token back the way a marketplace would.
+ *
+ * Which is genuinely a different act per lane, so it reads from the real source in each case rather
+ * than always going through the local server:
+ *   • fully on-chain → call `tokenURI(0)` on the contract. That IS what a marketplace does, and on
+ *     this lane the whole answer (art included) comes back from the chain with nothing else running.
+ *   • off-chain custody → fetch the resolver, because that's what the baked URI points at.
+ * Reading the on-chain lane over HTTP would have quietly implied the local server was load-bearing
+ * when it isn't — the opposite of the lesson.
+ */
+export declare function walkthroughReadBack(state: ProjectState, baseUrl: string, onChainUri: boolean): Promise<void>;
+/** Every flag `deploy-code` recognizes — so an unsupported/typo'd one warns instead of silently
+ *  no-opping. Keep in lockstep with the flags read below + the storageOverrides/lane helpers. */
+export declare const DEPLOY_CODE_FLAGS: Set<string>;
+export declare const SHARED_DEPLOY_FLAGS: string[];
+export declare const DEPLOY_FLAGS: Set<string>;
+export declare const DEPLOY_SERIES_FLAGS: Set<string>;
+export declare function cmdDeployCode(flags: Flags): Promise<void>;
+export declare function cmdDeployCodeBody(flags: Flags, emit: (p: Record<string, unknown>) => void): Promise<void>;
+/**
+ * Resolve `--721c` into the InitParams `transferValidator`. Absent → `zeroAddress`: a plain
+ * ERC-721, byte-for-byte the pre-721C deploy — no prompts, no output, no mention of 721C.
+ * `--721c` / `--721c recommended` → the per-chain recommended validator (refused, naming the
+ * chains that have one, when the manifest has no entry); `--721c 0x…` → checksum-validated AND
+ * pre-checked for code on this chain (the factory would revert `InvalidTransferValidator()` —
+ * surface it before any upload/staging/gas). When enrolling, prints the one plain statement of
+ * what enforcement means — once, adapted to the chosen validator.
+ */
+export declare function resolveTransferValidatorFlag(flags: Flags, publicClient: PublicClient, dryRun: boolean): Promise<Address>;
+//# sourceMappingURL=deploy.d.ts.map

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

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