@12-apps/payments-frontend 3.37.0 → 3.38.0

package/src/components/checkout/list/charge-runners.tsx

@@ -0,0 +1,156 @@
+/**
+ * The two charges the one list's button starts once an order is held
+ * (FUT-3592): the CARD — the buyer's saved card or the one they typed — and
+ * GOOGLE PAY's sheet. Each is the existing money path (`useCardSubmit`,
+ * `useWalletCharge`), run with no button of its own: the list's bar already
+ * was the button, and its 5-second window the buyer's chance to stop it.
+ *
+ * Mounted only while a charge is under way, so a runner never outlives the
+ * charge it was started for; what it learned on the way out — a refusal, an
+ * accepted charge — goes back to the list through its callbacks.
+ */
+import { useEffect, useRef, type JSX } from "react";
+
+import type { CardChainLink } from "../method-capability";
+import { NEW_CARD, type CardTokenizationConfig } from "../../../card";
+import { useRefreshOnCartChanged } from "../cart-changed";
+import { SubmittedState } from "../card-view";
+import type { ChallengeScope } from "../card-outcome";
+import { useCheckoutCopy } from "../copy-context";
+import type { BuyerInfo, CheckoutOrder, OnCheckoutResolved } from "../types";
+import { useCardSubmit } from "../use-card-checkout";
+import { useWalletCharge } from "../use-wallet-charge";
+
+import type { ListCard } from "./use-list-state";
+
+/** A charge that came back refused or unresolved — what the list shows beside the card. */
+export interface ListChargeFailure {
+  message: string;
+  code: string | null;
+}
+
+interface RunnerCallbacks {
+  /** Accepted, and now awaited — the list gives way to the wait. */
+  onAccepted: () => void;
+  /** Refused, unresolved, or never sent — back to the list, saying why (or not, for a dismissal). */
+  onFailed: (failure: ListChargeFailure | null) => void;
+}
+
+/** Press "Pagar" once, as soon as the order's card key is in hand. */
+function useFireOnce(ready: boolean, fire: () => void): void {
+  const fired = useRef(false);
+  const latest = useRef(fire);
+  latest.current = fire;
+  useEffect(() => {
+    if (fired.current || !ready) return;
+    fired.current = true;
+    latest.current();
+  }, [ready]);
+}
+
+/** The card, charged against the held order. Renders the wait once the charge is accepted. */
+export function CardRun({
+  order,
+  buyer,
+  card,
+  config,
+  chain,
+  scope,
+  onResolved,
+  pollIntervalMs,
+  onAccepted,
+  onFailed,
+}: RunnerCallbacks & {
+  order: CheckoutOrder;
+  buyer: BuyerInfo;
+  card: ListCard;
+  config: CardTokenizationConfig;
+  chain: readonly CardChainLink[];
+  scope: ChallengeScope;
+  onResolved: OnCheckoutResolved;
+  pollIntervalMs: number;
+}): JSX.Element | null {
+  const fieldCopy = useCheckoutCopy().card.fields;
+  const usingNewCard = card.selection === NEW_CARD;
+  const submit = useCardSubmit(
+    order,
+    buyer,
+    config,
+    onResolved,
+    pollIntervalMs,
+    {
+      card: card.card,
+      usingNewCard,
+      selection: card.selection ?? NEW_CARD,
+      saveCard: card.saveCard,
+      // The button was only live with every field valid; re-checked here
+      // because a submit that skipped it would tokenize garbage.
+      validate: () => ({
+        number: card.complete ? undefined : fieldCopy.numberInvalid,
+      }),
+      setFieldErrors: card.setFieldErrors,
+    },
+    chain,
+    scope,
+  );
+  useFireOnce(!submit.keyPending, () => void submit.handlePay());
+  // Re-priced by the host when the server says the cart moved (FUT-1139).
+  useRefreshOnCartChanged(submit.errorCode);
+  const { error, errorCode, submitted } = submit;
+  useEffect(() => {
+    if (error) onFailed({ message: error, code: errorCode });
+  }, [error, errorCode, onFailed]);
+  useEffect(() => {
+    if (submitted) onAccepted();
+  }, [submitted, onAccepted]);
+  return submitted ? <SubmittedState card={submit} /> : null;
+}
+
+/**
+ * Google Pay: the sheet was opened INSIDE the buyer's tap (`sheet`, priced at
+ * `sheetCents`) while the order was raised; its key is charged against that
+ * order only if the order costs what the sheet showed. A closed sheet sends
+ * nothing more.
+ */
+export function WalletRun({
+  order,
+  buyer,
+  sheet,
+  sheetCents,
+  scope,
+  onResolved,
+  pollIntervalMs,
+  onAccepted,
+  onFailed,
+}: RunnerCallbacks & {
+  order: CheckoutOrder;
+  buyer: BuyerInfo;
+  /** The sheet's answer: the wallet key, or `null` when the buyer closed it. */
+  sheet: Promise<string | null>;
+  sheetCents: number;
+  scope: ChallengeScope;
+  onResolved: OnCheckoutResolved;
+  pollIntervalMs: number;
+}): JSX.Element | null {
+  const words = useCheckoutCopy().screens.wallet.googlePay;
+  const wallet = useWalletCharge(order, buyer, onResolved, pollIntervalMs, scope);
+  useFireOnce(true, () => {
+    const refused = { message: words.cannotComplete, code: null };
+    sheet
+      .then((key) => {
+        if (key === null) return onFailed(null);
+        // The sheet showed one amount; never charge another under it.
+        if (order.totalCents !== sheetCents) return onFailed(refused);
+        return void wallet.payWithKey("GOOGLE_PAY", key);
+      })
+      .catch(() => onFailed(refused));
+  });
+  const { error, errorCode, phase } = wallet;
+  useEffect(() => {
+    if (error) onFailed({ message: error, code: errorCode });
+  }, [error, errorCode, onFailed]);
+  useEffect(() => {
+    if (phase === "polling") onAccepted();
+  }, [phase, onAccepted]);
+  return phase === "idle" ? null : <SubmittedState card={wallet} />;
+}

