@daski/pay 0.3.1 → 0.4.1

package/dist/commands/confirmation.js

@@ -1,9 +1,60 @@
+/**
+ * `daski order confirm` and `daski order revoke-confirmation` — the payer's
+ * delivery confirmation, in one of two modes chosen by the signer.
+ *
+ * Sponsored (plain wallets): the gateway prepares a delegated EAS request,
+ * this CLI rebuilds the narrow review message from deployment pins, chain
+ * state and the user's choice, the wallet signs only when both agree, and
+ * Daski's relayer submits it. Direct (contract accounts, or an EOA that asks
+ * for it): the gateway prepares the closed `attest` or `revoke` call, this
+ * CLI validates every field of it against the same chain facts and the
+ * profile's pinned EAS address, re-encodes the calldata, and prints the call
+ * for the wallet's own tool to submit. The CLI never sends a transaction in
+ * either mode, and never constructs anything that could.
+ *
+ * A direct submission is tracked in `orders.json`: `--tx <hash>` records the
+ * hash immediately as `submitted` (recorded, unverified) so a restart never
+ * loses the association; `--check` advances it to `observed` only when the
+ * receipt succeeded, the pinned EAS emitted the matching event with the payer
+ * as attester, `getAttestation` binds the attestation to what was prepared,
+ * and the gateway's final read, anchored at or past the receipt's block,
+ * shows the result. "Final" is the profile chain's finality tag, `safe` on
+ * the sandbox and `finalized` on Base mainnet, the rule the gateway applies
+ * through CHAIN_FINALITY_TAG. Evidence is bound to one final view: the
+ * profile's RPC must report the receipt's height as final before its
+ * canonical block at that height is compared with the receipt's block (a
+ * read below the RPC's own final height does not move without an L1
+ * reorganization, which the sandbox accepts), attestations are read pinned
+ * to that final height, and the gateway's final block must be that RPC's
+ * canonical block at its height, so the receipt's block is a final ancestor
+ * of the anchor. The RPC is taken as one consistent
+ * node. A batched receipt may carry other orders' events first; every
+ * candidate event is tried and the one whose attestation binds is taken.
+ * `--abandon` clears the local record when no hash is recorded or the receipt
+ * is a revert in a final canonical block, and cancels nothing at the
+ * wallet. A hash recorded by mistake is corrected (replaced with `--tx`, or
+ * cleared with `--abandon`) only once its transaction is final and
+ * canonical and no candidate event binds to this call; a missing, pending,
+ * not yet final, or matching receipt keeps the record.
+ *
+ * One order's journal is updated under a per-order lock: the read-check-write
+ * of a preparation spans gateway and chain calls, and two concurrent
+ * preparations must not both find nothing pending. The signer is resolved
+ * before the lock, so no passphrase prompt runs inside it.
+ */
 import { canonicalHash } from "@daski/x402-scheme";
-import { createPublicClient, encodeAbiParameters, getAddress, http, parseAbi, parseAbiParameters } from "viem";
+import { decodeEventLog, encodeAbiParameters, encodeFunctionData, getAddress, isAddressEqual, keccak256, parseAbi, parseAbiParameters, } from "viem";
+import { finalityTagFor } from "../chain/reader.js";
 import { CliError } from "../cli/errors.js";
 import { callAuthorizedLifecycleTool } from "../gateway/lifecycle.js";
