@artblocks/abx-sdk 0.1.0-alpha.4 → 0.1.0-alpha.41

package/dist/errors.js

@@ -0,0 +1,148 @@
+/**
+ * The SDK's error taxonomy — deliberately minimal. A caller that wants to react to a SPECIFIC
+ * failure (retry a stale estimate, surface a revert's tx hash) should catch by TYPE, not by
+ * parsing `.message`; every SDK-thrown error a caller is expected to distinguish extends this,
+ * following the same `name` + typed-fields convention `AbxServiceError` already uses (service.ts).
+ * This module stays small on purpose — it grows only when a real caller needs a new type to catch,
+ * not as a speculative taxonomy of everything that could go wrong.
+ */
+export class AbxSdkError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'AbxSdkError';
+    }
+}
+/**
+ * A sent transaction MINED with `status: 'reverted'`. Thrown by {@link makeHotSender} (and anything
+ * else driving `SendTx`) instead of letting a revert masquerade as a "confirmed" send — carries the
+ * tx hash so a caller can look it up on an explorer without re-parsing a message string.
+ */
+export class TxRevertedError extends AbxSdkError {
+    op;
+    txHash;
+    constructor(op, txHash) {
+        super(`${op} reverted (${txHash})`);
+        this.name = 'TxRevertedError';
+        this.op = op;
+        this.txHash = txHash;
+    }
+}
+/**
+ * `pinGas`'s refusal: every estimate attempt came back below the transaction's PROVABLE gas floor
+ * (`PreparedTx.gasFloor` — EVM code deposit at exactly 200 gas/byte, and nothing else is physics).
+ * That is proof the node answering the estimate hasn't seen the target's deploy block yet, not that
+ * the floor is wrong — see `pinGas` in `execute.ts` for the full reasoning. Carries both numbers so a
+ * caller can decide to retry against a different RPC rather than re-parse the message.
+ */
+export class GasEstimateBelowFloorError extends AbxSdkError {
+    estimate;
+    floor;
+    constructor(estimate, floor) {
+        super(`Refusing to send: the RPC estimated ${estimate} gas for a transaction that provably needs at least ${floor} ` +
+            `(storing ${floor / 200n} bytes on-chain costs 200 gas/byte in code deposit alone). An estimate below the floor means the node ` +
+            `is answering from stale state — usually it has not seen the contract's deploy block yet, so the call looks like it is going to ` +
+            `an empty account. Sending this would revert DeploymentFailed() and burn the gas. Retry in a few seconds, or use a different RPC.`);
+        this.name = 'GasEstimateBelowFloorError';
+        this.estimate = estimate;
+        this.floor = floor;
+    }
+}
+/**
+ * No signing key resolved. SINGLE env name: `ABX_DEPLOYER_PK` — thrown by {@link makeWalletClient}
+ * and {@link envSigningKey} (clients.ts). Names the two retired names explicitly (`SEPOLIA_FUNDED_PK`
+ * / `SEPOLIA_WALLET_PK`) rather than just omitting them, because a caller upgrading from an older
+ * alpha has one of those set in their `.env` and would otherwise see a plain "no key found" with no
+ * clue that the key IS there, just under a name the SDK no longer reads.
+ */
+export class MissingSigningKeyError extends AbxSdkError {
+    constructor() {
+        super('No signing key found. Set ABX_DEPLOYER_PK in your .env. ' +
+            '(SEPOLIA_FUNDED_PK and SEPOLIA_WALLET_PK are no longer read — rename the key to ABX_DEPLOYER_PK.)');
+        this.name = 'MissingSigningKeyError';
+    }
+}
+/**
+ * A registry-resolved dependency's on-chain bytes are gzip'd, and no `inflate` was supplied to
+ * decompress them (`resolveRegistryDep`/`dependencyScriptTags`, deps.ts). SDK core carries no
+ * `node:zlib` — it has to stay reachable from a browser bundle (see `test/browser-bundle.test.ts`)
+ * — so decompression is an injected function rather than a direct call. Thrown instead of letting
+ * the caller either crash on `opts.inflate(...)` being undefined or silently serve a broken
+ * document; names the exact fix instead of a generic "cannot read properties of undefined".
+ */
+export class InflateRequiredError extends AbxSdkError {
+    constructor() {
+        super("A registry-resolved dependency's on-chain bytes are gzip-compressed, but no `inflate` was " +
+            'provided to decompress them. On a Node host, pass `nodeInflate` from `@artblocks/abx-sdk/node` ' +
+            "(e.g. `dependencyScriptTags(client, state, {inflate: nodeInflate})`). In a browser, pass a " +
+            'DecompressionStream-based implementation — SDK core carries no `node:zlib` so it never assumes one.');
+        this.name = 'InflateRequiredError';
+    }
+}
+/**
+ * A caller asked reconstruction to stop at the `"safe"` or `"finalized"` block tag
+ * ({@link resolveBlockTag}, reconstruct.ts) and the RPC either rejected `eth_getBlockByNumber` for
+ * that tag or answered with no block number. Thrown rather than silently falling back to `latest`:
+ * the whole point of naming `safe`/`finalized` is the reorg-safety guarantee that tag carries, and a
+ * quiet substitution would hand back a normal-looking reconstruction that scanned further than the
+ * caller asked for — indistinguishable from success until a reorg proves it wrong. Some
+ * chains/providers genuinely don't serve these tags: pre-merge chains have no post-merge finality,
+ * and some non-archive or indexer-backed RPCs answer neither tag at all. Expected and actionable,
+ * not a bug — names the fallback so a caller isn't stuck.
+ */
+export class BlockTagUnavailableError extends AbxSdkError {
+    tag;
+    constructor(tag, cause) {
+        super(`This RPC doesn't support the "${tag}" block tag${cause instanceof Error ? ` (${cause.message})` : ''}. ` +
+            `Reconstruction can't resolve a "${tag}" boundary here — use \`latest\` (the default) or an explicit ` +
+            `block number instead, or point at an RPC that serves "${tag}" (most L1 mainnets and their public ` +
+            `testnets do; some rollups and indexer-backed endpoints don't — \`abx doctor\` rates configured endpoints).`);
+        this.name = 'BlockTagUnavailableError';
+        this.tag = tag;
+    }
+}
+/**
+ * A trust anchor {@link AnchorKind} that `ensureFactory`/`ensureSeriesFactory`/
+ * `ensureSeriesCodeFactory` (anchors.ts) could not resolve to a usable address, with
+ * `allowBootstrap` false — the caller must either point at a working one (override / env /
+ * manifest) or opt in to deploying a private one. Carries structured `detail` + `address` instead
+ * of a formatted sentence: the SDK doesn't know a UX's flag names or chain-key strings, so it never
+ * composes the actual guidance text itself — that's the CLI's `refuseMissingFactory`, which catches
+ * this and names the env var / `--bootstrap-factory` / the chain.
+ */
+export class AnchorUnavailableError extends AbxSdkError {
+    anchor;
+    detail;
+    address;
+    constructor(anchor, detail, address) {
+        super(`${anchor} trust anchor unavailable (${detail}${address ? `: ${address}` : ''})`);
+        this.name = 'AnchorUnavailableError';
+        this.anchor = anchor;
+        this.detail = detail;
+        this.address = address;
+    }
+}
+/**
+ * A candidate seed source that {@link probeSeedSource} found unusable — thrown by
+ * `assertSeedSourceUsable` (ops.ts). Carries the whole probe (verdict + what was observed) rather
+ * than a formatted sentence, same reason as {@link AnchorUnavailableError}: the SDK doesn't know
+ * whether the caller got this address from a `--seed-source` flag, an env var, or a form field, so
+ * it never composes the guidance itself.
+ *
+ * Worth catching by type: this is the ONE misconfiguration whose consequence is "every mint of the
+ * collection reverts", and it is invisible on every read surface (`seedSource()` returns exactly
+ * what was set; the `SeedSourceSet` event fires) — so a UX should treat it as a hard stop, not a
+ * warning it can proceed past.
+ */
+export class SeedSourceUnusableError extends AbxSdkError {
+    verdict;
+    address;
+    probe;
+    constructor(probe) {
+        super(`seed source ${probe.address} is not usable (${probe.verdict}${probe.error ? `: ${probe.error}` : ''})`);
+        this.name = 'SeedSourceUnusableError';
+        this.verdict = probe.verdict;
+        this.address = probe.address;
+        this.probe = probe;
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

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

package/dist/execute.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Gas limits for a sequenced transaction — decided HERE, once, rather than re-read at signing time.
+ *
+ * The failure this exists to prevent, in full, because it is not obvious and it cost a reporter every
+ * `deploy-code` attempt of a session: a project deploys in two transactions, and the second targets
+ * the contract the first just created. If the node answering `eth_estimateGas` has not yet seen the
+ * deploy block, the target looks like an account with no code — and an estimate for a call to a
+ * codeless account is just the calldata cost, around 200k. That number is then sent as the gas limit.
+ * Once the contract does exist the same call needs ~941k, because storing a program on-chain is
+ * dominated by CREATE code deposit at ~200 gas per byte. The CREATE receives 63/64 of a budget that
+ * cannot cover the deposit, returns 0, and Solady's `SSTORE2.write` reverts `DeploymentFailed()` — a
+ * revert that reads like a contract bug and is really an out-of-gas.
+ *
+ * (Measured, from the real transactions: `gasLimit 201,616 / gasUsed 198,870` and
+ * `gasLimit 169,301 / gasUsed 166,810` — 98.6% and 98.5% of their limits. Replaying those payloads
+ * against a codeless address reproduces both limits to the gas; against the real contract the same
+ * calls estimate at 941,331.)
+ *
+ * The deploy loop already pinned the *nonce* against exactly this read-after-write lag on a
+ * distributed RPC. The rule generalizes, and it is the reason this module exists: **anything read at
+ * send time on a distributed RPC needs pinning, not just the nonce.**
+ */
+import type { Account, Address, Hex, PublicClient, TransactionReceipt, WalletClient } from 'viem';
+import type { PreparedTx } from './ops.js';
+/**
+ * Wait until `address` has code from THIS client's point of view. A deploy receipt proves the
+ * contract exists on chain; it does not prove the node answering the next request has caught up.
+ * Bounded — on timeout we proceed and let the gas floor carry it, since a slow RPC is not a reason
+ * to refuse to continue a deploy that already spent money.
+ */
+export declare function waitForCodeAt(client: PublicClient, address: Address, timeoutMs?: number): Promise<boolean>;
+/**
+ * Decide a transaction's gas limit once, here.
+ *
+ * The important design point, because the obvious approach is wrong: when an estimate looks too low
+ * we do **not** substitute a computed number. A caller can only compute the *provable* part of a
+ * payload's cost (see `PreparedTx.gasFloor` — code deposit is 200 gas/byte and nothing else is
+ * physics); the same setup multicall also carries schema writes, dependency legs, URI legs and
+ * mints, whose cost we cannot derive without simulating them. A "probably enough" constant is a
+ * number tuned to whatever case was in front of its author: it papers over the symptom, then
+ * under-funds the next payload that carries a few more legs, producing the identical
+ * `DeploymentFailed()` with a fresh mystery attached.
+ *
+ * So the floor is used as a **detector**. An estimate below a provable minimum is not "low", it is
+ * *impossible* — proof that the node answering us is looking at the wrong state (typically it has
+ * not seen the deploy block yet, so the target reads as an account with no code and the estimate
+ * comes back as the calldata cost alone). The right response to a broken measurement is to take it
+ * again, and if it stays broken, to refuse — sending a transaction we can prove is under-funded
+ * would burn the gas AND orphan the contract.
+ *
+ * When the estimate IS plausible it is trusted, plus headroom for state drift between estimate and
+ * inclusion.
+ */
+export declare function pinGas(client: PublicClient, tx: {
+    from: Address;
+    to: Address | null;
+    data: Hex;
+    value?: Hex;
+    gasFloor?: Hex;
+}, opts?: {
+    attempts?: number;
+    delayMs?: number;
+}): Promise<bigint>;
+/** Sign + broadcast one {@link PreparedTx} and return its mined receipt (for event parsing). The
+ *  SDK's one send-injection point: a hot key ({@link makeHotSender}), a browser wallet (a
+ *  `WalletSession`), or anything else a caller wires up — the SDK never picks or performs the
+ *  signing itself. */
+export type SendTx = (tx: PreparedTx) => Promise<TransactionReceipt>;
+/** Progress from a {@link SendTx} built by {@link makeHotSender}, so a caller can narrate without
+ *  the SDK printing anything itself (the SDK never prints — see clients.ts / chunks.ts for the same
+ *  `onEvent` pattern). */
+export type SendEvent = {
+    kind: 'sending';
+    tx: PreparedTx;
+} | {
+    kind: 'mined';
+    receipt: TransactionReceipt;
+    tx: PreparedTx;
+};
+/**
+ * Build a {@link SendTx} that signs with an env-style hot key and broadcasts — the generalization of
+ * what used to be hand-rolled per call site (a deploy-then-setup loop in the CLI, the hot lane in
+ * `signer.ts`, the chunk-staging sender in `ownerops.ts`): one function that gets the read-after-
+ * write-lag handling right ONCE.
+ *
+ * Two lags, pinned once at construction / tracked locally per send, rather than re-read at send time:
+ *   - the NONCE — read once here as `max(pending, latest)`, then incremented locally per tx. Right
+ *     after a tx is mined a distributed RPC (e.g. Alchemy, `sepolia.base.org`) can briefly serve a
+ *     stale `pending` transaction count (read-after-write lag), so re-fetching it for the NEXT send
+ *     in the same sequence risks reusing the just-spent nonce — the tx it already has in the mempool
+ *     rejects the duplicate as "replacement transaction underpriced", and that send is silently
+ *     lost. The `max` covers the cross-INVOCATION case the local increment cannot see: a node whose
+ *     pending view has fallen behind its own head answers the first send of the next `abx` command
+ *     with a nonce it has already spent.
+ *   - GAS, one field over: a tx after the first in a sequence may target a contract an EARLIER tx in
+ *     this same sequence just created. If the node answering `eth_estimateGas` hasn't seen that
+ *     block yet, the target looks codeless and the estimate comes back as the calldata cost alone —
+ *     see `pinGas` above for the full story (and the measured numbers). So every send after the
+ *     first waits for its target's code to be visible before estimating.
+ *
+ * Every send: wait for code at the target when it's not the first send in this sender's sequence
+ * (mirrors the exact rule the deploy-code hot lane hand-rolled: every tx after the first, since the
+ * first is what creates what the rest target), pin the gas (a provable floor detector, never a
+ * substitute limit), broadcast, wait for the receipt, and throw a typed {@link TxRevertedError} —
+ * carrying the tx hash — on a `reverted` status rather than reporting a burned transaction as
+ * "confirmed".
+ */
+export declare function makeHotSender(args: {
+    wallet: WalletClient;
+    account: Account;
+    publicClient: PublicClient;
+    onEvent?: (e: SendEvent) => void;
+}): SendTx;
+/** Send a list of prepared txs, in order, via `send`; returns their receipts in the same order.
+ *  A small convenience for the common "just run this sequence" case — narration (if any) rides
+ *  `send`'s own `onEvent`, not a callback here. */
+export declare function runPrepared(txs: PreparedTx[], send: SendTx): Promise<TransactionReceipt[]>;
+//# sourceMappingURL=execute.d.ts.map

package/dist/execute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../src/execute.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,KAAK,EAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,YAAY,EAAE,kBAAkB,EAAE,YAAY,EAAC,MAAM,MAAM,CAAC;AAChG,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,UAAU,CAAC;AAGzC;;;;;GAKG;AACH,wBAAsB,aAAa,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC,CAQhH;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,MAAM,CAC1B,MAAM,EAAE,YAAY,EACpB,EAAE,EAAE;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,OAAO,GAAG,IAAI,CAAC;IAAC,IAAI,EAAE,GAAG,CAAC;IAAC,KAAK,CAAC,EAAE,GAAG,CAAC;IAAC,QAAQ,CAAC,EAAE,GAAG,CAAA;CAAC,EAC/E,IAAI,GAAE;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAM,GAC/C,OAAO,CAAC,MAAM,CAAC,CA8BjB;AAED;;;sBAGsB;AACtB,MAAM,MAAM,MAAM,GAAG,CAAC,EAAE,EAAE,UAAU,KAAK,OAAO,CAAC,kBAAkB,CAAC,CAAC;AAErE;;0BAE0B;AAC1B,MAAM,MAAM,SAAS,GACjB;IAAC,IAAI,EAAE,SAAS,CAAC;IAAC,EAAE,EAAE,UAAU,CAAA;CAAC,GACjC;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,kBAAkB,CAAC;IAAC,EAAE,EAAE,UAAU,CAAA;CAAC,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE;IAClC,MAAM,EAAE,YAAY,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE,YAAY,CAAC;IAC3B,OAAO,CAAC,EAAE,CAAC,CAAC,EAAE,SAAS,KAAK,IAAI,CAAC;CAClC,GAAG,MAAM,CAgDT;AAED;;mDAEmD;AACnD,wBAAsB,WAAW,CAAC,GAAG,EAAE,UAAU,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAIhG"}

package/dist/execute.js

@@ -0,0 +1,159 @@
+import { GasEstimateBelowFloorError, TxRevertedError } from './errors.js';
+/**
+ * Wait until `address` has code from THIS client's point of view. A deploy receipt proves the
+ * contract exists on chain; it does not prove the node answering the next request has caught up.
+ * Bounded — on timeout we proceed and let the gas floor carry it, since a slow RPC is not a reason
+ * to refuse to continue a deploy that already spent money.
+ */
+export async function waitForCodeAt(client, address, timeoutMs = 15_000) {
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        const code = await client.getCode({ address }).catch(() => undefined);
+        if (code && code !== '0x')
+            return true;
+        if (Date.now() >= deadline)
+            return false;
+        await new Promise((r) => setTimeout(r, 750));
+    }
+}
+/**
+ * Decide a transaction's gas limit once, here.
+ *
+ * The important design point, because the obvious approach is wrong: when an estimate looks too low
+ * we do **not** substitute a computed number. A caller can only compute the *provable* part of a
+ * payload's cost (see `PreparedTx.gasFloor` — code deposit is 200 gas/byte and nothing else is
+ * physics); the same setup multicall also carries schema writes, dependency legs, URI legs and
+ * mints, whose cost we cannot derive without simulating them. A "probably enough" constant is a
+ * number tuned to whatever case was in front of its author: it papers over the symptom, then
+ * under-funds the next payload that carries a few more legs, producing the identical
+ * `DeploymentFailed()` with a fresh mystery attached.
+ *
+ * So the floor is used as a **detector**. An estimate below a provable minimum is not "low", it is
+ * *impossible* — proof that the node answering us is looking at the wrong state (typically it has
+ * not seen the deploy block yet, so the target reads as an account with no code and the estimate
+ * comes back as the calldata cost alone). The right response to a broken measurement is to take it
+ * again, and if it stays broken, to refuse — sending a transaction we can prove is under-funded
+ * would burn the gas AND orphan the contract.
+ *
+ * When the estimate IS plausible it is trusted, plus headroom for state drift between estimate and
+ * inclusion.
+ */
+export async function pinGas(client, tx, opts = {}) {
+    const floor = tx.gasFloor ? BigInt(tx.gasFloor) : 0n;
+    const attempts = opts.attempts ?? 3;
+    let lastEstimate = null;
+    let lastError;
+    for (let i = 0; i < attempts; i++) {
+        try {
+            const estimate = await client.estimateGas({
+                account: tx.from,
+                to: tx.to ?? undefined,
+                data: tx.data,
+                ...(tx.value && tx.value !== '0x0' ? { value: BigInt(tx.value) } : {}),
+            });
+            // Plausible (or nothing provable to check it against) → trust it.
+            if (estimate >= floor)
+                return (estimate * 125n) / 100n;
+            lastEstimate = estimate;
+        }
+        catch (err) {
+            lastError = err;
+            // A revert during estimation is a real answer about the transaction, not a lagging node —
+            // surface it immediately, since its message ("caller is not the owner") is the useful part.
+            if (floor === 0n)
+                throw err;
+        }
+        if (i < attempts - 1)
+            await new Promise((r) => setTimeout(r, opts.delayMs ?? 1_500));
+    }
+    if (lastEstimate !== null) {
+        throw new GasEstimateBelowFloorError(lastEstimate, floor);
+    }
+    throw lastError instanceof Error ? lastError : new Error('gas estimation failed');
+}
+/**
+ * Build a {@link SendTx} that signs with an env-style hot key and broadcasts — the generalization of
+ * what used to be hand-rolled per call site (a deploy-then-setup loop in the CLI, the hot lane in
+ * `signer.ts`, the chunk-staging sender in `ownerops.ts`): one function that gets the read-after-
+ * write-lag handling right ONCE.
+ *
+ * Two lags, pinned once at construction / tracked locally per send, rather than re-read at send time:
+ *   - the NONCE — read once here as `max(pending, latest)`, then incremented locally per tx. Right
+ *     after a tx is mined a distributed RPC (e.g. Alchemy, `sepolia.base.org`) can briefly serve a
+ *     stale `pending` transaction count (read-after-write lag), so re-fetching it for the NEXT send
+ *     in the same sequence risks reusing the just-spent nonce — the tx it already has in the mempool
+ *     rejects the duplicate as "replacement transaction underpriced", and that send is silently
+ *     lost. The `max` covers the cross-INVOCATION case the local increment cannot see: a node whose
+ *     pending view has fallen behind its own head answers the first send of the next `abx` command
+ *     with a nonce it has already spent.
+ *   - GAS, one field over: a tx after the first in a sequence may target a contract an EARLIER tx in
+ *     this same sequence just created. If the node answering `eth_estimateGas` hasn't seen that
+ *     block yet, the target looks codeless and the estimate comes back as the calldata cost alone —
+ *     see `pinGas` above for the full story (and the measured numbers). So every send after the
+ *     first waits for its target's code to be visible before estimating.
+ *
+ * Every send: wait for code at the target when it's not the first send in this sender's sequence
+ * (mirrors the exact rule the deploy-code hot lane hand-rolled: every tx after the first, since the
+ * first is what creates what the rest target), pin the gas (a provable floor detector, never a
+ * substitute limit), broadcast, wait for the receipt, and throw a typed {@link TxRevertedError} —
+ * carrying the tx hash — on a `reverted` status rather than reporting a burned transaction as
+ * "confirmed".
+ */
+export function makeHotSender(args) {
+    const { wallet, account, publicClient } = args;
+    const notify = args.onEvent ?? (() => { });
+    let nonce;
+    let sent = 0;
+    return async (tx) => {
+        if (nonce === undefined) {
+            // Fetch once, then increment locally per send — see the read-after-write-lag reasoning above.
+            //
+            // Read BOTH views and take the higher. `pending` is by definition >= `latest` on a coherent
+            // node, but a distributed endpoint that has not caught up with its own head serves a *lower*
+            // pending count than its own latest-block count — measured on `sepolia.base.org` right after
+            // a confirmed write, and never on the publicnode fallback. That is the cross-invocation half
+            // of the same lag this sender already handles within one sequence: each `abx` command is a
+            // fresh process, so the first send of the NEXT command re-reads a nonce the node has already
+            // spent, and the broadcast is rejected as a duplicate — silently, because a viem simulation
+            // failure means nothing is ever sent. `max` is correct-or-better in every case: with real
+            // pending txs `pending` wins, and against a stale view `latest` floors it.
+            const [pending, latest] = await Promise.all([
+                publicClient.getTransactionCount({ address: account.address, blockTag: 'pending' }),
+                publicClient.getTransactionCount({ address: account.address, blockTag: 'latest' }),
+            ]);
+            nonce = Math.max(pending, latest);
+        }
+        // The SAME lag, one field over: every send after the first in this sender's sequence may target
+        // what an earlier send just created.
+        if (sent > 0 && tx.to)
+            await waitForCodeAt(publicClient, tx.to);
+        const gas = await pinGas(publicClient, { from: account.address, to: tx.to, data: tx.data, value: tx.value, gasFloor: tx.gasFloor });
+        notify({ kind: 'sending', tx });
+        const hash = await wallet.sendTransaction({
+            to: tx.to ?? undefined,
+            data: tx.data,
+            value: tx.value && tx.value !== '0x0' ? BigInt(tx.value) : undefined,
+            account,
+            chain: wallet.chain,
+            nonce,
+            gas,
+        });
+        nonce += 1;
+        sent += 1;
+        const receipt = await publicClient.waitForTransactionReceipt({ hash });
+        if (receipt.status !== 'success')
+            throw new TxRevertedError(tx.op, hash);
+        notify({ kind: 'mined', receipt, tx });
+        return receipt;
+    };
+}
+/** Send a list of prepared txs, in order, via `send`; returns their receipts in the same order.
+ *  A small convenience for the common "just run this sequence" case — narration (if any) rides
+ *  `send`'s own `onEvent`, not a callback here. */
+export async function runPrepared(txs, send) {
+    const receipts = [];
+    for (const tx of txs)
+        receipts.push(await send(tx));
+    return receipts;
+}
+//# sourceMappingURL=execute.js.map

package/dist/execute.js.map

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

package/dist/gateways.d.ts

@@ -0,0 +1,79 @@
+import type { ProjectState } from './types.js';
+/** The locator's network, which decides which gateways can be asked about it. `http` locators
+ *  carry their own base (they are already an absolute URL) and resolve to `''` here — a caller
+ *  returns them verbatim before consulting a gateway. */
+export type LocatorNetwork = 'arweave' | 'ipfs' | 'http';
+/** Resolved gateway overrides for the two content-addressed networks — the shape both
+ *  {@link resolveGatewayBase} and {@link gatewayConfigFromEnv} speak. */
+export interface GatewayOverrides {
+    ipfs?: string;
+    arweave?: string;
+}
+/**
+ * The gateway BASE for a locator network, given already-resolved `overrides` — PURE, no env
+ * read. Defaults to the generic public gateways (`ipfs.io` / `arweave.net`) when `overrides`
+ * doesn't name one; any other `network` (e.g. `http`, which carries its own base) resolves to
+ * `''`. Callers that want override → env → default precedence compose this with
+ * {@link gatewayConfigFromEnv} themselves (see `@artblocks/abx-storage`'s `resolveGatewayBase`
+ * for the reference compose) — kept separate so a host with its own config source never has this
+ * function reach into `process.env` on its behalf.
+ */
+export declare function resolveGatewayBase(network: 'ipfs' | 'arweave' | string, overrides?: GatewayOverrides): string;
+/**
+ * The ONLY env-reading piece of this module: `ABX_IPFS_GATEWAY` / `ABX_ARWEAVE_GATEWAY`, read via
+ * {@link readEnv} (safe where `process` doesn't exist). Exported separately from
+ * {@link resolveGatewayBase} so a host with its own gateway configuration (a database row, a
+ * remote config service) never has to touch `process.env` through this package at all — it just
+ * never calls this function and passes its own overrides straight to the pure resolver instead.
+ */
+export declare function gatewayConfigFromEnv(): GatewayOverrides;
+/** Build the URL that asks `gateway` for `id`. A locator that is already an absolute URL is asked
+ *  verbatim — rewriting someone's URL would answer a question they didn't ask. */
+export declare function gatewayUrlFor(network: LocatorNetwork, id: string, gateway: string): string;
+/** A scheme whose locator is content-addressed, and therefore its own integrity anchor. */
+export type ContentAddressedNetwork = 'ipfs' | 'arweave';
+/**
+ * Normalize a gateway HOST (the `ABX_IPFS_GATEWAY` / `ABX_ARWEAVE_GATEWAY` shape, and what
+ * {@link resolveGatewayBase} returns) into the on-chain PREFIX shape — trailing path included, so
+ * projection is a raw concat. A value that already ends in the scheme's path segment is left
+ * alone, so an operator may configure either form.
+ */
+export declare function gatewayPrefixFrom(network: ContentAddressedNetwork, base: string): string;
+/**
+ * The gateway prefix this project prefers for a scheme: the collection's reserved
+ * `abx_gateway_*` field, else the host's env/override default, else the public floor.
+ *
+ * The env read is a FLOOR, never an override. When a project has stated a preference on chain,
+ * every conforming resolver must serve that one — otherwise the same token renders differently
+ * depending on who is serving it, which is the property `abx_provenance` exists to make checkable.
+ * When a project has stated nothing, a host with its own gateway is strictly better than
+ * `ipfs.io`, and a managed provider serving a token it does not own has no other way to say so.
+ */
+export declare function projectGatewayPrefix(state: Pick<ProjectState, 'collectionFields'>, network: ContentAddressedNetwork, overrides?: GatewayOverrides): string;
+/**
+ * Project a content-addressed field value into its https URL, byte-identically to the deployed
+ * renderer. `null` when the value locates nothing (`ipfs://` with no CID) — the caller omits an
+ * optional field or falls back on a required one, rather than emitting a bare prefix that 404s.
+ *
+ * Order is load-bearing and mirrors the Solidity exactly: strip the scheme, THEN substitute
+ * `{id}`, THEN check for an absolute URL. That last check is what stops a value which already
+ * names its own host — precisely what a `backend.locator()` return looks like — from coming back
+ * as `https://arweave.net/https://arweave.net/<txid>`.
+ */
+export declare function projectGatewayUrl(network: ContentAddressedNetwork, value: string, prefix: string, tokenId?: string): string | null;
+/**
+ * The inverse of {@link gatewayUrlFor} / {@link projectGatewayUrl}: recover the bare content id
+ * (CID or txid, plus any path suffix) from whatever form a locator arrived in.
+ *
+ * This exists because a storage backend's `locator()` returns a **gateway HTTPS URL** — the form an
+ * operator can click — while an `ipfs` / `arweave` metadata field must hold IDENTITY, with the
+ * gateway supplied at read time. Baking the operator's gateway host into the field is exactly the
+ * weld this projection was built to remove: it makes a CID unmigratable and makes the chain report
+ * `source: url` for bytes that live on IPFS.
+ *
+ * `null` when no id can be recovered — notably a subdomain-style gateway
+ * (`https://<cid>.ipfs.dweb.link`), which ABX's own backends never produce. A caller that gets
+ * `null` should keep the URL as a plain `url` field and SAY so, rather than guess.
+ */
+export declare function contentIdFromLocator(network: ContentAddressedNetwork, locator: string): string | null;
+//# sourceMappingURL=gateways.d.ts.map

package/dist/gateways.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateways.d.ts","sourceRoot":"","sources":["../src/gateways.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAgB,YAAY,EAAC,MAAM,YAAY,CAAC;AAE5D;;yDAEyD;AACzD,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,CAAC;AAEzD;yEACyE;AACzE,MAAM,WAAW,gBAAgB;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,EAAE,SAAS,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAI7G;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,IAAI,gBAAgB,CAOvD;AAED;kFACkF;AAClF,wBAAgB,aAAa,CAAC,OAAO,EAAE,cAAc,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAK1F;AAaD,2FAA2F;AAC3F,MAAM,MAAM,uBAAuB,GAAG,MAAM,GAAG,SAAS,CAAC;AAIzD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,uBAAuB,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAKxF;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,kBAAkB,CAAC,EAC7C,OAAO,EAAE,uBAAuB,EAChC,SAAS,CAAC,EAAE,gBAAgB,GAC3B,MAAM,CAgBR;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,uBAAuB,EAChC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,MAAM,GACf,MAAM,GAAG,IAAI,CAUf;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,uBAAuB,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAgBrG"}