package/src/components/checkout/list/choice-list.tsx

@@ -0,0 +1,156 @@
+import { Box } from "@mui/material";
+import { useId, type JSX, type ReactNode } from "react";
+
+import { useCheckoutCopy } from "../copy-context";
+import type { BuyerInfo } from "../types";
+import { useCheckoutComponents } from "../ui";
+
+import { cardName, type OnlineRow } from "./choice";
+import type { ListChargeFailure } from "./charge-runners";
+import { OnlineContent, opensContent } from "./online-content";
+import { GroupHeading, OptionRow } from "./option-row";
+import type { CheckoutDoorOption, CheckoutOnlineChoice, PaymentListCopy } from "./types";
+import type { ListState } from "./use-list-state";
+
+/** An online row's label and hint, worded for what the store and the buyer hold. */
+function onlineWords(
+  method: CheckoutOnlineChoice,
+  copy: PaymentListCopy,
+  state: ListState,
+  provider: string | null,
+): { label: string; hint: string } {
+  if (method === "PIX") return copy.pix;
+  if (method === "GOOGLE_PAY") return copy.googlePay;
+  if (method === "HAND_OFF") return { label: copy.handOff.label, hint: copy.handOff.hint(provider) };
+  const head = state.card.saved[0];
+  return {
+    label: copy.card.label,
+    hint: head ? copy.card.hintSaved(cardName(copy, head)) : copy.card.hintNew,
+  };
+}
+
+/** The hint of a card the store declares and this browser cannot take — today's words (N9). */
+function useUnavailableHint(): string {
+  return useCheckoutCopy().screens.method.unavailableHere;
+}
+
+/** What every row of the list is drawn from. */
+interface RowProps {
+  name: string;
+  copy: PaymentListCopy;
+  state: ListState;
+  buyer: BuyerInfo;
+  onBuyerChange: (buyer: BuyerInfo) => void;
+  provider: string | null;
+  failure: ListChargeFailure | null;
+}
+
+/** One of the store's online options, with what opens inside it. */
+function OnlineOptionRow({ row, props }: { row: OnlineRow; props: RowProps }): JSX.Element {
+  const { copy, state, provider } = props;
+  const unavailable = useUnavailableHint();
+  const words = onlineWords(row.method, copy, state, provider);
+  const chosen = state.choice?.kind === "online" && state.choice.method === row.method;
+  return (
+    <OptionRow
+      name={props.name}
+      value={row.method}
+      chosen={chosen}
+      disabled={row.disabled}
+      label={words.label}
+      hint={row.disabled ? unavailable : words.hint}
+      onChoose={() => state.choose({ kind: "online", method: row.method })}
+      testId={`list-option-${row.method}`}
+    >
+      {opensContent(row.method, state.asked, props.failure) ? (
+        <OnlineContent
+        method={row.method}
+        asked={state.asked}
+        buyer={props.buyer}
+        onBuyerChange={props.onBuyerChange}
+        card={state.card}
+        copy={copy}
+        provider={provider}
+        failure={props.failure}
+        />
+      ) : null}
+    </OptionRow>
+  );
+}
+
+/** One of the host's door options: its words, and its content opened inside it. */
+function DoorOptionRow({ option, props }: { option: CheckoutDoorOption; props: RowProps }): JSX.Element {
+  const { choice } = props.state;
+  const chosen = choice?.kind === "door" && choice.id === option.id;
+  return (
+    <OptionRow
+      name={props.name}
+      value={`door:${option.id}`}
+      chosen={chosen}
+      label={option.label}
+      hint={chosen && option.hideHintWhileChosen ? undefined : option.hint}
+      onChoose={() => props.state.choose({ kind: "door", id: option.id })}
+      testId={`list-door-${option.id}`}
+    >
+      {option.content}
+    </OptionRow>
+  );
+}
+
+/** One heading and the rows under it, as a group named by the heading. */
+function Group({ id, heading, children }: { id: string; heading: string; children: ReactNode }): JSX.Element {
+  return (
+    <Box role="group" aria-labelledby={id} sx={{ display: "flex", flexDirection: "column", gap: 1.25 }}>
+      <GroupHeading id={id}>{heading}</GroupHeading>
+      {children}
+    </Box>
+  );
+}
+
+/**
+ * "Como você quer pagar?" — every way to pay as ONE radio group under two
+ * headings (FUT-3591, M6): the store's online options, then the host's door
+ * options. Choosing a row only chooses it; the bar's button acts.
+ *
+ * One radio `name` across both groups keeps them one choice for the keyboard;
+ * each heading names its own `role="group"`, and what opens inside a row sits
+ * beside its radio's label, never inside it.
+ */
+export function ChoiceList({
+  door,
+  locked,
+  ...rest
+}: Omit<RowProps, "name"> & {
+  door: readonly CheckoutDoorOption[];
+  /** A charge or a send is under way: the list is inert. */
+  locked: boolean;
+}): JSX.Element {
+  const { Text } = useCheckoutComponents();
+  const base = useId();
+  const props: RowProps = { ...rest, name: `${base}-choice` };
+  const { copy, state } = props;
+  return (
+    <Box
+      data-testid="payment-list"
+      data-locked={locked ? "true" : "false"}
+      aria-disabled={locked || undefined}
+      inert={locked || undefined}
+      sx={{ display: "flex", flexDirection: "column", gap: 1.5 }}
+    >
+      <Text variant="body" size="md" weight="bold" as="p" style={{ margin: 0 }}>
+        {copy.title}
+      </Text>
+      {/* Each heading only over a group that has rows (a door-only store shows the door one alone). */}
+      {state.rows.length > 0 ? (
+        <Group id={`${base}-online`} heading={copy.onlineHeading}>
+          {state.rows.map((row) => <OnlineOptionRow key={row.method} row={row} props={props} />)}
+        </Group>
+      ) : null}
+      {door.length > 0 ? (
+        <Group id={`${base}-door`} heading={copy.doorHeading}>
+          {door.map((option) => <DoorOptionRow key={option.id} option={option} props={props} />)}
+        </Group>
+      ) : null}
+    </Box>
+  );
+}

