@artblocks/abx-cli 0.1.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Art Blocks, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/assets/renderer-scaffold/README.md

@@ -0,0 +1,59 @@
+# ABX in-chain renderer scaffold
+
+A ready-to-build Foundry project for the **fully on-chain Solidity art lane** — the artwork is a
+smart contract that computes an SVG (and traits) from the token's `seed` and collector-set
+PostParams. No JavaScript, no browser, no bucket, no resolver, no effect runner: once the renderer
+is deployed and wired, `tokenURI` — name, image, traits — resolves from chain forever.
+
+`abx` does **not** compile or deploy Solidity for you; you build, test, and deploy this project with
+Foundry, then hand the deployed address(es) to `abx deploy-code`, which verifies they have code.
+
+## What's here
+
+- `src/MyRenderer.sol` — the **image** renderer: seed → geometry, a `palette` HexColor PostParam →
+  tint. **Fork the geometry/palette math for your own art.**
+- `src/MyTraits.sol` — the **attributes** renderer: reads the *same* seed math so traits agree with
+  the image by construction.
+- `src/interfaces/` — the two ABX interfaces you implement/read (`IAbxFieldRenderer`, `IAbxParams`).
+  Read `IAbxFieldRenderer.sol` first: it documents **the five invariants** (above all, `render()`
+  must NEVER revert — a revert bricks the whole `tokenURI`, including the collection surface
+  `tokenId == type(uint256).max`).
+- `test/MyRenderer.t.sol` — proves `render()` never reverts (incl. no-seed, no-palette, the
+  collection surface, and a fuzz over every seed/tokenId) and that image ↔ traits stay coherent.
+- `script/Deploy.s.sol` — deploys both renderers and prints the addresses + the next command.
+
+## Build, test, deploy
+
+```bash
+forge soldeer install          # fetch solady + forge-std (pinned in foundry.toml)
+forge build
+forge test                     # MUST pass — especially the never-revert cases
+
+# deploy to your testnet, then copy the printed addresses:
+forge script script/Deploy.s.sol --rpc-url <your-rpc-url> --private-key <key> --broadcast
+```
+
+## Wire it into a drop
+
+```bash
+abx deploy-code \
+  --image-renderer <MyRenderer address> \
+  --attributes-renderer <MyTraits address> \
+  --onchain-uri \
+  --schema palette:HexColor:TokenOwner \
+  --name "Your Collection" --symbol SYM [--max N] --sign --for <your wallet>
+```
+
+- `--onchain-uri` (no `--script`/`--code-dir`) is the in-chain lane — a small Solidity SVG is a
+  great fit for an on-chain `tokenURI` (unlike a 200KB JS bundle).
+- `--schema palette:HexColor:TokenOwner` declares the collector param your renderer reads. **Omit it
+  and the palette is fixed at the default** — collectors can't set it. After launch, a collector
+  runs `abx configure-param <addr> <id> palette #ff3366` and the on-chain image re-tints instantly
+  (the renderer reads the live param — nothing to re-render).
+- Verify from chain with `abx tokenuri <addr>` — no server involved.
+
+## The renderer contract, in one breath
+
+Implement `render(address token, uint256 tokenId, bytes32 field) view → (string contentType, bytes data)`:
+read live state via `IAbxParams(token).tokenParam(...)` / `.contractParam(...)`, compute the field's
+bytes, return them with the right MIME. Never revert. Keep the output small. `forge test` before you wire.

package/assets/renderer-scaffold/foundry.toml

@@ -0,0 +1,15 @@
+[profile.default]
+src = "src"
+out = "out"
+test = "test"
+script = "script"
+libs = ["dependencies"]
+solc = "0.8.28"
+evm_version = "paris"        # broad multi-chain compatibility (no PUSH0/cancun assumptions)
+optimizer = true
+optimizer_runs = 1_000_000   # a renderer is deployed once and called forever → optimize runtime
+
+# Dependencies are fetched with soldeer (`forge soldeer install`), pinned here.
+[dependencies]
+solady = "0.1.26"
+forge-std = "1.16.1"

package/assets/renderer-scaffold/remappings.txt

