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

package/assets/renderer-scaffold/src/interfaces/IAbxParams.sol

@@ -10,6 +10,13 @@ pragma solidity ^0.8.20;
 ///         The tokenData merge rule: a token-scope value overrides the contract-scope one. The
 ///         common pattern is `tokenParam` first, then `contractParam` as a fallback (see the
 ///         `_param` helper in MyRenderer.sol).
+///
+///         TWO READERS, PICK BY TYPE. Scalar types (`Bool`, `Select`, the ranges, `HexColor`,
+///         `Timestamp`) live entirely in the `bytes32` — read them with `tokenParam` /
+///         `contractParam`. The two payload types, **`Bytes` and `String`**, do NOT: their
+///         `bytes32` is a keccak COMMITMENT (`valueIsHash == true`) and the content is fetched with
+///         `tokenParamData` / `contractParamData` below. Reading a `Bytes` param with `tokenParam`
+///         hands you a hash, not the artwork — that is the tell you want the data reader.
 interface IAbxParams {
     /// Returns the token-scope param: its bytes32 `value`, `valueIsHash` (true if it commits to
     /// off-chain bytes — a literal scalar like a seed/HexColor is false), and `isSet` (does it exist).
@@ -23,4 +30,14 @@ interface IAbxParams {
         external
         view
         returns (bytes32 value, bool valueIsHash, bool isSet);
+
+    /// @notice A `Bytes`/`String` token param's FULL content — the payload types' real reader.
+    ///         Returns empty bytes for a literal scalar or an unset key, so an empty return is your
+    ///         "fall back to a default" signal. When non-empty, `keccak256(returned bytes)` equals
+    ///         the `value` that `tokenParam` reports — verify it if you want the commitment proof.
+    ///         Up to ~24KB per key: enough to carry an actual artwork payload on-chain.
+    function tokenParamData(uint256 tokenId, bytes32 key) external view returns (bytes memory);
+
+    /// @notice The contract-scope (collection-wide) blob — the fallback when a token has none.
+    function contractParamData(bytes32 key) external view returns (bytes memory);
 }

package/assets/renderer-scaffold/test/MyRenderer.t.sol

@@ -13,15 +13,38 @@ contract MockParams is IAbxParams {
     mapping(uint256 => mapping(bytes32 => bool)) private ts;
     mapping(bytes32 => bytes32) private cv;
     mapping(bytes32 => bool) private cs;
+    // `Bytes`/`String` params: the bytes32 holds keccak(content), the content lives here.
+    mapping(uint256 => mapping(bytes32 => bytes)) private td;
+    mapping(bytes32 => bytes) private cd;
 
     function setToken(uint256 id, bytes32 key, bytes32 val) external { tv[id][key] = val; ts[id][key] = true; }
     function setContract(bytes32 key, bytes32 val) external { cv[key] = val; cs[key] = true; }
 
+    /// Set a payload-typed (`Bytes`/`String`) param the way the real contract does: the scalar slot
+    /// carries the keccak COMMITMENT and `valueIsHash` is true, so a renderer that reads the bytes32
+    /// gets a hash — the data reader is the only way to the content.
+    function setTokenData(uint256 id, bytes32 key, bytes memory content) external {
+        td[id][key] = content;
+        tv[id][key] = keccak256(content);
+        ts[id][key] = true;
+    }
+    function setContractData(bytes32 key, bytes memory content) external {
+        cd[key] = content;
+        cv[key] = keccak256(content);
+        cs[key] = true;
+    }
+
     function tokenParam(uint256 id, bytes32 key) external view returns (bytes32, bool, bool) {
-        return (tv[id][key], false, ts[id][key]);
+        return (tv[id][key], td[id][key].length > 0, ts[id][key]);
     }
     function contractParam(bytes32 key) external view returns (bytes32, bool, bool) {
-        return (cv[key], false, cs[key]);
+        return (cv[key], cd[key].length > 0, cs[key]);
+    }
+    function tokenParamData(uint256 id, bytes32 key) external view returns (bytes memory) {
+        return td[id][key];
+    }
+    function contractParamData(bytes32 key) external view returns (bytes memory) {
+        return cd[key];
     }
 }
 
@@ -107,4 +130,30 @@ contract MyRendererTest is Test {
         (, bytes memory data) = img.render(address(params), tokenId, IMAGE);
         assertTrue(data.length > 0);
     }
+
+    /// READING A PAYLOAD PARAM (`Bytes`/`String`) — the pattern for carrying an actual artwork
+    /// payload on-chain. The scalar reader hands you a keccak COMMITMENT with `valueIsHash == true`;
+    /// the content only comes from `tokenParamData`. If your renderer reads a `Bytes` param through
+    /// `tokenParam` it will draw from a hash and produce garbage, silently — hence this test.
+    function test_bytesParam_readViaDataReader() public {
+        bytes memory grid = hex"00112233445566778899aabbccddeeff";
+        params.setTokenData(0, "grid", grid);
+
+        // The scalar surface: a commitment, explicitly flagged as one — NOT the content.
+        (bytes32 value, bool valueIsHash, bool isSet) = IAbxParams(address(params)).tokenParam(0, "grid");
+        assertTrue(isSet);
+        assertTrue(valueIsHash, "a Bytes param reports valueIsHash: read the data instead");
+        assertEq(value, keccak256(grid));
+
+        // The data surface: the real bytes, verifiable against that commitment.
+        bytes memory got = IAbxParams(address(params)).tokenParamData(0, "grid");
+        assertEq(got, grid);
+        assertEq(keccak256(got), value, "content must match the on-chain commitment");
+    }
+
+    /// An unset payload param returns empty bytes — your "use a default" signal, never a revert.
+    function test_bytesParam_unsetIsEmpty() public view {
+        assertEq(IAbxParams(address(params)).tokenParamData(0, "grid").length, 0);
+        assertEq(IAbxParams(address(params)).contractParamData("grid").length, 0);
+    }
 }