package/src/components/checkout/list/choice.ts

@@ -0,0 +1,193 @@
+/**
+ * The one list's decisions, as pure functions (FUT-3591): which online rows
+ * the store's chain offers, what is chosen before the buyer touches anything,
+ * which of the buyer's own details must be asked inside the option, and why
+ * the bar's button may not act yet. Nothing here renders or fetches, so every
+ * rule is a unit test away.
+ */
+import {
+  NEW_CARD,
+  validateCardNumber,
+  validateCvv,
+  validateExpiry,
+  validateHolder,
+  detectBrand,
+  onlyDigits,
+  type CardDetails,
+  type SavedCard,
+} from "../../../card";
+import type { CardFieldCopy } from "../../../card/copy";
+import { buyerFieldsFor, fieldSatisfied } from "../buyer-fields";
+import { handOffMethod } from "../method-capability";
+import type { BuyerInfo, CheckoutChainLink, CheckoutCustomerField, PaymentMethod } from "../types";
+
+import type { CheckoutDoorOption, CheckoutListChoice, CheckoutOnlineChoice, PaymentListCopy } from "./types";
+
+/** One online row: what it is, and whether this browser can take it. */
+export interface OnlineRow {
+  method: CheckoutOnlineChoice;
+  /** A card the store declares but this browser cannot mint for — drawn, not choosable. */
+  disabled: boolean;
+}
+
+/** What the chain lets this browser offer, as the list needs it. */
+export interface OnlineCapability {
+  /** The store finishes on the provider's own page. */
+  handOff: boolean;
+  /** The methods the chain declares, or `null` while unknown (fails OPEN). */
+  offered: PaymentMethod[] | null;
+  cardUnavailable: boolean;
+  /** Google Pay is declared AND this browser's `isReadyToPay` said yes. */
+  googlePayReady: boolean;
+}
+
+/**
+ * The "PAGAR AGORA, PELO APP" rows, in the prototype's order: Pix, card,
+ * Google Pay — or the single hand-off row for a store that takes the method
+ * on its own page (N18).
+ */
+export function onlineRows(cap: OnlineCapability): OnlineRow[] {
+  if (cap.handOff) return [{ method: "HAND_OFF", disabled: false }];
+  const offers = (method: PaymentMethod): boolean => cap.offered === null || cap.offered.includes(method);
+  const rows: OnlineRow[] = [];
+  if (offers("PIX")) rows.push({ method: "PIX", disabled: false });
+  if (offers("CARD")) rows.push({ method: "CARD", disabled: cap.cardUnavailable });
+  if (offers("CARD") && !cap.cardUnavailable && cap.googlePayReady) rows.push({ method: "GOOGLE_PAY", disabled: false });
+  return rows;
+}
+
+/** The chain method an online choice raises — what `createOrder` is asked for. */
+export function raisedMethod(choice: CheckoutOnlineChoice, offered: PaymentMethod[] | null): PaymentMethod {
+  if (choice === "PIX") return "PIX";
+  if (choice === "HAND_OFF") return handOffMethod(offered);
+  return "CARD";
+}
+
+/**
+ * What is chosen before the buyer touches anything (M7, owner 2026-10-15): a
+ * saved card makes "Cartão de crédito" the choice with that card selected —
+ * the list's head, which the host orders last-used first. Nothing else is ever
+ * preselected: never Pix, never a door tender (FUT-1478), and not a store's
+ * only method either (that pick used to raise an order with no tap at all).
+ *
+ * A buyer back here because a card was REFUSED (`fresh`) keeps the card
+ * chosen, with no saved card selected for them — the one this would pick is
+ * the one that failed (FUT-1145).
+ */
+export function preselection(
+  rows: readonly OnlineRow[],
+  saved: readonly SavedCard[],
+  fresh: boolean,
+): { choice: CheckoutListChoice; selection: string | null } | null {
+  const card = rows.find((row) => row.method === "CARD" && !row.disabled);
+  if (!card) return null;
+  if (fresh) return { choice: { kind: "online", method: "CARD" }, selection: saved.length > 0 ? null : NEW_CARD };
+  const head = saved[0];
+  if (!head) return null;
+  return { choice: { kind: "online", method: "CARD" }, selection: head.id };
+}
+
+/**
+ * The buyer's own details to ask INSIDE the chosen online option (M11): the
+ * fields the chain requires for that method which the buyer arrived without.
+ * Decided against what the buyer ARRIVED with, never against what they are
+ * typing, so the field does not vanish under their thumb as it completes.
+ * With a CPF on file the CPF is never asked — the server holds it.
+ */
+export function askedFields(input: {
+  chain: readonly CheckoutChainLink[] | undefined;
+  method: PaymentMethod;
+  arrivedWith: BuyerInfo | undefined;
+  taxIdOnFile: boolean;
+}): CheckoutCustomerField[] {
+  return buyerFieldsFor(input.chain, input.method).filter(
+    (field) =>
+      field.required &&
+      !(field.key === "taxId" && input.taxIdOnFile) &&
+      !fieldSatisfied(field, input.arrivedWith?.[field.key]),
+  );
+}
+
+/** Every one of the four card fields is valid — the button's question. */
+export function cardComplete(card: CardDetails, copy: CardFieldCopy): boolean {
+  const brand = detectBrand(onlyDigits(card.number));
+  return (
+    !validateCardNumber(card.number, copy) &&
+    !validateHolder(card.holder, copy) &&
+    !validateExpiry(card.expiry, copy) &&
+    !validateCvv(card.cvv, copy, brand)
+  );
+}
+
+/** The reason for the first of the asked fields the buyer has not satisfied yet. */
+function buyerReason(
+  asked: readonly CheckoutCustomerField[],
+  buyer: BuyerInfo,
+  reasons: PaymentListCopy["reasons"],
+): string | null {
+  const missing = asked.find((field) => !fieldSatisfied(field, buyer[field.key]));
+  if (!missing) return null;
+  if (missing.key === "taxId") return reasons.cpf;
+  if (missing.key === "phone") return reasons.phone;
+  return reasons.details;
+}
+
+/** What the card option still needs: a card chosen, and a typed one complete. */
+function cardReason(
+  selection: string | null,
+  complete: boolean,
+  reasons: PaymentListCopy["reasons"],
+): string | null {
+  if (selection === null) return reasons.chooseCard;
+  if (selection === NEW_CARD && !complete) return reasons.cardDetails;
+  return null;
+}
+
+/**
+ * Why the bar's button cannot act, in the order the prototype checks
+ * (FN:447-456): the host's hold, nothing chosen, the buyer's details, the
+ * card — and for a door option, the host's own reason. `null` ⇒ it can act.
+ */
+export function blockedReason(input: {
+  copy: PaymentListCopy;
+  hold: string | null;
+  choice: CheckoutListChoice | null;
+  door: CheckoutDoorOption | undefined;
+  asked: readonly CheckoutCustomerField[];
+  buyer: BuyerInfo;
+  selection: string | null;
+  cardIsComplete: boolean;
+}): string | null {
+  const { copy, choice } = input;
+  if (input.hold) return input.hold;
+  if (!choice) return copy.reasons.choose;
+  if (choice.kind === "door") return input.door ? input.door.blocked : copy.reasons.choose;
+  const buyer = buyerReason(input.asked, input.buyer, copy.reasons);
+  if (buyer) return buyer;
+  if (choice.method !== "CARD") return null;
+  return cardReason(input.selection, input.cardIsComplete, copy.reasons);
+}
+
+/** The bar button's verb for what is chosen. */
+export function actionLabel(
+  copy: PaymentListCopy,
+  choice: CheckoutListChoice | null,
+  door: CheckoutDoorOption | undefined,
+  provider: string | null,
+): string {
+  if (!choice) return copy.actions.choose;
+  if (choice.kind === "door") return door?.action ?? copy.actions.choose;
+  const verbs: Record<CheckoutOnlineChoice, string> = {
+    PIX: copy.actions.pix,
+    CARD: copy.actions.card,
+    GOOGLE_PAY: copy.actions.googlePay,
+    HAND_OFF: copy.actions.handOff(provider),
+  };
+  return verbs[choice.method];
+}
+
+/** A saved card's name — "Visa final 4242", or "Cartão final 4242" when the network is unknown. */
+export function cardName(copy: PaymentListCopy, card: Pick<SavedCard, "brand" | "last4">): string {
+  const brand = card.brand.trim();
+  return copy.savedCard(brand && brand.toLowerCase() !== "unknown" ? brand : null, card.last4);
+}