@@ -0,0 +1,3 @@
+solady/=dependencies/solady-0.1.26/src/
+forge-std/=dependencies/forge-std-1.16.1/src/
+abx/=src/interfaces/

package/assets/renderer-scaffold/script/Deploy.s.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {Script, console2} from "forge-std/Script.sol";
+import {MyRenderer} from "../src/MyRenderer.sol";
+import {MyTraits} from "../src/MyTraits.sol";
+
+/// @notice Deploys the image + traits renderers and prints their addresses. Run with:
+///   forge script script/Deploy.s.sol --rpc-url <your-rpc> --private-key <key> --broadcast
+/// then wire them into your drop:
+///   abx deploy-code --image-renderer <MyRenderer addr> --attributes-renderer <MyTraits addr> \
+///        --onchain-uri --schema palette:HexColor:TokenOwner --name "..." --symbol ...
+contract Deploy is Script {
+    function run() external {
+        vm.startBroadcast();
+        MyRenderer image = new MyRenderer();
+        MyTraits traits = new MyTraits();
+        vm.stopBroadcast();
+        console2.log("MyRenderer (image)     :", address(image));
+        console2.log("MyTraits  (attributes) :", address(traits));
+        console2.log("Next: abx deploy-code --image-renderer <image> --attributes-renderer <traits> --onchain-uri --schema palette:HexColor:TokenOwner ...");
+    }
+}

package/assets/renderer-scaffold/src/MyRenderer.sol

