@artblocks/abx-sdk 0.1.0-alpha.0

package/dist/generator.d.ts

@@ -0,0 +1,129 @@
+/**
+ * The canonical on-chain generator — `AbxGenerator` (specs/protocol/code-projects.md →
+ * "The canonical generator"). One field renderer for the `animation_url` field serving both
+ * code custody modes: **template** (script chunks → the full HTML document, chain-complete
+ * when every dependency resolves to on-chain bytes) and **directory** (`code` field → a
+ * parameterized gateway URL, `text/uri-list` → landed verbatim by the metadata renderer).
+ *
+ * The view surface here is hand-written (the generator isn't a factory-synced artifact —
+ * it's a per-chain singleton recorded in the deployments manifest; see `resolveGenerator`).
+ * `onChainStatus` is the honesty read `abx verify` consumes.
+ */
+import type { Address } from 'viem';
+/** The generator's view surface (IAbxFieldRenderer + the honesty/piecewise reads). */
+export declare const abxGeneratorAbi: readonly [{
+    readonly type: "function";
+    readonly name: "render";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "token";
+        readonly type: "address";
+    }, {
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "field";
+        readonly type: "bytes32";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "contentType";
+        readonly type: "string";
+    }, {
+        readonly name: "data";
+        readonly type: "bytes";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "onChainStatus";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "token";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "branch";
+        readonly type: "uint8";
+    }, {
+        readonly name: "chainComplete";
+        readonly type: "bool";
+    }, {
+        readonly name: "unresolvedRefs";
+        readonly type: "bytes32[]";
+    }, {
+        readonly name: "urlOverBudget";
+        readonly type: "bool";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "document";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "token";
+        readonly type: "address";
+    }, {
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "tokenDataJson";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "token";
+        readonly type: "address";
+    }, {
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "dependencyTag";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "token";
+        readonly type: "address";
+    }, {
+        readonly name: "index";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+    }];
+}];
+/** `AbxGenerator`'s branch constants, by index: 0 = none, 1 = template, 2 = directory. */
+export declare const GENERATOR_BRANCHES: readonly ["none", "template", "directory"];
+export type GeneratorBranch = (typeof GENERATOR_BRANCHES)[number];
+/** The generator's URL size budget for the directory branch (gateway request-line cap). */
+export declare const GENERATOR_URL_BUDGET_BYTES = 8192;
+/** The decoded `onChainStatus` read — the `abx verify` / marketplace-tooling surface. */
+export interface GeneratorStatus {
+    branch: number;
+    branchName: GeneratorBranch;
+    /** Template branch with EVERY dependency resolved to proven on-chain bytes. Always false off it. */
+    chainComplete: boolean;
+    /** Refs that emit `<!-- abx:unresolved … -->` markers, decoded to their readable tags. */
+    unresolvedRefs: string[];
+    /** Directory branch: the emitted URL exceeds the 8KB budget. Always false off it. */
+    urlOverBudget: boolean;
+}
+/** The one read this module needs — structurally satisfied by a viem `PublicClient` or a test mock. */
+export interface GeneratorReadClient {
+    readContract(args: {
+        address: Address;
+        abi: readonly unknown[];
+        functionName: string;
+        args: readonly unknown[];
+    }): Promise<unknown>;
+}
+/** eth_call `generator.onChainStatus(token)` and decode it (branch name + readable refs). */
+export declare function readGeneratorStatus(client: GeneratorReadClient, generator: Address, token: Address): Promise<GeneratorStatus>;
+//# sourceMappingURL=generator.d.ts.map