package/src/components/checkout/list/context.tsx

@@ -0,0 +1,55 @@
+import { createContext, useContext, useMemo, useState, type JSX, type ReactNode } from "react";
+
+import type { CheckoutPaymentList } from "./types";
+
+/**
+ * What the one list shares with the panes it mounts (FUT-3591/3592): its
+ * config — the words and the host's bar line — and the one piece of UI state a
+ * pane and the list both touch, whether the Pix QR is open on a phone.
+ *
+ * `null` outside list mode, which is how a pane composed for the tabs layout
+ * (or by hand) knows to keep the face it always had.
+ */
+export interface PaymentListMode {
+  list: CheckoutPaymentList;
+  /** The QR is open on a narrow screen ("Ver QR code (pagar de outro celular)"). */
+  qrOpen: boolean;
+  setQrOpen: (open: boolean) => void;
+  /** "Trocar a forma de pagamento": leave the raised Pix for the list. */
+  onLeavePix: () => void;
+  /**
+   * The Dados step's "Salvar meus dados para a próxima compra" (LGPD), offered
+   * wherever the list asks the buyer's details instead — same words, same
+   * default — because the list skips that step.
+   */
+  consent: ListConsent;
+}
+
+export interface ListConsent {
+  label: string;
+  checked: boolean;
+  onChange: (checked: boolean) => void;
+}
+
+const PaymentListContext = createContext<PaymentListMode | null>(null);
+
+export function PaymentListProvider({
+  list,
+  onLeavePix,
+  consent,
+  children,
+}: {
+  list: CheckoutPaymentList;
+  onLeavePix: () => void;
+  consent: ListConsent;
+  children: ReactNode;
+}): JSX.Element {
+  const [qrOpen, setQrOpen] = useState(false);
+  const value = useMemo(() => ({ list, qrOpen, setQrOpen, onLeavePix, consent }), [list, qrOpen, onLeavePix, consent]);
+  return <PaymentListContext.Provider value={value}>{children}</PaymentListContext.Provider>;
+}
+
+/** The list mode a pane is rendered in, or `null` for the tabs layout. */
+export function usePaymentListMode(): PaymentListMode | null {
+  return useContext(PaymentListContext);
+}