package/dist/commands/deploy.d.ts

@@ -0,0 +1,206 @@
+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;
+/** Parse `--copies <N|open>` into the `editionSize` InitParams field (`0n` = open/uncapped). Throws
+ *  with a pointed message on anything else — a bare `--copies` (no value), a non-integer, or the
+ *  literal `0` (which already has an on-chain meaning — "open" says the same thing without the
+ *  ambiguity of "did they mean zero copies, or unlimited?"). */
+export declare function parseCopies(raw: string | undefined): bigint;
+/** `--copies 1` is legal — a single-copy ERC-1155 edition — but it is almost never what a creator
+ *  actually wants (the plain 721 lane makes a simpler, more marketplace-familiar token for exactly
+ *  one copy). Advisory only; never refused — `--copies` exists precisely so nobody has to reach for
+ *  a different flag to get an edition. */
+export declare function copiesOneNote(cmd: string): string;
+/** A non-negative-integer flag (`--mint-amount`, …) — the shared parse + bound-check so every
+ *  edition flag that takes "a count" reports the same, plain-language rejection. */
+export declare function parseNonNegativeIntFlag(raw: string, flag: string): bigint;
+/**
+ * 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 function cmdDeployOneOfOneEditionBody(flags: Flags, 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>;
+export declare function cmdDeployEditionImageBody(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 const DEPLOY_EDITION_FLAGS: Set<string>;
+export declare const DEPLOY_SERIES_EDITION_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>;
+export declare const DEPLOY_CODE_EDITION_FLAGS: Set<string>;
+export declare function cmdDeployEditionCodeBody(flags: Flags, emit: (p: Record<string, unknown>) => void): Promise<void>;
+/**
+ * Resolve `--721c` into the InitParams `transferValidator`. Absent → `zeroAddress`: a plain
+ * ERC-721 (or, on an edition deploy, a plain ERC-1155), 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.
+ *
+ * `standard` picks only the WORDING (`ERC-721C` vs `ERC-1155C`) — the flag, the value grammar, and
+ * the resolved validator address are identical either way (the SAME `InitParams.transferValidator`
+ * opt-in per the parity plan's locked decision 3: 1155C ships with the same UX as 721C). Editions
+ * pass `'1155C'`; every 721 call site keeps the default, so their output is unchanged.
+ */
+export declare function resolveTransferValidatorFlag(flags: Flags, publicClient: PublicClient, dryRun: boolean, standard?: '721C' | '1155C'): 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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"}