package/dist/generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../src/generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAC,OAAO,EAAM,MAAM,MAAM,CAAC;AAGvC,sFAAsF;AACtF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyDlB,CAAC;AAEX,0FAA0F;AAC1F,eAAO,MAAM,kBAAkB,4CAA6C,CAAC;AAC7E,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAC;AAElE,2FAA2F;AAC3F,eAAO,MAAM,0BAA0B,OAAO,CAAC;AAE/C,yFAAyF;AACzF,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,eAAe,CAAC;IAC5B,oGAAoG;IACpG,aAAa,EAAE,OAAO,CAAC;IACvB,0FAA0F;IAC1F,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,qFAAqF;IACrF,aAAa,EAAE,OAAO,CAAC;CACxB;AAED,uGAAuG;AACvG,MAAM,WAAW,mBAAmB;IAClC,YAAY,CAAC,IAAI,EAAE;QACjB,OAAO,EAAE,OAAO,CAAC;QACjB,GAAG,EAAE,SAAS,OAAO,EAAE,CAAC;QACxB,YAAY,EAAE,MAAM,CAAC;QACrB,IAAI,EAAE,SAAS,OAAO,EAAE,CAAC;KAC1B,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACtB;AAED,6FAA6F;AAC7F,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,mBAAmB,EAC3B,SAAS,EAAE,OAAO,EAClB,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,eAAe,CAAC,CAc1B"}

package/dist/generator.js

@@ -0,0 +1,81 @@
+import { decodeTag } from './spine.js';
+/** The generator's view surface (IAbxFieldRenderer + the honesty/piecewise reads). */
+export const abxGeneratorAbi = [
+    {
+        type: 'function',
+        name: 'render',
+        stateMutability: 'view',
+        inputs: [
+            { name: 'token', type: 'address' },
+            { name: 'tokenId', type: 'uint256' },
+            { name: 'field', type: 'bytes32' },
+        ],
+        outputs: [
+            { name: 'contentType', type: 'string' },
+            { name: 'data', type: 'bytes' },
+        ],
+    },
+    {
+        type: 'function',
+        name: 'onChainStatus',
+        stateMutability: 'view',
+        inputs: [{ name: 'token', type: 'address' }],
+        outputs: [
+            { name: 'branch', type: 'uint8' },
+            { name: 'chainComplete', type: 'bool' },
+            { name: 'unresolvedRefs', type: 'bytes32[]' },
+            { name: 'urlOverBudget', type: 'bool' },
+        ],
+    },
+    {
+        type: 'function',
+        name: 'document',
+        stateMutability: 'view',
+        inputs: [
+            { name: 'token', type: 'address' },
+            { name: 'tokenId', type: 'uint256' },
+        ],
+        outputs: [{ name: '', type: 'string' }],
+    },
+    {
+        type: 'function',
+        name: 'tokenDataJson',
+        stateMutability: 'view',
+        inputs: [
+            { name: 'token', type: 'address' },
+            { name: 'tokenId', type: 'uint256' },
+        ],
+        outputs: [{ name: '', type: 'string' }],
+    },
+    {
+        type: 'function',
+        name: 'dependencyTag',
+        stateMutability: 'view',
+        inputs: [
+            { name: 'token', type: 'address' },
+            { name: 'index', type: 'uint256' },
+        ],
+        outputs: [{ name: '', type: 'string' }],
+    },
+];
+/** `AbxGenerator`'s branch constants, by index: 0 = none, 1 = template, 2 = directory. */
+export const GENERATOR_BRANCHES = ['none', 'template', 'directory'];
+/** The generator's URL size budget for the directory branch (gateway request-line cap). */
+export const GENERATOR_URL_BUDGET_BYTES = 8192;
+/** eth_call `generator.onChainStatus(token)` and decode it (branch name + readable refs). */
+export async function readGeneratorStatus(client, generator, token) {
+    const [branch, chainComplete, unresolvedRefs, urlOverBudget] = (await client.readContract({
+        address: generator,
+        abi: abxGeneratorAbi,
+        functionName: 'onChainStatus',
+        args: [token],
+    }));
+    return {
+        branch: Number(branch),
+        branchName: GENERATOR_BRANCHES[Number(branch)] ?? 'none',
+        chainComplete,
+        unresolvedRefs: unresolvedRefs.map((ref) => decodeTag(ref)),
+        urlOverBudget,
+    };
+}
+//# sourceMappingURL=generator.js.map

