@12-apps/payments-frontend 3.39.0 → 3.41.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@12-apps/payments-frontend",
-  "version": "3.39.0",
+  "version": "3.41.0",
   "type": "module",
   "sideEffects": false,
   "description": "Browser half of the vendor-agnostic payments platform: plug-and-play MUI components for the per-provider settings page (credential form from each provider's schema, masked hints, verify/enable) and the checkout page (PIX QR + polling, card tokenization, hosted-checkout redirect), plus the headless hooks and fetch clients they build on. Talks only to the host's payments HTTP surface — never to a provider directly. Microfrontend-ready: no app coupling, host injects theme and auth.",
@@ -23,7 +23,7 @@
     "storybook:build": "storybook build"
   },
   "dependencies": {
-    "@12-apps/payments-backend": "^4.30.0",
+    "@12-apps/payments-backend": "^4.31.0",
     "react-qr-code": "^2.2.0"
   },
   "peerDependencies": {

package/src/activation/use-redirect-activation.ts

@@ -53,7 +53,10 @@ import { clearReturnedSettlement, takeReturnedSettlement } from './returned-sett
  * things that clear it are settlement and an explicit "give up".
  */
 
-/** How often to ask the provider whether the payment landed. */
+/**
+ * How often to ask the provider whether the payment landed — the recorded
+ * third-party-wait exception, see {@link usePollTimer}.
+ */
 const DEFAULT_POLL_MS = 4000;
 
 /** Give up asking after this long, rather than polling a tab forever. */
@@ -126,6 +129,24 @@ interface ActivationCallbacks {
 /**
  * Ask the provider every few seconds, and stop asking eventually.
  *
+ * ## A deliberate poll: the recorded exception to "hear, do not poll" (FUT-2433)
+ *
+ * Every other wait in this package hears the host's channel and keeps no timer
+ * while it is live. This one cannot, and it is the one exception class the
+ * origin host records: a timer-driven read of a THIRD PARTY's state that no
+ * webhook or publisher of the host's reaches yet, bounded in time, and named.
+ * Each tick is not a read of the host's own rows — `verify-charge` asks the
+ * PROVIDER whether the activation charge was paid, and while nobody has asked,
+ * nothing server-side has moved that a hint could carry. The activation webhook
+ * that would settle it is not guaranteed to arrive (a tunnel, a preview box), so
+ * the wait is the confirmation. It runs only while the owner is paying on the
+ * provider's page and gives up at `pollTimeoutMs` (ten minutes by default).
+ *
+ * Where it is recorded: the origin host's realtime doc ("Allowed exceptions")
+ * and the decision record that superseded its 0071 with it. If activation
+ * ever becomes webhook-only, this relaxes to the channel exactly as the
+ * checkout's waits did (FUT-649) and the exception goes away.
+ *
  * The give-up is a `failed` state carrying the host's own sentence, because the
  * wording is load-bearing: the charge is STILL valid, and an owner who has
  * genuinely paid must not be told they did not pay in time.

package/src/components/PaymentProviderSettings.tsx

@@ -21,6 +21,7 @@ import {
   type ProviderChangeHandler,
 } from './settings-state';
 import { openSection, SetupGuideSection } from './SetupGuideSection';
+import { useSettingsLive, type PaymentsSettingsLiveSignal } from './settings-live';
 import type { PaymentsSettingsCopy } from './settings-copy';
 import { PaymentsSettingsCopyProvider } from './settings-copy-context';
 
@@ -102,6 +103,16 @@ export interface PaymentProviderSettingsProps {
    * its history ({@link ProviderChangeHandler}).
    */
   onProviderChange?: ProviderChangeHandler;
+  /**
+   * The host's realtime channel for this store's payment settings (FUT-648).
+   *
+   * A hint re-reads the view, and so does every (re)connect: an OAuth grant
+   * completed in another tab, a colleague's save, a webhook settling the
+   * activation charge all reach this screen without a reload. Omit it and the
+   * screen reads on mount and after its own actions, exactly as before — it
+   * keeps no timer either way. See {@link PaymentsSettingsLiveSignal}.
+   */
+  live?: PaymentsSettingsLiveSignal;
   /**
    * The activation step, rendered under the connection card.
    *
@@ -299,8 +310,10 @@ export function PaymentProviderSettings({
   selectedProvider,
   onProviderChange,
   renderVerification,
+  live,
 }: PaymentProviderSettingsProps) {
   const { view, error, reload } = useSettingsState(client);
+  useSettingsLive(live, () => void reload());
   const { selected, setSelected } = useSelectedProvider(
     initialProvider,
     selectedProvider,

package/src/components/checkout/list/bank-apps.ts

@@ -0,0 +1,113 @@
+/**
+ * Opening the buyer's bank app from the Pix face (FUT-3612).
+ *
+ * There is no standard Pix link that pays a copia-e-cola code, so this only
+ * OPENS the app; the buyer pastes the code the button already copied. Android
+ * opens an app through an `intent:` URL naming its package; iOS only through a
+ * URL scheme the bank's app registers. Neither tells the page whether it
+ * worked, so {@link openBankApp} watches the page: an app that opened takes
+ * the screen within a moment, and a page still visible after
+ * {@link OPEN_WAIT_MS} is a bank that did not open — not installed, or a link
+ * this phone does not know.
+ */
+import type { PixBankId } from "./types";
+
+/** How long a page may stay visible before the bank counts as not opened. */
+const OPEN_WAIT_MS = 1500;
+
+interface BankApp {
+  /** The Play Store package of the bank's personal app — each one checked on its Play listing (2026-10-16). */
+  android: string;
+  /**
+   * The URL scheme its app answers on iOS (without "://"). Only Nubank's
+   * (`nuapp`) is documented — in Nubank's own deep links. The other five
+   * publish no scheme we could find: theirs are the likeliest name, and a
+   * phone that does not know one is a bank that "did not open", which the face
+   * says (owner, 2026-10-16: Android and iOS, and say so when it does not open).
+   */
+  ios: string;
+  /** A scheme Android opens the app with, when one is known; else the app's launcher, by package. */
+  scheme?: string;
+}
+
+/** The six, in the prototype's order. */
+export const PIX_BANKS: readonly PixBankId[] = ["nubank", "itau", "bradesco", "bb", "caixa", "santander"];
+
+const APPS: Record<PixBankId, BankApp> = {
+  nubank: { android: "com.nu.production", ios: "nuapp", scheme: "nuapp" },
+  itau: { android: "com.itau", ios: "itau" },
+  bradesco: { android: "com.bradesco", ios: "bradesco" },
+  bb: { android: "br.com.bb.android", ios: "bbapp" },
+  caixa: { android: "br.gov.caixa.CAIXA", ios: "caixa" },
+  santander: { android: "com.santander.app", ios: "santanderpf" },
+};
+
+export type PhoneOs = "android" | "ios";
+
+/** The phone this page runs on, or `null` for a computer (or no browser at all). */
+export function phoneOs(nav: Pick<Navigator, "userAgent" | "maxTouchPoints"> | undefined = typeof navigator === "undefined" ? undefined : navigator): PhoneOs | null {
+  if (!nav) return null;
+  const ua = nav.userAgent;
+  if (/Android/i.test(ua)) return "android";
+  if (/iPhone|iPad|iPod/i.test(ua)) return "ios";
+  // iPadOS asks for the desktop site: a "Macintosh" with a touch screen.
+  if (/Macintosh/i.test(ua) && nav.maxTouchPoints > 1) return "ios";
+  return null;
+}
+
+/**
+ * The phone the host's bank flow runs on: its own word when it gave one
+ * (`phone`), else the browser's. `null` ⇒ a computer: no banks.
+ */
+export function bankFlowOs(phone: boolean | undefined): PhoneOs | null {
+  if (phone === false) return null;
+  if (phone === true) return phoneOs() ?? "android";
+  return phoneOs();
+}
+
+/**
+ * The URL that opens `bank`'s app on `os`. Android: an `intent:` URL naming the
+ * package — through the app's scheme when one is known, else its launcher; a
+ * phone without the app gets the bank's Play Store page from the browser.
+ */
+export function bankAppUrl(bank: PixBankId, os: PhoneOs): string {
+  const app = APPS[bank];
+  if (os === "ios") return `${app.ios}://`;
+  if (app.scheme) return `intent://#Intent;scheme=${app.scheme};package=${app.android};end`;
+  return `intent:#Intent;action=android.intent.action.MAIN;category=android.intent.category.LAUNCHER;package=${app.android};end`;
+}
+
+/**
+ * Open `bank`'s app, and say whether it opened: `true` when the page lost the
+ * screen (hidden, or left) within {@link OPEN_WAIT_MS}.
+ */
+export function openBankApp(
+  bank: PixBankId,
+  os: PhoneOs,
+  env: { win: Window; doc: Document; waitMs?: number } = { win: window, doc: document },
+): Promise<boolean> {
+  const { win, doc } = env;
+  return new Promise((resolve) => {
+    let left = false;
+    const onVisibility = (): void => {
+      if (doc.visibilityState === "hidden") left = true;
+    };
+    const onLeave = (): void => {
+      left = true;
+    };
+    doc.addEventListener("visibilitychange", onVisibility);
+    win.addEventListener("pagehide", onLeave);
+    win.addEventListener("blur", onLeave);
+    win.setTimeout(() => {
+      doc.removeEventListener("visibilitychange", onVisibility);
+      win.removeEventListener("pagehide", onLeave);
+      win.removeEventListener("blur", onLeave);
+      resolve(left);
+    }, env.waitMs ?? OPEN_WAIT_MS);
+    try {
+      win.location.href = bankAppUrl(bank, os);
+    } catch {
+      // A scheme the browser refuses outright is a bank that did not open.
+    }
+  });
+}

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

@@ -0,0 +1,26 @@
+import type { PixBankCopy } from "./types";
+
+/** The Pix-to-bank flow's words, en-US (FUT-3612). */
+export const EN_US_PIX_BANK_COPY: PixBankCopy = {
+  names: {
+    nubank: { name: "Nubank", the: "" },
+    itau: { name: "Itaú", the: "" },
+    bradesco: { name: "Bradesco", the: "" },
+    bb: { name: "Banco do Brasil", the: "" },
+    caixa: { name: "Caixa", the: "" },
+    santander: { name: "Santander", the: "" },
+  },
+  generateAndCopy: "Create and copy the Pix",
+  generateCopyAndOpen: (bank) => `Create, copy and open ${bank.name}`,
+  copyAndOpen: (bank) => `Copy and open ${bank.name}`,
+  openOther: "Open another bank",
+  listTitle: "Open your bank and paste in Pix copia e cola",
+  open: (bank) => `Open ${bank.name}`,
+  opening: (bank) => `Opening **${bank.name}**…`,
+  other: "Another bank",
+  notOpened: (bank) => `We couldn't open ${bank.name}. Is the app installed on this phone?`,
+  retry: "Try again",
+  copied: "Pix code copied",
+  copiedPick: "Pix code copied. Choose your bank.",
+  copiedOpening: (bank) => `Pix code copied. Opening ${bank.name}…`,
+};

package/src/components/checkout/list/bank-logos.tsx

@@ -0,0 +1,35 @@
+import { Box } from "@mui/material";
+import type { JSX } from "react";
+
+import type { PixBankId } from "./types";
+
+/**
+ * The six banks' own marks (FUT-3612, owner 2026-10-15: "coloca as logos dos
+ * bancos"), drawn at 32px beside each name so a buyer finds their bank by its
+ * mark. Inline as data URIs — no remote asset (ADR 0074's sibling rule, §5.1
+ * item 5) — and only to identify the bank. Sources: Nubank and Itaú from
+ * Wikimedia Commons (PD-textlogo, trademarked); Bradesco, Banco do Brasil,
+ * Caixa and Santander from the Bancos-em-SVG collection (the banks' symbols).
+ * Each is the bank's trademark.
+ */
+const LOGOS: Record<PixBankId, string> = {
+  nubank: "data:image/svg+xml;base64,PHN2ZyB4bWxuczpkYz0iaHR0cDovL3B1cmwub3JnL2RjL2VsZW1lbnRzLzEuMS8iIHhtbG5zOmNjPSJodHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9ucyMiIHhtbG5zOnJkZj0iaHR0cDovL3d3dy53My5vcmcvMTk5OS8wMi8yMi1yZGYtc3ludGF4LW5zIyIgeG1sbnM6c3ZnPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiB4bWxuczpzb2RpcG9kaT0iaHR0cDovL3NvZGlwb2RpLnNvdXJjZWZvcmdlLm5ldC9EVEQvc29kaXBvZGktMC5kdGQiIHhtbG5zOmlua3NjYXBlPSJodHRwOi8vd3d3Lmlua3NjYXBlLm9yZy9uYW1lc3BhY2VzL2lua3NjYXBlIiB2aWV3Qm94PSIwIDAgMjYzLjg0MjA3IDE0NS41NjczNyIgdmVyc2lvbj0iMS4xIiBpZD0ic3ZnNiIgc29kaXBvZGk6ZG9jbmFtZT0iTnViYW5rIGxvZ28gMjAyMS5zdmciIHdpZHRoPSIyNjMuODQyMDciIGhlaWdodD0iMTQ1LjU2NzM3IiBpbmtzY2FwZTpleHBvcnQtZmlsZW5hbWU9IkM6XFVzZXJzXGFsZXhcc2l0ZXNcbnViYW5rLWxvZ28tMC5wbmciIGlua3NjYXBlOmV4cG9ydC14ZHBpPSI1NjEuNzM3MTIiIGlua3NjYXBlOmV4cG9ydC15ZHBpPSI1NjEuNzM3MTIiIGlua3NjYXBlOnZlcnNpb249IjEuMC4yIChlODZjODcwODc5LCAyMDIxLTAxLTE1LCBjdXN0b20pIj4gPG1ldGFkYXRhIGlkPSJtZXRhZGF0YTEyIj4gPHJkZjpSREY+IDxjYzpXb3JrIHJkZjphYm91dD0iIj4gPGRjOmZvcm1hdD5pbWFnZS9zdmcreG1sPC9kYzpmb3JtYXQ+IDxkYzp0eXBlIHJkZjpyZXNvdXJjZT0iaHR0cDovL3B1cmwub3JnL2RjL2RjbWl0eXBlL1N0aWxsSW1hZ2UiIC8+IDxkYzp0aXRsZT48L2RjOnRpdGxlPiA8L2NjOldvcms+IDwvcmRmOlJERj4gPC9tZXRhZGF0YT4gPGRlZnMgaWQ9ImRlZnMxMCIgLz4gPHNvZGlwb2RpOm5hbWVkdmlldyBwYWdlY29sb3I9IiNmZmZmZmYiIGJvcmRlcmNvbG9yPSIjNjY2NjY2IiBib3JkZXJvcGFjaXR5PSIxIiBvYmplY3R0b2xlcmFuY2U9IjEwIiBncmlkdG9sZXJhbmNlPSIxMCIgZ3VpZGV0b2xlcmFuY2U9IjEwIiBpbmtzY2FwZTpwYWdlb3BhY2l0eT0iMCIgaW5rc2NhcGU6cGFnZXNoYWRvdz0iMiIgaW5rc2NhcGU6d2luZG93LXdpZHRoPSIxMzY2IiBpbmtzY2FwZTp3aW5kb3ctaGVpZ2h0PSI3MDUiIGlkPSJuYW1lZHZpZXc4IiBzaG93Z3JpZD0iZmFsc2UiIGlua3NjYXBlOnpvb209IjAuMjE0NTk3NTkiIGlua3NjYXBlOmN4PSIyMDguODkzNiIgaW5rc2NhcGU6Y3k9IjEyOC41MTMxNSIgaW5rc2NhcGU6d2luZG93LXg9Ii04IiBpbmtzY2FwZTp3aW5kb3cteT0iLTgiIGlua3NjYXBlOndpbmRvdy1tYXhpbWl6ZWQ9IjEiIGlua3NjYXBlOmN1cnJlbnQtbGF5ZXI9InN2ZzYiIGlua3NjYXBlOmRvY3VtZW50LXJvdGF0aW9uPSIwIiBmaXQtbWFyZ2luLXRvcD0iMCIgZml0LW1hcmdpbi1sZWZ0PSIwIiBmaXQtbWFyZ2luLXJpZ2h0PSIwIiBmaXQtbWFyZ2luLWJvdHRvbT0iMCIgLz4gPHBhdGggZD0iTSA0Ny42Mjc1OTgsMTMuODg1NjUgQyA1NS45NzA5MTgsNS4xMjAyMiA2Ny4wMzgxODgsMCA4MC4wNDAxNTgsMCBjIDI1LjMyOTMwMiwwIDQyLjEyMjg2MiwxOC40OTM2MSA0NS4zMzU4MTIsNDYuMTk4MzEgMS4wNDE3Myw4Ljk5NzAyIDEuMDMyMTcsMjEuNjgxNDYgMS4wMjE3MiwzNi4zNzMzOCAtMC4wMDIsMS41MDY2MiAtMC4wMDIsMy4wMzQ2NCAtMC4wMDIsNC41ODE3NSB2IDU1LjAzODM5IEggOTEuNTYzMDY4IHYgLTQwLjcwODEyIGMgMCwwIC0wLjA3MSwtMzQuODQwMzYgLTAuMjgzODYsLTQxLjM1MTggLTAuOTM0ODIsLTI4LjM1OTQ1IC0xNy43MjM4MywtNDYuMTc5MTEgLTQzLjY1NDk3LC00Ni4xOTgyNiAtNy44MjM2LDguMjY1NzcgLTEyLjAxNTU5LDE4LjM3MjEgLTEyLjYzMzgxLDMzLjgyNDk4IC0wLjA4NSwyLjE1NTMxIC0wLjA2MzYsOS43OTQ5MSAtMC4wMzU0LDE5Ljg2MzY3IDAuMDE0Niw1LjIxNjggMC4wMzEsMTEuMDg1OTIgMC4wMzU0LDE3LjE4MjA0IDAuMDI1OCwyNi41MzM4OCAwLDU3LjM5MzQxIDAsNTcuMzkzNDEgSCAwLjE1NzcwMTQ1IFYgNzkuNTQ4NDIgYyAwLC0yLjE0NjY4IC0wLjAzOTE1LC00LjMxMTU1IC0wLjA3ODM5LC02LjQ4NTA2IC0wLjA3ODk5OTk5NzEsLTQuMzcyMDUgLTAuMTU4NjI2LC04Ljc3Nzc1IDAuMDc4MzksLTEzLjE0MDI1IEMgMC41NTEyNTI0NSw1Mi42NTA2MiAxLjgwOTMyMjUsNDUuNTAxNCA1LjIwMjg2ODUsMzguODU5OTUgMTIuOTcwNjU4LDIzLjY0NDgxIDI4Ljg4Njg4OCwxMy44NDgzNSA0NS44NTQ4NDgsMTMuODQ4MzUgYyAwLjU5Mjc0LDAgMS4xODU5MywwLjAxMzcgMS43NzI3NSwwLjAzNjQgeiIgY2xhc3M9IlBhdGgteHJ0a3BkLTAgZXFmWWlSIiBpZD0icGF0aDIiIGlua3NjYXBlOmNvbm5lY3Rvci1jdXJ2YXR1cmU9IjAiIHN0eWxlPSJmaWxsOiM4MjBhZDE7ZmlsbC1vcGFjaXR5OjE7c3Ryb2tlLXdpZHRoOjQuNTQ5IiBpbmtzY2FwZTpleHBvcnQtZmlsZW5hbWU9IkM6XFVzZXJzXGFsZXhcc2l0ZXNcbnViYW5rLWxvZ28tNS5wbmciIGlua3NjYXBlOmV4cG9ydC14ZHBpPSIxMzIuNzY1MzgiIGlua3NjYXBlOmV4cG9ydC15ZHBpPSIxMzIuNzY1MzgiIC8+IDxwYXRoIGQ9Im0gMjYzLjY4NDMzLDg1LjY0NDk5IGMgMC4yMzcsLTQuMzYyNDkgMC4xNTczOSwtOC43Njg2NiAwLjA3ODcsLTEzLjE0MDI1IC0wLjAzOTYsLTIuMTczNTEgLTAuMDc4NywtNC4zMzgzOCAtMC4wNzg3LC02LjQ4NTA1IFYgMy4zNzAyMiBoIC0zNC44MzIxOCBjIDAsMCAtMC4wMjYsMzAuODU5NTMgMCw1Ny4zOTMwOSAwLjAwNCw2LjA5NjEyIDAuMDIwNSwxMS45NjQ3OSAwLjAzNSwxNy4xODE1OSAwLjAyODIsMTAuMDY5MjEgMC4wNDk2LDE3LjcwODgxIC0wLjAzNSwxOS44NjQxMyAtMC42MTgyMSwxNS40NTM0MiAtNC44MTA1NiwyNS41NTk0OCAtMTIuNjMzOTQsMzMuODI1NDggLTI1LjkzMDY5LC0wLjAxODIgLTQyLjcxOTIzLC0xNy44MzkzOCAtNDMuNjU0NTEsLTQ2LjE5ODMyIC0wLjIxMjksLTYuNTExNDQgLTAuMzAyOTcsLTIyLjY2OTk1IC0wLjMwMjk3LC00MS4zODQ1MSBWIDMuMzQzNjEgbCAtMzQuODA2NjksMC4wMzE4IHYgNTUuMDM4NTIgYyAwLDEuNTQ3MTIgLTAuMDAyLDMuMDc0NjggLTAuMDAyLDQuNTgxNzYgLTAuMDExLDE0LjY5MTkxIC0wLjAyLDI3LjM3NTkgMS4wMjE3LDM2LjM3MzM4IDMuMjA2MTUsMjcuNzA0NzkgMTkuOTk5Nyw0Ni4xOTgzIDQ1LjMyOSw0Ni4xOTgzIDEzLjAwMjQyLDAgMjQuMDY5NjksLTUuMTIwMzUgMzIuNDEzMDEsLTEzLjg4NTgyIDAuNTg2MzcsMC4wMjI3IDEuMTc5MTEsMC4wMzY0IDEuNzcxODQsMC4wMzY0IDE2Ljk2Nzc4LDAgMzIuODg0MjksLTkuNzk2MjggNDAuNjUyMTcsLTI1LjAxMTMzIDMuMzkzNTUsLTYuNjQyIDQuNjUxMzUsLTEzLjc5MDc2IDUuMDQ0ODQsLTIxLjA2MzI1IHoiIGNsYXNzPSJQYXRoLXhydGtwZC0wIGVxZllpUiIgaWQ9InBhdGg0IiBpbmtzY2FwZTpjb25uZWN0b3ItY3VydmF0dXJlPSIwIiBzdHlsZT0iZmlsbDojODIwYWQxO2ZpbGwtb3BhY2l0eToxO3N0cm9rZS13aWR0aDo0LjU0OSIgaW5rc2NhcGU6ZXhwb3J0LWZpbGVuYW1lPSJDOlxVc2Vyc1xhbGV4XHNpdGVzXG51YmFuay1sb2dvLTUucG5nIiBpbmtzY2FwZTpleHBvcnQteGRwaT0iMTMyLjc2NTM4IiBpbmtzY2FwZTpleHBvcnQteWRwaT0iMTMyLjc2NTM4IiAvPiA8cGF0aCBkPSJtIDExOC41ODczMSw3OTQuNjAwOTMgYyAxNC4xNTg0NiwtMTQuOTQ0NjQgMzIuOTM5NDIsLTIzLjY3NDM1IDU1LjAwMzc4LC0yMy42NzQzNSA0Mi45ODMzMSwwIDcxLjQ4MTY1LDMxLjUzMDY1IDc2LjkzNDAxLDc4Ljc2NTY1IDEuNzY3NzcsMTUuMzM5NSAxLjc1MTYsMzYuOTY1OCAxLjczMzg5LDYyLjAxNDcgMCwyLjU2ODggMCw1LjE3MzkgMCw3LjgxMTcgdiA5My44Mzc0NyBoIC01OS4xMTA0NCB2IC02OS40MDUxNyBjIDAsMCAtMC4xMjA1NSwtNTkuNDAwOSAtMC40ODE4NiwtNzAuNTAyNiAtMS41ODYxOCwtNDguMzUxNCAtMzAuMDc2NzgsLTc4LjczMyAtNzQuMDgxNjksLTc4Ljc2NTYgLTEzLjI3NjQyLDE0LjA5MjcgLTIwLjM5MDM3MiwzMS4zMjM0IC0yMS40Mzk0MDIsNTcuNjY5OCAtMC4xNDQxMiwzLjY3NDcgLTAuMTA3OTEsMTYuNjk5OCAtMC4wNjA2LDMzLjg2NjUgMC4wMjQ4LDguODk0NCAwLjA1MzMsMTguOTAwOSAwLjA2MDYsMjkuMjk0NSAwLjA0NSw0NS4yMzg5IDAsOTcuODUyNjcgMCw5Ny44NTI2NyBIIDM4LjAzNTA2OCBWIDkwNi41NTI0MyBjIDAsLTMuNjU5OSAtMC4wNjcsLTcuMzUwOSAtMC4xMzMsLTExLjA1NjcgLTAuMTMzOTMsLTcuNDU0MSAtMC4yNjkwMywtMTQuOTY1NiAwLjEzMywtMjIuNDAzNCAwLjY2ODAzLC0xMi4zOTkyIDIuODAyOTMsLTI0LjU4ODMgOC41NjE4LC0zNS45MTE1IDEzLjE4MTYzLC0yNS45NDExIDQwLjE5MTM0LC00Mi42NDM1IDY4Ljk4NTcyMiwtNDIuNjQzNSAxLjAwNTc3LDAgMi4wMTI0NCwwLjAyMyAzLjAwODIxLDAuMDYyIHoiIGNsYXNzPSJQYXRoLXhydGtwZC0wIGVxZllpUiIgaWQ9InBhdGgyLTYiIGlua3NjYXBlOmNvbm5lY3Rvci1jdXJ2YXR1cmU9IjAiIHN0eWxlPSJmaWxsOiNmZmZmZmY7c3Ryb2tlLXdpZHRoOjcuNzM3NjgiIGlua3NjYXBlOmV4cG9ydC1maWxlbmFtZT0iQzpcVXNlcnNcYWxleFxzaXRlc1xudWJhbmstbG9nby00LnBuZyIgaW5rc2NhcGU6ZXhwb3J0LXhkcGk9IjkyLjYxODA5NSIgaW5rc2NhcGU6ZXhwb3J0LXlkcGk9IjkyLjYxODA5NSIgLz4gPHBhdGggZD0ibSA0ODUuMjMyMTcsOTE2Ljk0NjgzIGMgMC40MDIyMSwtNy40Mzc5IDAuMjY3MTQsLTE0Ljk1MDEgMC4xMzM2LC0yMi40MDM1IC0wLjA2NzIsLTMuNzA1NyAtMC4xMzM2LC03LjM5NjcgLTAuMTMzNiwtMTEuMDU2NyB2IC0xMDYuODE0IGggLTU5LjEwOTYyIGMgMCwwIC0wLjA0NDMsNTIuNjEzOSAwLDk3Ljg1MjIgMC4wMSwxMC4zOTM2IDAuMDM0NiwyMC4zOTkzIDAuMDU5MywyOS4yOTM3IDAuMDQ3OCwxNy4xNjc1IDAuMDg0MSwzMC4xOTI2IC0wLjA1OTMsMzMuODY3MyAtMS4wNDkxMSwyNi4zNDczIC04LjE2MzQzLDQzLjU3NzYgLTIxLjQzOTU5LDU3LjY3MDcgLTQ0LjAwMzk4LC0wLjAzMSAtNzIuNDkzODUsLTMwLjQxNTMgLTc0LjA4MTA1LC03OC43NjU3IC0wLjM2MTI1LC0xMS4xMDE3IC0wLjUxNDE4LC0zOC42NTExIC0wLjUxNDE4LC03MC41NTg0IHYgLTY5LjQwNTE2IGwgLTU5LjA2NjM1LDAuMDU0MSB2IDkzLjgzNzg2IGMgMCwyLjYzNzcgMCw1LjI0MjEgMCw3LjgxMTYgLTAuMDE5MiwyNS4wNDkgLTAuMDMzLDQ2LjY3NDUgMS43MzM4Nyw2Mi4wMTQ3IDUuNDQwNzEsNDcuMjM1MiAzMy45MzkwNSw3OC43NjU2NyA3Ni45MjI1NSw3OC43NjU2NyAyMi4wNjUwMSwwIDQwLjg0NTg3LC04LjcyOTkgNTUuMDA0MzYsLTIzLjY3NDU3IDAuOTk1MDgsMC4wMzkgMi4wMDA5NCwwLjA2MiAzLjAwNjc5LDAuMDYyIDI4Ljc5NDA4LDAgNTUuODA0MTIsLTE2LjcwMjEgNjguOTg2MDUsLTQyLjY0MyA1Ljc1ODg5LC0xMS4zMjQzIDcuODkzMjgsLTIzLjUxMjUgOC41NjEwNSwtMzUuOTExNyB6IiBjbGFzcz0iUGF0aC14cnRrcGQtMCBlcWZZaVIiIGlkPSJwYXRoNC01IiBpbmtzY2FwZTpjb25uZWN0b3ItY3VydmF0dXJlPSIwIiBzdHlsZT0iZmlsbDojZmZmZmZmO3N0cm9rZS13aWR0aDo3LjczNzY4IiBpbmtzY2FwZTpleHBvcnQtZmlsZW5hbWU9IkM6XFVzZXJzXGFsZXhcc2l0ZXNcbnViYW5rLWxvZ28tNC5wbmciIGlua3NjYXBlOmV4cG9ydC14ZHBpPSI5Mi42MTgwOTUiIGlua3NjYXBlOmV4cG9ydC15ZHBpPSI5Mi42MTgwOTUiIC8+IDwvc3ZnPg==",
+  itau: "data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" width="500" height="500" viewBox="0 0 500 500"><path d="M218.676 10.574c-13.797.328-23.918.813-42.473 1.957-8.582.512-17.95 1.266-24.547 1.926-1.656.18-5.12.512-7.68.754-10.753 1.055-26.718 3.07-33.433 4.215-1.418.242-3.496.574-4.668.754-1.145.152-3.195.511-4.52.754-1.324.242-3.554.664-4.968.902-4.973.844-13.434 2.562-18.223 3.707-1.328.332-3.707.902-5.273 1.266-1.567.359-2.98.691-3.16.722-8.829 2.106-17.594 6.356-24.34 11.867C38.824 44.73 32.953 53.344 30 61.898c-.48 1.325-.965 2.68-1.113 3.012-.512 1.145-2.742 10.781-4.34 18.676-.238 1.324-.66 3.281-.902 4.367-.243 1.082-.57 2.98-.782 4.215-.183 1.234-.422 2.742-.574 3.312-.453 1.72-2.289 13.465-3.465 21.989-1.144 8.254-1.898 14.25-2.558 20.332-.332 2.98-.664 5.902-.723 6.476-.09.57-.363 3.493-.633 6.477-.242 2.98-.601 6.625-.785 8.133-.633 5.539-2.2 29.668-2.98 46.687-.602 12.617-.993 39.637-.782 54.367.211 18.372.66 34.79 1.082 40.512.153 2.317.453 7.2.633 10.844.18 3.644.422 8.312.574 10.39.692 10.422 1.235 17.258 1.504 19.426.153 1.328.512 4.852.754 7.801.242 2.953.602 6.477.754 7.832.18 1.356.512 4.277.75 6.508.754 7.137 1.328 11.805 1.809 14.91.242 1.656.664 4.488.902 6.324.875 6.625 1.898 13.07 3.012 18.977.242 1.324.633 3.555.906 4.969.512 3.011 1.687 9.007 2.531 12.8 2.89 13.286 4.156 17.258 7.559 23.797.933 1.805 2.137 3.914 2.68 4.668.511.754 1.265 1.836 1.656 2.41 1.718 2.559 6.629 7.559 9.34 9.489.449.328 1.324.96 1.894 1.414.606.48 1.176.843 1.328.843.121 0 .422.211.66.454 1.176 1.144 9.461 5.09 13.012 6.144.664.211 1.477.48 1.809.633.785.36 5.21 1.473 10.543 2.68 2.32.543 4.699 1.113 5.27 1.265 1.386.36 10.12 2.106 16.718 3.313 3.793.691 11.176 1.867 15.812 2.531 1.747.238 3.977.57 4.97.75 3.644.633 18.706 2.383 28.163 3.285 3.403.332 7.59.723 9.336.902 2.832.301 5.723.543 19.578 1.536 2.078.152 6.809.422 10.543.605 3.735.18 8.946.45 11.598.602 21.445 1.234 82.77 1.234 103.914 0 2.652-.18 7.863-.422 11.598-.602 6.414-.3 8.765-.453 18.824-1.207 12.89-.992 31.84-2.832 38.254-3.734 1.836-.27 5-.692 7.078-.965 7.68-.992 18.223-2.59 24.246-3.703 6.598-1.207 15.332-2.953 16.719-3.313.57-.152 2.949-.722 5.27-1.265 5.21-1.176 9.73-2.32 10.542-2.68a174.8 174.8 0 0 1 3.012-1.055c2.469-.812 10.664-4.699 11.355-5.363.211-.211.813-.66 1.325-.965 2.351-1.473 3.433-2.316 5.574-4.246 2.41-2.2 5.754-5.812 6.566-7.047.27-.422.993-1.445 1.594-2.258.633-.843 1.145-1.597 1.145-1.718 0-.122.484-.965 1.054-1.868.575-.902 1.266-2.23 1.54-2.953.3-.691.6-1.445.722-1.593.57-.754 2.68-6.75 3.582-10.153 1.418-5.27 4.066-17.71 5.031-23.586.242-1.504.512-2.918.602-3.16.273-.664 1.93-10.996 3.433-21.535.332-2.32.664-4.64.754-5.121.243-1.387 1.325-10.633 1.809-15.512.238-2.41.57-5.183.75-6.176.184-.996.512-4.246.754-7.23.242-2.98.574-6.656.723-8.133.18-1.504.453-4.937.632-7.68.18-2.742.453-6.113.602-7.53.183-1.415.512-6.626.754-11.595.273-4.972.574-11.086.754-13.554 1.355-21.899 1.355-79.368 0-101.957-.153-2.563-.422-7.59-.602-11.145-.183-3.555-.453-8.254-.605-10.394-.18-2.168-.57-7.5-.903-11.895-.332-4.398-.664-8.527-.754-9.187-.09-.665-.359-3.586-.601-6.477-.242-2.89-.512-5.602-.602-6.023-.09-.422-.422-3.196-.754-6.176-.78-7.2-1.746-15.149-1.957-16.082-.09-.422-.422-2.832-.754-5.305-1.476-11.262-4.214-26.957-6.566-37.648-.332-1.508-.871-3.946-1.203-5.422-.844-3.856-1.84-7.742-2.168-8.434-.152-.332-.422-1.144-.633-1.808-.664-2.227-4.008-9.668-4.851-10.844-.122-.18-1.082-1.594-2.11-3.16-2.137-3.223-7.617-8.946-10.902-11.356-6.504-4.789-13.735-8.043-23.07-10.332a440.932 440.932 0 0 1-4.82-1.207c-1.114-.328-3.345-.812-8.134-1.805a396.317 396.317 0 0 1-4.066-.875c-5.813-1.414-24.73-4.488-37.047-6.054-2.473-.301-4.91-.633-5.422-.75-.906-.184-5.273-.633-14.156-1.508-2.473-.242-5.875-.602-7.531-.754-1.656-.18-4.64-.45-6.625-.633-1.989-.148-5.242-.422-7.23-.57-6.747-.574-25.481-1.656-35.844-2.11-20.032-.874-57.02-1.144-79.97-.57ZM85.965 214.098c.18.148 1.055.422 1.926.632 1.629.391 3.918 1.446 5.632 2.59 1.356.903 4.551 4.336 5.18 5.543.305.602.633 1.145.723 1.235.094.09.363.691.605 1.355.211.66.48 1.356.633 1.504.39.574.844 4.156.844 6.809 0 2.59-.395 5.632-.906 6.746-1.625 3.734-2.41 4.968-4.457 7.14-1.899 1.957-2.68 2.559-5.27 3.825-2.11 1.054-3.617 1.597-4.82 1.714-.965.121-1.809.332-1.899.454-.21.363-6.746.363-6.746 0 0-.122-.754-.333-1.719-.454-.933-.117-2.105-.39-2.617-.601a30.998 30.998 0 0 0-1.988-.813c-.574-.21-1.117-.453-1.207-.543-.09-.12-.543-.39-1.055-.632-1.746-.872-5.36-4.88-6.414-7.079-.574-1.175-1.113-2.32-1.265-2.558-1.024-2.05-1.204-11.387-.243-13.555.274-.574.664-1.535.875-2.11.211-.57.453-1.113.543-1.202.09-.09.45-.696.782-1.356.574-1.117 4.156-4.972 4.668-4.972.12 0 .394-.211.605-.48.57-.634 3.492-2.048 5.27-2.5.843-.212 1.777-.513 2.109-.665.332-.148 1.144-.3 1.805-.39 1.777-.18 8.015.09 8.406.363Zm328.191 20.992v15.21h-58.433v-20.359l3.254-.515c7.199-1.113 11.687-1.867 11.957-2.047.18-.121 1.656-.36 3.312-.57 1.656-.211 3.164-.485 3.313-.606.183-.117 1.597-.39 3.164-.601 1.566-.18 3.613-.543 4.52-.782.902-.21 2.8-.543 4.214-.722 1.418-.184 2.832-.453 3.164-.575.332-.148 1.836-.421 3.313-.632 1.507-.18 3.191-.45 3.765-.633.57-.149 2.742-.57 4.82-.903 2.079-.332 4.79-.78 6.024-.992 1.234-.242 2.559-.422 2.95-.453l.663-.031Zm-249.398 13.433v18.043h30.12v26.809H164.73l.118 27.922c.093 30.09.03 28.613 1.66 32.316 1.234 2.864 4.726 5.785 7.738 6.508.512.121 1.086.36 1.328.543.57.45 12.77.45 13.313-.031.238-.18 1.324-.422 2.468-.543l2.02-.211v26.418l-.816.36c-.75.331-4.215.874-8.973 1.445-6.777.785-19.129.875-19.852.12-.18-.148-.66-.269-1.113-.269-1.176 0-6.055-.906-6.418-1.176-.18-.12-.992-.422-1.836-.601-.812-.211-1.625-.485-1.808-.602-.149-.152-.84-.422-1.504-.633-.664-.21-1.266-.484-1.356-.574-.09-.09-.633-.422-1.207-.754-2.5-1.324-3.25-1.804-4.578-2.922-.781-.632-1.504-1.171-1.656-1.171-.301-.032-2.59-2.532-4.395-4.82-1.386-1.778-3.437-5.18-4.129-6.93-.242-.57-.511-1.114-.601-1.204-.121-.09-.422-1.023-.723-2.109-.273-1.082-.633-2.227-.785-2.559-.148-.332-.512-1.687-.75-3.011a144.286 144.286 0 0 0-.816-3.766c-.211-.902-.36-11.508-.45-31.566l-.12-30.18h-17.442v-26.809h17.473v-30.363l2.046-.21c1.114-.118 2.168-.329 2.32-.45.18-.121 1.657-.39 3.313-.602 1.656-.21 3.164-.515 3.313-.632.18-.121 2.078-.454 4.218-.723 2.168-.305 4.067-.633 4.215-.754.18-.121 1.176-.332 2.258-.422a49.719 49.719 0 0 0 4.219-.691c3.223-.664 8.855-1.54 9.125-1.387.121.059.21 8.254.21 18.191Zm99.851 15.18c4.215.242 8.977.785 9.336 1.055.18.12.903.332 1.657.422 1.718.273 5.906 1.507 8.433 2.53 2.11.845 6.809 3.192 7.531 3.798.243.18.782.539 1.204.722.421.211 1.75 1.262 2.921 2.29 1.176 1.054 2.262 1.957 2.41 2.015.454.211 5.813 6.719 5.813 7.078 0 .09.274.575.606 1.024.632.906 3.312 6.117 3.312 6.449 0 .117.242.781.57 1.473.301.695.664 1.75.786 2.32.12.574.332 1.176.449 1.355.12.153.394 1.114.605 2.11.18.992.422 2.02.512 2.258.121.242.39 1.535.633 2.863.36 1.988.449 9.488.57 42.68l.121 40.3h-32.86l-.03-3.554c-.032-1.926-.122-4.727-.243-6.204l-.18-2.71-.874 1.203c-1.383 1.84-5.934 6.175-7.739 7.379-3.949 2.593-5 3.222-6.086 3.586-.664.18-1.535.543-1.957.78-.453.212-1.566.575-2.472.755-.903.21-1.805.484-1.957.601-1.535 1.145-20.512 1.117-21.989-.027-.148-.121-1.234-.39-2.41-.602-1.144-.21-2.5-.543-3.011-.785-.48-.21-1.778-.754-2.829-1.176a42.42 42.42 0 0 1-3.554-1.746 49.866 49.866 0 0 0-2.442-1.414c-1.265-.695-1.687-1.086-5.12-4.52-3.524-3.523-3.977-4.003-3.977-4.335 0-.121-.391-.785-.84-1.477-.485-.691-1.176-1.957-1.54-2.773-.359-.84-.843-1.836-1.054-2.258-.238-.422-.57-1.504-.781-2.41-.211-.903-.48-1.805-.602-1.957-.332-.422-.906-4.7-.906-6.567 0-.87-.148-1.746-.328-1.925-.363-.364-.274-1.567.66-8.829.18-1.414.453-2.71.574-2.859.121-.18.39-.965.57-1.777.391-1.567 1.208-3.614 2.051-5.153.27-.511.63-1.203.813-1.566.18-.39.422-.691.57-.691.121 0 .211-.18.211-.391 0-.332 3.313-4.64 3.887-5.031.12-.09.332-.39.422-.692.12-.332.48-.632.812-.722.332-.09.602-.274.602-.395 0-.3 5.062-4.277 6.777-5.27 1.234-.753 4.008-2.167 8.043-4.097.574-.3 6.203-2.106 8.676-2.8.902-.27 2.68-.634 3.914-.813 1.234-.211 2.41-.453 2.562-.57.18-.122 1.985-.395 4.067-.575 2.078-.18 4.637-.48 5.722-.633 4.278-.632 19.305-.511 20.903.153.543.238.57.12.36-2.442-.118-1.476-.329-2.742-.45-2.832-.152-.09-.332-.66-.453-1.265-.211-1.114-1.356-3.551-2.438-5.211-.695-1.051-3.617-4.067-3.949-4.067-.117 0-.629-.3-1.144-.691-1.325-.965-3.461-1.926-4.758-2.168-.633-.121-1.145-.332-1.145-.453 0-1.324-19.457-1.535-25.3-.239-.754.149-2.5.48-3.915.723-1.418.238-2.832.57-3.164.723-.332.148-1.414.422-2.41.601-.992.18-2.078.453-2.41.602-.332.152-1.535.484-2.68.754-1.144.27-2.23.57-2.41.722-.18.122-.992.422-1.836.633-.812.211-1.656.512-1.808.633-.18.121-.993.39-1.809.602-.84.18-2.016.601-2.617.902-.633.332-1.207.574-1.297.574-.09 0-.152-6.297-.152-13.976 0-10.875.093-14.036.394-14.278.211-.18 1.055-.48 1.867-.691.844-.18 1.657-.453 1.805-.574.184-.121 1.176-.48 2.262-.754 1.082-.301 2.105-.63 2.258-.75.18-.153 1.113-.395 2.078-.602.996-.21 2.02-.484 2.258-.633.273-.12 1.507-.453 2.742-.722a58.95 58.95 0 0 0 2.863-.633c.328-.094 2.016-.363 3.762-.606 1.75-.238 3.586-.57 4.066-.722 1.75-.54 17.531-1.535 21.086-1.324.992.058 3.164.18 4.82.27ZM98.492 326.508v59.937H63.254V266.566h35.238Zm266.266-22.594c0 35.664.152 42.563.875 43.527.148.149.332.75.453 1.325.422 2.257 2.379 5.543 4.605 7.77 1.176 1.206 2.5 2.26 2.922 2.378.453.094.785.274.785.395 0 .117 1.055.539 2.348.96 1.93.606 2.953.723 5.965.723 2.11 0 3.945-.148 4.367-.328.39-.21 1.324-.512 2.078-.723.754-.21 2.11-.843 3.012-1.449 1.687-1.082 4.82-3.972 4.82-4.457 0-.148.422-.812.903-1.445.511-.664.906-1.324.906-1.504 0-.184.27-.816.57-1.418.332-.602.692-1.625.813-2.258.09-.664.3-1.324.453-1.476.754-.965.875-7.047.875-42.38v-36.988h35.238v119.88H420.06c-13.04 0-16.778-.09-16.957-.391-.122-.18-.27-3.043-.332-6.325-.06-3.253-.211-5.933-.329-5.933-.12 0-.484.36-.843.812-1.688 2.29-4.34 4.88-8.496 8.313-.602.48-1.836 1.144-4.547 2.469-1.235.601-2.59 1.296-3.012 1.507-.422.211-1.566.543-2.563.754-.992.211-1.867.48-1.957.602-.3.45-5.632.902-10.902.902-5.18 0-9.398-.36-10.633-.875-.332-.148-1.476-.511-2.562-.781-1.082-.27-2.078-.633-2.258-.754-.148-.121-.871-.422-1.566-.633-.723-.18-1.293-.449-1.293-.57 0-.121-.543-.39-1.207-.602-.66-.21-1.204-.484-1.204-.605 0-.117-.332-.36-.722-.54-2.59-1.175-8.465-6.687-10.934-10.241-1.508-2.168-3.828-6.508-4.308-8.102-.18-.633-.543-1.566-.754-2.05-.211-.512-.57-1.594-.754-2.41-.18-.84-.45-1.716-.602-2.016-.148-.274-.422-1.688-.601-3.164-.18-1.446-.512-2.922-.692-3.254-.273-.45-.394-11.204-.453-43.313l-.09-42.68h35.27Zm0 0" style="stroke:none;fill-rule:nonzero;fill:#FF6200;fill-opacity:1"/><path d="M260.691 333.164c-1.472.149-2.98.39-3.312.54-.332.183-1.414.452-2.41.663-.961.18-2.258.543-2.86.813-4.52 1.957-6.718 3.254-8.222 4.82-1.446 1.508-2.895 4.309-3.133 6.055-.063.601-.274 1.386-.453 1.715-.332.695-.211 2.832.332 5.632.601 3.043 3.012 6.75 5.148 7.864 3.797 1.957 4.52 2.257 6.63 2.59 3.792.57 11.023.242 12.589-.602.27-.152 1.387-.664 2.469-1.145 1.086-.511 2.5-1.328 3.164-1.84.664-.511 1.414-1.113 1.687-1.324 1.715-1.293 4.88-6.535 5.301-8.703.09-.543.332-1.176.512-1.418.21-.27.36-3.043.422-8.012l.12-7.59-1.628-.179c-2.2-.273-13.04-.18-16.356.121Zm0 0" style="stroke:none;fill-rule:nonzero;fill:#FF6200;fill-opacity:1"/></svg>",
+  bradesco: "data:image/svg+xml;base64,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",
+  bb: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjUwMCIgaGVpZ2h0PSIyNTAwIiB2aWV3Qm94PSIwIDAgMTkyLjc1NiAxOTIuNzU2IiB2ZXJzaW9uPSIxLjEiIGlkPSJzdmcxMCIgc29kaXBvZGk6ZG9jbmFtZT0iYmFuY28tZG8tYnJhc2lsLXNlbS1mdW5kby5zdmciIGlua3NjYXBlOnZlcnNpb249IjEuMi4yICg3MzJhMDFkYTYzLCAyMDIyLTEyLTA5KSIgeG1sbnM6aW5rc2NhcGU9Imh0dHA6Ly93d3cuaW5rc2NhcGUub3JnL25hbWVzcGFjZXMvaW5rc2NhcGUiIHhtbG5zOnNvZGlwb2RpPSJodHRwOi8vc29kaXBvZGkuc291cmNlZm9yZ2UubmV0L0RURC9zb2RpcG9kaS0wLmR0ZCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiB4bWxuczpzdmc9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4gPGRlZnMgaWQ9ImRlZnMxNCIgLz4gPHNvZGlwb2RpOm5hbWVkdmlldyBpZD0ibmFtZWR2aWV3MTIiIHBhZ2Vjb2xvcj0iIzUwNTA1MCIgYm9yZGVyY29sb3I9IiNlZWVlZWUiIGJvcmRlcm9wYWNpdHk9IjEiIGlua3NjYXBlOnNob3dwYWdlc2hhZG93PSIwIiBpbmtzY2FwZTpwYWdlb3BhY2l0eT0iMCIgaW5rc2NhcGU6cGFnZWNoZWNrZXJib2FyZD0iMCIgaW5rc2NhcGU6ZGVza2NvbG9yPSIjNTA1MDUwIiBzaG93Z3JpZD0iZmFsc2UiIGlua3NjYXBlOnpvb209IjAuMjE2OCIgaW5rc2NhcGU6Y3g9IjEyNTAiIGlua3NjYXBlOmN5PSIxMjUwIiBpbmtzY2FwZTp3aW5kb3ctd2lkdGg9IjE5MjAiIGlua3NjYXBlOndpbmRvdy1oZWlnaHQ9IjEwMDkiIGlua3NjYXBlOndpbmRvdy14PSItOCIgaW5rc2NhcGU6d2luZG93LXk9Ii04IiBpbmtzY2FwZTp3aW5kb3ctbWF4aW1pemVkPSIxIiBpbmtzY2FwZTpjdXJyZW50LWxheWVyPSJzdmcxMCIgLz4gPGcgZmlsbC1ydWxlPSJldmVub2RkIiBjbGlwLXJ1bGU9ImV2ZW5vZGQiIGlkPSJnOCI+IDxwYXRoIGZpbGw9IiMzMzM0OGUiIGQ9Ik05Ni4zOTYgMTYuOTI1bC03OC44NSA1Mi44NSAzMi44MTkgMjEuMzExTDg5LjU3NyA2NC42NiA3NC4wMjMgNTQuNDQzbDIxLjMwNS0xNC4yNzQgNDYuMjMxIDMwLjY3OS03NS44NDUgNTAuOTE4IDE2LjQwNSAxMC44NjUgOTQuMzc5LTYyLjg0OC0uMjEzLS4yMTMtNzkuODg5LTUyLjY0NXpNMTc1LjAyNyAxNi45NDdsLTMyLjgwOCAyMS43MzEgMTYuNDA0IDExLjA3OCAxNi40MDQtMTEuMDc4VjE2Ljk0N3pNMTcuMDA1IDE3NS44MzJsMzIuODA5LTIxLjczLTE2LjQwNC0xMS4wNzktMTYuNDA1IDExLjA3OXYyMS43M3oiIGlkPSJwYXRoNCIgLz4gPHBhdGggZmlsbD0iIzMzMzQ4ZSIgZD0iTTk2LjM2IDE3NS43ODdsNzguODQ5LTUyLjg1MS0zMi44MTgtMjEuMzExLTM5LjIxMSAyNi40MjYgMTUuNTUyIDEwLjIxNy0yMS4zMDQgMTQuMjc1LTQ2LjIzMS0zMC42OCA3NS44NDQtNTAuOTE3LTE2LjQwNC0xMC44NjYtOTQuMzggNjIuODQ4LjIxMy4yMTUgNzkuODkgNTIuNjQ0eiIgaWQ9InBhdGg2IiAvPiA8L2c+IDwvc3ZnPg==",
+  caixa: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjUwMCIgaGVpZ2h0PSIyNTAwIiB2aWV3Qm94PSIwIDAgMTkyLjc1NiAxOTIuNzU2IiB2ZXJzaW9uPSIxLjEiIGlkPSJzdmc3NDI5IiBzb2RpcG9kaTpkb2NuYW1lPSJjYWl4YS1lY29ub21pY2EtZmVkZXJhbC1YLnN2ZyIgaW5rc2NhcGU6dmVyc2lvbj0iMS4yLjIgKDczMmEwMWRhNjMsIDIwMjItMTItMDkpIiB4bWxuczppbmtzY2FwZT0iaHR0cDovL3d3dy5pbmtzY2FwZS5vcmcvbmFtZXNwYWNlcy9pbmtzY2FwZSIgeG1sbnM6c29kaXBvZGk9Imh0dHA6Ly9zb2RpcG9kaS5zb3VyY2Vmb3JnZS5uZXQvRFREL3NvZGlwb2RpLTAuZHRkIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnN2Zz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciPiA8ZGVmcyBpZD0iZGVmczc0MzMiIC8+IDxzb2RpcG9kaTpuYW1lZHZpZXcgaWQ9Im5hbWVkdmlldzc0MzEiIHBhZ2Vjb2xvcj0iIzUwNTA1MCIgYm9yZGVyY29sb3I9IiNlZWVlZWUiIGJvcmRlcm9wYWNpdHk9IjEiIGlua3NjYXBlOnNob3dwYWdlc2hhZG93PSIwIiBpbmtzY2FwZTpwYWdlb3BhY2l0eT0iMCIgaW5rc2NhcGU6cGFnZWNoZWNrZXJib2FyZD0iMCIgaW5rc2NhcGU6ZGVza2NvbG9yPSIjNTA1MDUwIiBzaG93Z3JpZD0iZmFsc2UiIGlua3NjYXBlOnpvb209IjAuMTUzMzAwNzUiIGlua3NjYXBlOmN4PSIyOTMuNTQwNjQiIGlua3NjYXBlOmN5PSIxNDgwLjc0OTQiIGlua3NjYXBlOndpbmRvdy13aWR0aD0iMTkyMCIgaW5rc2NhcGU6d2luZG93LWhlaWdodD0iMTAwOSIgaW5rc2NhcGU6d2luZG93LXg9Ii04IiBpbmtzY2FwZTp3aW5kb3cteT0iLTgiIGlua3NjYXBlOndpbmRvdy1tYXhpbWl6ZWQ9IjEiIGlua3NjYXBlOmN1cnJlbnQtbGF5ZXI9InN2Zzc0MjkiIC8+IDxnIGZpbGwtcnVsZT0iZXZlbm9kZCIgY2xpcC1ydWxlPSJldmVub2RkIiBpZD0iZzc0MjciIHRyYW5zZm9ybT0ibWF0cml4KDQuNDMzNTkwOCwwLDAsNC40MzM1OTA4LC00NDguMTk1NzEsLTMyNi4wNzg1OCkiPiA8cGF0aCBkPSJtIDExNC43MjUsOTcuNjU2IGggMTQuNjM2IGwgMTAuMDMsMTYuNjEyIGggLTE0LjYzOSB6IiBmaWxsPSIjMGQ2ZmFiIiBpZD0icGF0aDc0MjEiIHNvZGlwb2RpOm5vZGV0eXBlcz0iY2NjY2MiIC8+IDxwYXRoIGZpbGw9IiNkYjgxMzUiIGQ9Im0gMTE2LjI0Niw5NS4xMDQgaCAxNS4xMjkgbCAxMy4xMzksLTE2LjU0IGggLTE1LjEyOSB6IG0gLTE1LjEyOSwxOS4yNjUgaCAxNS4xMjkgbCAxMy4xMzksLTE2Ljc0NCBoIC0xNS4xMjkgeiIgaWQ9InBhdGg3NDIzIiAvPiA8cGF0aCBmaWxsPSIjMGQ2ZmFiIiBkPSJtIDEwNi41NzIsNzguMzYyIGggMTQuMTIxIGwgOS42NzQsMTYuNzQyIGggLTE0LjEyMSB6IiBpZD0icGF0aDc0MjUiIHNvZGlwb2RpOm5vZGV0eXBlcz0iY2NjY2MiIC8+IDwvZz4gPC9zdmc+",
+  santander: "data:image/svg+xml;base64,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",
+};
+
+export function BankLogo({ bank }: { bank: PixBankId }): JSX.Element {
+  return (
+    <Box
+      component="img"
+      src={LOGOS[bank]}
+      alt=""
+      aria-hidden="true"
+      data-bank={bank}
+      sx={{ width: 32, height: 32, flex: "none", objectFit: "contain", borderRadius: 1 }}
+    />
+  );
+}

package/src/components/checkout/list/bank-pt-BR.ts

@@ -0,0 +1,26 @@
+import type { PixBankCopy } from "./types";
+
+/** The Pix-to-bank flow's words, pt-BR (FUT-3612). */
+export const PT_BR_PIX_BANK_COPY: PixBankCopy = {
+  names: {
+    nubank: { name: "Nubank", the: "o " },
+    itau: { name: "Itaú", the: "o " },
+    bradesco: { name: "Bradesco", the: "o " },
+    bb: { name: "Banco do Brasil", the: "o " },
+    caixa: { name: "Caixa", the: "a " },
+    santander: { name: "Santander", the: "o " },
+  },
+  generateAndCopy: "Gerar e copiar o Pix",
+  generateCopyAndOpen: (bank) => `Gerar, copiar e abrir ${bank.the}${bank.name}`,
+  copyAndOpen: (bank) => `Copiar e abrir ${bank.the}${bank.name}`,
+  openOther: "Abrir outro banco",
+  listTitle: "Abra seu banco e cole em Pix copia e cola",
+  open: (bank) => `Abrir ${bank.name}`,
+  opening: (bank) => `Abrindo ${bank.the}**${bank.name}**…`,
+  other: "Outro banco",
+  notOpened: (bank) => `Não conseguimos abrir ${bank.the}${bank.name}. O app está instalado neste celular?`,
+  retry: "Tentar de novo",
+  copied: "Código Pix copiado",
+  copiedPick: "Código Pix copiado. Escolha o banco.",
+  copiedOpening: (bank) => `Código Pix copiado. Abrindo ${bank.the}${bank.name}…`,
+};

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

@@ -84,9 +84,11 @@ export function lastUsedCard(saved: readonly SavedCard[]): SavedCard | undefined
 /**
  * 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 one used last ({@link lastUsedCard}). 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).
+ * the one used last ({@link lastUsedCard}). The buyer's LAST online method
+ * (`lastMethod`, FUT-3611) wins when the store offers it: Pix as Pix, since
+ * choosing creates nothing any more. Never a door tender (FUT-1478), and not
+ * a store's only method by itself 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
@@ -96,7 +98,10 @@ export function preselection(
   rows: readonly OnlineRow[],
   saved: readonly SavedCard[],
   fresh: boolean,
+  lastMethod: "PIX" | "CARD" | null = null,
 ): { choice: CheckoutListChoice; selection: string | null } | null {
+  const pixOffered = rows.some((row) => row.method === "PIX" && !row.disabled);
+  if (lastMethod === "PIX" && pixOffered && !fresh) return { choice: { kind: "online", method: "PIX" }, selection: 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 };

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

@@ -1,6 +1,19 @@
-import { createContext, useContext, useMemo, useState, type JSX, type ReactNode } from "react";
+import { createContext, useContext, useMemo, useRef, useState, type JSX, type MutableRefObject, type ReactNode } from "react";
 
-import type { CheckoutPaymentList } from "./types";
+import type { DeferredCopy } from "../pix-parts";
+
+import type { CheckoutPaymentList, PixBankId } from "./types";
+
+/**
+ * What the bar's Pix press asked of the code it is raising (FUT-3612): copy it
+ * the moment it arrives (the clipboard was opened inside the tap), then open
+ * `bank` — or show the six banks when `pick`. Consumed once by the Pix face.
+ */
+export interface PixIntent {
+  copy: DeferredCopy;
+  bank: PixBankId | null;
+  pick: boolean;
+}
 
 /**
  * What the one list shares with the panes it mounts (FUT-3591/3592): its
@@ -23,6 +36,15 @@ export interface PaymentListMode {
    * default — because the list skips that step.
    */
   consent: ListConsent;
+  /** The Pix press's intent, waiting for its code — see {@link PixIntent}. */
+  pixIntent: MutableRefObject<PixIntent | null>;
+  /**
+   * The armed charge (`armedCharge`) for this step: when it was armed and
+   * whether it was spent. Held HERE, above the faces, so a list face that
+   * remounts (after a Pix, "Prefere pagar com cartão?") can never fire it
+   * again — the 1-tap tap consented to ONE charge, right away.
+   */
+  armed: MutableRefObject<{ since: number; spent: boolean }>;
 }
 
 export interface ListConsent {
@@ -45,7 +67,9 @@ export function PaymentListProvider({
   children: ReactNode;
 }): JSX.Element {
   const [qrOpen, setQrOpen] = useState(false);
-  const value = useMemo(() => ({ list, qrOpen, setQrOpen, onLeavePix, consent }), [list, qrOpen, onLeavePix, consent]);
+  const pixIntent = useRef<PixIntent | null>(null);
+  const armed = useRef({ since: Date.now(), spent: false });
+  const value = useMemo(() => ({ list, qrOpen, setQrOpen, onLeavePix, consent, pixIntent, armed }), [list, qrOpen, onLeavePix, consent]);
   return <PaymentListContext.Provider value={value}>{children}</PaymentListContext.Provider>;
 }
 

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

@@ -10,7 +10,11 @@ import type { BuyerContact, CheckoutProviderConfig } from "../types";
 import type { useCheckoutController } from "../use-checkout-controller";
 import { useCheckoutComponents } from "../ui";
 
+
 import { actionLabel, blockedReason, cardName } from "./choice";
+import { usePaymentListMode, type PaymentListMode } from "./context";
+import { armPixCopy, armedReady, otherBankShown, pixBankLabel, useArmedCharge, useDropRefusedCopy } from "./list-memory";
+import { OtherBankLink } from "./list-pix";
 import { ChoiceList } from "./choice-list";
 import { CardRun, WalletRun, type ListChargeFailure } from "./charge-runners";
 import { ActionButton, ChargeBar, GooglePayAction, ListBar } from "./list-bar";
@@ -75,9 +79,10 @@ function onlineTotal(props: ListFaceProps): string {
 }
 
 /** An online choice's press: the card goes through the bar, Pix and the hand-off raise at once. */
-function actOnline(props: ListFaceProps, method: CheckoutOnlineChoice): void {
+function actOnline(props: ListFaceProps, method: CheckoutOnlineChoice, mode: PaymentListMode | null, pick = false): void {
   const { c, charge, cap } = props;
   saveAsked(props);
+  if (method === "PIX" && mode) armPixCopy(props.list, mode, pick);
   if (method === "CARD") return charge.start("CARD", onlineTotal(props));
   const raised = method === "PIX" ? "PIX" : handOffMethod(cap.offered);
   if (method === "HAND_OFF") props.onHandOff();
@@ -90,13 +95,14 @@ function actOnline(props: ListFaceProps, method: CheckoutOnlineChoice): void {
  * or a charge. A door option hands the press to the host; the card counts five
  * seconds first; everything else raises at once.
  */
-function useAct(props: ListFaceProps, clearFailure: () => void): () => void {
-  return () => {
+function useAct(props: ListFaceProps, clearFailure: () => void): (pick?: boolean) => void {
+  const mode = usePaymentListMode();
+  return (pick = false) => {
     const { choice } = props.state;
     if (!choice || inFlight(props)) return;
     if (choice.kind === "door") return chosenDoor(props)?.onSend();
     clearFailure();
-    actOnline(props, choice.method);
+    actOnline(props, choice.method, mode, pick);
   };
 }
 
@@ -176,7 +182,7 @@ function buttonFacts(props: ListFaceProps): { label: string; total: string; busy
   const door = chosenDoor(props);
   const online = state.choice?.kind === "online";
   return {
-    label: list.hold ? list.hold.action : actionLabel(list.copy, state.choice, door, props.provider),
+    label: list.hold ? list.hold.action : pixBankLabel(list, state) ?? actionLabel(list.copy, state.choice, door, props.provider),
     total: door ? (door.totalLabel ?? props.total) : online ? onlineTotal(props) : props.total,
     busy: inFlight(props),
   };
@@ -198,27 +204,58 @@ function googlePayLive(props: ListFaceProps, reason: string | null, busy: boolea
   return choice?.kind === "online" && choice.method === "GOOGLE_PAY" && props.cap.googlePay !== null && reason === null && !busy;
 }
 
+/** The 5-second bar (or the charge going out), and the host's footer while it counts. */
+function ChargingBar({ props, onCancel }: { props: ListFaceProps; onCancel: () => void }): JSX.Element {
+  const { charge, list } = props;
+  const counting = charge.phase === "counting";
+  const footer = counting ? list.chargeFooter?.(charge.cancel) : null;
+  return (
+    <>
+      <ChargeBar text={chargingText(props)} full={!counting} cancelLabel={list.copy.cancel} onCancel={onCancel} />
+      {footer ? <Box data-testid="list-charge-footer">{footer}</Box> : null}
+    </>
+  );
+}
+
+/** The button, and "Abrir outro banco" under it when a remembered bank would open. */
+function PressButton({ props, act, reason, returnFocus }: {
+  props: ListFaceProps;
+  act: (pick?: boolean) => void;
+  reason: string | null;
+  returnFocus: boolean;
+}): JSX.Element {
+  const { list, state } = props;
+  const { label, total, busy } = buttonFacts(props);
+  const other = list.pixBank && otherBankShown(list, state, reason === null && !busy) ? list.pixBank.copy.openOther : null;
+  return (
+    <>
+      <ActionButton label={label} total={total} disabled={reason !== null || busy} loading={busy} onClick={() => act()} focusOnMount={returnFocus} />
+      {other ? <OtherBankLink label={other} onClick={() => act(true)} /> : null}
+    </>
+  );
+}
+
 /** The button, the 5-second bar, Google's own button, or nothing for a charge nobody can confirm yet. */
 function BarAction({ props, failure, act, onGooglePay, onCancel, reason, returnFocus }: {
   props: ListFaceProps;
   failure: ListChargeFailure | null;
-  act: () => void;
+  act: (pick?: boolean) => void;
   onGooglePay: () => void;
   onCancel: () => void;
   reason: string | null;
   returnFocus: boolean;
 }): JSX.Element | null {
-  const { charge, list, cap } = props;
-  if (cardCharging(charge)) {
-    return <ChargeBar text={chargingText(props)} full={charge.phase !== "counting"} cancelLabel={list.copy.cancel} onCancel={onCancel} />;
-  }
+  const { charge, cap } = props;
+  if (cardCharging(charge)) return <ChargingBar props={props} onCancel={onCancel} />;
   // An UNRESOLVED charge may be holding the buyer's money: no pay control at
   // all under "não pague de novo" (FUT-563), as the card pane does today.
   if (failure?.code === UNRESOLVED_CODE) return null;
-  const { label, total, busy } = buttonFacts(props);
-  if (googlePayUnpriced(props)) return <ActionButton label={label} total={total} disabled loading={false} onClick={act} />;
-  if (googlePayLive(props, reason, busy) && cap.googlePay) return <GooglePayAction client={cap.googlePay.client} onPress={onGooglePay} />;
-  return <ActionButton label={label} total={total} disabled={reason !== null || busy} loading={busy} onClick={act} focusOnMount={returnFocus} />;
+  if (googlePayUnpriced(props)) {
+    const { label, total } = buttonFacts(props);
+    return <ActionButton label={label} total={total} disabled loading={false} onClick={() => act()} />;
+  }
+  if (googlePayLive(props, reason, inFlight(props)) && cap.googlePay) return <GooglePayAction client={cap.googlePay.client} onPress={onGooglePay} />;
+  return <PressButton props={props} act={act} reason={reason} returnFocus={returnFocus} />;
 }
 
 /** The charge under way, once there is an order to run it against. */
@@ -318,6 +355,9 @@ export function ListFace(props: ListFaceProps): JSX.Element {
   const door = chosenDoor(props);
   const reason = reasonOf(props, door);
   useChargeGuard(props, reason);
+  const free = reason === null && props.charge.phase === "idle" && !c.creating;
+  useArmedCharge(armedReady(list, state, free), act);
+  useDropRefusedCopy(c.createError);
   const { returnFocus, onCancel } = useCancelWithFocus(charge);
   const shown = charge.phase !== "waiting";
   const facts = barFacts(props, door, reason);
@@ -327,7 +367,7 @@ export function ListFace(props: ListFaceProps): JSX.Element {
         <ChoiceList copy={list.copy} state={state} door={list.door ?? []} buyer={c.buyer} onBuyerChange={c.setBuyer} provider={props.provider} failure={failure} locked={facts.locked} covered={coveredByHost(list)} />
       ) : null}
       <Runners props={props} sheet={sheet.current} onFailed={onFailed} />
-      <RaiseError c={c} onRetry={act} />
+      <RaiseError c={c} onRetry={() => act()} />
       {shown ? (
         <ListBar summary={list.summary} extras={facts.extras} payer={facts.charging ? null : <PayerLine props={props} />} reason={facts.underButton} live={facts.live}>
           <BarAction props={props} failure={failure} act={act} onGooglePay={onGooglePay} onCancel={onCancel} reason={reason} returnFocus={returnFocus} />