package/src/components/checkout/list/en-US.ts

@@ -0,0 +1,61 @@
+import type { PaymentListCopy } from "./types";
+
+/** The one-list Pagamento step's words, en-US (FUT-3591, FUT-3592). */
+export const EN_US_PAYMENT_LIST_COPY: PaymentListCopy = {
+  title: "How would you like to pay?",
+  onlineHeading: "Pay now, in the app",
+  doorHeading: "Pay on delivery",
+  pix: { label: "Pix", hint: "Get a code to copy and paste" },
+  card: {
+    label: "Credit card",
+    hintSaved: (card) => `${card} or another card`,
+    hintNew: "Enter your card details",
+  },
+  googlePay: { label: "Google Pay", hint: "With the card saved in your Google account" },
+  handOff: {
+    label: "Pix or card",
+    hint: (provider) =>
+      provider ? `You pay on ${provider}'s page and come back` : "You pay on the payment page and come back",
+  },
+  savedCard: (brand, last4) => `${brand ?? "Card"} ending ${last4}`,
+  otherCard: "Another card",
+  buyer: {
+    cpf: "CPF",
+    phone: "Mobile",
+    name: "Name",
+    email: "Email",
+    why: (provider) => (provider ? `(${provider} asks for it to pay in the app)` : "(needed to pay in the app)"),
+    cpfIncomplete: "A CPF has 11 digits.",
+    phoneIncomplete: "The mobile number needs the area code and 9 digits.",
+  },
+  reasons: {
+    choose: "Choose how to pay.",
+    cpf: "Enter your CPF to pay in the app.",
+    phone: "Enter your mobile number to pay in the app.",
+    details: "Fill in your details to pay in the app.",
+    chooseCard: "Choose the card.",
+    cardDetails: "Fill in the card details.",
+  },
+  actions: {
+    choose: "Choose how to pay",
+    card: "Pay",
+    pix: "Create Pix",
+    googlePay: "Pay with Google Pay",
+    handOff: (provider) => (provider ? `Go to ${provider}` : "Go to payment"),
+  },
+  payer: (name) => `Paying as ${name} · CPF ✓`,
+  payerChange: "Change",
+  charging: (total, card) => `Paying ${total} with ${card ?? "the card entered"}…`,
+  cancel: "Cancel",
+  pixFace: {
+    title: (total) => `Pay ${total} with Pix`,
+    validUntil: (time) =>
+      `Valid until ${time}. Copy the code and paste it in your bank app, under Pix copy and paste.`,
+    showQr: "Show QR code (pay from another phone)",
+    hideQr: "Hide QR code",
+    changeMethod: "Change payment method",
+    copyCode: "Copy Pix code",
+    waiting: "Waiting for the Pix payment…",
+  },
+  handOffWaiting: (provider) => (provider ? `Waiting for ${provider}…` : "Waiting for the payment…"),
+};