package/dist/generator.js.map

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

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @artblocks/abx-sdk — Layer 2, the neutral low-level library.
+ *
+ * Turns ABX protocol operations into typed function calls: deploy, reconstruct
+ * from chain, resolve a token, verify content. It picks no provider, no UX, and
+ * (beyond a default chain target) no chain. Everything here is something a
+ * builder could re-derive from the contracts alone — the SDK exists so they
+ * don't have to. The Self-Host Toolkit and any competing provider import this
+ * same public library.
+ */
+export type { Address, Hex, PublicClient, WalletClient, Account } from 'viem';
+export * from './types.js';
+export * from './spine.js';
+export * from './chains.js';
+export * from './clients.js';
+export * from './deploy.js';
+export * from './ops.js';
+export * from './reconstruct.js';
+export * from './tokendata.js';
+export * from './probe.js';
+export * from './token.js';
+export * from './traits.js';
+export * from './fastlz.js';
+export * from './chunks.js';
+export * from './create2.js';
+export * from './deployments.js';
+export * from './deps.js';
+export * from './generator.js';
+export { loadDotEnv } from './env.js';
+export { oneOfOneImageAbi, oneOfOneImageFactoryAbi, seriesImageAbi, seriesImageFactoryAbi, seriesCodeAbi, seriesCodeFactoryAbi, abxSeedSourceAbi, abxMetadataRendererAbi, abxChunkStoreAbi, abxFixedPriceMinterAbi, spineEventAbi, } from './abi/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,YAAY,EAAC,OAAO,EAAE,GAAG,EAAE,YAAY,EAAE,YAAY,EAAE,OAAO,EAAC,MAAM,MAAM,CAAC;AAE5E,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC;AAC/B,OAAO,EAAC,UAAU,EAAC,MAAM,UAAU,CAAC;AACpC,OAAO,EACL,gBAAgB,EAChB,uBAAuB,EACvB,cAAc,EACd,qBAAqB,EACrB,aAAa,EACb,oBAAoB,EACpB,gBAAgB,EAChB,sBAAsB,EACtB,gBAAgB,EAChB,sBAAsB,EACtB,aAAa,GACd,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,20 @@
+export * from './types.js';
+export * from './spine.js';
+export * from './chains.js';
+export * from './clients.js';
+export * from './deploy.js';
+export * from './ops.js';
+export * from './reconstruct.js';
+export * from './tokendata.js';
+export * from './probe.js';
+export * from './token.js';
+export * from './traits.js';
+export * from './fastlz.js';
+export * from './chunks.js';
+export * from './create2.js';
+export * from './deployments.js';
+export * from './deps.js';
+export * from './generator.js';
+export { loadDotEnv } from './env.js';
+export { oneOfOneImageAbi, oneOfOneImageFactoryAbi, seriesImageAbi, seriesImageFactoryAbi, seriesCodeAbi, seriesCodeFactoryAbi, abxSeedSourceAbi, abxMetadataRendererAbi, abxChunkStoreAbi, abxFixedPriceMinterAbi, spineEventAbi, } from './abi/index.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC;AAC/B,OAAO,EAAC,UAAU,EAAC,MAAM,UAAU,CAAC;AACpC,OAAO,EACL,gBAAgB,EAChB,uBAAuB,EACvB,cAAc,EACd,qBAAqB,EACrB,aAAa,EACb,oBAAoB,EACpB,gBAAgB,EAChB,sBAAsB,EACtB,gBAAgB,EAChB,sBAAsB,EACtB,aAAa,GACd,MAAM,gBAAgB,CAAC"}

package/dist/ops.d.ts

