@provex/utils 1.11.0 → 2.0.0

package/dist/buy/browsePanelDerivations.test.js

@@ -0,0 +1,552 @@
+/**
+ * @fileoverview Tests for the pure derivations behind the buy panel.
+ *
+ * `browsePanelDerivations.ts` exists so these can be checked without mounting
+ * BrowsePanel. The reconciliation suite guards a bug that put buyers on a rail
+ * their currency cannot settle on. The rest cover helpers whose failure modes
+ * are silent (a swallowed keystroke, a wrong-by-10000 amount) rather than loud.
+ */
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { pulsechain } from 'viem/chains';
+import { providers } from '../payment.js';
+import { SUPPORTED_CURRENCIES } from '../currencies.js';
+import { reconcileProviderForCurrency, sanitizeAmountInput, parseAmountToBaseUnits, sortDepositsByRate, isSelectedDepositBest, resolveTargetedVerifier, buildVolumeByProviderKey, isBrowseFormValid, } from './browsePanelDerivations.js';
+const chainId = pulsechain.id;
+// Which providers are verifiable is DEPLOYMENT CONFIGURATION, not a fact about
+// the chain. `VITE_ENABLED_PROVIDERS` / `VITE_DISABLED_PROVIDERS` override the
+// `disabled` field in the registry, and staging already sets
+// `vite_enabled_providers: "paypal"`. Left ambient, the two "not verifiable on
+// this chain" cases below assert whatever the local environment file happens to
+// say — they failed on first run for exactly that reason, because the local
+// environment enables PayPal the way staging does.
+//
+// So pin it. The disabled list wins over the enabled list, which makes this
+// deterministic no matter what the ambient configuration holds.
+//
+// `payment.ts` memoizes both lists on the first `isProviderDisabled` call, so
+// this has to land before any test runs and cannot be undone within the file.
+process.env.DISABLED_PROVIDERS = 'paypal';
+describe('reconcileProviderForCurrency', () => {
+    it('moves a pounds buyer off a United States dollar rail', () => {
+        // The reported bug. The buyer picks Venmo (mode → manual, so the auto-pick
+        // effect stops running), then switches to pounds. Nothing else in the panel
+        // notices, and they get an empty order book with no explanation.
+        const next = reconcileProviderForCurrency({
+            selectedProvider: providers.VENMO,
+            fallbackProvider: providers.REVOLUT,
+            chainId,
+            currency: SUPPORTED_CURRENCIES.GBP,
+        });
+        assert.equal(next, providers.REVOLUT);
+    });
+    it('leaves a provider that already serves the currency alone', () => {
+        // Must not churn the URL on every render. If this ever returns non-null,
+        // the caller writes a new provider, which re-runs this check — a loop.
+        const next = reconcileProviderForCurrency({
+            selectedProvider: providers.VENMO,
+            fallbackProvider: providers.REVOLUT,
+            chainId,
+            currency: SUPPORTED_CURRENCIES.USD,
+        });
+        assert.equal(next, null);
+    });
+    it('leaves the selection alone when the fallback cannot serve it either', () => {
+        // No rail here serves roubles, so the panel's fallback
+        // degrades to its terminal Venmo. Swapping a dead end for another dead end
+        // helps nobody, and the write would re-trigger this check forever.
+        const next = reconcileProviderForCurrency({
+            selectedProvider: providers.REVOLUT,
+            fallbackProvider: providers.VENMO,
+            chainId,
+            currency: SUPPORTED_CURRENCIES.RUB,
+        });
+        assert.equal(next, null);
+    });
+    it('moves off a provider this deployment does not offer', () => {
+        // A shared link can name any provider — `parse` only checks the key is
+        // known, not that this deployment offers it. PayPal lists pounds but is
+        // disabled here (see the `beforeAll` above), so it settles nothing.
+        const next = reconcileProviderForCurrency({
+            selectedProvider: providers.PAYPAL,
+            fallbackProvider: providers.REVOLUT,
+            chainId,
+            currency: SUPPORTED_CURRENCIES.GBP,
+        });
+        assert.equal(next, providers.REVOLUT);
+    });
+    it('rejects a fallback this deployment does not offer', () => {
+        // The mirror of the case above, for the fallback side. Both arguments go
+        // through the same two gates; a check applied to only one of them would
+        // pass every test above and still hand the panel an unusable rail.
+        const next = reconcileProviderForCurrency({
+            selectedProvider: providers.VENMO,
+            fallbackProvider: providers.PAYPAL,
+            chainId,
+            currency: SUPPORTED_CURRENCIES.GBP,
+        });
+        assert.equal(next, null);
+    });
+    it('repairs the seeded default for a link carrying only a currency', () => {
+        // `?currency=EUR` with no provider param falls through to the URL config's
+        // `defaultValue: 'venmo'`, which is module-level and cannot be currency
+        // aware. This is the only thing that corrects it in manual mode.
+        const next = reconcileProviderForCurrency({
+            selectedProvider: providers.VENMO,
+            fallbackProvider: providers.WISE,
+            chainId,
+            currency: SUPPORTED_CURRENCIES.EUR,
+        });
+        assert.equal(next, providers.WISE);
+    });
+});
+// ---------------------------------------------------------------------------
+// sanitizeAmountInput
+// ---------------------------------------------------------------------------
+describe('sanitizeAmountInput', () => {
+    it('passes through a clean integer string', () => {
+        assert.equal(sanitizeAmountInput('1234', 2), '1234');
+    });
+    it('passes through a clean decimal string', () => {
+        assert.equal(sanitizeAmountInput('12.34', 2), '12.34');
+    });
+    it('strips alphabetic characters', () => {
+        // Pasting from a price tag or copy that includes a currency code
+        // ('USD 100') shouldn't drop the digits — just strip the letters.
+        assert.equal(sanitizeAmountInput('USD 100', 2), '100');
+    });
+    it('strips thousands separators (commas)', () => {
+        // The filter strips comma alongside other non-digits, so a
+        // pasted "1,234.56" yields "1234.56" rather than nothing.
+        // Preserves the user's intent on paste.
+        assert.equal(sanitizeAmountInput('1,234.56', 2), '1234.56');
+    });
+    it('strips negative signs (minus is not in the allowed set)', () => {
+        // Defensive: input filter rejects `-`. The downstream
+        // parseAmountToBaseUnits also clamps negatives to 0n but
+        // belt-and-suspenders.
+        assert.equal(sanitizeAmountInput('-100', 2), '100');
+    });
+    it('collapses multiple decimal points into the first one', () => {
+        // Pasting "12.34.56" (e.g. from a malformed source) keeps the
+        // first dot and merges the rest into the fractional side.
+        assert.equal(sanitizeAmountInput('12.34.56', 2), '12.34');
+    });
+    it('clamps the fractional part to maxDecimals', () => {
+        // USD has 2 decimals — typing "100.99999" should clamp to "100.99".
+        // The user's keystroke isn't simply ignored; the visible value
+        // updates to reflect the actual stored precision.
+        assert.equal(sanitizeAmountInput('100.99999', 2), '100.99');
+    });
+    it('allows zero-decimal currencies (JPY) — maxDecimals = 0', () => {
+        // JPY has decimals=0. With maxDecimals=0, any fractional part
+        // gets clamped away entirely. This is the path that prevents
+        // ¥100.5 from being accepted as a valid input.
+        assert.equal(sanitizeAmountInput('100.5', 0), '100');
+    });
+    it('preserves a trailing dot mid-typing', () => {
+        // While the user is typing "12." (before they enter decimals),
+        // the dot must survive — clamping to 2 means dot + up-to-2 fract
+        // chars, but the empty case is still valid mid-input.
+        assert.equal(sanitizeAmountInput('12.', 2), '12.');
+    });
+    it('returns empty string for empty input', () => {
+        assert.equal(sanitizeAmountInput('', 2), '');
+    });
+    it('returns empty string when input is non-digit-only', () => {
+        assert.equal(sanitizeAmountInput('abc', 2), '');
+    });
+});
+// ---------------------------------------------------------------------------
+// parseAmountToBaseUnits
+// ---------------------------------------------------------------------------
+describe('parseAmountToBaseUnits', () => {
+    it('parses USD amount into USDC 6-decimal base units', () => {
+        // $1.00 (decimals=2) → parseUnits = 100n → * 10^4 = 1_000_000n
+        assert.equal(parseAmountToBaseUnits('1.00', 2), 1000000n);
+    });
+    it('parses JPY amount (decimals=0) into USDC base units', () => {
+        // ¥1 (decimals=0) → parseUnits = 1n → * 10^6 = 1_000_000n.
+        // The rebase makes ¥1 and $1.00 both equal 1_000_000n base
+        // units, deferring the FX adjustment to the rate-multiplication
+        // step elsewhere.
+        assert.equal(parseAmountToBaseUnits('1', 0), 1000000n);
+    });
+    it('parses fractional amounts that exceed currency decimals (truncates)', () => {
+        // parseUnits respects the decimals arg, so '1.99' under
+        // decimals=2 = 199n base, then * 10^4 = 1_990_000n.
+        assert.equal(parseAmountToBaseUnits('1.99', 2), 1990000n);
+    });
+    it('defaults decimals to 2 when currencyDecimals is undefined', () => {
+        // Matches the panel's `currency?.decimals ?? 2` shape — keeps
+        // the helper usable before the currency object has loaded.
+        assert.equal(parseAmountToBaseUnits('1.00', undefined), 1000000n);
+    });
+    it('returns null for empty input', () => {
+        assert.equal(parseAmountToBaseUnits('', 2), null);
+    });
+    it('treats a lone dot as zero (mid-typing intermediate state)', () => {
+        // When the user has typed only '.', viem's parseUnits resolves
+        // it to 0n ("empty integer + empty fraction"). The hook returns
+        // 0n rather than null — which is the right semantics, because
+        // the user hasn't entered an amount yet but isn't in an
+        // unparseable state either. The CTA still gates off because
+        // downstream `!!amountInInt` short-circuits on 0n.
+        assert.equal(parseAmountToBaseUnits('.', 2), 0n);
+    });
+    it('catches parseUnits throws and returns null', () => {
+        // The try/catch is defensive for any sanitize-step bypass —
+        // a malformed pasted value that gets past the input filter.
+        // Pinning the catch path so a refactor can't accidentally drop
+        // it and crash the panel on bad input.
+        assert.equal(parseAmountToBaseUnits('not-a-number', 2), null);
+    });
+});
+const usd = SUPPORTED_CURRENCIES.USD;
+// The panel passes the indexer client's `getRate`. Here the rate is read from
+// the fixture directly, because this package cannot import the client.
+const venmoRateOf = (deposit) => BigInt(deposit.currentConversionRates.get('venmo')?.get(usd.contractId)?.value ?? '0');
+const makeDeposit = ({ depositId, chainId = 369, rateValue = '1000000000000000000', }) => {
+    const rates = new Map([
+        [usd.contractId, { value: rateValue }],
+    ]);
+    return {
+        depositId,
+        chainId,
+        currentConversionRates: new Map([
+            ['venmo', rates],
+        ]),
+    };
+};
+describe('sortDepositsByRate', () => {
+    it('sorts by rate ascending (lowest rate = best deal first)', () => {
+        // Lower numeric rate = fewer fiat units per USDC = buyer pays
+        // less. The "best" deposit goes first in the sort order so the
+        // Reserve button defaults to the best deal.
+        const cheap = makeDeposit({ depositId: 1n, rateValue: '1000000000000000000' }); // 1.0
+        const mid = makeDeposit({ depositId: 2n, rateValue: '1020000000000000000' }); // 1.02
+        const expensive = makeDeposit({ depositId: 3n, rateValue: '1050000000000000000' }); // 1.05
+        const sorted = sortDepositsByRate({
+            deposits: [expensive, cheap, mid],
+            rateOf: venmoRateOf,
+        });
+        assert.deepEqual(sorted.map((d) => d.depositId), [1n, 2n, 3n]);
+    });
+    it('breaks rate ties by depositId ascending (deterministic order)', () => {
+        // Without the tiebreaker, the sort order would depend on input
+        // order — leading to a "Best of N" badge that flips depending
+        // on which deposit happened to load first. depositId is stable
+        // and the only naturally-ordered field across rate-tied deposits.
+        const a = makeDeposit({ depositId: 3n, rateValue: '1000000000000000000' });
+        const b = makeDeposit({ depositId: 1n, rateValue: '1000000000000000000' });
+        const c = makeDeposit({ depositId: 2n, rateValue: '1000000000000000000' });
+        const sorted = sortDepositsByRate({
+            deposits: [a, b, c],
+            rateOf: venmoRateOf,
+        });
+        assert.deepEqual(sorted.map((d) => d.depositId), [1n, 2n, 3n]);
+    });
+    it('does not mutate the input array', () => {
+        // The .slice() guard is critical: callers may pass a memoized
+        // array, and an in-place sort would propagate the mutation
+        // upward (breaking React's structural-equality assumptions).
+        const original = [
+            makeDeposit({ depositId: 2n, rateValue: '1010000000000000000' }),
+            makeDeposit({ depositId: 1n, rateValue: '1000000000000000000' }),
+        ];
+        const originalOrder = original.map((d) => d.depositId);
+        sortDepositsByRate({
+            deposits: original,
+            rateOf: venmoRateOf,
+        });
+        assert.deepEqual(original.map((d) => d.depositId), originalOrder);
+    });
+    it('returns an empty array when input is empty', () => {
+        assert.deepEqual(sortDepositsByRate({
+            deposits: [],
+            rateOf: venmoRateOf,
+        }), []);
+    });
+});
+describe('sortDepositsByRate: tie order does not depend on input order', () => {
+    const rateValue = '1000000000000000000';
+    const ids = (deposits) => deposits.map((d) => d.depositId);
+    it('orders two equal-rate deposits the same way from either input order', () => {
+        const one = makeDeposit({ depositId: 1n, rateValue });
+        const two = makeDeposit({ depositId: 2n, rateValue });
+        assert.deepEqual(ids(sortDepositsByRate({ deposits: [one, two], rateOf: venmoRateOf })), [1n, 2n]);
+        assert.deepEqual(ids(sortDepositsByRate({ deposits: [two, one], rateOf: venmoRateOf })), [1n, 2n]);
+    });
+});
+describe('sortDepositsByRate: duplicate entries', () => {
+    it('keeps both copies of the same deposit instead of dropping or reordering them', () => {
+        const only = makeDeposit({ depositId: 7n });
+        const sorted = sortDepositsByRate({ deposits: [only, only], rateOf: venmoRateOf });
+        assert.deepEqual(sorted, [only, only]);
+    });
+});
+describe('isSelectedDepositBest', () => {
+    it('returns false when there is no selected deposit', () => {
+        assert.equal(isSelectedDepositBest({
+            selectedDeposit: null,
+            sortedDeposits: [],
+        }), false);
+    });
+    it('returns false when there is only ONE matched deposit', () => {
+        // "Best of 1" is trivially true but not useful — a single-deposit
+        // match shouldn't show the "Best" badge because there's no
+        // comparison set. Pinning so a "simplify the check" refactor
+        // doesn't make the badge always-on for single matches.
+        const only = makeDeposit({ depositId: 1n });
+        assert.equal(isSelectedDepositBest({
+            selectedDeposit: only,
+            sortedDeposits: [only],
+        }), false);
+    });
+    it('returns true when the selected deposit is sortedDeposits[0]', () => {
+        const best = makeDeposit({ depositId: 1n });
+        const other = makeDeposit({ depositId: 2n });
+        assert.equal(isSelectedDepositBest({
+            selectedDeposit: best,
+            sortedDeposits: [best, other],
+        }), true);
+    });
+    it('returns false when the user manually picked a non-best deposit', () => {
+        // The whole reason this predicate is separate from "len > 1":
+        // a user who deliberately picked the second-best (e.g. their
+        // favored provider) shouldn't see a "Best" badge anymore.
+        const best = makeDeposit({ depositId: 1n });
+        const other = makeDeposit({ depositId: 2n });
+        assert.equal(isSelectedDepositBest({
+            selectedDeposit: other,
+            sortedDeposits: [best, other],
+        }), false);
+    });
+});
+// ---------------------------------------------------------------------------
+// resolveTargetedVerifier
+// ---------------------------------------------------------------------------
+// Sentinel verifier values — distinct strings so the test asserts
+// WHICH branch returned the verifier, not just truthiness.
+const VENMO_VERIFIER = 'venmo-verifier';
+const ZELLE_VERIFIER = 'zelle-verifier';
+const ZELLE_CHASE_VERIFIER = 'zelle-chase-verifier';
+// Builds a DepositLikeForResolver fixture with a custom verifier map
+// and a custom rate map, so each test can pin one resolution outcome
+// in isolation.
+const makeResolverFixture = ({ verifiers, rates, }) => ({
+    chainId: 8453,
+    getVerifier: (key) => verifiers[key] ?? null,
+    currentConversionRates: new Map(Object.entries(rates).map(([providerKey, rateValue]) => [
+        providerKey,
+        new Map([[usd.contractId, rateValue ? { value: rateValue } : undefined]]),
+    ])),
+});
+describe('resolveTargetedVerifier', () => {
+    it('returns null when deposit is null', () => {
+        assert.equal(resolveTargetedVerifier({
+            deposit: null,
+            paymentMethod: 'venmo',
+            currency: usd,
+        }), null);
+    });
+    describe('only the rail is ever targeted', () => {
+        it('targets the rail on a deposit that carries both the rail and a bank', () => {
+            // The decisive case for Zelle. A Zelle attestation is issued for the
+            // rail — the bank rides in the action type, never the platform — so an
+            // intent signalled on `zelle-chase` can never be fulfilled. The buyer's
+            // bank pick decides which bank the capture opens, nothing more.
+            const deposit = makeResolverFixture({
+                verifiers: { zelle: ZELLE_VERIFIER, 'zelle-chase': ZELLE_CHASE_VERIFIER },
+                rates: { zelle: '1', 'zelle-chase': '1' },
+            });
+            const result = resolveTargetedVerifier({
+                deposit,
+                paymentMethod: 'zelle',
+                currency: usd,
+            });
+            assert.deepEqual(result, {
+                providerKey: 'zelle',
+                verifier: ZELLE_VERIFIER,
+            });
+        });
+        it('returns null for a deposit whose only Zelle method is a bank', () => {
+            // Pre-migration deposits carry bank-level methods only. Targeting one
+            // produces an intent no attestation can satisfy: the buyer reserves
+            // funds, pays a real person, and then cannot submit. Refusing here
+            // fails the order at the Reserve button instead — before any money
+            // moves. `fetchMatchableDeposits` also excludes these deposits, so in
+            // practice the buyer never sees one; this is the second line of defence.
+            const deposit = makeResolverFixture({
+                verifiers: { 'zelle-chase': ZELLE_CHASE_VERIFIER },
+                rates: { 'zelle-chase': '1' },
+            });
+            const result = resolveTargetedVerifier({
+                deposit,
+                paymentMethod: 'zelle',
+                currency: usd,
+            });
+            assert.equal(result, null);
+        });
+        it('returns null when the rail has a rate but the bank holds the verifier', () => {
+            // A half-migrated deposit: the rate row landed on the rail but the
+            // verifier is still bank-level. Neither half alone is fulfillable.
+            const deposit = makeResolverFixture({
+                verifiers: { 'zelle-chase': ZELLE_CHASE_VERIFIER },
+                rates: { zelle: '1' },
+            });
+            const result = resolveTargetedVerifier({
+                deposit,
+                paymentMethod: 'zelle',
+                currency: usd,
+            });
+            assert.equal(result, null);
+        });
+    });
+    describe('rails without banks', () => {
+        it('uses the verifier when both rate and verifier exist', () => {
+            const deposit = makeResolverFixture({
+                verifiers: { venmo: VENMO_VERIFIER },
+                rates: { venmo: '1' },
+            });
+            const result = resolveTargetedVerifier({
+                deposit,
+                paymentMethod: 'venmo',
+                currency: usd,
+            });
+            assert.deepEqual(result, {
+                providerKey: 'venmo',
+                verifier: VENMO_VERIFIER,
+            });
+        });
+        it('returns null when there is no rate for the currency', () => {
+            // Verifier exists but no rate row for THIS currency (e.g. the deposit
+            // accepts USD via venmo but the buyer picked EUR).
+            const deposit = makeResolverFixture({
+                verifiers: { venmo: VENMO_VERIFIER },
+                rates: {}, // no rates at all
+            });
+            const result = resolveTargetedVerifier({
+                deposit,
+                paymentMethod: 'venmo',
+                currency: usd,
+            });
+            assert.equal(result, null);
+        });
+        it('returns null when there is a rate but no verifier', () => {
+            // Rate row exists but the deposit isn't actually accepting the
+            // payment method (verifier missing). Defensive: an indexer race
+            // could surface a stale rate row whose verifier was just removed.
+            const deposit = makeResolverFixture({
+                verifiers: {},
+                rates: { venmo: '1' },
+            });
+            const result = resolveTargetedVerifier({
+                deposit,
+                paymentMethod: 'venmo',
+                currency: usd,
+            });
+            assert.equal(result, null);
+        });
+    });
+});
+// ---------------------------------------------------------------------------
+// buildVolumeByProviderKey
+// ---------------------------------------------------------------------------
+describe('buildVolumeByProviderKey', () => {
+    it('builds a Map from verifier→totalVolume entries', () => {
+        const map = buildVolumeByProviderKey([
+            { verifier: 'venmo', totalVolume: 100n },
+            { verifier: 'cashapp', totalVolume: 50n },
+        ]);
+        assert.equal(map.get('venmo'), 100n);
+        assert.equal(map.get('cashapp'), 50n);
+        assert.equal(map.size, 2);
+    });
+    it('returns an empty map when input is null', () => {
+        // The indexer query returns undefined while loading — the panel's
+        // `?.verifiersByVolume` chain passes through to the helper. Pin
+        // so a refactor that throws on null surfaces here.
+        assert.equal(buildVolumeByProviderKey(null).size, 0);
+        assert.equal(buildVolumeByProviderKey(undefined).size, 0);
+    });
+    it('skips entries with null/undefined verifier', () => {
+        // Defensive: an indexer row with a null verifier shouldn't crash
+        // or land in the map as a "null" key (which would compare against
+        // nothing on the tiebreaker side).
+        const map = buildVolumeByProviderKey([
+            { verifier: 'venmo', totalVolume: 100n },
+            { verifier: null, totalVolume: 50n },
+            { verifier: undefined, totalVolume: 25n },
+        ]);
+        assert.equal(map.size, 1);
+        assert.equal(map.get('venmo'), 100n);
+    });
+    it('preserves the bigint totalVolume without conversion', () => {
+        // The volume is in token base units; this map is consumed by the
+        // useDefaultProviderByRate tiebreaker which expects bigint. Any
+        // Number() coercion would lose precision past ~$9M.
+        const big = 10000000000000000n;
+        const map = buildVolumeByProviderKey([
+            { verifier: 'venmo', totalVolume: big },
+        ]);
+        assert.equal(map.get('venmo'), big);
+    });
+});
+describe('parseAmountToBaseUnits: negative amounts', () => {
+    it('clamps a negative amount to zero rather than propagating the sign', () => {
+        // viem's parseUnits returns -500n here. The input filter strips '-' already,
+        // so this is defence in depth against a refactor that stops stripping it: a
+        // negative would otherwise flow into the deposit match and the cap check as
+        // an apparently valid order size, and pass both.
+        assert.equal(parseAmountToBaseUnits('-5.00', 2), 0n);
+    });
+});
+describe('sanitizeAmountInput: pasted amounts', () => {
+    it('salvages a pasted amount with thousands separators', () => {
+        // Stripping the separators keeps the paste usable. Rejecting the whole
+        // string would silently clear a figure the buyer copied from their bank.
+        assert.equal(sanitizeAmountInput('1,000.00', 2), '1000.00');
+    });
+});
+describe('isBrowseFormValid', () => {
+    const valid = {
+        amountInInt: 100n,
+        amountOutInt: 100n,
+        hasSelectedDeposit: true,
+        depositRate: 1n,
+        amountExceedsCap: false,
+        makerUnavailable: false,
+        isOnCooldown: false,
+    };
+    it('accepts a complete form', () => {
+        assert.equal(isBrowseFormValid(valid), true);
+    });
+    it('rejects each individual blocker', () => {
+        // Table-driven so a newly added precondition that is never actually
+        // consulted shows up as a missing row rather than as a passing suite.
+        const blockers = [
+            ['no amount in', { amountInInt: null }],
+            ['no amount out', { amountOutInt: null }],
+            ['no deposit chosen', { hasSelectedDeposit: false }],
+            ['no rate on the deposit', { depositRate: null }],
+            ['amount over the reputation cap', { amountExceedsCap: true }],
+            ['maker payee details unavailable', { makerUnavailable: true }],
+            ['buyer on cooldown', { isOnCooldown: true }],
+        ];
+        for (const [label, override] of blockers) {
+            assert.equal(isBrowseFormValid({ ...valid, ...override }), false, label);
+        }
+    });
+    it('does not ask for a bank before Reserve', () => {
+        // Zelle settles under one on-chain rail, so the bank never changes which
+        // seller matches. The buyer names it on the payment step instead. A form
+        // that wanted a bank here would block Reserve for a reason the order does
+        // not have.
+        assert.equal(isBrowseFormValid(valid), true);
+    });
+});
+// Type-only guard: `providers.PAYPAL` must stay a real key, or the
+// not-verifiable-on-this-chain tests above would be asserting on a typo.
+const _paypalIsAKnownProvider = providers.PAYPAL;
+void _paypalIsAKnownProvider;