@artblocks/abx-sdk 0.1.0-alpha.0

package/dist/ops.js

@@ -0,0 +1,811 @@
+import { encodeFunctionData, toHex, zeroAddress } from 'viem';
+import { oneOfOneImageAbi, oneOfOneImageFactoryAbi, oneOfOneImageFactoryBytecode, seriesImageAbi, seriesImageFactoryAbi, seriesImageFactoryBytecode, abxMetadataRendererBytecode, abxFixedPriceMinterAbi, abxFixedPriceMinterBytecode, seriesCodeAbi, seriesCodeFactoryAbi, } from './abi/index.js';
+import { encodeTag } from './spine.js';
+const ZERO_VALUE = '0x0';
+function short(addr) {
+    return addr.length > 12 ? `${addr.slice(0, 6)}…${addr.slice(-4)}` : addr;
+}
+/** The `Multicallable.multicall` fragment — identical on every ABX contract (the token
+ *  and the chunk store both inherit Solady's `Multicallable`), so one fragment batches
+ *  for any target. */
+const MULTICALL_ABI = [
+    {
+        type: 'function',
+        name: 'multicall',
+        stateMutability: 'payable',
+        inputs: [{ name: 'data', type: 'bytes[]' }],
+        outputs: [{ name: 'results', type: 'bytes[]' }],
+    },
+];
+/**
+ * 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 function prepareMulticall(args) {
+    const { ops } = args;
+    if (ops.length === 0)
+        throw new Error('prepareMulticall: no ops to batch');
+    const to = ops[0].to;
+    if (to === null)
+        throw new Error('prepareMulticall: cannot batch a contract-creation tx');
+    for (const o of ops) {
+        if (o.to !== to) {
+            throw new Error('prepareMulticall: all ops must target the same contract (multicall is delegatecall-to-self, not a cross-contract call)');
+        }
+        if (o.value !== ZERO_VALUE) {
+            throw new Error(`prepareMulticall: op "${o.op}" carries value; multicall must be value-free`);
+        }
+    }
+    return {
+        op: 'multicall',
+        to,
+        data: encodeFunctionData({
+            abi: MULTICALL_ABI,
+            functionName: 'multicall',
+            args: [ops.map((o) => o.data)],
+        }),
+        value: ZERO_VALUE,
+        chainId: args.chainId ?? ops[0].chainId,
+        summary: args.summary ?? `Batch ${ops.length} ops in one tx (${ops.map((o) => o.op).join(', ')})`,
+        fields: { contract: to, batched: String(ops.length), ops: ops.map((o) => o.op).join(',') },
+    };
+}
+/**
+ * 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 function batchOps(ops) {
+    const out = [];
+    let run = [];
+    const flush = () => {
+        if (run.length === 1)
+            out.push(run[0]);
+        else if (run.length > 1)
+            out.push(prepareMulticall({ ops: run }));
+        run = [];
+    };
+    for (const op of ops) {
+        const mergeable = op.to !== null && op.value === ZERO_VALUE;
+        if (mergeable && run.length > 0 && run[0].to === op.to) {
+            run.push(op);
+        }
+        else {
+            flush();
+            run = mergeable ? [op] : [];
+            if (!mergeable)
+                out.push(op); // standalone (creation or value-bearing)
+        }
+    }
+    flush();
+    return out;
+}
+/** Transfer a token to a new holder (a sale/gift settlement). Signer must be `from`. */
+export function prepareTransfer(args) {
+    const id = BigInt(args.tokenId);
+    return {
+        op: 'transfer',
+        to: args.contract,
+        data: encodeFunctionData({
+            abi: oneOfOneImageAbi,
+            functionName: 'safeTransferFrom',
+            args: [args.from, args.to, id],
+        }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: `Transfer token #${id} → ${short(args.to)}`,
+        fields: { contract: args.contract, from: args.from, to: args.to, tokenId: id.toString() },
+    };
+}
+/**
+ * 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 function prepareMint(args) {
+    return {
+        op: 'mint',
+        to: args.contract,
+        data: encodeFunctionData({ abi: oneOfOneImageAbi, functionName: 'mint', args: [args.to] }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        // `mint(address)` issues the NEXT sequential token — id #0 for a 1/1, but the next unminted id
+        // for a Series (chain-determined at mint time). Don't hardcode "#0" (misleads on a Series where
+        // #0 is already minted); say "next" — correct for both.
+        summary: `Mint the next token → ${short(args.to)}`,
+        fields: { contract: args.contract, to: args.to, token: 'next in order' },
+    };
+}
+/** 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 function prepareSetTokenURIBase(args) {
+    return {
+        op: 'set-token-uri-base',
+        to: args.contract,
+        data: encodeFunctionData({ abi: oneOfOneImageAbi, functionName: 'setTokenURIBase', args: [args.base] }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: `Set tokenURI base → ${args.base}`,
+        fields: { contract: args.contract, tokenURIBase: args.base },
+    };
+}
+/** 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 function prepareSetTokenURIOverride(args) {
+    return {
+        op: 'set-token-uri-override',
+        to: args.contract,
+        data: encodeFunctionData({
+            abi: oneOfOneImageAbi,
+            functionName: 'setTokenURIOverride',
+            args: [BigInt(args.tokenId), args.uri],
+        }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: args.uri
+            ? `Set tokenURI override #${args.tokenId} → ${args.uri}`
+            : `Clear tokenURI override #${args.tokenId}`,
+        fields: { contract: args.contract, tokenId: String(args.tokenId), tokenURIOverride: args.uri },
+    };
+}
+/** Re-point the collection (ERC-7572) resolver BASE; derived on-chain as
+ *  `{base}/{chainId}/{address}`. Signer must be the owner. */
+export function prepareSetContractURIBase(args) {
+    return {
+        op: 'set-contract-uri-base',
+        to: args.contract,
+        data: encodeFunctionData({ abi: oneOfOneImageAbi, functionName: 'setContractURIBase', args: [args.base] }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: `Set contractURI base → ${args.base}`,
+        fields: { contract: args.contract, contractURIBase: args.base },
+    };
+}
+/** 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 function prepareSetContractURIOverride(args) {
+    return {
+        op: 'set-contract-uri-override',
+        to: args.contract,
+        data: encodeFunctionData({ abi: oneOfOneImageAbi, functionName: 'setContractURIOverride', args: [args.uri] }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: args.uri ? `Set contractURI override → ${args.uri}` : 'Clear contractURI override',
+        fields: { contract: args.contract, contractURIOverride: args.uri },
+    };
+}
+/**
+ * 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 function prepareSetTokenURIRenderer(args) {
+    const onChain = args.renderer !== zeroAddress;
+    return {
+        op: 'set-token-uri-renderer',
+        to: args.contract,
+        data: encodeFunctionData({
+            abi: oneOfOneImageAbi,
+            functionName: 'setTokenURIRenderer',
+            args: [args.renderer],
+        }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: onChain ? `Resolve tokenURI on-chain via ${short(args.renderer)}` : 'Resolve tokenURI off-chain (clear renderer)',
+        fields: { contract: args.contract, renderer: args.renderer },
+    };
+}
+/** Set (or clear) the collection's on-chain URI renderer. Signer must be the owner. */
+export function prepareSetContractURIRenderer(args) {
+    const onChain = args.renderer !== zeroAddress;
+    return {
+        op: 'set-contract-uri-renderer',
+        to: args.contract,
+        data: encodeFunctionData({
+            abi: oneOfOneImageAbi,
+            functionName: 'setContractURIRenderer',
+            args: [args.renderer],
+        }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: onChain ? `Resolve contractURI on-chain via ${short(args.renderer)}` : 'Resolve contractURI off-chain (clear renderer)',
+        fields: { contract: args.contract, renderer: args.renderer },
+    };
+}
+/** Freeze the token-URI config (pointer + renderer) forever. Irreversible. Signer = owner. */
+export function prepareLockTokenURI(args) {
+    return {
+        op: 'lock-token-uri',
+        to: args.contract,
+        data: encodeFunctionData({ abi: oneOfOneImageAbi, functionName: 'lockTokenURI', args: [] }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: 'Freeze the tokenURI config (pointer + renderer) — permanent',
+        fields: { contract: args.contract },
+    };
+}
+/** Freeze the collection-URI config forever. Irreversible. Signer = owner. */
+export function prepareLockContractURI(args) {
+    return {
+        op: 'lock-contract-uri',
+        to: args.contract,
+        data: encodeFunctionData({ abi: oneOfOneImageAbi, functionName: 'lockContractURI', args: [] }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: 'Freeze the contractURI config (pointer + renderer) — permanent',
+        fields: { contract: args.contract },
+    };
+}
+/** Set the contract-wide default royalty. Signer must be the owner. */
+export function prepareSetRoyalty(args) {
+    if (args.bps < 0 || args.bps > 10000)
+        throw new Error(`royalty bps out of range (0–10000): ${args.bps}`);
+    return {
+        op: 'set-royalty',
+        to: args.contract,
+        data: encodeFunctionData({
+            abi: oneOfOneImageAbi,
+            functionName: 'setDefaultRoyalty',
+            args: [args.receiver, args.bps],
+        }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: `Set royalty → ${(args.bps / 100).toFixed(2)}% to ${short(args.receiver)}`,
+        fields: { contract: args.contract, receiver: args.receiver, bps: String(args.bps) },
+    };
+}
+/**
+ * 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 function prepareSetTokenField(args) {
+    const id = BigInt(args.tokenId);
+    return {
+        op: 'set-field',
+        to: args.contract,
+        data: encodeFunctionData({
+            abi: oneOfOneImageAbi,
+            functionName: 'setTokenField',
+            args: [id, encodeTag(args.field), encodeTag(args.representation), args.value],
+        }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: `Set on-chain ${args.field} (${args.representation}) for token #${id}`,
+        fields: { contract: args.contract, tokenId: id.toString(), field: args.field, representation: args.representation, value: args.value },
+    };
+}
+/** Freeze a token field forever, across all its representations (irreversible). Signer = owner. */
+export function prepareLockTokenField(args) {
+    const id = BigInt(args.tokenId);
+    return {
+        op: 'lock-field',
+        to: args.contract,
+        data: encodeFunctionData({ abi: oneOfOneImageAbi, functionName: 'lockTokenField', args: [id, encodeTag(args.field)] }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: `Lock token #${id} field "${args.field}" — permanent`,
+        fields: { contract: args.contract, tokenId: id.toString(), field: args.field },
+    };
+}
+/** Set/replace a collection (contract-wide) on-chain metadata field. Signer = owner. */
+export function prepareSetContractField(args) {
+    return {
+        op: 'set-collection-field',
+        to: args.contract,
+        data: encodeFunctionData({
+            abi: oneOfOneImageAbi,
+            functionName: 'setContractField',
+            args: [encodeTag(args.field), encodeTag(args.representation), args.value],
+        }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: `Set on-chain collection ${args.field} (${args.representation})`,
+        fields: { contract: args.contract, field: args.field, representation: args.representation, value: args.value },
+    };
+}
+/** Freeze a collection field forever (irreversible). Signer = owner. */
+export function prepareLockContractField(args) {
+    return {
+        op: 'lock-collection-field',
+        to: args.contract,
+        data: encodeFunctionData({ abi: oneOfOneImageAbi, functionName: 'lockContractField', args: [encodeTag(args.field)] }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: `Lock collection field "${args.field}" — permanent`,
+        fields: { contract: args.contract, field: args.field },
+    };
+}
+/** Transfer contract ownership (admin). Signer must be the current owner. */
+export function prepareTransferOwnership(args) {
+    return {
+        op: 'set-admin',
+        to: args.contract,
+        data: encodeFunctionData({ abi: oneOfOneImageAbi, functionName: 'transferOwnership', args: [args.newOwner] }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: `Transfer contract ownership → ${short(args.newOwner)}`,
+        fields: { contract: args.contract, newOwner: args.newOwner },
+    };
+}
+/**
+ * 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 function prepareDeployOneOfOne(args) {
+    return {
+        op: 'deploy',
+        to: args.factory,
+        data: encodeFunctionData({
+            abi: oneOfOneImageFactoryAbi,
+            functionName: 'deployDeterministic',
+            args: [args.params, args.salt],
+        }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: `Deploy "${args.params.name}" → ${args.clone}`,
+        fields: {
+            factory: args.factory,
+            clone: args.clone,
+            name: args.params.name,
+            symbol: args.params.symbol,
+            owner: args.params.owner,
+        },
+    };
+}
+/** The unsigned form of the factory (trust-anchor) deploy — a contract creation. */
+export function prepareDeployFactory(args) {
+    return {
+        op: 'deploy-factory',
+        to: null,
+        data: oneOfOneImageFactoryBytecode,
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: 'Deploy the canonical clone factory (trust anchor)',
+        fields: {},
+    };
+}
+/** The unsigned form of the canonical metadata-renderer deploy — a contract creation. */
+export function prepareDeployRenderer(args) {
+    return {
+        op: 'deploy-renderer',
+        to: null,
+        data: abxMetadataRendererBytecode,
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: 'Deploy the canonical on-chain metadata renderer',
+        fields: {},
+    };
+}
+// ── Series (multi-token) ops ──────────────────────────────────────────────────
+// Token ids are sequential and a token's metadata is its token id (no decoupling). Signer
+// must be the owner or an authorized minter for the mint ops; owner-only for the config ops.
+/**
+ * Mint the next sequential token on a Series (its metadata is its token id). Reverts when
+ * sold out.
+ */
+export function prepareSeriesMint(args) {
+    return {
+        op: 'mint',
+        to: args.contract,
+        data: encodeFunctionData({ abi: seriesImageAbi, functionName: 'mint', args: [args.to] }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: `Mint next token (in order) → ${short(args.to)}`,
+        fields: { contract: args.contract, to: args.to },
+    };
+}
+/** Mint `count` Series tokens in order in one tx — N individual `Transfer`s. */
+export function prepareSeriesMintMany(args) {
+    const n = Number(args.count);
+    return {
+        op: 'mint-many',
+        to: args.contract,
+        data: encodeFunctionData({
+            abi: seriesImageAbi,
+            functionName: 'mintMany',
+            args: [args.to, BigInt(args.count)],
+        }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: `Mint ${n} tokens (in order) → ${short(args.to)}`,
+        fields: { contract: args.contract, to: args.to, count: String(n) },
+    };
+}
+/**
+ * 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 function prepareSetMinter(args) {
+    const clearing = args.minter === zeroAddress;
+    return {
+        op: 'set-minter',
+        to: args.contract,
+        data: encodeFunctionData({ abi: seriesImageAbi, functionName: 'setMinter', args: [args.minter] }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: clearing ? 'Clear the authorized minter (owner-only)' : `Set authorized minter → ${short(args.minter)}`,
+        fields: { contract: args.contract, minter: args.minter },
+    };
+}
+/** Lower the supply cap (monotonic — never raises, never below the minted count). Signer = owner. */
+export function prepareSetMaxInvocations(args) {
+    const max = BigInt(args.maxInvocations);
+    return {
+        op: 'set-max-invocations',
+        to: args.contract,
+        data: encodeFunctionData({ abi: seriesImageAbi, functionName: 'setMaxInvocations', args: [max] }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: `Set max invocations → ${max}`,
+        fields: { contract: args.contract, maxInvocations: max.toString() },
+    };
+}
+/** 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 function prepareSetPaused(args) {
+    return {
+        op: 'set-paused',
+        to: args.contract,
+        data: encodeFunctionData({ abi: seriesImageAbi, functionName: 'setPaused', args: [args.paused] }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: args.paused ? 'Pause minting (owner-only until unpaused)' : 'Unpause minting (open to the minter)',
+        fields: { contract: args.contract, paused: String(args.paused) },
+    };
+}
+/** Set (or clear, with `0x0`) the primary-sale payout destination. Signer = owner. */
+export function prepareSetPrimaryPayee(args) {
+    return {
+        op: 'set-primary-payee',
+        to: args.contract,
+        data: encodeFunctionData({ abi: seriesImageAbi, functionName: 'setPrimaryPayee', args: [args.payee] }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: args.payee !== zeroAddress ? `Set primary payee → ${short(args.payee)}` : 'Clear primary payee',
+        fields: { contract: args.contract, primaryPayee: args.payee },
+    };
+}
+/** The unsigned form of a Series genesis deploy — `deployDeterministic(params, salt)` on the Series factory. */
+export function prepareDeploySeries(args) {
+    return {
+        op: 'deploy-series',
+        to: args.factory,
+        data: encodeFunctionData({
+            abi: seriesImageFactoryAbi,
+            functionName: 'deployDeterministic',
+            args: [args.params, args.salt],
+        }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: `Deploy Series "${args.params.name}" (${String(args.params.maxInvocations)} max) → ${args.clone}`,
+        fields: {
+            factory: args.factory,
+            clone: args.clone,
+            name: args.params.name,
+            symbol: args.params.symbol,
+            owner: args.params.owner,
+            maxInvocations: String(args.params.maxInvocations),
+        },
+    };
+}
+/** The unsigned form of the Series factory (trust-anchor) deploy — a contract creation. */
+export function prepareDeploySeriesFactory(args) {
+    return {
+        op: 'deploy-series-factory',
+        to: null,
+        data: seriesImageFactoryBytecode,
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: 'Deploy the canonical Series clone factory (trust anchor)',
+        fields: {},
+    };
+}
+// ── Fixed-price minter (the Minter spine) ─────────────────────────────────────
+// The minter is a shared, ownerless, multi-tenant singleton. `configure` defers to the
+// token owner; `purchase`/`purchaseTo` are public. See specs/protocol/minter-spine.md.
+/**
+ * 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 function prepareConfigureSale(args) {
+    const paymentToken = args.paymentToken ?? zeroAddress;
+    const price = BigInt(args.price);
+    const allocation = BigInt(args.allocation);
+    const isEth = paymentToken === zeroAddress;
+    return {
+        op: 'configure-sale',
+        to: args.minter,
+        data: encodeFunctionData({
+            abi: abxFixedPriceMinterAbi,
+            functionName: 'configure',
+            args: [args.token, paymentToken, price, allocation],
+        }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: `Configure sale: ${price} ${isEth ? 'wei' : `of ${short(paymentToken)}`}/token, allocation ${allocation}`,
+        fields: {
+            minter: args.minter,
+            token: args.token,
+            paymentToken,
+            price: price.toString(),
+            allocation: allocation.toString(),
+        },
+    };
+}
+/**
+ * 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 function preparePurchase(args) {
+    const value = BigInt(args.value ?? 0n);
+    const toRecipient = args.to && args.to !== zeroAddress;
+    return {
+        op: 'purchase',
+        to: args.minter,
+        data: toRecipient
+            ? encodeFunctionData({ abi: abxFixedPriceMinterAbi, functionName: 'purchaseTo', args: [args.token, args.to] })
+            : encodeFunctionData({ abi: abxFixedPriceMinterAbi, functionName: 'purchase', args: [args.token] }),
+        value: value > 0n ? toHex(value) : ZERO_VALUE,
+        chainId: args.chainId,
+        summary: toRecipient
+            ? `Buy 1 token → ${short(args.to)}${value > 0n ? ` for ${value} wei` : ''}`
+            : `Buy 1 token${value > 0n ? ` for ${value} wei` : ''}`,
+        fields: { minter: args.minter, token: args.token, to: args.to ?? '(sender)', value: value.toString() },
+    };
+}
+/** The unsigned form of the shared fixed-price minter deploy — a contract creation. */
+export function prepareDeployFixedPriceMinter(args) {
+    return {
+        op: 'deploy-fixed-price-minter',
+        to: null,
+        data: abxFixedPriceMinterBytecode,
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: 'Deploy the canonical fixed-price minter (shared, ownerless)',
+        fields: {},
+    };
+}
+/** Deterministic deploy of a {SeriesCode} clone — the code-project factory op. */
+export function prepareDeploySeriesCode(args) {
+    return {
+        op: 'deploy-code',
+        to: args.factory,
+        data: encodeFunctionData({
+            abi: seriesCodeFactoryAbi,
+            functionName: 'deployDeterministic',
+            args: [args.params, args.salt],
+        }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: `Deploy code project "${args.params.name}" (${String(args.params.maxInvocations)} max) → ${args.clone}`,
+        fields: {
+            factory: args.factory,
+            clone: args.clone,
+            name: args.params.name,
+            symbol: args.params.symbol,
+            owner: args.params.owner,
+            seedSource: args.params.seedSource,
+            maxInvocations: String(args.params.maxInvocations),
+        },
+    };
+}
+/** 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 function prepareCodeSetup(args) {
+    const deps = args.deps ?? [];
+    return {
+        op: 'code-setup',
+        to: args.contract,
+        data: encodeFunctionData({ abi: seriesCodeAbi, functionName: 'multicall', args: [args.calls] }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        // Human, and ACCURATE to what THIS multicall actually contains — a creator signs it in their
+        // wallet. (The old label was protocol jargon AND wrong for the renderer-only lane: it always
+        // claimed a "generator animation field" even when no generator/animation was in the tx.)
+        summary: (() => {
+            const parts = [];
+            if (args.chunkCount)
+                parts.push(`store your program (${args.chunkCount} on-chain chunk${args.chunkCount === 1 ? '' : 's'})`);
+            if (args.schemaKeys.length)
+                parts.push(`enable collector-set parameter${args.schemaKeys.length === 1 ? '' : 's'}: ${args.schemaKeys.join(', ')}`);
+            if (deps.length)
+                parts.push(`declare ${deps.length} dependenc${deps.length === 1 ? 'y' : 'ies'}: ${deps.join(', ')}`);
+            if (args.onchainUri)
+                parts.push('wire on-chain metadata resolution (the animation + URI renderers)');
+            return parts.length ? `Finish setup — ${parts.join('; ')}` : 'Finish setup';
+        })(),
+        fields: {
+            contract: args.contract,
+            scriptChunks: String(args.chunkCount),
+            schemas: args.schemaKeys.join(',') || '—',
+            ...(deps.length ? { dependencies: deps.join(',') } : {}),
+            ...(args.onchainUri ? { onchainUri: 'yes' } : {}),
+        },
+    };
+}
+// ── dependencies (Dependencies extension — code projects) ─────────────────────
+// The ordered library declarations of a template-mode code project (index 0 = the runtime,
+// by convention). Owner-only; the list stays dense (set at index ≤ count, remove only the
+// last). See specs/protocol/dependency-registry.md + src/deps.ts for the ref encoding.
+/** 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 function prepareSetDependency(args) {
+    const index = BigInt(args.index);
+    const kind = args.resolution === 1 ? 'on-chain' : 'registry';
+    const shown = args.display ?? args.ref;
+    return {
+        op: 'set-dependency',
+        to: args.contract,
+        data: encodeFunctionData({
+            abi: seriesCodeAbi,
+            functionName: 'setDependency',
+            args: [index, args.resolution, args.ref],
+        }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: `Set dependency [${index}] → ${shown} (${kind})${index === 0n ? ' — index 0 = the runtime' : ''}`,
+        fields: { contract: args.contract, index: index.toString(), resolution: kind, ref: shown },
+    };
+}
+/** Remove the LAST dependency (the list stays dense — order is load-bearing). Signer = owner. */
+export function prepareRemoveLastDependency(args) {
+    return {
+        op: 'remove-last-dependency',
+        to: args.contract,
+        data: encodeFunctionData({ abi: seriesCodeAbi, functionName: 'removeLastDependency', args: [] }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: 'Remove the last dependency (the list stays dense)',
+        fields: { contract: args.contract },
+    };
+}
+/** Set (or clear, with `0x0`) the soft, non-validating dependency registry pointer —
+ *  what `name@version` refs resolve through. Signer must be the owner. */
+export function prepareSetDependencyRegistry(args) {
+    const clearing = args.registry === zeroAddress;
+    return {
+        op: 'set-dependency-registry',
+        to: args.contract,
+        data: encodeFunctionData({ abi: seriesCodeAbi, functionName: 'setDependencyRegistry', args: [args.registry] }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: clearing
+            ? 'Clear the dependency registry pointer (soft — refs stay declared)'
+            : `Set dependency registry → ${short(args.registry)} (soft, non-validating)`,
+        fields: { contract: args.contract, registry: args.registry },
+    };
+}
+/** Freeze the dependency set (list + registry pointer) forever. Irreversible. Signer = owner. */
+export function prepareLockDependencies(args) {
+    return {
+        op: 'lock-dependencies',
+        to: args.contract,
+        data: encodeFunctionData({ abi: seriesCodeAbi, functionName: 'lockDependencies', args: [] }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: 'Freeze the dependency set (list + registry pointer) — permanent',
+        fields: { contract: args.contract },
+    };
+}
+/** 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 function prepareSetContractParam(args) {
+    return {
+        op: 'set-contract-param',
+        to: args.contract,
+        data: encodeFunctionData({
+            abi: seriesCodeAbi,
+            functionName: 'setContractParam',
+            args: [encodeTag(args.key), args.value],
+        }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: `Set contract param ${args.key} = ${args.display ?? args.value}`,
+        fields: { contract: args.contract, key: args.key, value: args.display ?? args.value },
+    };
+}
+/** 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 function prepareSetContractParamData(args) {
+    return {
+        op: 'set-contract-param-data',
+        to: args.contract,
+        data: encodeFunctionData({
+            abi: seriesCodeAbi,
+            functionName: 'setContractParamData',
+            args: [encodeTag(args.key), args.data],
+        }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: `Set contract param ${args.key} (data, ${(args.data.length - 2) / 2} bytes)`,
+        fields: { contract: args.contract, key: args.key },
+    };
+}
+/** 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 function prepareSetParamHooks(args) {
+    return {
+        op: 'set-param-hooks',
+        to: args.contract,
+        data: encodeFunctionData({
+            abi: seriesCodeAbi,
+            functionName: 'setParamHooks',
+            args: [args.configureHook, args.augmentHook, args.transferHook],
+        }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: `Set param hooks — configure ${args.configureHook}, augment ${args.augmentHook}, transfer ${args.transferHook}`,
+        fields: {
+            contract: args.contract,
+            configureHook: args.configureHook,
+            augmentHook: args.augmentHook,
+            transferHook: args.transferHook,
+        },
+    };
+}
+/** Set a schema-governed PostParam (literal scalar) — signer must satisfy the schema's auth. */
+export function prepareConfigureTokenParam(args) {
+    return {
+        op: 'configure-param',
+        to: args.contract,
+        data: encodeFunctionData({
+            abi: seriesCodeAbi,
+            functionName: 'configureTokenParam',
+            args: [args.tokenId, encodeTag(args.key), args.value],
+        }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: `Configure ${args.key} = ${args.display} on token ${args.tokenId}`,
+        fields: { contract: args.contract, tokenId: String(args.tokenId), key: args.key, value: args.display },
+    };
+}
+/** Set a schema-governed `String`/`Bytes` PostParam (the data path — one blob, hash evented). */
+export function prepareConfigureTokenParamData(args) {
+    return {
+        op: 'configure-param-data',
+        to: args.contract,
+        data: encodeFunctionData({
+            abi: seriesCodeAbi,
+            functionName: 'configureTokenParamData',
+            args: [args.tokenId, encodeTag(args.key), args.data],
+        }),
+        value: ZERO_VALUE,
+        chainId: args.chainId,
+        summary: `Configure ${args.key} (data, ${(args.data.length - 2) / 2} bytes) on token ${args.tokenId}`,
+        fields: { contract: args.contract, tokenId: String(args.tokenId), key: args.key },
+    };
+}
+//# sourceMappingURL=ops.js.map