-import { updateOrder } from "../store/orders.js";
-import { readWithCapability, withOrder } from "./order.js";
+import { confirmationPinsMissing, easAddressMismatch } from "../gateway/metadata.js";
+import { findByIntent, updateOrder, withOrderLock, } from "../store/orders.js";
+import { readWithCapability } from "./order.js";
+export const FINAL_ATTESTATION_WARNING = "this is the last confirmation you can submit; it can still be revoked";
+export const ATTESTATION_CAP = 3;
+const ZERO_UID = `0x${"00".repeat(32)}`;
+const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+const HEX32 = /^0x[0-9a-fA-F]{64}$/;
 const attestTypes = { Attest: [
         { name: "schema", type: "bytes32" }, { name: "recipient", type: "address" },
         { name: "expirationTime", type: "uint64" }, { name: "revocable", type: "bool" },
@@ -14,21 +65,62 @@ const revokeTypes = { Revoke: [
         { name: "schema", type: "bytes32" }, { name: "uid", type: "bytes32" },
         { name: "value", type: "uint256" }, { name: "nonce", type: "uint256" }, { name: "deadline", type: "uint64" },
     ] };
+/** EAS 1.2.0: the two calls direct mode validates, the read that binds a receipt, and the events. */
+export const EAS_ABI = parseAbi([
+    "function attest((bytes32 schema,(address recipient,uint64 expirationTime,bool revocable,bytes32 refUID,bytes data,uint256 value) data) request) payable returns (bytes32)",
+    "function revoke((bytes32 schema,(bytes32 uid,uint256 value) data) request) payable",
+    "function getAttestation(bytes32 uid) view returns ((bytes32 uid,bytes32 schema,uint64 time,uint64 expirationTime,uint64 revocationTime,bytes32 refUID,address recipient,address attester,bool revocable,bytes data))",
+    "function getNonce(address account) view returns (uint256)",
+    "event Attested(address indexed recipient,address indexed attester,bytes32 uid,bytes32 indexed schemaUID)",
+    "event Revoked(address indexed recipient,address indexed attester,bytes32 uid,bytes32 indexed schemaUID)",
+]);
+export const REPUTATION_ABI = parseAbi([
+    "function getRecord(bytes32 orderKey) view returns ((bytes32 orderKey,bytes32 authorizationKey,uint256 providerAgentId,bytes32 serviceId,address payer,address providerOwner,address providerAgentWallet,address providerPayee,address canonicalToken,uint256 grossAmount,uint64 paidAt,bytes32 providerIdentitySnapshotHash,bytes32 listingManifestHash,bytes32 releaseEvidenceHash,uint8 outcome,uint8 confirmation,uint64 outcomeAttestationDelay,uint64 outcomeTimestamp,uint64 confirmationTimestamp,uint8 confirmationSubmissions,bool outcomeRecorded,bool reputationEligible,bytes32 currentConfirmationUid))",
+]);
+/** The attestation payload for an order and label. */
+export function confirmationData(orderKey, choice) {
+    return encodeAbiParameters(parseAbiParameters("bytes32 orderKey,uint8 confirmation"), [orderKey, choice === "Confirmed" ? 1 : 2]);
+}
+/** Mode by signer: a contract account submits directly; a plain wallet is sponsored unless it asks otherwise. */
+export function selectConfirmationMode(description, requested) {
+    const contract = description.accountType === "contract";
+    if (requested === undefined)
+        return contract ? "direct" : "sponsored";
+    if (requested !== "sponsored" && requested !== "direct") {
+        throw new CliError({
+            code: "DASKI_CONFIRMATION_SUBMISSION_INVALID",
+            message: `--submission must be sponsored or direct, not "${requested}".`,
+            remediation: "Omit the flag to let the signer decide, or pass --submission direct.",
+        });
+    }
+    if (requested === "sponsored" && contract) {
+        throw new CliError({
+            code: "DASKI_CONFIRMATION_SPONSORED_REQUIRES_EOA",
+            message: `The ${description.provider} signer is a contract account; Daski sponsors attestations ` +
+                "for plain wallets only.",
+            remediation: "Omit --submission (or pass --submission direct): the CLI prints a validated call for " +
+                "the wallet's own tool to submit.",
+        });
+    }
+    return requested;
+}
 /** Rebuild the narrow EAS review message from chain facts and the user's choice. */
 export function validateConfirmationPreparation(prepared, facts, choice, acknowledged, now = Math.floor(Date.now() / 1000)) {
     const proposed = prepared.signableTypedData;
     const deadline = Number(proposed?.message?.deadline);
+    const final = choice !== "revoke" && facts.submissionsUsed === ATTESTATION_CAP - 1;
     if (!proposed || prepared.orderKey !== facts.orderKey || prepared.currentRefUid !== facts.currentUid ||
-        prepared.transitionsUsed !== facts.transitionsUsed || facts.transitionsUsed >= 3 ||
-        (facts.transitionsUsed === 2 && !acknowledged) || !Number.isSafeInteger(deadline) || deadline <= now || deadline > now + 330) {
+        prepared.submissionsUsed !== facts.submissionsUsed || Boolean(prepared.finalAttestation) !== final ||
+        (choice !== "revoke" && facts.submissionsUsed >= ATTESTATION_CAP) ||
+        (choice === "revoke" && facts.currentUid === ZERO_UID) || (final && !acknowledged) ||
+        !Number.isSafeInteger(deadline) || deadline <= now || deadline > now + 330) {
         throw invalidPreparation();
     }
     const common = { schema: facts.schemaUid, value: "0", nonce: facts.nonce, deadline: String(deadline) };
     const expected = { domain: { name: "EAS", version: "1.2.0", chainId: facts.chainId, verifyingContract: facts.eas },
         types: choice === "revoke" ? revokeTypes : attestTypes, primaryType: choice === "revoke" ? "Revoke" : "Attest",
         message: choice === "revoke" ? { ...common, uid: facts.currentUid } : { ...common, recipient: facts.recipient,
-            expirationTime: "0", revocable: true, refUID: facts.currentUid,
-            data: encodeAbiParameters(parseAbiParameters("bytes32 orderKey,uint8 confirmation"), [facts.orderKey, choice === "Confirmed" ? 1 : 2]) } };
+            expirationTime: "0", revocable: true, refUID: facts.currentUid, data: confirmationData(facts.orderKey, choice) } };
     if (canonicalHash(proposed) !== canonicalHash(expected))
         throw invalidPreparation();
     return expected;
@@ -37,87 +129,706 @@ function invalidPreparation() {
     return new CliError({ code: "DASKI_CONFIRMATION_MISMATCH", message: "The review preparation does not match this order and choice.",
         remediation: "Check the order and request a fresh review preparation." });
 }
+function invalidCall(reason) {
+    return new CliError({
+        code: "DASKI_CONFIRMATION_PREPARATION_INVALID",
+        message: `The prepared call does not match this order's chain facts: ${reason}.`,
+        remediation: "Nothing was shown or submitted. Run daski doctor --json to check the gateway's " +
+            "confirmation pins, then request a fresh preparation.",
+    });
+}
+function sameHex(a, b) {
+    return typeof a === "string" && a.toLowerCase() === b.toLowerCase();
+}
+function exactKeys(value, keys) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const actual = Object.keys(value).sort();
+    return actual.join(",") === [...keys].sort().join(",");
+}
+/**
+ * Validates a direct-mode call against chain facts exactly as the sponsored
+ * path validates its typed data: chain id, the pinned EAS as target, the
+ * pinned schema, the recipient, refUID, data and zero value derived from
+ * `getRecord` and the label, and calldata that re-encodes identically. Any
+ * mismatch aborts before the call is shown.
+ */
+export function validateDirectCall(value, facts, choice, easAddress) {
+    if (!exactKeys(value, ["chainId", "to", "function", "request", "calldata", "value"]))
+        throw invalidCall("unexpected call shape");
+    const call = value;
+    if (call.value !== "0")
+        throw invalidCall(`value ${String(call.value)} is not zero`);
+    if (call.chainId !== facts.chainId)
+        throw invalidCall(`chain ${String(call.chainId)} is not ${facts.chainId}`);
+    if (typeof call.to !== "string" || !/^0x[0-9a-fA-F]{40}$/.test(call.to) ||
+        !isAddressEqual(getAddress(call.to), easAddress) || !isAddressEqual(easAddress, facts.eas)) {
+        throw invalidCall(`target ${String(call.to)} is not the pinned EAS ${easAddress}`);
+    }
+    const action = choice === "revoke" ? "revoke" : "attest";
+    if (call.function !== action)
+        throw invalidCall(`function ${String(call.function)} is not ${action}`);
+    if (!exactKeys(call.request, ["schema", "data"]) || !sameHex(call.request.schema, facts.schemaUid)) {
+        throw invalidCall("the request does not name the pinned confirmation schema");
+    }
+    const fields = call.request.data;
+    let calldata;
+    let data;
+    if (action === "attest") {
+        if (!exactKeys(fields, ["recipient", "expirationTime", "revocable", "refUID", "data", "value"])) {
+            throw invalidCall("unexpected attest request shape");
+        }
+        data = confirmationData(facts.orderKey, choice);
+        if (typeof fields.recipient !== "string" || !/^0x[0-9a-fA-F]{40}$/.test(fields.recipient) ||
+            !isAddressEqual(getAddress(fields.recipient), facts.recipient))
+            throw invalidCall("recipient differs from the provider on record");
+        if (fields.expirationTime !== "0" || fields.revocable !== true || fields.value !== "0")
+            throw invalidCall("expirationTime, revocable or value differ from the confirmation profile");
+        if (!sameHex(fields.refUID, facts.currentUid))
+            throw invalidCall("refUID differs from the current confirmation");
+        if (!sameHex(fields.data, data))
+            throw invalidCall("data differs from the order key and label");
+        if (facts.submissionsUsed >= ATTESTATION_CAP)
+            throw invalidCall("all attestations for this order are used");
+        calldata = encodeFunctionData({ abi: EAS_ABI, functionName: "attest", args: [{
+                    schema: facts.schemaUid, data: { recipient: facts.recipient, expirationTime: 0n, revocable: true,
+                        refUID: facts.currentUid, data, value: 0n }
+                }] });
+    }
+    else {
+        if (!exactKeys(fields, ["uid", "value"]))
+            throw invalidCall("unexpected revoke request shape");
+        if (facts.currentUid === ZERO_UID)
+            throw invalidCall("no confirmation is active to revoke");
+        if (!sameHex(fields.uid, facts.currentUid))
+            throw invalidCall("uid differs from the current confirmation");
+        if (fields.value !== "0")
+            throw invalidCall("value is not zero");
+        calldata = encodeFunctionData({ abi: EAS_ABI, functionName: "revoke", args: [{
+                    schema: facts.schemaUid, data: { uid: facts.currentUid, value: 0n }
+                }] });
+    }
+    if (!sameHex(call.calldata, calldata))
+        throw invalidCall("calldata does not re-encode from the request");
+    return {
+        action,
+        call: {
+            chainId: facts.chainId, to: easAddress, function: action,
+            request: call.request, calldata: call.calldata.toLowerCase(), value: "0",
+        },
+        data,
+    };
+}
 export async function runConfirmation(options) {
+    const { withOrder } = await import("./order.js");
     return withOrder(options, (context, record) => confirmOrder(context, record, options));
 }
