@bananapus/nana-sdk-core 2.21.0 → 2.23.0

package/dist/esm/review/relayr.js

@@ -1,6 +1,7 @@
-import { decodeFunctionData, encodeFunctionData, isAddress, keccak256, } from "viem";
+import { ContractFunctionRevertedError, decodeFunctionData, encodeFunctionData, isAddress, keccak256, RpcError, RpcRequestError, } from "viem";
 import { erc2771ForwarderAbi, jbContractAddress, } from "../generated/juicebox.js";
 import { isBytes32, isHexBytes, uint256 } from "../untrusted.js";
+import { isDefiniteWalletRejection } from "./contractWrite.js";
 import { simulateStateChangingTransaction } from "./simulation.js";
 // Relayr runs a bundle of transactions on several chains for one prepaid
 // native payment on one of them. Everything its API returns is untrusted:
@@ -59,7 +60,8 @@ const TESTNETS = [11155111, 11155420, 84532, 421614];
 const PAYMENT_CODE_MAX_BYTES = 2_048;
 const BUNDLE_READ_TIMEOUT_MS = 15_000;
 const HTTP_DETAIL_CHARACTERS = 240;
-const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/u;
+/** A Relayr bundle or transaction ID, in lower case. */
+export const RELAYR_UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/u;
 // RFC 3339 with an explicit offset. A time without one is read in the
 // machine's timezone, which would make the same quote pass or fail by place.
 const DEADLINE_TIME = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/iu;
@@ -69,6 +71,7 @@ const NO_PROOF = "This saved Relayr bundle lacks exact destination proof. Keep i
 const NOT_IDENTIFIED = "Relayr has not identified every exact destination transaction. Keep checking the original bundle; do not pay again.";
 const EXPIRED = "This Relayr quote expired. Review the action again for a new quote.";
 const UNKNOWN_PAYMENT = "Relayr has not said whether this bundle is paid. Do not pay again yet; check it later.";
