@artblocks/abx-cli 0.1.0-alpha.5 → 0.1.0-alpha.50

package/dist/commands/project.d.ts

@@ -0,0 +1,431 @@
+import { type Address, type PublicClient, type MetadataField } from '@artblocks/abx-sdk';
+import { type Flags } from '../flags.js';
+import { type RemoteTarget } from '../remote.js';
+export declare function cmdPredict(flags: Flags): Promise<void>;
+export declare function cmdAdd(address: Address | undefined, flags: Flags): Promise<void>;
+export declare function cmdIndex(address: Address | undefined, flags: Flags): Promise<void>;
+export declare function cmdVerify(address: Address | undefined, flags: Flags): Promise<void>;
+export type AvailabilityStatus = 'available' | 'partial' | 'unavailable' | 'unknown';
+export interface AvailabilityVerdict {
+    status: AvailabilityStatus;
+    note: string;
+}
+/**
+ * Pure by design — every caller (`cmdVerifyBody`'s local lane and `cmdVerifyRemote`'s hosted lane)
+ * feeds it facts it already gathered rather than each re-deriving its own verdict, so the two
+ * lanes' JSON payloads read the same word for the same situation.
+ *
+ * `isCode` selects which signal decides the verdict: a code project's render presence
+ * (`minted`/`present`), or — for everything else — whether a byte-check actually ran
+ * (`anyCheck`) versus a locator this run could not independently re-hash (`unrecomputablePointers`).
+ * The two signals are never combined into one number on purpose: "3 of 5 renders present" and "2
+ * locator commitments unconfirmed" are different facts about different projects, and mixing them
+ * would produce a verdict that answers neither question honestly.
+ */
+export declare function computeAvailability(opts: {
+    isCode: boolean;
+    minted: number;
+    present: number;
+    anyCheck: boolean;
+    unrecomputablePointers: number;
+    onChainContent?: number;
+}): AvailabilityVerdict;
+export declare function onChainImageSource(fields: MetadataField[]): string | null;
+/**
+ * Does this token's `image` field carry a locator commitment `verifyProject` never produced a
+ * check for? Exported and pure (a plain `fields` array in, a verdict out — no chain, no indexer)
+ * so the three-way distinction is unit-testable directly, rather than only reachable through a
+ * full `cmdVerifyBody` run against real chain state.
+ *
+ * Returns the representation name to report (`ipfs`/`arweave`/`url`/`url-template`) when the image
+ * field is a bare locator, else `null` — including when there's no `image` field at all, which is
+ * "no commitment", a different fact from "an unrecomputable one".
+ */
+export declare function pointerOnlyImageCheck(fields: MetadataField[]): string | null;
+export declare function cmdVerifyBody(address: Address, flags: Flags, emit: (p: Record<string, unknown>) => void): Promise<void>;
+export declare function cmdVerifyRemote(address: Address, remote: RemoteTarget, emit: (p: Record<string, unknown>) => void): Promise<void>;
+/** What {@link reportRemoteByteIntegrity} found, structured for the JSON payload as well as its own
+ *  prose. `status` deliberately has a 4th value the local lane's `contentIntegrity` doesn't need:
+ *  `'not-checked'` — no credential, a rejected token, an older node with no `/verify` route, or an
+ *  unreachable endpoint. That is a DIFFERENT fact from `'no-commitments'` (the route answered and
+ *  said there's nothing to check) and must never collapse into it — "we didn't ask" and "we asked
+ *  and there was nothing" are different reasons for the same empty result. */
+export interface RemoteByteIntegrity {
+    status: 'ok' | 'mismatch' | 'no-commitments' | 'not-checked';
+    checks: Array<{
+        tokenId: string;
+        kind: string;
+        verified: boolean;
+    }>;
+}
+/**
+ * The half `abx verify --remote` was missing: do the served BYTES still hash to the on-chain
+ * commitment? Everything above it checks renders (is a thumbnail current, is it a placeholder) — a
+ * different question, and a green ✓ there was reading as "the image is correct" when the bytes could
+ * genuinely mismatch.
+ *
+ * The service is the right place to answer it: it holds both the bytes and the chain, and it already
+ * exposes exactly this check (`GET /api/project/:addr/verify`, bearer-gated because it triggers
+ * outbound fetches). When we can't reach that — no credential, or an older node — say plainly that
+ * byte integrity was NOT checked rather than leaving the ✓ above to imply it was.
+ */
+export declare function reportRemoteByteIntegrity(address: Address, remote: RemoteTarget, base: string, onChainRepresentations?: string[]): Promise<RemoteByteIntegrity>;
+export declare const STATE_ABI: readonly [{
+    readonly type: "function";
+    readonly name: "owner";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "totalSupply";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "nextTokenId";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "maxInvocations";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "paused";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "minter";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "primaryPayee";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "tokenURIRenderer";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "royaltyInfo";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+    }, {
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }, {
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "supportsInterface";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "bytes4";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "getTransferValidator";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "seedSource";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "tokenURILocked";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "contractURILocked";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "scriptLocked";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "dependenciesLocked";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "contractFieldLocked";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "bytes32";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}];
+/** The edition twin of {@link STATE_ABI} — `owner`/`maxInvocations`/`paused`/`minter`/
+ *  `primaryPayee`/`tokenURIRenderer`/`royaltyInfo` are shared, unchanged, function names (see
+ *  `kind.ts`'s own note on why); `totalSupply`/`maxSupply` take an id. The creator-token probe is
+ *  ALSO shared, unchanged: Limit Break uses the identical `ICreatorToken` ERC-165 id (0xad0d7f6c)
+ *  and `getTransferValidator()` surface for 721C and 1155C, and `CreatorToken1155` advertises them
+ *  the same way when enrolled — so an enrolled edition reports its validator exactly like a 721. */
+export declare const EDITION_STATE_ABI: readonly [{
+    readonly type: "function";
+    readonly name: "owner";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "maxInvocations";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "totalSupply";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "maxSupply";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "paused";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "minter";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "primaryPayee";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "tokenURIRenderer";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "royaltyInfo";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+    }, {
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }, {
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "supportsInterface";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "bytes4";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "getTransferValidator";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "seedSource";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "tokenURILocked";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "contractURILocked";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "scriptLocked";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "dependenciesLocked";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "contractFieldLocked";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "bytes32";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}];
+/** One boolean lock, tri-state: `true` (frozen forever) · `false` (open — the owner can still
+ *  change it) · `null` (the read failed — an RPC refusal, or a wrong dialect). Never collapse
+ *  `null` into `false`: an unread lock is not proof it's off, and `state`'s whole job here is to
+ *  keep that distinction visible all the way to the JSON payload. */
+type LockRead = boolean | null;
+/** Every irreversible lock a collection can carry, as read straight from chain. */
+export interface CollectionLocks {
+    tokenURI: LockRead;
+    contractURI: LockRead;
+    /** The bounded METADATA_FIELD scan — see {@link readFieldLocks}'s doc for the caveat this carries. */
+    fields: {
+        field: string;
+        locked: LockRead;
+    }[];
+    /** `null` (the OBJECT, not the inner `locked`) ⇒ not applicable: this contract has no on-chain
+     *  script surface at all (not a code project), a different fact from "unknown" ({@link LockRead}'s
+     *  `null`), which is reserved for "the surface exists but the read failed". */
+    script: {
+        locked: LockRead;
+    } | null;
+    dependencies: {
+        locked: LockRead;
+    } | null;
+}
+/**
+ * Read every applicable irreversible lock for one collection: token/contract URI config, the
+ * bounded standard field set, and — for a code project — the script and dependency freezes.
+ * `paramHooks.locked` is deliberately NOT read here: `cmdStateBody`/`cmdStateEditionBody` already
+ * read it (`readParamHooksLocked`) as part of the existing param-hooks readout, and re-reading it
+ * would cost a second `eth_call` for a fact already on hand — see the callers, which pass it into
+ * {@link printLocks} instead.
+ *
+ * `isCode` gates `scriptLocked`/`dependenciesLocked`: those getters exist ONLY on the two code
+ * twins (SeriesCode/EditionCode), so asking a plain image/Series contract for them isn't a failed
+ * read to report as "unknown" — it's a surface that was never there, reported as `null` (not
+ * applicable) via the OUTER object rather than the boolean inside it.
+ */
+export declare function readCollectionLocks(publicClient: PublicClient, address: Address, abi: readonly unknown[], isCode: boolean): Promise<CollectionLocks>;
+export declare function cmdState(address: Address | undefined, flags: Flags): Promise<void>;
+export declare function cmdStateBody(address: Address, flags: Flags, emit: (p: Record<string, unknown>) => void): Promise<void>;
+/**
+ * `abx status [address] [--remote [name|url]] [--watch]` — INDEXING status: where a project sits in
+ * the lifecycle (`queued | backfilling | live | stale | failed`) and how far behind head it is.
+ *
+ * One vocabulary for both sides of the membrane, which is the point: bare = this node, `--remote` =
+ * ask the service, and the same five words either way. Distinct from `abx state <address>`, which
+ * reads the CHAIN (owner, royalty, locks) and knows nothing about who is serving it.
+ */
+export declare function cmdStatus(address: Address | undefined, flags: Flags): Promise<void>;
+/** The `--remote` half of {@link cmdStatus}: one project, or the roll-up for every project the token
+ *  can see. `--watch` tails until everything reaches a terminal state. */
+export declare function cmdStatusRemote(address: Address | undefined, remote: RemoteTarget, flags: Flags): Promise<void>;
+export declare function cmdForget(address: Address | undefined, flags: Flags): Promise<void>;
+export {};
+//# sourceMappingURL=project.d.ts.map

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

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