v6 - Card brands - US debit cards (restricted cards)

[araratthehero]

Description

Restricted-brand handling alignment with Web/iOS.

Restricted brands (accel, pulse, star, nyce — US ATM/debit network rails) were stripped from supportedCardBrands client-side before the BIN lookup request was built. That caused the backend to return them as supported=false, the state handler to drop them, and merchants to never know the card had a restricted rail.

This PR moves restricted-brand handling from a client-side filter to the data-to-state classification boundary, matching Web/iOS behavior:

• CardComponentParamsMapper.removeRestrictedCards() is removed. Restricted brands flow through to the BIN lookup request.
• RestrictedCardType moves from internal.ui.model to internal.helper and is simplified from an enum to a Set<String> with a top-level isRestrictedCardType() function.
• Two new internal CardBrandState variants:
  • RestrictedBrand — only restricted brand(s) detected. UI mirrors NoBrandsDetected. No brand sent in /payments.
  • SingleReliableWithRestrictedBrand(cardBrandData) — single supported brand alongside restricted brand(s) (e.g. [visa, accel]). Only the supported logo is shown; restricted logos are never rendered. No brand sent in /payments since the rail is ambiguous.
• Restricted brands are filtered from the supported card brands grid in CardViewStateProducer, so they never appear in the UI logo list.

6 commits, all on internal code.

Behavior matrix

Scenario	Detected	Logos shown	brand in payload	State
Standard single	[visa]	visa	yes	SingleReliableBrand (unchanged)
Standard dual	[visa, mc]	both	yes	DualBrand (unchanged)
Standard dual w/ selection	[visa, cartebancaire]	both	yes (selected)	DualBrandWithShopperSelection (unchanged)
Dual with restricted	[visa, accel]	visa only	no	SingleReliableWithRestrictedBrand (new)
3 brands with restricted	[visa, cartebancaire, accel]	visa + cartebancaire	yes (selected)	DualBrandWithShopperSelection (existing path)
Restricted only	[accel]	placeholder + grid	no	RestrictedBrand (new)
Supported + unsupported restricted	[visa(supported), accel(unsupported)]	visa	yes	SingleReliableBrand (unsupported restricted ignored)
All unsupported	[discover] (merchant=[visa])	error	n/a	UnsupportedBrand (unchanged)
No detection	[]	grid	n/a	NoBrandsDetected (unchanged)

Checklist

• Code is unit tested
• Changes are tested manually
• Aligned public API changes with other platforms (if applicable)

Ticket Number

COSDK-1204

[github-actions]

✅ No public API changes

[gemini-code-assist]

Code Review

This pull request refactors the handling of restricted card brands (accel, pulse, star, nyce) by moving the logic to a dedicated helper and updating the card detection flow. It introduces new states, RestrictedBrand and SingleReliableWithRestrictedBrand, within CardBrandState to better manage scenarios where restricted brands are detected alongside or instead of supported brands. Additionally, the CardViewStateProducer now filters restricted brands from the supported brands list, and extensive unit tests have been added to ensure correct behavior. I have no feedback to provide as there were no review comments to assess.

[sonarqubecloud]

Quality Gate passed

Issues
0 New issues
0 Accepted issues

Measures
0 Security Hotspots
85.7% Coverage on New Code
0.0% Duplication on New Code

See analysis details on SonarQube Cloud

[jreij]

Do you think using hidden instead of restricted could make this flow clearer?

[araratthehero]

I agree. Will make the change.

[jreij]

What do you think of adding a boolean inside DetectedCardType that indicates if the brand should be hidden/restricted? IMO it achieves two things:

• It aligns with other similar values such as isSupported and isShopperSelectionAllowedInDualBranded
• When this value starts coming from the backend, it will be easy to migrate the logic, only inside NetworkCardBrandDetectionService (same will happen for isShopperSelectionAllowedInDualBranded)

[jreij]

I think this when block is a bit difficult to read now, I had a similar issue when I was writing it in my PR and here's what I can suggest:

when {
    // network detection + no detected brands
    detectedCardTypes.isEmpty() -> CardBrandState.NoBrandsDetected

    nonRestrictedSupportedBrands.isEmpty() -> {
        if (anyRestrictedBrandDetected) {
            // network detection + only restricted brands are supported
            CardBrandState.RestrictedBrand
        } else {
            // network detection + detected brands but no supported brands
            CardBrandState.UnsupportedBrand
        }
    }

    nonRestrictedSupportedBrands.size == 1 -> {
        if (anyRestrictedBrandDetected) {
            // network detection + 1 non-restricted supported brand + restricted brand(s)
            CardBrandState.SingleReliableWithRestrictedBrand(
                cardBrandData = nonRestrictedSupportedBrands.first().toCardBrandData(),
            )
        } else {
            // network detection + 1 non-restricted supported brand
            CardBrandState.SingleReliableBrand(
                cardBrandData = nonRestrictedSupportedBrands.first().toCardBrandData(),
            )
        }
    }

    // network detection + multiple non-restricted supported brands
    else -> {
        getDualBrandedCardBrandState(currentState.cardBrandState, nonRestrictedSupportedBrands)
    }
}

Basically you make it a when with 4 cases:

• No brands at all
• No brands that are supported and not restricted
• 1 brand that is supported and not restricted
• More than 1 brand supported and not restricted

Then inside the blocks you check if anything is restricted. Let me know if you find this easier to read.

[jreij]

Nit: for readability consider ordering the values of this sealed class by: no brands - single brand - dual brand instead of putting the cases with restricted at the bottom.