@@ -0,0 +1,123 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {LibString} from "solady/utils/LibString.sol";
+import {IAbxFieldRenderer} from "abx/IAbxFieldRenderer.sol";
+import {IAbxParams} from "abx/IAbxParams.sol";
+
+/// @title MyRenderer — a fully on-chain generative image, tinted by a collector PostParam
+/// @notice FORK THIS. It renders the `image` field as an `image/svg+xml` document computed
+///         entirely on-chain from:
+///           • the per-token `seed` (mint-time randomness) → the geometry (ring count, weight,
+///             rotation, hues), so every token is a distinct composition; and
+///           • a `palette` (HexColor) PostParam a collector can set → the background tint, so
+///             owners reshape their piece after minting (`abx configure-param <addr> <id> palette #ff3366`).
+///
+///         Wire it: deploy this contract, then
+///           `abx deploy-code --image-renderer <this address> --attributes-renderer <MyTraits> \
+///                 --onchain-uri --schema palette:HexColor:TokenOwner --name "..." --symbol ...`
+///         (declare the `palette` schema, or the param is fixed at the default and collectors
+///          can't set it.) Pair with MyTraits.sol so image AND traits read the SAME seed math.
+///
+///         Swap the geometry/palette math below for your own art. Keep the FIVE INVARIANTS in
+///         IAbxFieldRenderer — above all, NEVER revert (a revert bricks the whole tokenURI).
+contract MyRenderer is IAbxFieldRenderer {
+    using LibString for uint256;
+
+    /// @dev Wiring this renderer to a field it doesn't compute is a deploy-time miswiring — fail
+    ///      loudly on THAT, but never on the field you DO render (invariant #3).
+    error UnsupportedField();
+
+    string private constant CONTENT_TYPE = "image/svg+xml";
+    bytes32 private constant F_IMAGE = "image";
+    bytes32 private constant SEED_KEY = "seed";
+    bytes32 private constant PALETTE_KEY = "palette";
+    string private constant DEFAULT_PALETTE = "#0e1a40";
+
+    /// @inheritdoc IAbxFieldRenderer
+    function render(address token, uint256 tokenId, bytes32 field)
+        external
+        view
+        returns (string memory contentType, bytes memory data)
+    {
+        if (field != F_IMAGE) revert UnsupportedField();
+
+        // Invariant #1: the collection surface (contractURI) has no token — return a neutral
+        // card, never a revert.
+        if (tokenId == type(uint256).max) {
+            return (CONTENT_TYPE, bytes(_svg(keccak256("collection"), DEFAULT_PALETTE)));
+        }
+
+        bytes32 seed = _seed(token, tokenId); // always renderable (falls back if unset)
+        string memory palette = _palette(token, tokenId); // "#rrggbb", default if unset
+        return (CONTENT_TYPE, bytes(_svg(seed, palette)));
+    }
+
+    // ── the art: seed → geometry, palette → tint (replace with your own) ──────────
+
+    function _svg(bytes32 seed, string memory palette) private pure returns (string memory) {
+        uint256 rings = 3 + (uint8(seed[0]) % 6); // 3..8 rings (MUST match MyTraits' math)
+        uint256 weight = 1 + (uint8(seed[1]) % 3); // stroke 1..3
+        uint256 rot = uint8(seed[2]) % 360; // whole-piece rotation
+        uint256 baseHue = (uint256(uint8(seed[3])) * 360) / 256; // this token's colorway
+
+        string memory circles;
+        for (uint256 i = 1; i <= rings; ++i) {
+            uint256 r = (46 * i) / rings;
+            uint256 hue = (baseHue + i * 40) % 360;
+            circles = string.concat(
+                circles,
+                '<circle cx="50" cy="50" r="',
+                r.toString(),
+                '" fill="none" stroke="hsl(',
+                hue.toString(),
+                ',72%,58%)" stroke-width="',
+                weight.toString(),
+                '" stroke-opacity="0.85"/>'
+            );
+        }
+
+        return string.concat(
+            '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">',
+            '<rect width="100" height="100" fill="',
+            palette,
+            '"/><g transform="rotate(',
+            rot.toString(),
+            ' 50 50)">',
+            circles,
+            '</g></svg>'
+        );
+    }
+
+    // ── param reads (mirror these in your traits renderer for coherence) ──────────
+
+    /// @dev The token's `seed`, or a deterministic fallback so the image is ALWAYS renderable
+    ///      (pre-mint preview, or a project with no seed source). Never reverts.
+    function _seed(address token, uint256 tokenId) private view returns (bytes32) {
+        (bytes32 value, bool isHash) = _param(token, tokenId, SEED_KEY);
+        if (uint256(value) != 0 && !isHash) return value;
+        return keccak256(abi.encodePacked(token, tokenId));
+    }
+
+    /// @dev `palette` (HexColor) → "#rrggbb". Token scope wins over contract scope; a default
+    ///      when unset. HexColor stores the RGB in the low 3 bytes of the param value.
+    function _palette(address token, uint256 tokenId) private view returns (string memory) {
+        (bytes32 value, bool isHash) = _param(token, tokenId, PALETTE_KEY);
+        if (uint256(value) == 0 || isHash) return DEFAULT_PALETTE;
+        return string.concat("#", LibString.toHexStringNoPrefix(uint256(value) & 0xffffff, 3));
+    }
+
+    /// @dev token-scope value, falling back to contract-scope (the tokenData merge rule). Returns
+    ///      the value + whether it's a keccak commitment (a literal scalar param is NOT a hash).
+    function _param(address token, uint256 tokenId, bytes32 key)
+        private
+        view
+        returns (bytes32 value, bool valueIsHash)
+    {
+        bool isSet;
+        (value, valueIsHash, isSet) = IAbxParams(token).tokenParam(tokenId, key);
+        if (isSet) return (value, valueIsHash);
+        (value, valueIsHash,) = IAbxParams(token).contractParam(key);
+        return (value, valueIsHash);
+    }
+}

package/assets/renderer-scaffold/src/MyTraits.sol

