@vtex/faststore 0.0.6 → 0.0.8

package/dist/sdk/payment/use-place-order.js

@@ -1,7 +1,7 @@
 "use client";
+import { loggableErrorName } from "../../utils/loggable-error-name.js";
 import { usePaymentSubmission } from "./submission-registry.js";
 import { PAYMENT_NETWORK_ERROR_CODE } from "./operations.js";
-import { loggableErrorName } from "../../utils/loggable-error-name.js";
 import { isTrustedGatewayOrigin } from "./gateway-origin.js";
 import { useCallback, useMemo, useRef, useState } from "react";
 //#region src/sdk/payment/use-place-order.ts
@@ -128,23 +128,59 @@ function toMinorUnits(amount) {
 	return Math.round(Number(amount) * 100);
 }
 /**
-* The one call into holder-owned code. A holder's continuation is specified to resolve `userErrors` —
-* `sendPayments` already collapses every gateway outcome to one — so a throw means its contract broke.
-* Only a sanitised error *name* is logged (T160): the closure that threw holds the card, and a message
-* or stack could echo it — and so, unsanitised, could `.name` itself, since it is a writable own
-* property. See `loggableErrorName()`.
+* The one call into holder-owned code. A holder's continuation is specified to resolve a
+* `PaymentSubmissionResult` — `sendPayments` already collapses every gateway outcome to one — so a throw,
+* or a result that is not that shape, means its contract broke. Only a sanitised error *name* is logged
+* (T160): the closure that threw holds the card, and a message or stack could echo it — and so,
+* unsanitised, could `.name` itself, since it is a writable own property. See `loggableErrorName()`.
+*
+* T112 (Decision 6): the result is totalled here and fails closed. Anything that is not an object with an
+* array `userErrors` — a nullish resolution, or the bare array the contract returned before this change —
+* collapses to `{ reachedGateway: true, userErrors: [NETWORK_ERROR] }`, and a `reachedGateway` that is not
+* a boolean is read as `true`: only a literal `false` may free the attempt, so a holder that omits the
+* signal locks it rather than inviting a second payment. An empty `userErrors` is a success whatever the
+* flag says. Each field is read once, into a local, and the result handed back is a fresh object — a
+* getter that answers differently across reads has no second read to answer differently on.
 */
 async function invokeSubmission(submit, transaction) {
 	try {
 		const result = await submit(transaction);
 		if (result == null) {
 			console.error("[payment.placeOrder] the registered submission resolved with no result");
-			return [NETWORK_ERROR];
+			return {
+				reachedGateway: true,
+				userErrors: [NETWORK_ERROR]
+			};
 		}
-		return result;
+		const { reachedGateway, userErrors } = result;
+		if (!Array.isArray(userErrors)) {
+			console.error("[payment.placeOrder] the registered submission resolved a result with no userErrors list");
+			return {
+				reachedGateway: true,
+				userErrors: [NETWORK_ERROR]
+			};
+		}
+		if (userErrors.length === 0) return {
+			reachedGateway: true,
+			userErrors: []
+		};
+		if (typeof reachedGateway !== "boolean") {
+			console.error("[payment.placeOrder] the registered submission resolved a non-boolean reachedGateway");
+			return {
+				reachedGateway: true,
+				userErrors
+			};
+		}
+		return {
+			reachedGateway,
+			userErrors
+		};
 	} catch (error) {
 		console.error("[payment.placeOrder] the registered submission threw", loggableErrorName(error));
-		return [NETWORK_ERROR];
+		return {
+			reachedGateway: true,
+			userErrors: [NETWORK_ERROR]
+		};
 	}
 }
 /**
@@ -161,6 +197,26 @@ function runPreflight(check) {
 	}
 }
 /**
+* Asks the registered missing-method explainer (T47) why nothing is selected. A hint, never a check
+* (Decision 5): a throw, a non-object, or an object whose `code` or `message` is not a string all answer
+* `null`, so the caller keeps the generic refusal. A throw logs only the sanitised error name — the
+* closure that throws can see the typed number, so never its message.
+*/
+function runMissingMethodExplainer(explain) {
+	try {
+		const explained = explain();
+		if (typeof explained !== "object" || explained === null) return null;
+		const { code, message } = explained;
+		return typeof code === "string" && typeof message === "string" ? {
+			code,
+			message
+		} : null;
+	} catch (error) {
+		console.error("[payment.placeOrder] the registered explainer threw", loggableErrorName(error));
+		return null;
+	}
+}
+/**
 * The `startTransaction` counterpart of `invokeSubmission`/`runPreflight` (fix pass, Medium finding):
 * before this, `run()` awaited `startTransaction()` directly, so a **rejection** — as opposed to a
 * resolved payload carrying `userErrors` — escaped past every one of `run()`'s own outcome branches
@@ -277,6 +333,49 @@ async function invokeGatewayCallback(gatewayCallback, orderGroup, attemptId) {
 	};
 }
 /**
+* The two codes the server sends today on `gatewayCallback`. Neither is a verdict on the order, so
+* `callbackFreesAttempt` never frees an attempt that carries either (T110, Decision 3):
+* `REDIRECT_REQUIRED` is a bank challenge, and `MISSING_TRANSACTION_COOKIES` means the card POST was
+* already accepted while the callback never reached VTEX, so a second POST could authorize the card twice.
+*/
+const REDIRECT_REQUIRED_CODE = "REDIRECT_REQUIRED";
+const MISSING_TRANSACTION_COOKIES_CODE = "MISSING_TRANSACTION_COOKIES";
+/** The entry's `code`, or `undefined` when it cannot be read (a `null` entry, a getter that throws). */
+function readCode(userError) {
+	try {
+		return userError.code;
+	} catch {
+		return;
+	}
+}
+/** True when the entry carries a string `code` other than this package's own `NETWORK_ERROR`. Never throws. */
+function carriesServerCode(userError) {
+	const code = readCode(userError);
+	return typeof code === "string" && code !== "NETWORK_ERROR";
+}
+/**
+* T110: whether a `gatewayCallback` that reported `userErrors` frees the attempt for a fresh run. It does
+* when the server sent a string `code`, none of the entries is a locked code (`REDIRECT_REQUIRED`,
+* `MISSING_TRANSACTION_COOKIES`), and the result carries no `orderId`: an order the callback confirmed is
+* never freed. Everything else keeps the attempt resume-only, because a payment that may have gone through
+* must never be paid twice. Total, and never throws: a non-array, an empty list or an entry nobody can read
+* frees nothing.
+*
+* Dormant today: the server sends only the two locked codes, so no real callback frees an attempt yet.
+* The rule fires for a server-coded error the server does not send yet (task T225 will). It fails open on
+* a code it does not know (spec AC-5: no per-code table); a future allowlist of the codes that really are
+* declines belongs to T225, not to this hook.
+*/
+function callbackFreesAttempt(callback) {
+	const { orderId, userErrors } = callback;
+	if (orderId != null) return false;
+	if (!Array.isArray(userErrors)) return false;
+	return userErrors.some((userError) => carriesServerCode(userError)) && !userErrors.some((userError) => {
+		const code = readCode(userError);
+		return code === REDIRECT_REQUIRED_CODE || code === MISSING_TRANSACTION_COOKIES_CODE;
+	});
+}
+/**
 * T176 (FR-2, FR-3): what the caller reads from a `gatewayCallback` that reported `userErrors`, on both
 * paths that issue it. The gateway already accepted the card POST by then, so a result made only of this
 * package's own collapse — `PAYMENT_NETWORK_ERROR_CODE`, which `usePaymentActions` and
@@ -292,14 +391,7 @@ function reconcileCallbackUserErrors(userErrors) {
 	try {
 		if (!Array.isArray(userErrors)) return [PLACE_ORDER_UNCONFIRMED_ERROR];
 		if (userErrors.length === 0) return userErrors;
-		return userErrors.some((userError) => {
-			try {
-				const code = userError.code;
-				return typeof code === "string" && code !== "NETWORK_ERROR";
-			} catch {
-				return false;
-			}
-		}) ? userErrors : [PLACE_ORDER_UNCONFIRMED_ERROR];
+		return userErrors.some((userError) => carriesServerCode(userError)) ? userErrors : [PLACE_ORDER_UNCONFIRMED_ERROR];
 	} catch {
 		return [PLACE_ORDER_UNCONFIRMED_ERROR];
 	}
@@ -332,6 +424,165 @@ function generateAttemptId() {
 function writeAttemptIfCurrent(setAttempt, attemptId, next) {
 	setAttempt?.((prev) => prev !== null && prev.attemptId === attemptId && prev.phase !== "settled" ? next : prev);
 }
+/** The record an attempt carries once nothing was paid: a fresh full sequence is legal next time. */
+function refusedRecord(attemptId) {
+	return {
+		attemptId,
+		phase: "refused",
+		orderGroup: null,
+		orderId: null
+	};
+}
+/**
+* The record `resume()` writes once its one `gatewayCallback` answered: `refused` when the retry rule
+* freed the attempt, `unresolved` for any other error, `settled` with the order id on success.
+*/
+function resumedRecord(current, callback, failed, freed) {
+	if (freed) return refusedRecord(current.attemptId);
+	if (failed) return {
+		...current,
+		phase: "unresolved"
+	};
+	return {
+		...current,
+		phase: "settled",
+		orderId: callback.orderId
+	};
+}
+/**
+* The terminal record `run()`'s `catch` re-asserts: the `settled` one a throw may have interrupted, else
+* `unresolved` once the card was handed over, else `refused`. A failed leg writes the same pair, with
+* no placed attempt: `refused` when it freed the attempt, `unresolved` (keeping the order group) otherwise.
+*/
+function recoveryRecord(attemptId, placedAttempt, handedOver, settledOrderGroup) {
+	if (placedAttempt !== null) return placedAttempt;
+	return handedOver ? {
+		attemptId,
+		phase: "unresolved",
+		orderGroup: settledOrderGroup,
+		orderId: null
+	} : refusedRecord(attemptId);
+}
+/**
+* `run()`'s recovery write, guarded because it goes through the same caller-supplied `setAttempt` that
+* may be what threw in the first place: nothing further can be tried once the writer itself is broken, so
+* it is logged (name only, FR-7) and the caller returns its result either way.
+*/
+function writeRecoveryRecord(setAttempt, attemptId, record) {
+	try {
+		writeAttemptIfCurrent(setAttempt, attemptId, record);
+	} catch (writeError) {
+		console.error("[payment.placeOrder] the place-order recovery write threw", attemptId, loggableErrorName(writeError));
+	}
+}
+/** `run()`'s refusal before any request: nothing was paid and the card never left the browser. */
+function refusalBeforeOpening(userErrors) {
+	return {
+		orderId: null,
+		userErrors,
+		reachedGateway: false
+	};
+}
+function refused(userErrors) {
+	return {
+		kind: "refused",
+		result: refusalBeforeOpening(userErrors)
+	};
+}
+/**
+* T47 (Decision 2/4/5): the holder may know a more specific reason than "choose a method". Asked only
+* with nothing selected, and never before the checks that follow, so the order of checks cannot change.
+* Only the opaque refusal comes back, and only its code is logged.
+*/
+function refuseMissingMethod({ path, resolveMissingMethodExplainer }) {
+	const explain = path === null ? null : resolveMissingMethodExplainer(path);
+	const explained = explain === null ? null : runMissingMethodExplainer(explain);
+	if (explained !== null) {
+		console.error("[payment.placeOrder] no payment method is selected, and the registered explainer named why", explained.code);
+		return refused([explained]);
+	}
+	console.error("[payment.placeOrder] no payment method is selected");
+	return refused([MISSING_METHOD_ERROR]);
+}
+/**
+* Every synchronous refusal `run()` resolves before anything is opened, in their original order: no
+* registered submission, no selected method, the submit gate, then the holder's own pre-flight. A
+* transaction nothing can complete is dangling state on the order form. The first two causes are one
+* state to a shopper and differ only in the log.
+*/
+function checkSubmissionPreconditions({ channel, selectedMethod, submitGate }) {
+	const { path, resolve, resolvePreflight } = channel;
+	const submit = path === null ? null : resolve(path);
+	if (submit === null) {
+		console.error("[payment.placeOrder] no submission is registered for the entry path", path ?? "none");
+		return refused([MISSING_SUBMISSION_ERROR]);
+	}
+	if (selectedMethod === null) return refuseMissingMethod(channel);
+	if (submitGate) {
+		console.error("[payment.placeOrder] a client-side gate refused the submission", submitGate.code);
+		return refused([submitGate]);
+	}
+	const preflight = path === null ? null : resolvePreflight(path);
+	if (preflight) {
+		const refusals = runPreflight(preflight);
+		if (refusals.length > 0) {
+			console.error("[payment.placeOrder] the registered pre-flight refused the submission", refusals[0]?.code);
+			return refused(refusals);
+		}
+	}
+	return {
+		kind: "ready",
+		submit,
+		method: selectedMethod
+	};
+}
+/**
+* `run()`'s first backend leg: opens the transaction and settles its payload. Either refusal records
+* `refused` — nothing was paid, so a fresh full sequence stays legal next time — through
+* `writeAttemptIfCurrent`, not a plain write: the caller's closure may be running after its own CTA
+* unmounted (NFR-3), so a newer completion for the same attempt must win instead.
+*/
+async function openTransaction(startTransaction, setAttempt, attemptId) {
+	const payload = await invokeStartTransaction(startTransaction);
+	if (payload.userErrors.length > 0) {
+		writeAttemptIfCurrent(setAttempt, attemptId, refusedRecord(attemptId));
+		return {
+			kind: "refused",
+			result: refusalBeforeOpening(payload.userErrors)
+		};
+	}
+	const settled = settleTransaction(payload);
+	if (settled === null) {
+		writeAttemptIfCurrent(setAttempt, attemptId, refusedRecord(attemptId));
+		return {
+			kind: "refused",
+			result: refusalBeforeOpening([INVALID_TRANSACTION_ERROR])
+		};
+	}
+	return {
+		kind: "opened",
+		settled
+	};
+}
+/** The descriptor `run()` hands to the registered submission. Nothing in it is sensitive. */
+function buildTransaction({ settled, method, selectedInstallment, billingAddressDifferent }) {
+	return {
+		gatewayUrl: settled.gatewayUrl,
+		transactionId: settled.transactionId,
+		merchantName: settled.merchantName,
+		orderGroup: settled.orderGroup,
+		userProfileId: settled.userProfileId,
+		paymentSystem: method.id,
+		groupName: method.groupName,
+		currencyCode: settled.value.currencyCode,
+		valueInCents: settled.valueInCents,
+		referenceValueInCents: settled.referenceValueInCents,
+		installments: selectedInstallment?.count ?? 1,
+		installmentsValueInCents: selectedInstallment && selectedInstallment.count !== 1 ? toMinorUnits(selectedInstallment.value.amount) : settled.valueInCents,
+		interestRate: selectedInstallment?.interestRate ?? 0,
+		...billingAddressDifferent == null ? {} : { billingAddressDifferent }
+	};
+}
 /**
 * T29 (Decision 3, FR-3): the only path back into a `sent`/`unresolved` attempt — `gatewayCallback` is
 * the sole call it ever issues. Module scope, not a `useCallback` inside the hook (fix pass, Low
@@ -342,13 +593,17 @@ function writeAttemptIfCurrent(setAttempt, attemptId, next) {
 * still have read. Hoisting here makes the claim actually true: none of those three is even
 * *importable* from a bare module-level function that takes only `gatewayCallback`/`setAttempt`/
 * `setPlacing`/`current` as arguments — a resume is safe by construction, not by convention.
+*
+* T110: a callback the retry rule frees records `refused`, as `run()` does, so the next click is a fresh
+* full run. This function still issues nothing but `gatewayCallback`.
 */
 async function resume(gatewayCallback, setAttempt, setPlacing, current) {
 	if (!gatewayCallback || current.orderGroup === null) {
 		console.error("[payment.placeOrder] cannot resume an attempt with no order group");
 		return {
 			orderId: null,
-			userErrors: [NETWORK_ERROR]
+			userErrors: [NETWORK_ERROR],
+			reachedGateway: true
 		};
 	}
 	writeAttemptIfCurrent(setAttempt, current.attemptId, {
@@ -360,30 +615,27 @@ async function resume(gatewayCallback, setAttempt, setPlacing, current) {
 	const failed = callback.userErrors.length > 0;
 	const result = failed ? {
 		orderId: null,
-		userErrors: reconcileCallbackUserErrors(callback.userErrors)
+		userErrors: reconcileCallbackUserErrors(callback.userErrors),
+		reachedGateway: true
 	} : {
 		orderId: callback.orderId,
-		userErrors: []
+		userErrors: [],
+		reachedGateway: true
 	};
+	const freed = failed && callbackFreesAttempt(callback);
 	try {
-		writeAttemptIfCurrent(setAttempt, current.attemptId, failed ? {
-			...current,
-			phase: "unresolved"
-		} : {
-			...current,
-			phase: "settled",
-			orderId: callback.orderId
-		});
+		writeAttemptIfCurrent(setAttempt, current.attemptId, resumedRecord(current, callback, failed, freed));
 	} catch (error) {
 		console.error("[payment.placeOrder] the resume record write threw", current.attemptId, loggableErrorName(error));
 	}
 	return result;
 }
 function usePlaceOrder({ $data, $actions, attempt, setAttempt, billingAddressDifferent, submitGate }) {
-	const { path, resolve, resolvePreflight } = usePaymentSubmission();
+	const { path, resolve, resolvePreflight, resolveMissingMethodExplainer } = usePaymentSubmission();
 	const [placing, setPlacing] = useState(false);
 	const [userErrors, setUserErrors] = useState([]);
 	const [orderId, setOrderId] = useState(null);
+	const [reachedGateway, setReachedGateway] = useState(null);
 	const inFlight = useRef(null);
 	const startTransaction = $actions?.payment?.startTransaction;
 	const gatewayCallback = $actions?.payment?.gatewayCallback;
@@ -397,42 +649,22 @@ function usePlaceOrder({ $data, $actions, attempt, setAttempt, billingAddressDif
 			console.error("[payment.placeOrder] the payment action namespace is not injected");
 			return {
 				orderId: null,
-				userErrors: [NETWORK_ERROR]
-			};
-		}
-		const submit = path === null ? null : resolve(path);
-		if (submit === null) {
-			console.error("[payment.placeOrder] no submission is registered for the entry path", path ?? "none");
-			return {
-				orderId: null,
-				userErrors: [MISSING_SUBMISSION_ERROR]
-			};
-		}
-		if (selectedMethod === null) {
-			console.error("[payment.placeOrder] no payment method is selected");
-			return {
-				orderId: null,
-				userErrors: [MISSING_METHOD_ERROR]
-			};
-		}
-		if (submitGate) {
-			console.error("[payment.placeOrder] a client-side gate refused the submission", submitGate.code);
-			return {
-				orderId: null,
-				userErrors: [submitGate]
+				userErrors: [NETWORK_ERROR],
+				reachedGateway: false
 			};
 		}
-		const preflight = path === null ? null : resolvePreflight(path);
-		if (preflight) {
-			const refusals = runPreflight(preflight);
-			if (refusals.length > 0) {
-				console.error("[payment.placeOrder] the registered pre-flight refused the submission", refusals[0]?.code);
-				return {
-					orderId: null,
-					userErrors: refusals
-				};
-			}
-		}
+		const verdict = checkSubmissionPreconditions({
+			channel: {
+				path,
+				resolve,
+				resolvePreflight,
+				resolveMissingMethodExplainer
+			},
+			selectedMethod,
+			submitGate
+		});
+		if (verdict.kind === "refused") return verdict.result;
+		const { submit, method } = verdict;
 		let handedOver = false;
 		let settledOrderGroup = null;
 		let placedAttempt = null;
@@ -446,32 +678,9 @@ function usePlaceOrder({ $data, $actions, attempt, setAttempt, billingAddressDif
 		});
 		try {
 			setPlacing(true);
-			const payload = await invokeStartTransaction(startTransaction);
-			if (payload.userErrors.length > 0) {
-				writeAttemptIfCurrent(setAttempt, attemptId, {
-					attemptId,
-					phase: "refused",
-					orderGroup: null,
-					orderId: null
-				});
-				return {
-					orderId: null,
-					userErrors: payload.userErrors
-				};
-			}
-			const settled = settleTransaction(payload);
-			if (settled === null) {
-				writeAttemptIfCurrent(setAttempt, attemptId, {
-					attemptId,
-					phase: "refused",
-					orderGroup: null,
-					orderId: null
-				});
-				return {
-					orderId: null,
-					userErrors: [INVALID_TRANSACTION_ERROR]
-				};
-			}
+			const opened = await openTransaction(startTransaction, setAttempt, attemptId);
+			if (opened.kind === "refused") return opened.result;
+			const { settled } = opened;
 			settledOrderGroup = settled.orderGroup;
 			writeAttemptIfCurrent(setAttempt, attemptId, {
 				attemptId,
@@ -479,35 +688,23 @@ function usePlaceOrder({ $data, $actions, attempt, setAttempt, billingAddressDif
 				orderGroup: settled.orderGroup,
 				orderId: null
 			});
-			const transaction = {
-				gatewayUrl: settled.gatewayUrl,
-				transactionId: settled.transactionId,
-				merchantName: settled.merchantName,
-				orderGroup: settled.orderGroup,
-				userProfileId: settled.userProfileId,
-				paymentSystem: selectedMethod.id,
-				groupName: selectedMethod.groupName,
-				currencyCode: settled.value.currencyCode,
-				valueInCents: settled.valueInCents,
-				referenceValueInCents: settled.referenceValueInCents,
-				installments: selectedInstallment?.count ?? 1,
-				installmentsValueInCents: selectedInstallment && selectedInstallment.count !== 1 ? toMinorUnits(selectedInstallment.value.amount) : settled.valueInCents,
-				interestRate: selectedInstallment?.interestRate ?? 0,
-				...billingAddressDifferent != null ? { billingAddressDifferent } : {}
-			};
+			const transaction = buildTransaction({
+				settled,
+				method,
+				selectedInstallment,
+				billingAddressDifferent
+			});
 			handedOver = true;
 			const submissionErrors = await invokeSubmission(submit, transaction);
-			if (submissionErrors.length > 0) {
+			if (submissionErrors.userErrors.length > 0) {
+				const freed = submissionErrors.reachedGateway === false;
+				handedOver = !freed;
 				outcome = {
 					orderId: null,
-					userErrors: submissionErrors
+					userErrors: submissionErrors.userErrors,
+					reachedGateway: !freed
 				};
-				writeAttemptIfCurrent(setAttempt, attemptId, {
-					attemptId,
-					phase: "unresolved",
-					orderGroup: settled.orderGroup,
-					orderId: null
-				});
+				writeAttemptIfCurrent(setAttempt, attemptId, recoveryRecord(attemptId, null, handedOver, settled.orderGroup));
 				return outcome;
 			}
 			writeAttemptIfCurrent(setAttempt, attemptId, {
@@ -520,14 +717,11 @@ function usePlaceOrder({ $data, $actions, attempt, setAttempt, billingAddressDif
 			if (callback.userErrors.length > 0) {
 				outcome = {
 					orderId: null,
-					userErrors: reconcileCallbackUserErrors(callback.userErrors)
+					userErrors: reconcileCallbackUserErrors(callback.userErrors),
+					reachedGateway: true
 				};
-				writeAttemptIfCurrent(setAttempt, attemptId, {
-					attemptId,
-					phase: "unresolved",
-					orderGroup: settled.orderGroup,
-					orderId: null
-				});
+				handedOver = !callbackFreesAttempt(callback);
+				writeAttemptIfCurrent(setAttempt, attemptId, recoveryRecord(attemptId, null, handedOver, settled.orderGroup));
 				return outcome;
 			}
 			placedAttempt = {
@@ -538,7 +732,8 @@ function usePlaceOrder({ $data, $actions, attempt, setAttempt, billingAddressDif
 			};
 			outcome = {
 				orderId: callback.orderId,
-				userErrors: []
+				userErrors: [],
+				reachedGateway: true
 			};
 			track?.({
 				name: "purchase",
@@ -552,24 +747,11 @@ function usePlaceOrder({ $data, $actions, attempt, setAttempt, billingAddressDif
 			return outcome;
 		} catch (error) {
 			console.error("[payment.placeOrder] the place-order sequence threw", attemptId, loggableErrorName(error));
-			try {
-				writeAttemptIfCurrent(setAttempt, attemptId, placedAttempt ?? (handedOver ? {
-					attemptId,
-					phase: "unresolved",
-					orderGroup: settledOrderGroup,
-					orderId: null
-				} : {
-					attemptId,
-					phase: "refused",
-					orderGroup: null,
-					orderId: null
-				}));
-			} catch (writeError) {
-				console.error("[payment.placeOrder] the place-order recovery write threw", attemptId, loggableErrorName(writeError));
-			}
+			writeRecoveryRecord(setAttempt, attemptId, recoveryRecord(attemptId, placedAttempt, handedOver, settledOrderGroup));
 			return outcome ?? {
 				orderId: null,
-				userErrors: [NETWORK_ERROR]
+				userErrors: [NETWORK_ERROR],
+				reachedGateway: handedOver
 			};
 		}
 	}, [
@@ -579,6 +761,7 @@ function usePlaceOrder({ $data, $actions, attempt, setAttempt, billingAddressDif
 		path,
 		resolve,
 		resolvePreflight,
+		resolveMissingMethodExplainer,
 		selectedMethod,
 		selectedInstallment,
 		billingAddressDifferent,
@@ -590,28 +773,33 @@ function usePlaceOrder({ $data, $actions, attempt, setAttempt, billingAddressDif
 		const settleSequence = (sequence) => {
 			setUserErrors([]);
 			setOrderId(null);
+			setReachedGateway(null);
 			const settle = (result) => {
 				inFlight.current = null;
 				setPlacing(false);
 				setUserErrors(result.userErrors);
 				setOrderId(result.orderId);
+				setReachedGateway(result.reachedGateway);
 				return result;
 			};
 			const outcome = sequence.then(settle, () => settle({
 				orderId: null,
-				userErrors: [NETWORK_ERROR]
+				userErrors: [NETWORK_ERROR],
+				reachedGateway: true
 			}));
 			inFlight.current = outcome;
 			return outcome;
 		};
 		if (attempt) {
-			if (attempt.phase === "settled") return Promise.resolve({
+			if (attempt.phase === "settled") return settleSequence(Promise.resolve({
 				orderId: attempt.orderId,
-				userErrors: []
-			});
+				userErrors: [],
+				reachedGateway: true
+			}));
 			if (attempt.phase === "opening" || attempt.phase === "finalizing") return settleSequence(Promise.resolve({
 				orderId: attempt.orderId,
-				userErrors: [PLACE_ORDER_IN_FLIGHT_ERROR]
+				userErrors: [PLACE_ORDER_IN_FLIGHT_ERROR],
+				reachedGateway: true
 			}));
 			if (attempt.phase === "sent" || attempt.phase === "unresolved") return settleSequence(resume(gatewayCallback, setAttempt, setPlacing, attempt));
 		}
@@ -626,12 +814,14 @@ function usePlaceOrder({ $data, $actions, attempt, setAttempt, billingAddressDif
 		placeOrder,
 		placing,
 		userErrors,
-		orderId
+		orderId,
+		reachedGateway
 	}), [
 		placeOrder,
 		placing,
 		userErrors,
-		orderId
+		orderId,
+		reachedGateway
 	]);
 }
 //#endregion