+/**
+ * Gateway refusals the submit phase raises before any sponsorship is reserved
+ * (request shape, mode, signature, exhausted budget): the signed request was
+ * never admitted, so the retained submission is cleared and another mode can
+ * be prepared. Anything else may have been admitted and keeps the record for
+ * --resume: an unavailable chain read, a transport failure, and
+ * CONFIRMATION_PREPARATION_STALE, which the gateway also answers once its
+ * preparation TTL has passed for a submission it admitted earlier, so a stale
+ * answer on --resume says nothing about whether the operation is running.
+ */
+const REFUSED_BEFORE_ADMISSION = new Set([
+    "CONFIRMATION_REQUEST_INVALID",
+    "CONFIRMATION_SPONSORED_REQUIRES_EOA",
+    "CONFIRMATION_SIGNATURE_INVALID",
+    "CONFIRMATION_SPONSORSHIP_LIMIT",
+]);
+/** The record as the store holds it now; the caller's copy may predate another process's write. */
+function latest(record) {
+    return findByIntent(record.intentId) ?? record;
+}
 export async function confirmOrder(context, record, options, factsReader = readConfirmationFacts) {
-    if (!options.resume && !options.revoke && !["Confirmed", "NotConfirmed"].includes(options.confirmation ?? "")) {
+    const handle = record.handle ?? options.handle;
+    if (options.tx !== undefined || options.check || options.abandon) {
+        // Only --check signs (the gateway's check authorization); the signer is
+        // resolved before the lock so a passphrase prompt never runs inside it.
+        const signer = options.check ? await context.resolveSigner() : undefined;
+        return withOrderLock(record.intentId, () => {
+            const current = latest(record);
+            if (options.check && !options.tx && !options.abandon) {
+                const target = checkTarget(current.confirmationTx, options.submission, signer.describe());
+                if (target.kind === "gateway")
+                    return checkGatewayReview(context, current, handle, target.submission);
+            }
+            return manageDirectRecord(context, current, options);
+        });
+    }
+    const choice = options.revoke ? "revoke"
+        : options.confirmation === "Confirmed" || options.confirmation === "NotConfirmed" ? options.confirmation : undefined;
+    if (!options.resume && choice === undefined) {
         throw new CliError({ code: "DASKI_CONFIRMATION_CHOICE_REQUIRED", message: "Choose the delivery confirmation for this order.",
             remediation: "After the user's choice, pass --choice Confirmed or --choice NotConfirmed. Leaving it Pending requires no action." });
     }
-    if (record.confirmationSubmission && !options.resume)
-        throw new CliError({ code: "DASKI_CONFIRMATION_PENDING",
-            message: "A review submission for this order is awaiting reconciliation.", remediation: `Run daski order confirm ${options.handle} --resume.` });
     const call = (action, request) => callAuthorizedLifecycleTool({
         client: context.client, signer: context.signer, toolName: action === "confirmation" ? "daski_confirm_delivery" : "daski_revoke_delivery_confirmation",
-        action, orderHandle: record.handle ?? options.handle, request, chainId: context.profile.chainId, gatewayUrl: context.profile.gatewayUrl
+        action, orderHandle: handle, request, chainId: context.profile.chainId, gatewayUrl: context.profile.gatewayUrl
     });
-    let submission = record.confirmationSubmission;
-    if (!submission) {
-        if (options.resume)
-            throw new CliError({ code: "DASKI_CONFIRMATION_NOT_PENDING", message: "There is no pending review submission.",
-                remediation: "Check order status, then supply the user's review choice if a new review is wanted." });
-        const action = options.revoke ? "revoke-confirmation" : "confirmation";
-        const facts = await factsReader(context, record);
-        const prepared = await call(action, { phase: "prepare", acknowledgeFinalTransition: options.acknowledgeFinalTransition === true,
-            ...(options.revoke ? {} : { confirmation: options.confirmation }) });
-        if (!prepared.signableTypedData) {
-            if (prepared.warning?.code !== "FINAL_CONFIRMATION_TRANSITION")
+    // Every path below signs something; building the signer may prompt a
+    // person, which must not happen while the order's lock is held.
+    const signer = await context.resolveSigner();
+    return withOrderLock(record.intentId, async () => {
+        record = latest(record);
+        if (record.confirmationSubmission && !options.resume)
+            throw new CliError({ code: "DASKI_CONFIRMATION_PENDING",
+                message: "A review submission for this order is awaiting reconciliation.", remediation: `Run daski order confirm ${options.handle} --resume.` });
+        let submission = record.confirmationSubmission;
+        if (!submission) {
+            if (options.resume)
+                throw new CliError({ code: "DASKI_CONFIRMATION_NOT_PENDING", message: "There is no pending review submission.",
+                    remediation: "Check order status, then supply the user's review choice if a new review is wanted." });
+            const action = options.revoke ? "revoke-confirmation" : "confirmation";
+            // One review journal per order: a direct submission still prepared or
+            // submitted blocks any new preparation, sponsored included, so a second
+            // review cannot be signed while the first is unresolved on chain.
+            if (isPendingDirect(record.confirmationTx))
+                throw directPending(handle, record.confirmationTx);
+            const mode = selectConfirmationMode(signer.describe(), options.submission);
+            const facts = await factsReader(context, record);
+            assertCapacity(facts, choice, handle);
+            const acknowledged = options.acknowledgeFinalTransition === true;
+            // Revocation preparation carries no acknowledgement: only an attestation
+            // can be final, and the gateway's closed request shape rejects the key.
+            const prepared = await call(action, { phase: "prepare", submission: mode,
+                ...(options.revoke ? {} : { confirmation: options.confirmation, acknowledgeFinalTransition: acknowledged }) });
+            // Whether this attestation is the final one is a chain fact, decided here
+            // for both modes; the gateway's count and flag must agree with it, and
+            // the signable or call is withheld only for the unacknowledged final one.
+            const final = choice !== "revoke" && facts.submissionsUsed === ATTESTATION_CAP - 1;
+            if (prepared.submissionsUsed !== facts.submissionsUsed || Boolean(prepared.finalAttestation) !== final) {
+                throw invalidPreparation();
+            }
+            const summary = { submissionsUsed: facts.submissionsUsed, revocationAvailable: facts.currentUid !== ZERO_UID, finalAttestation: final };
+            const withheld = mode === "sponsored" ? !prepared.signableTypedData : !prepared.call;
+            if (withheld) {
+                if (!final || acknowledged)
+                    throw invalidPreparation();
+                return { orderHandle: record.handle, mode, ...summary,
+                    warning: { code: "FINAL_ATTESTATION", message: FINAL_ATTESTATION_WARNING },
+                    next: "Show the warning to the user. After explicit acceptance, repeat with --acknowledge-final-transition." };
+            }
+            if (final && !acknowledged)
                 throw invalidPreparation();
-            return { orderHandle: record.handle, ...prepared,
-                next: "Show the final-transition warning to the user. After explicit acceptance, repeat with --acknowledge-final-transition." };
+            const warning = final ? { code: "FINAL_ATTESTATION", message: FINAL_ATTESTATION_WARNING } : undefined;
+            if (mode === "direct") {
+                const validated = validateDirectCall(prepared.call, facts, choice, context.profile.easAddress);
+                const expected = await expectedBinding(context, facts, validated, signer);
+                const tracked = {
+                    action: validated.action,
+                    callHash: canonicalHash(validated.call),
+                    expected,
+                    state: "prepared",
+                    preparedAt: new Date().toISOString(),
+                };
+                updateOrder(record.intentId, { confirmationTx: tracked });
+                return { orderHandle: record.handle, mode, action: validated.action, ...summary,
+                    ...(warning ? { warning } : {}),
+                    call: validated.call,
+                    callHash: tracked.callHash,
+                    note: "This CLI validated the call against chain facts and sends no transaction.",
+                    next: "Submit the call with the wallet's own tool (for the Circle agent wallet, the circle CLI). " +
+                        `Then record the hash: daski order confirm ${handle} --tx <hash>, and verify it: ` +
+                        `daski order confirm ${handle} --check.` };
+            }
+            const typedData = validateConfirmationPreparation(prepared, facts, choice, acknowledged);
+            if (typeof prepared.preparationId !== "string")
+                throw invalidPreparation();
+            const signature = await signer.signTypedData(typedData);
+            submission = { action, request: { phase: "submit", submission: "sponsored", preparationId: prepared.preparationId, signature } };
+            updateOrder(record.intentId, { confirmationSubmission: submission, readCapability: undefined });
+        }
+        try {
+            const result = await call(submission.action, submission.request);
+            updateOrder(record.intentId, { confirmationSubmission: undefined, readCapability: undefined });
+            return { orderHandle: record.handle, mode: "sponsored", ...result };
+        }
+        catch (error) {
+            if (error instanceof CliError && error.code === "CONFIRMATION_SUBMISSION_PENDING")
+                return {
+                    orderHandle: record.handle, mode: "sponsored", status: "pending", preparationId: submission.request.preparationId,
+                    next: `Run daski order confirm ${options.handle} --resume to check the same submission.`
+                };
+            if (error instanceof CliError && REFUSED_BEFORE_ADMISSION.has(error.code)) {
+                updateOrder(record.intentId, { confirmationSubmission: undefined });
+            }
+            if (error instanceof CliError && error.code === "CONFIRMATION_PREPARATION_STALE") {
+                throw new CliError({
+                    code: error.code,
+                    message: error.message,
+                    remediation: "The gateway may already have admitted this submission before its preparation expired, " +
+                        `so the signed submission is kept. Keep running daski order confirm ${options.handle} --resume ` +
+                        `(or --check) until the gateway reports the operation's state; a new preparation is refused ` +
+                        "while this one is pending.",
+                    details: error.details,
+                });
+            }
+            throw error;
+        }
+    });
+}
+function assertCapacity(facts, choice, handle) {
+    if (choice === "revoke") {
+        if (facts.currentUid === ZERO_UID)
+            throw new CliError({
+                code: "DASKI_CONFIRMATION_NOT_ACTIVE",
+                message: "No confirmation is active for this order, so there is nothing to revoke.",
+                remediation: `Submit one with daski order confirm ${handle} --choice Confirmed|NotConfirmed.`,
+            });
+        return;
+    }
+    if (facts.submissionsUsed >= ATTESTATION_CAP)
+        throw new CliError({
+            code: "DASKI_CONFIRMATION_CAP_REACHED",
+            message: `All ${ATTESTATION_CAP} confirmations for this order have been submitted; none can be added.`,
+            remediation: facts.currentUid === ZERO_UID
+                ? "No confirmation is active and no further one can be submitted for this order."
+                : `The current confirmation can still be revoked: daski order revoke-confirmation ${handle}.`,
+        });
+}
+function isPendingDirect(tracked) {
+    return tracked !== undefined && (tracked.state === "prepared" || tracked.state === "submitted");
+}
+/** A direct record that --tx, --check, or --abandon can act on: anything but none or abandoned. */
+function isDirectTracked(tracked) {
+    return tracked !== undefined && tracked.state !== "abandoned";
+}
+/**
+ * What --check consults. An explicit --submission decides: `direct` verifies
+ * the recorded transaction (refused when none is tracked), `sponsored` asks
+ * the gateway. Otherwise a direct record still prepared or submitted is
+ * verified, and anything else (no record, an abandoned one, or one already
+ * observed) asks the gateway for the order's current state in the signer's
+ * mode, so a review submitted after an observed direct one is never hidden
+ * behind the retained receipt.
+ */
+function checkTarget(tracked, requested, description) {
+    if (requested === "direct")
+        return { kind: "record" };
+    if (requested === "sponsored")
+        return { kind: "gateway", submission: "sponsored" };
+    if (requested !== undefined) {
+        throw new CliError({
+            code: "DASKI_CONFIRMATION_SUBMISSION_INVALID",
+            message: `--submission must be sponsored or direct, not "${requested}".`,
+            remediation: "Omit the flag to check the pending direct record or the gateway's state, or pass --submission direct|sponsored.",
+        });
+    }
+    if (isPendingDirect(tracked))
+        return { kind: "record" };
+    return { kind: "gateway", submission: selectConfirmationMode(description, undefined) };
+}
+/**
+ * `--check` against the gateway: its final read of the order's confirmation
+ * state, which its relayer reconciles after a sponsored submission mined and
+ * which a direct submission moves once its receipt is covered. Nothing is
+ * stored locally; an observed direct record is reported next to it as
+ * history.
+ */
+async function checkGatewayReview(context, record, handle, submission) {
+    const check = await callAuthorizedLifecycleTool({
+        client: context.client, signer: context.signer, toolName: "daski_confirm_delivery", action: "confirmation",
+        orderHandle: handle, request: { phase: "check", submission },
+        chainId: context.profile.chainId, gatewayUrl: context.profile.gatewayUrl,
+    });
+    const anchor = finalizedAnchor(check);
+    const tracked = record.confirmationTx;
+    return { orderHandle: record.handle, mode: submission, state: "checked",
+        confirmedCurrent: check.confirmedCurrent ?? null, lastObserved: check.lastObserved ?? null,
+        submissionsUsed: check.submissionsUsed ?? null,
+        finalizedBlock: anchor ? anchor.number.toString() : null,
+        ...(record.confirmationSubmission ? { pendingSubmission: record.confirmationSubmission.request.preparationId } : {}),
+        ...(tracked && isDirectTracked(tracked)
+            ? { directRecord: { action: tracked.action, state: tracked.state, callHash: tracked.callHash,
+                    ...(tracked.txHash ? { txHash: tracked.txHash } : {}), ...(tracked.uid ? { uid: tracked.uid } : {}) } }
+            : {}),
+        note: `confirmedCurrent is the gateway's final state; lastObserved is its latest read. ${finalityNote(context.profile.chainId)}` +
+            (tracked?.state === "observed" ? " The observed direct record is kept as history; --submission direct returns its recorded evidence." : ""),
+        next: record.confirmationSubmission
+            ? `A sponsored submission is still pending here: daski order confirm ${handle} --resume.`
+            : `Run daski order confirm ${handle} --check again once the chain's final view has caught up.` };
+}
+function directPending(handle, tracked) {
+    return new CliError({
+        code: "DASKI_CONFIRMATION_TX_PENDING",
+        message: `A direct ${tracked.action} for this order is ${tracked.state}` +
+            (tracked.txHash ? ` (transaction ${tracked.txHash})` : "") + "; a new preparation is refused until it is resolved.",
+        remediation: tracked.txHash
+            ? `Verify it with daski order confirm ${handle} --check. If the transaction reverted, clear it with --abandon.`
+            : `Submit the prepared call and record it with daski order confirm ${handle} --tx <hash>, or clear it with --abandon.`,
+    });
+}
+/** What a receipt must later bind to: the values the prepared call commits to. */
+async function expectedBinding(context, facts, validated, signer) {
+    if (validated.action === "attest") {
+        return { schema: facts.schemaUid, recipient: facts.recipient, refUID: facts.currentUid, dataHash: keccak256(validated.data) };
+    }
+    // A revocation binds to the attestation it revokes, read now so the receipt
+    // can be matched later without trusting the event alone.
+    const current = await readAttestation(context.chain, facts.eas, facts.currentUid);
+    const payer = getAddress(await signer.getAddress());
+    if (!sameHex(current.uid, facts.currentUid) || !sameHex(current.schema, facts.schemaUid) ||
+        !isAddressEqual(current.attester, payer))
+        throw invalidCall("the current confirmation is not this payer's");
+    return { schema: facts.schemaUid, recipient: getAddress(current.recipient), refUID: current.refUID,
+        dataHash: keccak256(current.data), uid: facts.currentUid };
+}
+async function readAttestation(chain, eas, uid, blockNumber) {
+    return chain.readContract({ address: eas, abi: EAS_ABI, functionName: "getAttestation", args: [uid],
+        ...(blockNumber === undefined ? {} : { blockNumber }) });
+}
+// -- direct record management: --tx, --check, --abandon -------------------------
+async function manageDirectRecord(context, record, options) {
+    const handle = record.handle ?? options.handle;
+    const tracked = record.confirmationTx;
+    const flags = [options.tx !== undefined, options.check === true, options.abandon === true].filter(Boolean).length;
+    if (flags > 1 || options.resume || options.confirmation !== undefined) {
+        throw new CliError({ code: "DASKI_CONFIRMATION_FLAGS_CONFLICT",
+            message: "--tx, --check and --abandon each stand alone.",
+            remediation: "Pass exactly one of them, without --choice or --resume." });
+    }
+    if (!tracked || tracked.state === "abandoned") {
+        throw new CliError({ code: "DASKI_CONFIRMATION_TX_NOT_PREPARED",
+            message: "No direct confirmation is being tracked for this order.",
+            remediation: `Prepare one first: daski order confirm ${handle} --choice Confirmed|NotConfirmed (or daski order revoke-confirmation ${handle}).` });
+    }
+    const base = { orderHandle: record.handle, mode: "direct", action: tracked.action, callHash: tracked.callHash };
+    const cancelsNothing = "This cancels nothing at the wallet: a transaction already sent is unaffected.";
+    if (options.tx !== undefined) {
+        if (!HEX32.test(options.tx))
+            throw new CliError({ code: "DASKI_CONFIRMATION_TX_MALFORMED",
+                message: `--tx expects a 32-byte transaction hash, got "${options.tx}".`,
+                remediation: "Pass the hash the wallet's tool reported, e.g. --tx 0x<64 hex characters>." });
+        const txHash = options.tx.toLowerCase();
+        if (tracked.state === "observed")
+            throw new CliError({ code: "DASKI_CONFIRMATION_TX_ALREADY_RECORDED",
+                message: `This confirmation was already observed as ${tracked.txHash}.`,
+                remediation: "Nothing to record. Prepare a new confirmation if another submission is wanted." });
+        let corrected;
+        if (tracked.state === "submitted" && tracked.txHash !== txHash) {
+            // Replacing a recorded hash is a journal correction, allowed only once the
+            // recorded transaction is canonical, final, and provably not the
+            // prepared call.
+            const unrelated = await provenUnrelated(context, tracked, handle);
+            if (!unrelated)
+                throw new CliError({ code: "DASKI_CONFIRMATION_TX_ALREADY_RECORDED",
+                    message: `Transaction ${tracked.txHash} is already recorded for this confirmation.`,
+                    remediation: `Verify it with daski order confirm ${handle} --check. A recorded hash is replaced only once its ` +
+                        "transaction is final and carries no event that binds to the prepared call; if it reverted, --abandon clears it first." });
+            corrected = { previousTxHash: tracked.txHash, reason: unrelated };
         }
-        const typedData = validateConfirmationPreparation(prepared, facts, options.revoke ? "revoke" : options.confirmation, options.acknowledgeFinalTransition === true);
-        if (typeof prepared.preparationId !== "string")
-            throw invalidPreparation();
-        const signature = await context.signer.signTypedData(typedData);
-        submission = { action, request: { phase: "submit", preparationId: prepared.preparationId, signature } };
-        updateOrder(record.intentId, { confirmationSubmission: submission, readCapability: undefined });
+        updateOrder(record.intentId, { confirmationTx: { ...tracked, txHash, state: "submitted" } });
+        return { ...base, txHash, state: "submitted", verification: "recorded, not yet verified",
+            ...(corrected ? { corrected, note: `The previously recorded transaction is final and unrelated to the prepared call (${corrected.reason}); the record now tracks the new hash. ${cancelsNothing}` } : {}),
+            next: `Run daski order confirm ${handle} --check once the transaction is mined. ${finalityNote(context.profile.chainId)}` };
     }
+    if (options.check)
+        return checkDirectRecord(context, record, tracked, handle, base);
+    // --abandon: only when nothing recorded can still execute: no hash, a
+    // revert in a final canonical block, or a final canonical
+    // transaction provably not this call. A revert in a block that is not yet final
+    // settles nothing: a reorganization can re-include the transaction against
+    // different state.
+    let unrelatedReceipt;
+    if (tracked.txHash) {
+        const receipt = await context.chain.getTransactionReceipt(tracked.txHash);
+        if (!receipt)
+            throw new CliError({ code: "DASKI_CONFIRMATION_TX_MAY_EXECUTE",
+                message: `Transaction ${tracked.txHash} has no receipt yet and may still execute.`,
+                remediation: `Wait for it to be mined, then run daski order confirm ${handle} --check. Abandon is allowed only when the receipt is a final revert or the transaction is final and unrelated to this call.` });
+        if (receipt.status === "success") {
+            const unrelated = await provenUnrelated(context, tracked, handle, receipt);
+            if (!unrelated)
+                throw new CliError({ code: "DASKI_CONFIRMATION_TX_MAY_EXECUTE",
+                    message: `Transaction ${tracked.txHash} executed; the record cannot be abandoned.`,
+                    remediation: `Verify it with daski order confirm ${handle} --check.` });
+            unrelatedReceipt = unrelated;
+        }
+        else {
+            const view = await receiptView(context, receipt);
+            if (!view.final || !view.canonical)
+                throw new CliError({ code: "DASKI_CONFIRMATION_TX_MAY_EXECUTE",
+                    message: `Transaction ${tracked.txHash} reverted in ${view.final
+                        ? "a block that is not the chain's canonical block at its height"
+                        : `block ${receipt.blockNumber}, which is not final yet (final block ${view.finalBlock})`}; it may still be re-included.`,
+                    remediation: `Wait for the block to become final. ${finalityNote(context.profile.chainId)} Then run daski order confirm ${handle} --check and --abandon.` });
+        }
+    }
+    updateOrder(record.intentId, { confirmationTx: { ...tracked, state: "abandoned" } });
+    return { ...base, ...(tracked.txHash ? { txHash: tracked.txHash } : {}), state: "abandoned",
+        ...(unrelatedReceipt ? { unrelatedReceipt } : {}),
+        note: `Local tracking was cleared. ${cancelsNothing}` +
+            (unrelatedReceipt ? " If the prepared call was sent under another hash, prepare nothing new: record that hash instead." : ""),
+        next: `Prepare again when ready: daski order confirm ${handle} --choice Confirmed|NotConfirmed.` };
+}
+/** How long "final" takes on the profile's chain, for the buyer's next step. */
+function finalityNote(chainId) {
+    return finalityTagFor(chainId) === "finalized"
+        ? "Finality on Base mainnet (the finalized tag) takes minutes to tens of minutes."
+        : "The sandbox treats Base Sepolia's safe tag as final; it lags the head by minutes.";
+}
+/**
+ * The one final view every canonical read uses (R04): the RPC's final height
+ * is read first, and the canonical block at the receipt's height is compared
+ * only when that height is already final there, so the comparison cannot be
+ * overtaken by a reorganization. The RPC is one consistent node; a balancer
+ * over unsynchronized nodes is outside this guarantee.
+ */
+async function receiptView(context, receipt) {
+    const finalBlock = await context.chain.getFinalBlockNumber();
+    if (receipt.blockNumber > finalBlock)
+        return { finalBlock, final: false, canonical: false };
+    const canonical = sameHex(await context.chain.getBlockHash(receipt.blockNumber), receipt.blockHash);
+    return { finalBlock, final: true, canonical };
+}
+/**
+ * The reason a recorded, successful transaction is provably not the prepared
+ * call, or null when it is (or may be) this call. The finalized view is
+ * established first; only a finalized canonical receipt none of whose
+ * candidate events binds is unrelated. A related receipt keeps the record;
+ * an unrelated one that is not yet finalized and canonical is refused until
+ * it is, so a reorganization cannot turn a correction into a lost call.
+ */
+async function provenUnrelated(context, tracked, handle, known) {
+    if (!tracked.txHash)
+        return null;
+    const receipt = known ?? await context.chain.getTransactionReceipt(tracked.txHash);
+    if (!receipt || receipt.status !== "success")
+        return null;
+    const view = await receiptView(context, receipt);
+    if (!view.final)
+        throw new CliError({ code: "DASKI_CONFIRMATION_TX_UNFINALIZED",
+            message: `Transaction ${tracked.txHash} is not final yet (block ${receipt.blockNumber}, final block ${view.finalBlock}); whether it carried this confirmation cannot be settled.`,
+            remediation: `Wait for the block to become final. ${finalityNote(context.profile.chainId)} Then repeat the same daski order confirm ${handle} command.` });
+    if (!view.canonical)
+        throw new CliError({ code: "DASKI_CONFIRMATION_TX_UNFINALIZED",
+            message: `Transaction ${tracked.txHash} was carried by a block that is not the chain's canonical block at height ${receipt.blockNumber}.`,
+            remediation: `The transaction may be re-included or dropped. Wait, then repeat the same daski order confirm ${handle} command.` });
     try {
-        const result = await call(submission.action, submission.request);
-        updateOrder(record.intentId, { confirmationSubmission: undefined, readCapability: undefined });
-        return { orderHandle: record.handle, ...result };
+        await boundConfirmationUid(context, receipt, tracked, view.finalBlock);
+        return null;
     }
     catch (error) {
-        if (error instanceof CliError && error.code === "CONFIRMATION_SUBMISSION_PENDING")
-            return {
-                orderHandle: record.handle, status: "pending", preparationId: submission.request.preparationId,
-                next: `Run daski order confirm ${options.handle} --resume to check the same submission.`
-            };
-        if (error instanceof CliError && error.code === "CONFIRMATION_PREPARATION_STALE") {
-            updateOrder(record.intentId, { confirmationSubmission: undefined });
+        if (!(error instanceof CliError) || error.code !== "DASKI_CONFIRMATION_RECEIPT_UNRELATED")
+            throw error;
+        return error.message;
+    }
+}
+async function checkDirectRecord(context, record, tracked, handle, base) {
+    if (tracked.state === "observed") {
+        return { ...base, txHash: tracked.txHash, uid: tracked.uid, state: "observed", note: "Already observed; nothing further to verify." };
+    }
+    if (!tracked.txHash)
+        throw new CliError({ code: "DASKI_CONFIRMATION_TX_NOT_RECORDED",
+            message: "The prepared call has no transaction hash recorded yet.",
+            remediation: `Submit it with the wallet's own tool, then record the hash: daski order confirm ${handle} --tx <hash>.` });
+    const receipt = await context.chain.getTransactionReceipt(tracked.txHash);
+    if (!receipt) {
+        return { ...base, txHash: tracked.txHash, state: "submitted", receipt: "pending",
+            next: `The transaction is not mined yet. Run daski order confirm ${handle} --check again shortly.` };
+    }
+    const view = await receiptView(context, receipt);
+    const later = `${finalityNote(context.profile.chainId)} Run daski order confirm ${handle} --check again later.`;
+    if (receipt.status !== "success") {
+        const settled = view.final && view.canonical;
+        return { ...base, txHash: tracked.txHash, state: "submitted", receipt: "reverted", revertFinal: settled,
+            next: settled
+                ? `The transaction reverted in a final block. Clear the record with daski order confirm ${handle} --abandon, then prepare again.`
+                : `The transaction reverted, but ${view.final ? "the block that carried it is not the chain's canonical block" : "its block is not final yet"}; it may still be re-included. Run daski order confirm ${handle} --check again later, then --abandon.` };
+    }
+    if (!view.final) {
+        return { ...base, txHash: tracked.txHash, state: "submitted", receipt: "success",
+            verification: `the receipt's block ${receipt.blockNumber} is not final on the profile's RPC yet (final block ${view.finalBlock})`, next: later };
+    }
+    if (!view.canonical) {
+        return { ...base, txHash: tracked.txHash, state: "submitted", receipt: "reorganized",
+            verification: `the block that carried the transaction is not the chain's canonical block at height ${receipt.blockNumber}`,
+            next: `The transaction may be re-included or dropped. Run daski order confirm ${handle} --check again later.` };
+    }
+    const uid = await boundConfirmationUid(context, receipt, tracked, view.finalBlock);
+    const check = await callAuthorizedLifecycleTool({
+        client: context.client, signer: context.signer,
+        toolName: tracked.action === "attest" ? "daski_confirm_delivery" : "daski_revoke_delivery_confirmation",
+        action: tracked.action === "attest" ? "confirmation" : "revoke-confirmation",
+        orderHandle: handle, request: { phase: "check", submission: "direct" },
+        chainId: context.profile.chainId, gatewayUrl: context.profile.gatewayUrl,
+    });
+    const notYet = (verification) => ({ ...base, txHash: tracked.txHash, uid, state: "submitted", receipt: "success",
+        verification, check, next: later });
+    const anchor = finalizedAnchor(check);
+    if (!anchor || anchor.number < receipt.blockNumber) {
+        return notYet("the receipt, the EAS event and the attestation match the prepared call; the gateway's final read is not past the receipt's block yet");
+    }
+    // The gateway's final block must be this RPC's canonical block at its
+    // height; the receipt's block, final on this RPC at a lower or equal
+    // height, is then its ancestor, so the receipt's effect is what the anchor
+    // shows. The receipt's block is compared once more against the same view
+    // so an RPC that contradicted itself between the reads cannot pass.
+    if (!sameHex(await context.chain.getBlockHash(anchor.number), anchor.hash)) {
+        return notYet(`the gateway's final block ${anchor.number} is not the chain's canonical block at that height as the profile's RPC reports it`);
+    }
+    if (!sameHex(await context.chain.getBlockHash(receipt.blockNumber), receipt.blockHash)) {
+        return { ...base, txHash: tracked.txHash, uid, state: "submitted", receipt: "reorganized", check,
+            verification: `the profile's RPC changed its canonical block at height ${receipt.blockNumber} between reads`,
+            next: `Run daski order confirm ${handle} --check again later.` };
+    }
+    // Execution is proven: the final canonical receipt and the bound EAS
+    // record close the transaction. Whether the review still stands is a
+    // separate fact: the wallet may have revoked or replaced it since, and
+    // that must never leave the journal pending.
+    const review = reviewEffect(check, tracked, uid);
+    updateOrder(record.intentId, { confirmationTx: { ...tracked, uid, state: "observed" }, readCapability: undefined });
+    return { ...base, txHash: tracked.txHash, uid, state: "observed", receipt: "success", review,
+        observedBlock: receipt.blockNumber.toString(), finalizedBlock: anchor.number.toString(), check,
+        ...(review === "current" ? {} : {
+            note: tracked.action === "attest"
+                ? "The attestation executed but is no longer the order's current review: it was revoked or replaced afterwards."
+                : "The revocation executed; a later review is current.",
+        }) };
+}
+function unrelatedReceipt(reason) {
+    return new CliError({
+        code: "DASKI_CONFIRMATION_RECEIPT_UNRELATED",
+        message: `The recorded transaction does not carry this confirmation: ${reason}.`,
+        remediation: "The record stays submitted. If the hash was recorded by mistake, record the right one with " +
+            "--tx <hash> or clear the record with --abandon; a reverted transaction can be abandoned once its " +
+            "block is final. Otherwise check the wallet's tool for the transaction that carried the prepared call.",
+    });
+}
+/**
+ * Every Attested or Revoked event the pinned EAS emitted in the receipt for
+ * this payer and the confirmation schema (for a revocation, of the revoked
+ * uid). A smart-wallet batch can carry several orders' events, so all are
+ * candidates.
+ */
+function candidateEventUids(receipt, easAddress, tracked, payer) {
+    const wanted = tracked.action === "attest" ? "Attested" : "Revoked";
+    const uids = [];
+    let sawEas = false;
+    for (const log of receipt.logs) {
+        if (!isAddressEqual(log.address, easAddress))
+            continue;
+        sawEas = true;
+        let decoded;
+        try {
+            decoded = decodeEventLog({ abi: EAS_ABI, data: log.data, topics: log.topics });
         }
-        throw error;
+        catch {
+            continue;
+        }
+        if (decoded.eventName !== wanted)
+            continue;
+        const args = decoded.args;
+        if (!sameHex(args.schemaUID, tracked.expected.schema) || !isAddressEqual(args.attester, payer))
+            continue;
+        if (tracked.action === "revoke" && !sameHex(args.uid, tracked.expected.uid ?? ""))
+            continue;
+        uids.push(args.uid);
     }
+    return { uids, sawEas };
+}
+/**
+ * The uid among the receipt's candidate events whose attestation binds to
+ * the prepared call, or DASKI_CONFIRMATION_RECEIPT_UNRELATED when none does.
+ * Attestations are read pinned to the RPC's final height, the same view
+ * the receipt was placed in; a uid commits to every field the binding checks,
+ * and a revocation time only ever moves from zero, so that view is complete.
+ */
+async function boundConfirmationUid(context, receipt, tracked, finalizedBlock) {
+    const easAddress = context.profile.easAddress;
+    const { uids, sawEas } = candidateEventUids(receipt, easAddress, tracked, context.payerAddress);
+    const wanted = tracked.action === "attest" ? "Attested" : "Revoked";
+    if (uids.length === 0) {
+        throw unrelatedReceipt(sawEas
+            ? `no ${wanted} event for the confirmation schema with the payer as attester`
+            : `no log was emitted by the pinned EAS ${easAddress}`);
+    }
+    const mismatches = [];
+    for (const uid of uids) {
+        const mismatch = bindingMismatch(await readAttestation(context.chain, easAddress, uid, finalizedBlock), tracked, uid);
+        if (!mismatch)
+            return uid;
+        mismatches.push(mismatch);
+    }
+    throw unrelatedReceipt(mismatches.length === 1
+        ? mismatches[0]
+        : `none of the ${uids.length} candidate events binds to the prepared call (${mismatches.join("; ")})`);
+}
+/** Events do not carry refUID, recipient or data; the attestation itself must. Returns the first mismatch, or null. */
+function bindingMismatch(attestation, tracked, uid) {
+    const expected = tracked.expected;
+    if (!sameHex(attestation.uid, uid))
+        return "the EAS holds no attestation for the event's uid";
+    if (!sameHex(attestation.schema, expected.schema))
+        return "the attestation's schema differs";
+    if (!sameHex(attestation.refUID, expected.refUID))
+        return "the attestation's refUID differs from the prepared call";
+    if (!isAddressEqual(attestation.recipient, expected.recipient))
+        return "the attestation's recipient differs from the prepared call";
+    if (!sameHex(keccak256(attestation.data), expected.dataHash))
+        return "the attestation's data differs from the prepared call";
+    if (tracked.action === "revoke" && attestation.revocationTime === 0n)
+        return "the attestation is not revoked";
+    return null;
+}
+/** The gateway's final block view (wire field `finalizedBlock`: `{ number, hash }`, number a decimal string), or null. */
+function finalizedAnchor(check) {
+    const anchor = check.finalizedBlock;
+    if (!anchor || typeof anchor !== "object" || Array.isArray(anchor))
+        return null;
+    const { number, hash } = anchor;
+    if (typeof number !== "string" || !/^\d+$/.test(number) || typeof hash !== "string" || !HEX32.test(hash))
+        return null;
+    return { number: BigInt(number), hash: hash.toLowerCase() };
+}
+/**
+ * What the gateway's final read says about the executed review now: an
+ * attestation is `current` while it is the order's current uid and
+ * `superseded` once revoked or replaced; a revocation is `current` while the
+ * revoked uid is no longer current. The caller has established that the
+ * anchor is at or past the receipt's block and canonical on the profile's RPC.
+ */
+function reviewEffect(check, tracked, uid) {
+    const finalized = check.confirmedCurrent;
+    if (!finalized || typeof finalized !== "object" || Array.isArray(finalized))
+        return "superseded";
+    const current = finalized.currentUid;
+    if (typeof current !== "string")
+        return "superseded";
+    const stands = tracked.action === "attest" ? sameHex(current, uid) : !sameHex(current, tracked.expected.uid ?? "");
+    return stands ? "current" : "superseded";
 }
 /** Read the deployment pins separately, then verify the selected order and EAS nonce on chain. */
-async function readConfirmationFacts(context, record) {
+export async function readConfirmationFacts(context, record) {
     const status = await readWithCapability(context, record, { toolName: "daski_get_order_status", action: "status", request: {} });
-    if (typeof status.orderKey !== "string" || !/^0x[0-9a-fA-F]{64}$/.test(status.orderKey))
-        throw invalidPreparation();
-    const response = await fetch(`${context.profile.gatewayUrl.replace(/\/$/, "")}/.well-known/mcp.json`, { signal: AbortSignal.timeout(15000) });
-    if (!response.ok)
+    if (typeof status.orderKey !== "string" || !HEX32.test(status.orderKey))
         throw invalidPreparation();
-    const metadata = await response.json();
-    const pins = metadata.confirmationSigning;
-    if (!pins || pins.chainId !== context.profile.chainId || !/^0x[0-9a-fA-F]{64}$/.test(pins.schemaUid))
+    const pins = (await context.metadata()).confirmationSigning;
+    if (!pins)
+        throw confirmationPinsMissing(context.profile.gatewayUrl);
+    if (pins.chainId !== context.profile.chainId)
         throw invalidPreparation();
-    const client = createPublicClient({ transport: http(context.profile.rpcUrl) });
-    const abi = parseAbi([
-        "function getNonce(address account) view returns (uint256)",
-        "function getRecord(bytes32 orderKey) view returns ((bytes32 orderKey,bytes32 authorizationKey,uint256 providerAgentId,bytes32 serviceId,address payer,address providerOwner,address providerAgentWallet,address providerPayee,address canonicalToken,uint256 grossAmount,uint64 paidAt,bytes32 providerIdentitySnapshotHash,bytes32 listingManifestHash,bytes32 releaseEvidenceHash,uint8 outcome,uint8 confirmation,uint64 outcomeAttestationDelay,uint64 outcomeTimestamp,uint64 confirmationTimestamp,uint8 confirmationTransitions,bool outcomeRecorded,bool reputationEligible,bytes32 currentConfirmationUid))",
-    ]);
+    if (!isAddressEqual(pins.eas, context.profile.easAddress))
+        throw easAddressMismatch(pins.eas, context.profile.easAddress, context.profile.chainId);
     const orderKey = status.orderKey;
     const [current, nonce] = await Promise.all([
-        client.readContract({ address: getAddress(pins.reputationStorage), abi, functionName: "getRecord", args: [orderKey] }),
-        client.readContract({ address: getAddress(pins.eas), abi, functionName: "getNonce", args: [context.payerAddress] }),
+        context.chain.readContract({ address: pins.reputationStorage, abi: REPUTATION_ABI, functionName: "getRecord", args: [orderKey] }),
+        context.chain.readContract({ address: pins.eas, abi: EAS_ABI, functionName: "getNonce", args: [context.payerAddress] }),
     ]);
     if (current.orderKey !== orderKey || getAddress(current.payer) !== context.payerAddress ||
         String(current.providerAgentId) !== record.providerAgentId || !current.outcomeRecorded || !current.reputationEligible)
         throw invalidPreparation();
-    return { chainId: pins.chainId, eas: getAddress(pins.eas), schemaUid: pins.schemaUid, orderKey,
-        recipient: getAddress(current.providerAgentWallet === "0x0000000000000000000000000000000000000000" ? current.providerOwner : current.providerAgentWallet),
-        currentUid: current.currentConfirmationUid, nonce: nonce.toString(), transitionsUsed: Number(current.confirmationTransitions) };
+    // The record's provider agent wallet is the attestation recipient; the
+    // contract refuses to register a zero wallet, so a zero here is a record
+    // this CLI does not understand.
+    if (current.providerAgentWallet === ZERO_ADDRESS)
+        throw invalidPreparation();
+    return { chainId: pins.chainId, eas: pins.eas, schemaUid: pins.schemaUid, reputationStorage: pins.reputationStorage, orderKey,
+        recipient: getAddress(current.providerAgentWallet),
+        currentUid: current.currentConfirmationUid, nonce: nonce.toString(), submissionsUsed: Number(current.confirmationSubmissions) };
 }
 //# sourceMappingURL=confirmation.js.map