@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {LibString} from "solady/utils/LibString.sol";
+import {IAbxFieldRenderer} from "abx/IAbxFieldRenderer.sol";
+import {IAbxParams} from "abx/IAbxParams.sol";
+
+/// @title MyTraits — on-chain marketplace traits, coherent with MyRenderer
+/// @notice FORK THIS. Renders the `attributes` field as an `application/json` array a marketplace
+///         reads. Wire with `abx deploy-code --attributes-renderer <this address> --onchain-uri`.
+///
+///         COHERENCE RULE: read the SAME seed bytes the SAME way as your image renderer, so a
+///         trait can never disagree with what's drawn (here `Rings` = `3 + seed[0] % 6`, byte-
+///         identical to MyRenderer). Derive traits from the seed with integer/threshold math so
+///         they're exactly reproducible on-chain (a raw float or `Math.random` would not be).
+contract MyTraits is IAbxFieldRenderer {
+    using LibString for uint256;
+
+    error UnsupportedField();
+
+    string private constant CONTENT_TYPE = "application/json";
+    bytes32 private constant F_ATTRIBUTES = "attributes";
+    bytes32 private constant SEED_KEY = "seed";
+    bytes32 private constant PALETTE_KEY = "palette";
+
+    /// @inheritdoc IAbxFieldRenderer
+    function render(address token, uint256 tokenId, bytes32 field)
+        external
+        view
+        returns (string memory contentType, bytes memory data)
+    {
+        if (field != F_ATTRIBUTES) revert UnsupportedField();
+
+        // Invariant #1: the collection surface has no per-token traits — an empty array, not a revert.
+        if (tokenId == type(uint256).max) return (CONTENT_TYPE, bytes("[]"));
+
+        bytes32 seed = _seed(token, tokenId);
+        uint256 rings = 3 + (uint8(seed[0]) % 6); // SAME math as MyRenderer._svg
+        (bytes32 pal, bool palIsHash) = _param(token, tokenId, PALETTE_KEY);
+        bool paletteSet = uint256(pal) != 0 && !palIsHash;
+
+        string memory json = string.concat(
+            "[",
+            _trait("Rings", rings.toString()),
+            ",",
+            _trait("Palette", paletteSet ? "Custom" : "Default"),
+            "]"
+        );
+        return (CONTENT_TYPE, bytes(json));
+    }
+
+    function _trait(string memory k, string memory v) private pure returns (string memory) {
+        return string.concat(
+            '{"trait_type":"', LibString.escapeJSON(k), '","value":"', LibString.escapeJSON(v), '"}'
+        );
+    }
+
+    function _seed(address token, uint256 tokenId) private view returns (bytes32) {
+        (bytes32 value, bool isHash) = _param(token, tokenId, SEED_KEY);
+        if (uint256(value) != 0 && !isHash) return value;
+        return keccak256(abi.encodePacked(token, tokenId));
+    }
+
+    function _param(address token, uint256 tokenId, bytes32 key)
+        private
+        view
+        returns (bytes32 value, bool valueIsHash)
+    {
+        bool isSet;
+        (value, valueIsHash, isSet) = IAbxParams(token).tokenParam(tokenId, key);
+        if (isSet) return (value, valueIsHash);
+        (value, valueIsHash,) = IAbxParams(token).contractParam(key);
+        return (value, valueIsHash);
+    }
+}

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

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+/// @title IAbxFieldRenderer — the contract your in-chain art implements
+/// @notice A field renderer returns ONE metadata field's value, COMPUTED from chain state
+///         (the token's seed + PostParams, its owner, anything readable on-chain). The ABX
+///         metadata renderer staticcalls it to build `tokenURI` — e.g. an `image` renderer's
+///         SVG becomes `data:image/svg+xml;base64,…`. Deploy your renderer, then wire it with
+///         `abx deploy-code --image-renderer <address> [--attributes-renderer <address>] --onchain-uri`.
+///
+/// @dev THE FIVE INVARIANTS (a reverting or malformed renderer bricks the WHOLE tokenURI —
+///      the metadata renderer staticcalls you with NO try/catch):
+///        1. NEVER revert for ANY (token, tokenId, field) — including the collection surface
+///           `tokenId == type(uint256).max` (used by `contractURI`). Return a neutral value.
+///        2. Return the correct `contentType` (`image/svg+xml` for an image; `application/json`
+///           for an `attributes` array).
+///        3. Guard `field`: revert only a truly unsupported field (a deploy-time miswiring), but
+///           still never revert on the fields you DO render.
+///        4. `view` + deterministic: same chain state → same bytes.
+///        5. Bounded output: keep it small (a few hundred bytes of SVG) so `tokenURI` stays a
+///           cheap single eth_call. `forge test` the never-revert cases before you wire it.
+interface IAbxFieldRenderer {
+    /// @param token   the ABX collection contract (read its params via {IAbxParams}).
+    /// @param tokenId the token, or `type(uint256).max` for the collection surface.
+    /// @param field   which field to compute (e.g. `"image"`, `"attributes"`).
+    /// @return contentType MIME of `data` (e.g. `image/svg+xml`, `application/json`).
+    /// @return data        the field's finished bytes.
+    function render(address token, uint256 tokenId, bytes32 field)
+        external
+        view
+        returns (string memory contentType, bytes memory data);
+}

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

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+/// @title IAbxParams — read the token's on-chain params (seed + collector PostParams)
+/// @notice Your renderer reads live state through this. Each value is a `bytes32`; `isSet` tells
+///         you whether it exists (fall back to a default if not — see invariant #1). `valueIsHash`
+///         is true when the on-chain value is a keccak commitment to off-chain bytes (a literal
+///         scalar param like a `seed` or a `HexColor` palette is NOT a hash — check `!valueIsHash`).
+///
+///         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).
+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).
+    function tokenParam(uint256 tokenId, bytes32 key)
+        external
+        view
+        returns (bytes32 value, bool valueIsHash, bool isSet);
+
+    /// @notice The contract-scope (collection-wide) value — the fallback when a token has none.
+    function contractParam(bytes32 key)
+        external
+        view
+        returns (bytes32 value, bool valueIsHash, bool isSet);
+}

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

