feat(withdraw): charge the Rhino fee on Ethereum, Tron and Solana

src/app/(mobile-ui)/withdraw/crypto/__tests__/crypto-withdraw-confirm.test.tsx

@@ -75,8 +75,12 @@ jest.mock('@/utils/token.utils', () => ({
 }))
 
 jest.mock('@/utils/cross-chain-fee.utils', () => ({
-    isWithdrawFeeDisproportionate: () => false,
+    ...jest.requireActual('@/utils/cross-chain-fee.utils'),
+    isWithdrawFeeDisproportionate: (...args: unknown[]) => mockIsWithdrawFeeDisproportionate(...args),
 }))
+// Off by default so the existing cases keep their old behaviour; the fee suite
+// restores the real rule to cover the heads-up the schedule can now trigger.
+const mockIsWithdrawFeeDisproportionate = jest.fn((..._args: unknown[]) => false)
 
 const mockIsAmountWithinBalance = jest.fn((..._args: unknown[]) => true)
 jest.mock('@/utils/balance.utils', () => ({
@@ -122,14 +126,25 @@ jest.mock('@/services/requests', () => ({
 
 jest.mock('@/features/withdraw/views/ConfirmWithdrawView', () => ({
     __esModule: true,
-    default: (props: { onConfirm: () => void; onBack: () => void }) => (
+    default: (props: {
+        onConfirm: () => void
+        onBack: () => void
+        networkFee?: number
+        receiveAmount?: string | null
+        showHighFeeWarning?: boolean
+        belowMinimumMessage?: string | null
+    }) => (
         <>
             <button data-testid="back-review" onClick={props.onBack}>
                 Back
             </button>
             <button data-testid="confirm-withdraw" onClick={props.onConfirm}>
                 Confirm
             </button>
+            <span data-testid="network-fee">{String(props.networkFee)}</span>
+            <span data-testid="receive-amount">{String(props.receiveAmount)}</span>
+            <span data-testid="high-fee-warning">{String(!!props.showHighFeeWarning)}</span>
+            <span data-testid="below-minimum">{String(props.belowMinimumMessage)}</span>
         </>
     ),
 }))
@@ -333,7 +348,18 @@ beforeEach(() => {
     mockWithdrawFlow.showCompatibilityModal = false
     jest.clearAllMocks()
     mockRecordPayment.mockResolvedValue(PAYMENT_RESULT)
-    Object.assign(mockCrossChainTransfer, { isXChain: false, isDiffToken: false, quoteExpiresAt: null })
+    Object.assign(mockCrossChainTransfer, {
+        isXChain: false,
+        isDiffToken: false,
+        quoteExpiresAt: null,
+        feeUsd: 0,
+        receiveAmount: '50',
+        isCalculating: false,
+        isFeeEstimationError: false,
+    })
+    chargeDetails.chainId = '42161'
+    withdrawData.token.price = 1
+    mockIsWithdrawFeeDisproportionate.mockImplementation(() => false)
     mockUrlAmount = '50'
     mockStepper.step = 'review'
     mockWithdrawFlow.isMaxWithdrawal = false
@@ -342,6 +368,119 @@ beforeEach(() => {
     mockIsAmountWithinBalance.mockImplementation(() => true)
 })
 
+// Peanut stops sponsoring the withdrawal fee on Ethereum, Tron and Solana.
+// Rhino enables the charge on their side; until a quote carries it, the
+// schedule prices the fee AND comes off the delivery, so the card never
+// promises the full amount next to a fee.
+describe('crypto withdraw confirm — network fee', () => {
+    const realRule = jest.requireActual('@/utils/cross-chain-fee.utils').isWithdrawFeeDisproportionate
+
+    it('prices a zero-quote Ethereum withdrawal from the schedule', () => {
+        chargeDetails.chainId = '1'
+        Object.assign(mockCrossChainTransfer, { isXChain: true, feeUsd: 0 })
+
+        render(<WithdrawCryptoPage />)
+
+        // $1.50 flat destination gas + 0.07% of the $50 withdrawn
+        expect(screen.getByTestId('network-fee').textContent).toBe('1.535')
+    })
+
+    it('takes the scheduled fee off what the recipient receives', () => {
+        chargeDetails.chainId = '1'
+        Object.assign(mockCrossChainTransfer, { isXChain: true, feeUsd: 0, receiveAmount: '50' })
+
+        render(<WithdrawCryptoPage />)
+
+        // the quote never priced the fee, so the delivery has to lose it here
+        expect(screen.getByTestId('receive-amount').textContent).toBe('48.465')
+    })
+
+    it('converts the fee into the destination token before deducting it', () => {
+        chargeDetails.chainId = '1'
+        withdrawData.token.price = 2000 // withdrawing ETH, quoted in ETH
+        Object.assign(mockCrossChainTransfer, { isXChain: true, feeUsd: 0, receiveAmount: '1' })
+
+        render(<WithdrawCryptoPage />)
+
+        // 1 ETH - ($1.535 / $2000), not 1 - 1.535
+        expect(screen.getByTestId('receive-amount').textContent).toBe('0.999232')
+    })
+
+    it('leaves the quoted delivery alone — a priced quote already deducted its fee', () => {
+        chargeDetails.chainId = '1'
+        Object.assign(mockCrossChainTransfer, { isXChain: true, feeUsd: 2, receiveAmount: '48' })
+
+        render(<WithdrawCryptoPage />)
+
+        expect(screen.getByTestId('network-fee').textContent).toBe('2')
+        expect(screen.getByTestId('receive-amount').textContent).toBe('48')
+    })
+
+    it('stays sponsored on a same-chain withdrawal', () => {
+        Object.assign(mockCrossChainTransfer, { isXChain: false, isDiffToken: false, feeUsd: 0 })
+
+        render(<WithdrawCryptoPage />)
+
+        expect(screen.getByTestId('network-fee').textContent).toBe('0')
+    })
+
+    it('stays sponsored on a cross-chain route Peanut still covers', () => {
+        chargeDetails.chainId = '8453' // Base — flat gas is cents, still sponsored
+        Object.assign(mockCrossChainTransfer, { isXChain: true, feeUsd: 0 })
+
+        render(<WithdrawCryptoPage />)
+
+        expect(screen.getByTestId('network-fee').textContent).toBe('0')
+        expect(screen.getByTestId('receive-amount').textContent).toBe('50')
+    })
+
+    it('waits for the quote — an in-flight quote is not a zero fee', () => {
+        chargeDetails.chainId = '1'
+        Object.assign(mockCrossChainTransfer, { isXChain: true, feeUsd: undefined, isCalculating: true })
+
+        render(<WithdrawCryptoPage />)
+
+        // otherwise the heads-up fires while the row still shows a spinner
+        expect(screen.getByTestId('network-fee').textContent).toBe('0')
+        expect(screen.getByTestId('high-fee-warning').textContent).toBe('false')
+    })
+
+    it('prices nothing when the quote failed — that row shows a dash', () => {
+        chargeDetails.chainId = '1'
+        Object.assign(mockCrossChainTransfer, { isXChain: true, feeUsd: 0, isFeeEstimationError: true })
+
+        render(<WithdrawCryptoPage />)
+
+        expect(screen.getByTestId('network-fee').textContent).toBe('0')
+        expect(screen.getByTestId('high-fee-warning').textContent).toBe('false')
+    })
+
+    it('blocks a withdrawal the fee would swallow whole', () => {
+        // $0.50 clears Rhino's Solana minimum but costs $0.50035 to deliver,
+        // so there is nothing left to arrive.
+        chargeDetails.chainId = 'solana'
+        mockUrlAmount = '0.5'
+        Object.assign(mockCrossChainTransfer, { isXChain: true, feeUsd: 0, receiveAmount: '0.5' })
+
+        render(<WithdrawCryptoPage />)
+
+        expect(screen.getByTestId('below-minimum').textContent).toMatch(/more than you are withdrawing/)
+    })
+
+    it('raises the heads-up when flat gas dominates a minimum Ethereum withdrawal', () => {
+        mockIsWithdrawFeeDisproportionate.mockImplementation((...args: unknown[]) =>
+            realRule(...(args as Parameters<typeof realRule>))
+        )
+        chargeDetails.chainId = '1'
+        mockUrlAmount = '5' // Ethereum's floor — $1.50 of it is 30%
+        Object.assign(mockCrossChainTransfer, { isXChain: true, feeUsd: 0 })
+
+        render(<WithdrawCryptoPage />)
+
+        expect(screen.getByTestId('high-fee-warning').textContent).toBe('true')
+    })
+})
+
 describe('crypto withdraw preparation', () => {
     it('creates a standalone WITHDRAW charge without an existing request link', async () => {
         mockStepper.step = 'recipient'

src/app/(mobile-ui)/withdraw/crypto/page.tsx

@@ -17,7 +17,11 @@
 import { chargesApi } from '@/services/charges'
 import type { CreateChargeRequest, TCharge } from '@/services/services.types'
 import { NATIVE_TOKEN_ADDRESS } from '@/utils/token.utils'
-import { isWithdrawFeeDisproportionate, getMinWithdrawUsdForChain } from '@/utils/cross-chain-fee.utils'
+import {
+    isWithdrawFeeDisproportionate,
+    getMinWithdrawUsdForChain,
+    estimateRhinoNetworkFeeUsd,
+} from '@/utils/cross-chain-fee.utils'
 import { isAmountWithinBalance } from '@/utils/balance.utils'
 import { isBelowRhinoMinDeposit, resolveWithdrawAmount } from '@/utils/withdraw.utils'
 import * as peanutInterfaces from '@/interfaces/peanut-sdk-types'
@@ -724,7 +728,7 @@
             executionInFlightRef.current = false
             setIsSendingTx(false)
         }
     }, [
         chargeDetails,
         withdrawData,
         amountToWithdraw,
@@ -808,7 +812,42 @@
 
     // Get network fee from Rhino preview. Under SDA the fee is a transparent
     // bridge-fee in USD — no slippage distinction.
-    const networkFee = useMemo<number>(() => feeUsd ?? 0, [feeUsd])
+    //
+    // Peanut no longer sponsors the fee on Ethereum, Tron and Solana, and a
+    // quote issued before Rhino enables the charge comes back at zero. The
+    // schedule supplies the fee in that window. It is held apart from the
+    // quoted fee because only this one is missing from `receiveAmount`: a
+    // quoted fee is already deducted there (withdraw quotes are pay mode).
+    // Wait for the quote to resolve before pricing — an in-flight or failed
+    // quote is not a zero fee, and a number here would reach the heads-up
+    // while the row itself shows a spinner or a dash.
+    const scheduledFeeUsd = useMemo<number>(() => {
+        if (!isCrossChainWithdrawal || !chargeDetails) return 0
+        if (feeUsd === undefined || isCalculating || isFeeEstimationError) return 0
+        if (feeUsd > 0) return 0
+        return estimateRhinoNetworkFeeUsd(chargeDetails.chainId, parseFloat(usdAmount)) ?? 0
+    }, [isCrossChainWithdrawal, chargeDetails, feeUsd, isCalculating, isFeeEstimationError, usdAmount])
+
+    const networkFee = useMemo<number>(
+        () => (feeUsd && feeUsd > 0 ? feeUsd : scheduledFeeUsd),
+        [feeUsd, scheduledFeeUsd]
+    )
+
+    // What the recipient actually gets. Rhino deducts the fee on delivery, so a
+    // scheduled fee has to come off the quoted delivery here — the card must
+    // not promise the full amount and name a fee beside it. The quote is
+    // denominated in the destination token, so convert with its price (ETH to
+    // Ethereum is quoted in ETH, not dollars).
+    const receiveAmountAfterFee = useMemo<string | null | undefined>(() => {
+        if (!scheduledFeeUsd || !receiveAmount) return receiveAmount
+        const tokenPrice = withdrawData?.token.price
+        if (!tokenPrice || !Number.isFinite(tokenPrice) || tokenPrice <= 0) return receiveAmount
+        const net = parseFloat(receiveAmount) - scheduledFeeUsd / tokenPrice
+        if (!Number.isFinite(net) || net <= 0) return receiveAmount
+        // Trim the zeros toFixed pads to the token's precision — the row reads
+        // "$48.465", not "$48.465000".
+        return net.toFixed(Number(withdrawData?.token.decimals ?? 6)).replace(/\.?0+$/, '')
+    }, [scheduledFeeUsd, receiveAmount, withdrawData])
 
     // Non-blocking heads-up when the bridge fee is a large share of the amount
     // (flat mainnet gas dominating a small withdraw). The user can still proceed
@@ -854,13 +893,21 @@
     // Rhino accepts SDA deposits below the route minimum on-chain but never
     // bridges them — funds strand at the SDA, uncredited. Block the CTA before
     // the user signs. Same-chain USDC transfers have no minimum.
-    const belowMinimumMessage = useMemo<string | null>(
-        () =>
-            isCrossChainWithdrawal && isBelowRhinoMinDeposit(payAmount, minDepositLimitUsd)
-                ? `The minimum withdrawal to this network is $${minDepositLimitUsd}. Enter a larger amount.`
-                : null,
-        [isCrossChainWithdrawal, payAmount, minDepositLimitUsd]
-    )
+    const belowMinimumMessage = useMemo<string | null>(() => {
+        if (!isCrossChainWithdrawal) return null
+        if (isBelowRhinoMinDeposit(payAmount, minDepositLimitUsd)) {
+            return `The minimum withdrawal to this network is $${minDepositLimitUsd}. Enter a larger amount.`
+        }
+        // Rhino's route minimum predates the fee, so it can still admit an
+        // amount the fee swallows whole — $0.50 to Solana costs $0.50035 to
+        // deliver. Block it rather than show a delivery the recipient will
+        // never see.
+        const amountUsdValue = parseFloat(usdAmount)
+        if (scheduledFeeUsd > 0 && Number.isFinite(amountUsdValue) && scheduledFeeUsd >= amountUsdValue) {
+            return `The network fee to ${withdrawData?.chain.networkName ?? 'this network'} is $${scheduledFeeUsd.toFixed(2)}, which is more than you are withdrawing. Enter a larger amount or pick a cheaper network.`
+        }
+        return null
+    }, [isCrossChainWithdrawal, payAmount, minDepositLimitUsd, scheduledFeeUsd, usdAmount, withdrawData])
 
     // Redirect to main withdraw page for amount input. The push must run in an
     // effect — navigating during render is a React violation ("Cannot update
@@ -903,7 +950,7 @@
                     isCrossChain={isCrossChainWithdrawal}
                     isCalculating={isCalculating}
                     quoteFailed={isFeeEstimationError}
-                    receiveAmount={receiveAmount}
+                    receiveAmount={receiveAmountAfterFee}
                     payAmount={payAmount}
                     showHighFeeWarning={showHighFeeWarning}
                     insufficientBalance={insufficientBalance}

src/features/withdraw/views/ConfirmWithdrawView.tsx

@@ -211,9 +211,10 @@ export default function ConfirmWithdrawView({
                         loading={isCrossChain && isCalculating}
                         estimationFailed={isCrossChain && quoteFailed}
                         // Two different things to explain: nothing charged on
-                        // top (the sponsored row), or a quoted fee — which this
-                        // flow quotes receive-mode, so it sits inside You pay,
-                        // not on top of it.
+                        // top (the sponsored row), or a quoted fee. Withdraw
+                        // quotes are pay-mode (useCrossChainTransfer), so the
+                        // fee comes out of what the recipient receives — it is
+                        // never added on top of You pay.
                         moreInfoText={
                             isCrossChain && (networkFee ?? 0) > 0
                                 ? t('confirm.networkFeeChargedInfo')

src/i18n/app/messages/en.json

@@ -1900,15 +1900,15 @@
         },
         "confirm": {
             "recipientReceives": "Recipient receives",
-            "recipientReceivesInfo": "Peanut covers the bridge cost. A small network cost may be deducted on delivery.",
+            "recipientReceivesInfo": "This is what arrives at the destination, after any delivery cost.",
             "tokenAndNetwork": "Token and network",
             "tokenOnChain": "{token} on <c>{chain}</c>",
             "tokenAlt": "token",
             "chainAlt": "chain",
             "to": "To",
             "networkFee": "Network fee",
-            "networkFeeInfo": "Peanut covers the bridge cost. A small network cost may be deducted on delivery.",
-            "networkFeeChargedInfo": "This route quotes a fee. It's already included in the amount you pay.",
+            "networkFeeInfo": "Delivering on this network is free — Peanut covers it. Some networks, like Ethereum, Tron and Solana, charge a fee that comes out of the amount received.",
+            "networkFeeChargedInfo": "Networks charge different amounts to deliver. This one charges, and it comes out of the amount received. Others, like Arbitrum, are free.",
             "youPay": "You pay",
             "highFeeWarning": "Note: the network fee is a large share of this withdrawal. Withdrawing a larger amount or choosing a cheaper network reduces it."
         },

src/i18n/app/messages/es-419.json

@@ -1900,15 +1900,15 @@
         },
         "confirm": {
             "recipientReceives": "El destinatario recibe",
-            "recipientReceivesInfo": "Peanut cubre el costo del puente. Es posible que se descuente un pequeño costo de red al entregar.",
+            "recipientReceivesInfo": "Esto es lo que llega al destino, después de cualquier costo de entrega.",
             "tokenAndNetwork": "Token y red",
             "tokenOnChain": "{token} en <c>{chain}</c>",
             "tokenAlt": "token",
             "chainAlt": "red",
             "to": "Para",
             "networkFee": "Comisión de red",
-            "networkFeeInfo": "Peanut cubre el costo del puente. Es posible que se descuente un pequeño costo de red al entregar.",
-            "networkFeeChargedInfo": "Esta ruta cobra una comisión. Ya está incluida en el monto que pagas.",
+            "networkFeeInfo": "Entregar en esta red es gratis — Peanut lo cubre. Algunas redes, como Ethereum, Tron y Solana, cobran una comisión que se descuenta del monto recibido.",
+            "networkFeeChargedInfo": "Cada red cobra distinto por entregar. Esta cobra, y se descuenta del monto recibido. Otras, como Arbitrum, son gratis.",
             "youPay": "Pagas",
             "highFeeWarning": "Nota: la comisión de red es una parte grande de este retiro. Retirar un monto mayor o elegir una red más barata la reduce."
         },

src/i18n/app/messages/pt-BR.json

@@ -1900,15 +1900,15 @@
         },
         "confirm": {
             "recipientReceives": "O destinatário recebe",
-            "recipientReceivesInfo": "Peanut cobre o custo da ponte. Um pequeno custo de rede pode ser descontado na entrega.",
+            "recipientReceivesInfo": "Este é o valor que chega ao destino, após qualquer custo de entrega.",
             "tokenAndNetwork": "Token e rede",
             "tokenOnChain": "{token} na <c>{chain}</c>",
             "tokenAlt": "token",
             "chainAlt": "rede",
             "to": "Para",
             "networkFee": "Taxa de rede",
-            "networkFeeInfo": "Peanut cobre o custo da ponte. Um pequeno custo de rede pode ser descontado na entrega.",
-            "networkFeeChargedInfo": "Esta rota cobra uma taxa. Ela já está incluída no valor que você paga.",
+            "networkFeeInfo": "Entregar nesta rede é gratuito — a Peanut cobre. Algumas redes, como Ethereum, Tron e Solana, cobram uma taxa descontada do valor recebido.",
+            "networkFeeChargedInfo": "Cada rede cobra um valor diferente para entregar. Esta cobra, e a taxa sai do valor recebido. Outras, como Arbitrum, são gratuitas.",
             "youPay": "Você paga",
             "highFeeWarning": "Atenção: a taxa de rede é uma parte grande deste saque. Sacar um valor maior ou escolher uma rede mais barata reduz a taxa."
         },