+const UNNAMED = "Name every payment this session sent for the quote before paying it again.";
 const UNVERIFIABLE = "Only an authenticated Relayr payment with its transaction hash can be verified.";
 /**
  * The chain or Relayr contradicts the expected transaction: this evidence can
@@ -121,15 +124,19 @@ export class RelayrPaymentRetryError extends Error {
         this.name = "RelayrPaymentRetryError";
     }
 }
-/** `error` with `cause` set like a native error cause, but on ES2021 and never enumerable: an RPC error's URL can carry a key. */
-function withCause(error, cause) {
-    Object.defineProperty(error, "cause", {
-        value: cause,
+/** `target` with `key` set to `value`, writable but never enumerable: an RPC error's URL can carry a key, and no JSON or log may show it. */
+function withHidden(target, key, value) {
+    Object.defineProperty(target, key, {
+        value,
         writable: true,
         enumerable: false,
         configurable: true,
     });
-    return error;
+    return target;
+}
+/** `error` with `cause` set like a native error cause, but on ES2021 and never enumerable: an RPC error's URL can carry a key. */
+function withCause(error, cause) {
+    return withHidden(error, "cause", cause);
 }
 function errorWithCause(message, cause) {
     return withCause(new Error(message), cause);
@@ -155,7 +162,7 @@ function uuidOf(value) {
     if (typeof value !== "string")
         return null;
     const uuid = value.toLowerCase();
-    return UUID.test(uuid) ? uuid : null;
+    return RELAYR_UUID_RE.test(uuid) ? uuid : null;
 }
 function readEntry(entry) {
     if (!entry || typeof entry !== "object")
@@ -792,7 +799,7 @@ export async function verifyRelayrPayment(client, { hash, from, payment, }) {
  */
 export async function requireRelayrPaymentRetry(client, { hashes, from, payment, }, { fetch: fetchBundle = globalThis.fetch, nowSeconds = Date.now() / 1_000, } = {}) {
     if (!Array.isArray(hashes) || !hashes.length) {
-        throw new RelayrPaymentRetryError("Name every payment this session sent for the quote before paying it again.", "invalid");
+        throw new RelayrPaymentRetryError(UNNAMED, "invalid");
     }
     const reviewed = verifiablePayment(hashes, from, payment);
     if (!reviewed)
@@ -834,6 +841,11 @@ export async function requireRelayrBundleUnpaid(bundleUuid, { fetch: fetchBundle
     }
     requireUnpaidBundle(await readBundle(fetchBundle, uuid, () => new RelayrPaymentRetryError(UNKNOWN_PAYMENT, "unknown")));
 }
+/** Relayr has not run the call: `pending`, in any case, with no destination hash. */
+function relayrRecordPending(record) {
+    return (relayrDestinationHash(record) === null &&
+        relayrStateIsPending(record?.status?.state));
+}
 /** {@link requireRelayrBundleUnpaid}'s check of a bundle already read. */
 function requireUnpaidBundle({ payment_received, transactions, }) {
     if (payment_received === true) {
@@ -844,8 +856,7 @@ function requireUnpaidBundle({ payment_received, transactions, }) {
         !transactions.length) {
         throw new RelayrPaymentRetryError(UNKNOWN_PAYMENT, "unknown");
     }
-    if (transactions.some((record) => relayrDestinationHash(record) !== null ||
-        !relayrStateIsPending(record?.status?.state))) {
+    if (transactions.some((record) => !relayrRecordPending(record))) {
         throw new RelayrPaymentRetryError("Relayr reports a transaction of this bundle as running or run. Do not pay again.", "running");
     }
 }
@@ -959,4 +970,575 @@ export async function verifyRelayrDestinations(clientFor, { bindings, records, a
     }
     return verified;
 }
+/**
+ * `read` at the chain's finalized block, with that block's timestamp, once
+ * the block at its number still has the same hash after the read. Null while
+ * any of it cannot be read: a node without the finalized tag, an RPC error, a
+ * malformed block, or a block that is no longer canonical.
+ */
+export async function atCanonicalFinalizedBlock(client, read) {
+    try {
+        const { number, hash, timestamp } = await client.getBlock({
+            blockTag: "finalized",
+        });
+        if (typeof number !== "bigint" ||
+            !isBytes32(hash) ||
+            typeof timestamp !== "bigint") {
+            return null;
+        }
+        const value = await read(number);
+        const canonical = await client.getBlock({ blockNumber: number });
+        return canonical.hash === hash ? { value, timestamp } : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** `clientFor(chainId)`, or none when it has none or throws. */
+function clientOn(clientFor, chainId) {
+    try {
+        return clientFor(chainId);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The nonce the canonical forwarder on `chainId` expects next from `signer`
+ * at the chain's finalized block, still canonical, with that block's
+ * timestamp. Null while that cannot be read.
+ */
+async function finalizedForwarderNonce(clientFor, chainId, signer) {
+    const forwarder = forwarderOn(chainId);
+    const reader = forwarder && isAddressLike(signer)
+        ? clientOn(clientFor, chainId)
+        : undefined;
+    if (!forwarder || !reader)
+        return null;
+    const finalized = await atCanonicalFinalizedBlock(reader, (blockNumber) => reader.readContract({
+        address: forwarder,
+        abi: erc2771ForwarderAbi,
+        functionName: "nonces",
+        args: [signer],
+        blockNumber,
+    }));
+    const nonce = finalized && uint256(finalized.value);
+    return finalized && nonce !== null
+        ? { nonce, timestamp: finalized.timestamp }
+        : null;
+}
+/**
+ * The requests a session published, each read from its entry (an `execute`
+ * on its chain's canonical forwarder, as {@link relayrForwardRequest} reads
+ * it), with the nonce it was signed with when `nonces` has one for every
+ * entry. Null when there are none, or one is not such a request: requests
+ * that can't be read can't be classified, so they never count as dead.
+ */
+export function relayrSignedRequests(entries, nonces) {
+    const published = Array.isArray(entries) ? entries : [];
+    const saved = Array.isArray(nonces) && nonces.length === published.length
+        ? nonces
+        : undefined;
+    const requests = published.flatMap((entry, index) => {
+        const request = relayrForwardRequest(entry);
+        return request
+            ? [
+                {
+                    chainId: entry.chain,
+                    signer: request.from,
+                    deadline: request.deadline,
+                    ...(saved ? { nonce: saved[index] } : {}),
+                },
+            ]
+            : [];
+    });
+    return published.length && requests.length === published.length
+        ? requests
+        : null;
+}
+/**
+ * The one classification of signed forward requests (ruling R114): each at a
+ * canonical finalized block on its chain, read once per chain and signer with
+ * `clientFor(chainId)`. Never throws for a chain it cannot read: its requests
+ * are live.
+ */
+export async function relayrRequestStates(clientFor, requests) {
+    const finalized = new Map();
+    return Promise.all(requests.map(async ({ chainId, signer, deadline, nonce, }) => {
+        const key = `${chainId}:${String(signer).toLowerCase()}`;
+        if (!finalized.has(key)) {
+            finalized.set(key, finalizedForwarderNonce(clientFor, chainId, signer));
+        }
+        const block = await finalized.get(key);
+        // A saved nonce that can't be read leaves the request unknown, and a
+        // deadline that can't be read has not passed.
+        const saved = nonce === undefined ? null : uint256(nonce);
+        const end = uint256(deadline);
+        if (block && (nonce === undefined || saved !== null)) {
+            if (saved !== null && block.nonce > saved) {
+                return { live: false, mayHaveRun: true, unused: false };
+            }
+            if (end !== null && end < block.timestamp) {
+                return {
+                    live: false,
+                    mayHaveRun: saved === null,
+                    unused: block.nonce === saved,
+                };
+            }
+        }
+        return { live: true, deadline: Number(deadline) };
+    }));
+}
+/**
+ * What `states` allow together. No states are neither run nor unused, so a
+ * session with none holds.
+ */
+export function relayrRequestsVerdict(states) {
+    const deadlines = states.flatMap((state) => state.live ? [state.deadline] : []);
+    const mayHaveRun = states.some((state) => !state.live && state.mayHaveRun);
+    if (deadlines.length) {
+        return { live: true, until: Math.max(...deadlines), mayHaveRun };
+    }
+    return {
+        live: false,
+        mayHaveRun,
+        unused: states.length > 0 && states.every((state) => !state.live && state.unused),
+    };
+}
+/**
+ * Ruling R117: whether every request is dead at a canonical finalized block
+ * on its chain, anything unknown counting as live. A saved session reserves
+ * its signers' forwarder nonces on its chains exactly while one of its
+ * requests is live, never by a device clock or a quote's expiry. Requests that
+ * can't be classified (null) or none at all are never dead.
+ */
+export async function relayrRequestsDead(clientFor, requests) {
+    return (Array.isArray(requests) &&
+        requests.length > 0 &&
+        !relayrRequestsVerdict(await relayrRequestStates(clientFor, requests)).live);
+}
+/**
+ * Whether the chain's finalized block, still canonical, is past `deadline`
+ * (seconds, as a safe integer, decimal or 0x-hex digits, or a bigint): its
+ * timestamp is later. False while that is unknown, or the deadline can't be
+ * read.
+ */
+export async function relayrDeadlinePassed(client, deadline) {
+    const finalized = await atCanonicalFinalizedBlock(client, async () => undefined);
+    const end = uint256(deadline);
+    return !!finalized && end !== null && finalized.timestamp > end;
+}
+/** Whether `value` is a {@link RelayrDiscardReason}, for a reason read back from storage. */
+export function isRelayrDiscardReason(value) {
+    return value === "ran" || value === "changed" || value === "expired";
+}
+/** The transport failures that mean a recheck could not reach the chain. */
+const UNREACHED = ["HttpRequestError", "TimeoutError", "WebSocketRequestError"];
+/**
+ * Revert data: whole bytes of hex, at least a 4-byte selector, bare or in
+ * Nethermind's "Reverted 0x…" form.
+ */
+const REVERT_DATA = /^(?:Reverted )?0x(?:[0-9a-fA-F]{2}){4,}$/u;
+/**
+ * Whether one error carries revert data, whatever its JSON-RPC code: in its
+ * `data`, in a `data.data` a node nests there, or in the `raw` data of viem's
+ * contract revert. Such an error is the chain answering.
+ */
+function revertedWithData(link) {
+    const { raw, data } = link;
+    const nested = data !== null && typeof data === "object"
+        ? data.data
+        : undefined;
+    return [raw, data, nested].some((value) => typeof value === "string" && REVERT_DATA.test(value));
+}
+/**
+ * Ruling R118: the node could not answer the recheck, so it says nothing
+ * about the project. Within the error's first eight links (its cause chain),
+ * one is a transport failure (HTTP, timeout or WebSocket), a JSON-RPC failure
+ * (viem's `RpcRequestError` or any `RpcError`, such as -32001, -32005 or
+ * -32603), or a contract revert without revert data, as viem reads a bare
+ * revert, transient or not; and no link carries revert data, which on any
+ * code is the chain answering. An app's error that wraps such a failure as
+ * its `cause` reads the same way.
+ */
+function recheckUnreached(error) {
+    const links = [];
+    for (let link = error; links.length < 8 && link instanceof Error; link = link.cause) {
+        links.push(link);
+    }
+    return (!links.some(revertedWithData) &&
+        links.some((link) => UNREACHED.includes(link.name) ||
+            link instanceof RpcRequestError ||
+            link instanceof RpcError ||
+            link instanceof ContractFunctionRevertedError));
+}
+/**
+ * What a session does next from its requests' `verdict` (see
+ * {@link RelayrSessionOutcome}), which was classified before the action's own
+ * recheck, since a request that ran would make the recheck refuse.
+ *
+ * `nonces` must be the saved nonces of exactly the requests that were
+ * classified into `verdict`, in the same order: `refresh` and `re-sign` hand
+ * them back to sign at, and nothing here can check them against the verdict.
+ * Without them (omitted, empty or not a list), a session whose requests are
+ * all dead and unused holds as `reorg-hold`, and is neither discarded nor
+ * signed again.
+ *
+ * `recheck`, the action's proof that its calls still apply, resolves when
+ * they do and throws when they don't; a value it resolves with is never read.
+ * It runs only once every request is dead and unused. Without one, as in an
+ * account view, such a session can be discarded as `expired`. A recheck that
+ * fails because the node could not answer decides nothing. Known limit: a
+ * reorg that drops an earlier forwarded transaction can leave a finalized
+ * nonce below a saved one, and the session holds until the nonce catches up.
+ */
+export async function relayrSessionOutcome(verdict, { nonces, recheck, } = {}) {
+    const saved = Array.isArray(nonces) && nonces.length ? [...nonces] : null;
+    if (verdict.live) {
+        return verdict.mayHaveRun
+            ? { kind: "hold", until: verdict.until }
+            : { kind: "refresh", until: verdict.until, nonces: saved };
+    }
+    if (verdict.mayHaveRun)
+        return { kind: "discard", reason: "ran" };
+    if (!verdict.unused || !saved)
+        return { kind: "reorg-hold" };
+    if (!recheck)
+        return { kind: "discard", reason: "expired" };
+    try {
+        await recheck();
+    }
+    catch (error) {
+        return recheckUnreached(error)
+            ? withHidden({ kind: "unchecked" }, "error", error)
+            : withHidden({ kind: "discard", reason: "changed" }, "error", error);
+    }
+    return { kind: "re-sign", nonces: saved };
+}
+/** The payment `details` describes, as a session records it once sent under `hash`. */
+export function sentRelayrPayment(details, hash) {
+    return {
+        ...details,
+        amount: details.amount.toString(),
+        deadline: details.deadline.toString(),
+        hash,
+    };
+}
+/** The most payments one quote's journal keeps. No payment is sent beyond them. */
+export const MAX_RELAYR_SENT_PAYMENTS = 16;
+/**
+ * A saved sent payment, read strictly, or null. Its deadline must be the one
+ * its calldata pays until, which the payment's proof binds onchain.
+ */
+function relayrSentPaymentSnapshot(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const { hash, chainId, target, calldata, amount, deadline, bundleUuid } = value;
+    return isBytes32(hash) &&
+        typeof chainId === "number" &&
+        relayrSupportsChain(chainId) &&
+        isStrictAddress(target) &&
+        typeof calldata === "string" &&
+        /^0x[0-9a-f]{136}$/iu.test(calldata) &&
+        typeof amount === "string" &&
+        /^\d{1,78}$/u.test(amount) &&
+        typeof deadline === "string" &&
+        /^\d{1,13}$/u.test(deadline) &&
+        typeof bundleUuid === "string" &&
+        RELAYR_UUID_RE.test(bundleUuid) &&
+        BigInt(deadline) === calldataDeadline(calldata)
+        ? {
+            hash,
+            chainId,
+            target,
+            calldata: calldata,
+            amount,
+            deadline,
+            bundleUuid,
+        }
+        : null;
+}
+/**
+ * A saved list of sent payments, read strictly: at most
+ * {@link MAX_RELAYR_SENT_PAYMENTS}, each with only a payment's own fields.
+ * Null when any of it is malformed.
+ */
+export function relayrSentPaymentsSnapshot(values) {
+    if (!Array.isArray(values) || values.length > MAX_RELAYR_SENT_PAYMENTS) {
+        return null;
+    }
+    const payments = values.map(relayrSentPaymentSnapshot);
+    return payments.every((payment) => payment !== null)
+        ? payments
+        : null;
+}
+/**
+ * The saved option a quote paid before is paid again with: exactly the one
+ * its latest payment used, on its chain with its calldata (in any case) and
+ * amount. Throws when no option is that one, and when an option on that
+ * chain with that calldata whose amount can't be read comes before it.
+ */
+export function relayrRetryOption(payments, options) {
+    const latest = Array.isArray(payments)
+        ? payments[payments.length - 1]
+        : undefined;
+    let option;
+    if (latest && Array.isArray(options)) {
+        for (const item of options) {
+            if (item.chain !== latest.chainId ||
+                typeof item.calldata !== "string" ||
+                item.calldata.toLowerCase() !== latest.calldata.toLowerCase() ||
+                typeof item.amount !== "string") {
+                continue;
+            }
+            // An earlier twin whose amount can't be read ends the search, refused.
+            const amount = uint256(item.amount);
+            if (amount === null)
+                break;
+            if (amount === uint256(latest.amount)) {
+                option = item;
+                break;
+            }
+        }
+    }
+    if (!option) {
+        throw new Error("This Relayr quote cannot be paid again from its saved record. Keep it pending; do not pay again.");
+    }
+    return option;
+}
+/**
+ * Where a failed payment attempt leaves its quote: `reverted` when the
+ * payment reverted onchain, or when the wallet declined to pay a quote paid
+ * before, which stays on {@link requireRelayrPaymentRetry}'s rule; `unpaid`
+ * when the wallet declined its first payment; null when nothing is known, and
+ * the journal stays as it is. `sending` is whether the wallet held the
+ * payment, and `paid` whether the quote was paid before.
+ */
+export function relayrPaymentAttemptOutcome(error, { sending, paid }) {
+    if (error instanceof RelayrPaymentRevertedError)
+        return "reverted";
+    if (sending && isDefiniteWalletRejection(error)) {
+        return paid ? "reverted" : "unpaid";
+    }
+    return null;
+}
+/**
+ * Clear a quote paid before for one more payment, with
+ * {@link requireRelayrPaymentRetry}'s rule for each option its payments used.
+ * `payments` is every payment the session sent for the quote, as mined; those
+ * of one option (its chain, its calldata in any case, and its amount) are
+ * proven together on its chain, with `clientFor`. Before reading anything it
+ * refuses, as `invalid`, an empty list and anything
+ * {@link relayrSentPaymentsSnapshot} refuses, and a payment of another
+ * bundle; a chain without a client is `unknown`. Never pay on an error.
+ */
+export async function requireRelayrRetry(clientFor, { payments, from, bundleUuid, }, options = {}) {
+    if (!Array.isArray(payments) || !payments.length) {
+        throw new RelayrPaymentRetryError(UNNAMED, "invalid");
+    }
+    const sent = relayrSentPaymentsSnapshot(payments);
+    if (!sent)
+        throw new RelayrPaymentRetryError(UNVERIFIABLE, "invalid");
+    if (sent.some((payment) => payment.bundleUuid !== bundleUuid)) {
+        throw new Error("A saved Relayr payment belongs to another bundle. Do not pay again; check the original bundle.");
+    }
+    const byPayment = new Map();
+    for (const payment of sent) {
+        const key = `${payment.chainId}:${payment.calldata.toLowerCase()}:${payment.amount}`;
+        const group = byPayment.get(key) ?? { payment, hashes: [] };
+        group.hashes.push(payment.hash);
+        byPayment.set(key, group);
+    }
+    for (const { payment, hashes } of byPayment.values()) {
+        const client = clientOn(clientFor, payment.chainId);
+        if (!client) {
+            throw new RelayrPaymentRetryError(`No RPC is available for chain ${payment.chainId}. Do not pay again yet; check it later.`, "unknown");
+        }
+        await requireRelayrPaymentRetry(client, { hashes, from, payment }, options);
+    }
+}
+/**
+ * Prove a saved session's latest payment when it resumes, on its chain with
+ * `clientFor`. Resolves true once it succeeded onchain, and false while that
+ * can't be proven: no payment, an `account` that is not an address, no client
+ * for its chain, or a read that failed. A canonical revert runs `onReverted`
+ * and is thrown, as is any other {@link RelayrProofError}; the quote then
+ * waits on {@link requireRelayrPaymentRetry}'s rule.
+ */
+export async function proveSavedRelayrPayment(clientFor, payments, account, onReverted) {
+    const latest = Array.isArray(payments)
+        ? payments[payments.length - 1]
+        : undefined;
+    if (!latest || !isStrictAddress(account))
+        return false;
+    const client = clientOn(clientFor, latest.chainId);
+    if (!client)
+        return false;
+    try {
+        await verifyRelayrPayment(client, {
+            hash: latest.hash,
+            from: account,
+            payment: latest,
+        });
+        return true;
+    }
+    catch (error) {
+        if (error instanceof RelayrPaymentRevertedError)
+            onReverted();
+        if (error instanceof RelayrProofError)
+            throw error;
+        return false;
+    }
+}
+/**
+ * Whether the quote a session paid can still be paid at `nowMs` (the clock by
+ * default): its latest payment's deadline is more than 15 seconds away, as
+ * {@link quoteExpired} reads it and {@link requireRelayrPaymentRetry}
+ * requires. A deadline or a time that can't be read is closed.
+ */
+export function relayrPaidQuoteOpen(payments, nowMs = Date.now()) {
+    const latest = Array.isArray(payments)
+        ? payments[payments.length - 1]
+        : undefined;
+    const deadline = latest ? uint256(latest.deadline) : null;
+    return (deadline !== null &&
+        Number.isFinite(nowMs) &&
+        !quoteExpired(deadline, nowMs / 1_000));
+}
+/**
+ * Every option of a quote that {@link relayrPaymentDetails} accepts, expired
+ * or not, several on one chain included, with its details: the options a
+ * session keeps, and whose deadlines a release waits out. An option nothing
+ * can authenticate is never paid from, so it is left out.
+ */
+export function relayrQuotedOptions(quote, destinationChainIds) {
+    return (Array.isArray(quote.payment_info) ? quote.payment_info : []).flatMap((option) => {
+        try {
+            return [
+                {
+                    option,
+                    details: relayrPaymentDetails(option, {
+                        bundleUuid: quote.bundle_uuid,
+                        destinationChainIds,
+                        nowSeconds: 0,
+                    }),
+                },
+            ];
+        }
+        catch {
+            return [];
+        }
+    });
+}
+/** One uncached read of the bundle, or null when it can't be read, names another bundle or lists no calls. */
+async function relayrBundleIfNamed(bundleUuid, fetchBundle) {
+    try {
+        const { payment_received, transactions } = await readRelayrBundle(bundleUuid, { fetch: fetchBundle });
+        return Array.isArray(transactions)
+            ? { paymentReceived: payment_received, records: transactions }
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Nothing can fund the quote any more: every payment it sent is proven
+ * canonically reverted, and the deadline of each of those payments, and of
+ * each option {@link relayrQuotedOptions} keeps, has passed at a canonical
+ * finalized block on its chain. Anything unread is false.
+ */
+async function relayrQuoteUnfundable(clientFor, { payments, options, bundleUuid, destinationChainIds, account, }) {
+    if (!Array.isArray(payments) ||
+        !payments.length ||
+        !Array.isArray(options) ||
+        !isStrictAddress(account)) {
+        return false;
+    }
+    for (const payment of payments) {
+        const client = clientOn(clientFor, payment.chainId);
+        if (!client)
+            return false;
+        try {
+            await verifyRelayrPayment(client, {
+                hash: payment.hash,
+                from: account,
+                payment,
+            });
+            return false;
+        }
+        catch (error) {
+            if (!(error instanceof RelayrPaymentRevertedError))
+                return false;
+        }
+        // The proof read the calldata's deadline word; the saved one must be it.
+        if (uint256(payment.deadline) !== calldataDeadline(payment.calldata)) {
+            return false;
+        }
+    }
+    const deadlines = new Map(payments.map((payment) => [
+        `${payment.chainId}:${payment.deadline}`,
+        payment,
+    ]));
+    for (const { details } of relayrQuotedOptions({ bundle_uuid: bundleUuid, payment_info: [...options] }, destinationChainIds)) {
+        deadlines.set(`${details.chainId}:${details.deadline}`, {
+            chainId: details.chainId,
+            deadline: details.deadline.toString(),
+        });
+    }
+    for (const { chainId, deadline } of deadlines.values()) {
+        const client = clientOn(clientFor, chainId);
+        if (!client || !(await relayrDeadlinePassed(client, deadline))) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * What a quote whose own payments reverted allows (ruling R104), from one
+ * uncached read of its bundle (with `fetch`, the global one by default):
+ *
+ * - `funded` when Relayr reports a payment, or a call running or run: another
+ *   payment funded it, so its destinations are proven, never paid again;
+ * - `payable` while the quote of its latest payment is open at `nowMs` (the
+ *   clock, read after the bundle, by default), for
+ *   {@link requireRelayrPaymentRetry}'s rule;
+ * - `released` once nothing can fund it: every payment it sent is proven
+ *   canonically reverted on its chain (with `clientFor`), every deadline of
+ *   those payments and of the options {@link relayrQuotedOptions} keeps
+ *   passed at a canonical finalized block, and
+ *   {@link requireRelayrBundleUnpaid}, reading the bundle once more, finds it
+ *   unpaid with every call pending. Its action then quotes its calls again.
+ *
+ * Throws while an expired quote's release is unproven, and, unless the
+ * bundle is funded, for a payment of another bundle or a time that can't be
+ * read. Resolves with the records Relayr reported, or null when the bundle
+ * could not be read.
+ */
+export async function revertedRelayrQuote(clientFor, quote, { fetch: fetchBundle = globalThis.fetch, nowMs, } = {}) {
+    const bundle = await relayrBundleIfNamed(quote.bundleUuid, fetchBundle);
+    const records = bundle?.records ?? null;
+    if (bundle &&
+        (bundle.paymentReceived === true ||
+            bundle.records.some((record) => !relayrRecordPending(record)))) {
+        return { state: "funded", records };
+    }
+    // The clock is read after the bundle, whose read can take a while.
+    const now = nowMs ?? Date.now();
+    const ownPayments = Array.isArray(quote.payments) &&
+        quote.payments.every((payment) => payment?.bundleUuid === quote.bundleUuid);
+    if (ownPayments && Number.isFinite(now)) {
+        if (relayrPaidQuoteOpen(quote.payments, now)) {
+            return { state: "payable", records };
+        }
+        if (bundle &&
+            (await relayrQuoteUnfundable(clientFor, quote)) &&
+            (await requireRelayrBundleUnpaid(quote.bundleUuid, {
+                fetch: fetchBundle,
+            }).then(() => true, () => false))) {
+            return { state: "released", records };
+        }
+    }
+    throw new Error("This Relayr quote expired after its payment reverted. A new quote needs its deadline final onchain and Relayr to report nothing ran; try again in a few minutes.");
+}
 //# sourceMappingURL=relayr.js.map