@@ -0,0 +1,110 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {Test} from "forge-std/Test.sol";
+import {MyRenderer} from "../src/MyRenderer.sol";
+import {MyTraits} from "../src/MyTraits.sol";
+import {IAbxParams} from "abx/IAbxParams.sol";
+
+/// A tiny stand-in for the ABX contract's param surface, so the renderers can be tested in
+/// isolation — set a seed / palette (or don't) and assert the renderer behaves.
+contract MockParams is IAbxParams {
+    mapping(uint256 => mapping(bytes32 => bytes32)) private tv;
+    mapping(uint256 => mapping(bytes32 => bool)) private ts;
+    mapping(bytes32 => bytes32) private cv;
+    mapping(bytes32 => bool) private cs;
+
+    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; }
+
+    function tokenParam(uint256 id, bytes32 key) external view returns (bytes32, bool, bool) {
+        return (tv[id][key], false, ts[id][key]);
+    }
+    function contractParam(bytes32 key) external view returns (bytes32, bool, bool) {
+        return (cv[key], false, cs[key]);
+    }
+}
+
+contract MyRendererTest is Test {
+    MyRenderer img;
+    MyTraits traits;
+    MockParams params;
+
+    bytes32 constant IMAGE = "image";
+    bytes32 constant ATTRIBUTES = "attributes";
+
+    function setUp() public {
+        img = new MyRenderer();
+        traits = new MyTraits();
+        params = new MockParams();
+    }
+
+    function _has(bytes memory hay, string memory needle) internal pure returns (bool) {
+        bytes memory n = bytes(needle);
+        if (n.length == 0 || hay.length < n.length) return n.length == 0;
+        for (uint256 i = 0; i <= hay.length - n.length; ++i) {
+            bool ok = true;
+            for (uint256 j = 0; j < n.length; ++j) if (hay[i + j] != n[j]) { ok = false; break; }
+            if (ok) return true;
+        }
+        return false;
+    }
+
+    function test_image_contentTypeAndSvg() public {
+        params.setToken(0, "seed", bytes32(uint256(0x1234)));
+        (string memory ct, bytes memory data) = img.render(address(params), 0, IMAGE);
+        assertEq(ct, "image/svg+xml");
+        assertTrue(_has(data, "<svg"));
+        assertTrue(_has(data, "</svg>"));
+    }
+
+    function test_palette_tintsTheImage() public {
+        params.setToken(0, "seed", bytes32(uint256(0x1234)));
+        params.setToken(0, "palette", bytes32(uint256(0xff3366))); // RGB in low 3 bytes
+        (, bytes memory data) = img.render(address(params), 0, IMAGE);
+        assertTrue(_has(data, "#ff3366"));
+    }
+
+    function test_neverReverts_noSeedNoPalette() public view {
+        // unset seed + palette → deterministic fallback, still a valid SVG, no revert
+        (string memory ct, bytes memory data) = img.render(address(params), 7, IMAGE);
+        assertEq(ct, "image/svg+xml");
+        assertTrue(_has(data, "<svg"));
+    }
+
+    function test_neverReverts_collectionSurface() public view {
+        // tokenId == type(uint256).max is the collection surface (contractURI) — MUST NOT revert
+        (string memory ct, bytes memory data) = img.render(address(params), type(uint256).max, IMAGE);
+        assertEq(ct, "image/svg+xml");
+        assertTrue(_has(data, "<svg"));
+    }
+
+    function test_unsupportedField_reverts() public {
+        vm.expectRevert(MyRenderer.UnsupportedField.selector);
+        img.render(address(params), 0, ATTRIBUTES);
+    }
+
+    function test_traits_coherentWithImage() public {
+        bytes32 seed = bytes32(uint256(0xABCDEF));
+        params.setToken(0, "seed", seed);
+        (string memory ct, bytes memory data) = traits.render(address(params), 0, ATTRIBUTES);
+        assertEq(ct, "application/json");
+        // Rings trait must equal the image's ring count: 3 + seed[0] % 6
+        uint256 rings = 3 + (uint8(seed[0]) % 6);
+        assertTrue(_has(data, string.concat('"value":"', vm.toString(rings), '"')));
+        assertTrue(_has(data, "Rings"));
+    }
+
+    function test_traits_collectionSurface_emptyArray() public view {
+        (, bytes memory data) = traits.render(address(params), type(uint256).max, ATTRIBUTES);
+        assertEq(string(data), "[]");
+    }
+
+    /// The whole point: render() must NOT revert for ANY seed / tokenId. A revert here bricks tokenURI.
+    function testFuzz_imageNeverReverts(uint256 tokenId, bytes32 seed, uint24 rgb) public {
+        params.setToken(tokenId, "seed", seed);
+        params.setToken(tokenId, "palette", bytes32(uint256(rgb)));
+        (, bytes memory data) = img.render(address(params), tokenId, IMAGE);
+        assertTrue(data.length > 0);
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,69 @@
+import { type ArweaveJwk, type ResolveStorageOptions } from '@artblocks/abx-storage';
+import { type Address } from '@artblocks/abx-sdk';
+export declare function dataDir(): string;
+/**
+ * Whether `baseUrl` is a localhost/loopback address — a URL that, once baked into an on-chain
+ * `tokenURI`/`contractURI`, resolves for NO ONE off this machine. The single source of truth for
+ * the off-chain-deploy refusal shared by `deploy`, `deploy-series`, and `deploy-code` (previously
+ * duplicated inline — that drift is exactly how `deploy-code` shipped without the guard).
+ */
+export declare function loopbackBaseUrl(baseUrl: string): boolean;
+/** Canonical clone factory for the active chain — flag override → `ABX_FACTORY` → manifest. */
+export declare function factoryAddress(override?: string): Address | null;
+/** Canonical Series clone factory — flag override → `ABX_SERIES_FACTORY` → manifest. */
+export declare function seriesFactoryAddress(override?: string): Address | null;
+/** Canonical on-chain metadata renderer — flag override → `ABX_RENDERER` → manifest. */
+export declare function rendererAddress(override?: string): Address | null;
+/** Canonical multi-chunk on-chain content store — flag override → `ABX_CHUNK_STORE` → manifest. */
+export declare function chunkStoreAddress(override?: string): Address | null;
+/** Canonical shared fixed-price minter — flag override → `ABX_FIXED_PRICE_MINTER` → manifest. */
+export declare function fixedPriceMinterAddress(override?: string): Address | null;
+/** Per-invocation storage overrides parsed from flags (e.g. `abx deploy --backend cloud --bucket …`). */
+export interface StorageOverrides {
+    backend?: string;
+    endpoint?: string;
+    bucket?: string;
+    region?: string;
+    prefix?: string;
+    publicBase?: string;
+    gateway?: string;
+    mode?: 'kubo' | 'pinata';
+    apiUrl?: string;
+    uploadUrl?: string;
+    provider?: 'turbo' | 'http-bundler';
+    /** Which identity signs Turbo (arweave) uploads + holds the credits: the CLI-managed Arweave key
+     *  (default) or the `.env` EVM signing key (`eth`). The browser-wallet identity is injected by
+     *  the deploy path, not chosen here. */
+    storageSigner?: 'arweave' | 'eth';
+}
+/** Resolve the storage-signer lane: flag → `ABX_STORAGE_SIGNER` → default `arweave`. */
+export declare function storageSignerChoice(ov?: StorageOverrides): 'arweave' | 'eth';
+/**
+ * Build the storage backend options the SDK needs, resolving **explicit override → env →
+ * default** for non-secret values; secrets come from env only. No persisted config layer — a
+ * flag or a declared env var is the only way to choose a backend, so nothing is hidden.
+ */
+export declare function storageOptions(ov?: StorageOverrides): ResolveStorageOptions;
+/** The active backend id, for display (no secrets, no construction). */
+export declare function activeBackendId(): string;
+/** Resolve the active backend id + where it came from — for transparent readouts. */
+export declare function backendResolution(ov?: StorageOverrides): {
+    backend: string;
+    source: 'flag' | 'env' | 'default';
+};
+/** Where the managed Turbo identity lives — for display ("back this up"). */
+export declare function arweaveKeyFilePath(): string;
+/**
+ * Load the Turbo identity if one exists — env inline secret, an explicit key-file path, or the
+ * managed location. **Never creates** (read-only paths like `serve`/`status` must not mint a key)
+ * and **never silently replaces** a corrupt key (that would strand its credits) — a bad key throws.
+ */
+export declare function loadArweaveJwk(): ArweaveJwk | undefined;
+/** Load or CREATE the managed Turbo identity, persisting a fresh key (0600) to the data dir. */
+export declare function ensureArweaveJwk(): {
+    jwk: ArweaveJwk;
+    address: string;
+    created: boolean;
+    path: string;
+};
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,UAAU,EACf,KAAK,qBAAqB,EAC3B,MAAM,wBAAwB,CAAC;AAChC,OAAO,EASL,KAAK,OAAO,EACb,MAAM,oBAAoB,CAAC;AAoB5B,wBAAgB,OAAO,IAAI,MAAM,CAEhC;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAExD;AAOD,+FAA+F;AAC/F,wBAAgB,cAAc,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAEhE;AAED,wFAAwF;AACxF,wBAAgB,oBAAoB,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAEtE;AAED,wFAAwF;AACxF,wBAAgB,eAAe,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAEjE;AAED,mGAAmG;AACnG,wBAAgB,iBAAiB,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAEnE;AAED,iGAAiG;AACjG,wBAAgB,uBAAuB,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAEzE;AAID,yGAAyG;AACzG,MAAM,WAAW,gBAAgB;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,GAAG,cAAc,CAAC;IACpC;;4CAEwC;IACxC,aAAa,CAAC,EAAE,SAAS,GAAG,KAAK,CAAC;CACnC;AAED,wFAAwF;AACxF,wBAAgB,mBAAmB,CAAC,EAAE,GAAE,gBAAqB,GAAG,SAAS,GAAG,KAAK,CAGhF;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,EAAE,GAAE,gBAAqB,GAAG,qBAAqB,CAgD/E;AAED,wEAAwE;AACxE,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAED,qFAAqF;AACrF,wBAAgB,iBAAiB,CAAC,EAAE,GAAE,gBAAqB,GAAG;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,CAAA;CAAC,CAIlH;AAaD,6EAA6E;AAC7E,wBAAgB,kBAAkB,IAAI,MAAM,CAE3C;AAOD;;;;GAIG;AACH,wBAAgB,cAAc,IAAI,UAAU,GAAG,SAAS,CAKvD;AAED,gGAAgG;AAChG,wBAAgB,gBAAgB,IAAI;IAAC,GAAG,EAAE,UAAU,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAQrG"}