@@ -0,0 +1,379 @@
+import { type Address, type Hex } from 'viem';
+import type { OneOfOneInitParams, SeriesCodeInitParams, SeriesInitParams } from './deploy.js';
+/**
+ * An unsigned, ready-to-sign transaction — the SDK's neutral output for every
+ * write. It carries only the data needed to sign (`to`/`data`/`value`/`chainId`)
+ * plus a human layer (`summary`/`fields`) so a UX can show the *intention*, not
+ * hex. Signing is the caller's job: an env key, a browser wallet, a multisig —
+ * the SDK takes no custody and broadcasts nothing.
+ *
+ * `to` is `null` for a contract-creation tx (the factory deploy).
+ */
+export interface PreparedTx {
+    op: string;
+    to: Address | null;
+    data: Hex;
+    value: Hex;
+    chainId: number;
+    summary: string;
+    fields: Record<string, string>;
+}
+/**
+ * Batch several ops into ONE atomic transaction via the target's
+ * `Multicallable.multicall`. This is how a human applies many owner ops — set several
+ * fields, point a renderer, lock — in a single signature instead of N transactions.
+ *
+ * Security: a multicall is *exactly* equivalent to sending each op individually from
+ * the same signer — it grants no extra authority (each subcall re-runs its own
+ * `onlyOwner`/lock checks under the preserved `msg.sender`) and it's all-or-nothing
+ * (any revert bubbles, so nothing partially applies). Enforced here:
+ *   - every op MUST target the same contract — `multicall` `delegatecall`s into the
+ *     contract itself, so it can only batch that contract's own functions (it is NOT a
+ *     cross-contract call primitive; spanning contracts is the *account's* job — an
+ *     EIP-7702 EOA, ERC-4337 account, or Safe);
+ *   - every op MUST be value-free — `multicall` reverts on non-zero `msg.value` (the
+ *     classic multicall double-spend guard), and no ABX op carries value anyway.
+ */
+export declare function prepareMulticall(args: {
+    ops: PreparedTx[];
+    chainId?: number;
+    summary?: string;
+}): PreparedTx;
+/**
+ * Collapse a list of ops into the minimal transaction set: same-target runs of ≥2 ops
+ * become one `multicall`, lone ops pass through untouched, and contract-creation txs
+ * (`to === null`, e.g. a factory/renderer/store deploy) are never folded. Order is
+ * preserved — important when a later op depends on an earlier one's effect — so a run is
+ * only merged while the target stays the same. This is what turns "6 owner edits" into
+ * "1 transaction" for the UX, while staying honest about what genuinely needs its own tx.
+ */
+export declare function batchOps(ops: PreparedTx[]): PreparedTx[];
+/** Transfer a token to a new holder (a sale/gift settlement). Signer must be `from`. */
+export declare function prepareTransfer(args: {
+    contract: Address;
+    from: Address;
+    to: Address;
+    tokenId: bigint | number;
+    chainId: number;
+}): PreparedTx;
+/**
+ * Mint the single token (id 0) to `to`. Owner-only and one-shot — for deferred
+ * issuance: deploy first (warm the resolver at the known address), then mint, or
+ * mint straight to a buyer on a primary sale. Signer must be the owner.
+ */
+export declare function prepareMint(args: {
+    contract: Address;
+    to: Address;
+    chainId: number;
+}): PreparedTx;
+/** Re-point a token's resolver BASE (move the resolver). The per-token pointer is derived
+ *  on-chain as `{base}/{chainId}/{address}/{tokenId}`. Affects every token without an
+ *  override. Signer must be the owner. */
+export declare function prepareSetTokenURIBase(args: {
+    contract: Address;
+    base: string;
+    chainId: number;
+}): PreparedTx;
+/** Set (or clear, with "") a per-token full-URI override — a fixed locator (e.g. `ipfs://`)
+ *  that wins over the derived base path for one token. Signer must be the owner. */
+export declare function prepareSetTokenURIOverride(args: {
+    contract: Address;
+    tokenId: number | bigint;
+    uri: string;
+    chainId: number;
+}): PreparedTx;
+/** Re-point the collection (ERC-7572) resolver BASE; derived on-chain as
+ *  `{base}/{chainId}/{address}`. Signer must be the owner. */
+export declare function prepareSetContractURIBase(args: {
+    contract: Address;
+    base: string;
+    chainId: number;
+}): PreparedTx;
+/** Set (or clear, with "") the collection's full-URI override — a fixed locator that wins
+ *  over the derived base. Signer must be the owner. */
+export declare function prepareSetContractURIOverride(args: {
+    contract: Address;
+    uri: string;
+    chainId: number;
+}): PreparedTx;
+/**
+ * Set (or clear) the token's on-chain URI renderer — the toggle between off-chain
+ * resolution (`renderer == 0x0`, use the stored `tokenURI`) and on-chain resolution
+ * (a non-zero `IAbxMetadataRenderer` that assembles the JSON from on-chain fields).
+ * Signer must be the owner; reverts if the URI config is locked.
+ */
+export declare function prepareSetTokenURIRenderer(args: {
+    contract: Address;
+    renderer: Address;
+    chainId: number;
+}): PreparedTx;
+/** Set (or clear) the collection's on-chain URI renderer. Signer must be the owner. */
+export declare function prepareSetContractURIRenderer(args: {
+    contract: Address;
+    renderer: Address;
+    chainId: number;
+}): PreparedTx;
+/** Freeze the token-URI config (pointer + renderer) forever. Irreversible. Signer = owner. */
+export declare function prepareLockTokenURI(args: {
+    contract: Address;
+    chainId: number;
+}): PreparedTx;
+/** Freeze the collection-URI config forever. Irreversible. Signer = owner. */
+export declare function prepareLockContractURI(args: {
+    contract: Address;
+    chainId: number;
+}): PreparedTx;
+/** Set the contract-wide default royalty. Signer must be the owner. */
+export declare function prepareSetRoyalty(args: {
+    contract: Address;
+    receiver: Address;
+    bps: number;
+    chainId: number;
+}): PreparedTx;
+/**
+ * Set/replace an on-chain metadata field for a token. `field` is what (e.g. "image",
+ * "description"), `representation` is how it's carried (e.g. "inline", "keccak256",
+ * "arweave"), `value` is the bytes. Reverts once the field is locked. Signer = owner.
+ */
+export declare function prepareSetTokenField(args: {
+    contract: Address;
+    tokenId: bigint | number;
+    field: string;
+    representation: string;
+    value: Hex;
+    chainId: number;
+}): PreparedTx;
+/** Freeze a token field forever, across all its representations (irreversible). Signer = owner. */
+export declare function prepareLockTokenField(args: {
+    contract: Address;
+    tokenId: bigint | number;
+    field: string;
+    chainId: number;
+}): PreparedTx;
+/** Set/replace a collection (contract-wide) on-chain metadata field. Signer = owner. */
+export declare function prepareSetContractField(args: {
+    contract: Address;
+    field: string;
+    representation: string;
+    value: Hex;
+    chainId: number;
+}): PreparedTx;
+/** Freeze a collection field forever (irreversible). Signer = owner. */
+export declare function prepareLockContractField(args: {
+    contract: Address;
+    field: string;
+    chainId: number;
+}): PreparedTx;
+/** Transfer contract ownership (admin). Signer must be the current owner. */
+export declare function prepareTransferOwnership(args: {
+    contract: Address;
+    newOwner: Address;
+    chainId: number;
+}): PreparedTx;
+/**
+ * The unsigned form of the genesis deploy: a `deployDeterministic(params, salt)`
+ * call on the factory. The clone address is deterministic in (factory, salt) — a
+ * pure function of the salt, independent of the signer — so the URIs in `params`
+ * can be baked to point at the predicted address before anyone connects (see
+ * `predictClone`). `params.mintTo` decides whether the token mints in this tx or
+ * is deferred to a later `mint`. Building the URIs is the caller's job.
+ */
+export declare function prepareDeployOneOfOne(args: {
+    factory: Address;
+    params: OneOfOneInitParams;
+    salt: Hex;
+    chainId: number;
+    clone: Address;
+}): PreparedTx;
+/** The unsigned form of the factory (trust-anchor) deploy — a contract creation. */
+export declare function prepareDeployFactory(args: {
+    chainId: number;
+}): PreparedTx;
+/** The unsigned form of the canonical metadata-renderer deploy — a contract creation. */
+export declare function prepareDeployRenderer(args: {
+    chainId: number;
+}): PreparedTx;
+/**
+ * Mint the next sequential token on a Series (its metadata is its token id). Reverts when
+ * sold out.
+ */
+export declare function prepareSeriesMint(args: {
+    contract: Address;
+    to: Address;
+    chainId: number;
+}): PreparedTx;
+/** Mint `count` Series tokens in order in one tx — N individual `Transfer`s. */
+export declare function prepareSeriesMintMany(args: {
+    contract: Address;
+    to: Address;
+    count: bigint | number;
+    chainId: number;
+}): PreparedTx;
+/**
+ * Set (or clear, with `0x0`) the single authorized minter. Setting a new minter atomically
+ * replaces any previous one; `0x0` clears it (back to owner-only). Signer must be the owner.
+ */
+export declare function prepareSetMinter(args: {
+    contract: Address;
+    minter: Address;
+    chainId: number;
+}): PreparedTx;
+/** Lower the supply cap (monotonic — never raises, never below the minted count). Signer = owner. */
+export declare function prepareSetMaxInvocations(args: {
+    contract: Address;
+    maxInvocations: bigint | number;
+    chainId: number;
+}): PreparedTx;
+/** Pause or unpause minting. While paused only the owner may mint (reserves/config); unpausing
+ *  opens it to the authorized minter. Signer must be the owner. */
+export declare function prepareSetPaused(args: {
+    contract: Address;
+    paused: boolean;
+    chainId: number;
+}): PreparedTx;
+/** Set (or clear, with `0x0`) the primary-sale payout destination. Signer = owner. */
+export declare function prepareSetPrimaryPayee(args: {
+    contract: Address;
+    payee: Address;
+    chainId: number;
+}): PreparedTx;
+/** The unsigned form of a Series genesis deploy — `deployDeterministic(params, salt)` on the Series factory. */
+export declare function prepareDeploySeries(args: {
+    factory: Address;
+    params: SeriesInitParams;
+    salt: Hex;
+    chainId: number;
+    clone: Address;
+}): PreparedTx;
+/** The unsigned form of the Series factory (trust-anchor) deploy — a contract creation. */
+export declare function prepareDeploySeriesFactory(args: {
+    chainId: number;
+}): PreparedTx;
+/**
+ * Set/update a project's fixed-price sale on the shared minter. Signer must be the ABX
+ * token's owner. `paymentToken == 0x0` prices the sale in ETH; otherwise it's that ERC-20.
+ * `price` is raw units per token; `allocation` is the max this minter may sell (its budget,
+ * distinct from the token's own `maxInvocations` cap). Enabling the sale is separate from
+ * granting mint rights — also `prepareSetMinter(token, minter)`.
+ */
+export declare function prepareConfigureSale(args: {
+    minter: Address;
+    token: Address;
+    paymentToken?: Address;
+    price: bigint | number;
+    allocation: bigint | number;
+    chainId: number;
+}): PreparedTx;
+/**
+ * Buy one token from the shared minter. `to` omitted → minted to the signer (`purchase`);
+ * `to` set → minted to that address (`purchaseTo`). `value` is the ETH to attach (equal to
+ * the sale price for an ETH sale; `0` for an ERC-20 sale, where the buyer must have approved
+ * the minter to pull `price` beforehand). Public — no owner rights needed.
+ */
+export declare function preparePurchase(args: {
+    minter: Address;
+    token: Address;
+    to?: Address;
+    value?: bigint | number;
+    chainId: number;
+}): PreparedTx;
+/** The unsigned form of the shared fixed-price minter deploy — a contract creation. */
+export declare function prepareDeployFixedPriceMinter(args: {
+    chainId: number;
+}): PreparedTx;
+/** Deterministic deploy of a {SeriesCode} clone — the code-project factory op. */
+export declare function prepareDeploySeriesCode(args: {
+    factory: Address;
+    params: SeriesCodeInitParams;
+    salt: Hex;
+    chainId: number;
+    clone: Address;
+}): PreparedTx;
+/** The code project's post-deploy setup: script chunks + PostParam schemas (+ dependency
+ *  declarations, when the project has any; + the on-chain-URI legs under `--onchain-uri`),
+ *  one atomic multicall. */
+export declare function prepareCodeSetup(args: {
+    contract: Address;
+    calls: Hex[];
+    chainId: number;
+    chunkCount: number;
+    schemaKeys: string[];
+    deps?: string[];
+    onchainUri?: boolean;
+}): PreparedTx;
+/** Set/replace the dependency at `index` — `resolution` 0 = Registry (`ref` = readable
+ *  `name@version` bytes32), 1 = OnChain (`ref` = a data-contract address, left-aligned).
+ *  Encode the pair with `parseDependencyRef`. Signer must be the owner. */
+export declare function prepareSetDependency(args: {
+    contract: Address;
+    index: bigint | number;
+    resolution: 0 | 1;
+    ref: Hex;
+    display?: string;
+    chainId: number;
+}): PreparedTx;
+/** Remove the LAST dependency (the list stays dense — order is load-bearing). Signer = owner. */
+export declare function prepareRemoveLastDependency(args: {
+    contract: Address;
+    chainId: number;
+}): PreparedTx;
+/** Set (or clear, with `0x0`) the soft, non-validating dependency registry pointer —
+ *  what `name@version` refs resolve through. Signer must be the owner. */
+export declare function prepareSetDependencyRegistry(args: {
+    contract: Address;
+    registry: Address;
+    chainId: number;
+}): PreparedTx;
+/** Freeze the dependency set (list + registry pointer) forever. Irreversible. Signer = owner. */
+export declare function prepareLockDependencies(args: {
+    contract: Address;
+    chainId: number;
+}): PreparedTx;
+/** Set a CONTRACT-scope param to a literal `bytes32` (the raw owner setter — Params base).
+ *  Only for schema-less keys (a schema'd key closes the raw path: `SchemaGoverned`). This is
+ *  the write behind well-known contract params like `params.keys` / `display.gateway`.
+ *  Signer must be the owner. */
+export declare function prepareSetContractParam(args: {
+    contract: Address;
+    key: string;
+    value: Hex;
+    display?: string;
+    chainId: number;
+}): PreparedTx;
+/** Set a CONTRACT-scope param via the data path (one blob; the evented value is its keccak256).
+ *  The raw owner setter for schema-less keys — the long-form twin of {@link prepareSetContractParam}. */
+export declare function prepareSetContractParamData(args: {
+    contract: Address;
+    key: string;
+    data: Hex;
+    chainId: number;
+}): PreparedTx;
+/** Wire the three param-lifecycle hook addresses (configure/augment/transfer) in ONE owner call.
+ *  The contract has no per-hook setter — `setParamHooks` writes all three at once — so a caller
+ *  changing one hook must pass the CURRENT values for the other two (read them via `paramHooks()`),
+ *  else it silently clears them. `zeroAddress` for any role means "no hook". SeriesCode only. */
+export declare function prepareSetParamHooks(args: {
+    contract: Address;
+    configureHook: Address;
+    augmentHook: Address;
+    transferHook: Address;
+    chainId: number;
+}): PreparedTx;
+/** Set a schema-governed PostParam (literal scalar) — signer must satisfy the schema's auth. */
+export declare function prepareConfigureTokenParam(args: {
+    contract: Address;
+    tokenId: bigint;
+    key: string;
+    value: Hex;
+    display: string;
+    chainId: number;
+}): PreparedTx;
+/** Set a schema-governed `String`/`Bytes` PostParam (the data path — one blob, hash evented). */
+export declare function prepareConfigureTokenParamData(args: {
+    contract: Address;
+    tokenId: bigint;
+    key: string;
+    data: Hex;
+    chainId: number;
+}): PreparedTx;
+//# sourceMappingURL=ops.d.ts.map