Add a private swap toggle to the swap amount scene

When enabled, the swap routes privately through Houdini's swap-to-address
path: the destination address is derived from the chosen receive wallet,
a Houdini-only private quote is fetched, confirmed, and approved. The
toggle only appears for destination chains Houdini can privately route to.

Author: j0ntz

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## Unreleased (develop)
 
+- added: Private swap toggle on the swap amount scene that routes the exchange through Houdini's swap-to-address path to the chosen receive wallet. Depends on unpublished edge-core-js and edge-exchange-plugins changes.
 - added: Houdini private send prototype (dev-only): a swap-to-address flow that gets a live HoudiniSwap private quote, creates the private exchange order, and broadcasts the on-chain deposit. Depends on unpublished edge-core-js and edge-exchange-plugins changes.
 - added: Logbox disable option to env.json
 - added: Reverse-resolve recipient addresses to ENS / Unstoppable Domains / ZNS names in the send flow, address modal, and transaction history.

src/components/scenes/SwapCreateScene.tsx

@@ -1,4 +1,4 @@
-import { gt, gte } from 'biggystring'
+import { div, gt, gte } from 'biggystring'
 import {
   asMaybeInsufficientFundsError,
   asMaybeSwapAboveLimitError,
@@ -21,10 +21,16 @@ import { useSwapRequestOptions } from '../../hooks/swap/useSwapRequestOptions'
 import { useHandler } from '../../hooks/useHandler'
 import { useWatch } from '../../hooks/useWatch'
 import { lstrings } from '../../locales/strings'
+import { getExchangeDenom } from '../../selectors/DenominationSelectors'
 import { useDispatch, useSelector } from '../../types/reactRedux'
 import type { NavigationBase, SwapTabSceneProps } from '../../types/routerTypes'
 import { getCurrencyCode } from '../../util/CurrencyInfoHelpers'
 import { getWalletName } from '../../util/CurrencyWalletHelpers'
+import {
+  fetchHoudiniPrivateQuote,
+  HOUDINI_DESTINATION_ASSETS,
+  isPluginDisabled
+} from '../../util/houdiniPrivateSend'
 import { zeroString } from '../../util/utils'
 import { EdgeButton } from '../buttons/EdgeButton'
 import { KavButtons } from '../buttons/KavButtons'
@@ -42,12 +48,19 @@ import { SceneWrapper } from '../common/SceneWrapper'
 import { styled } from '../hoc/styled'
 import { SwapVerticalIcon } from '../icons/ThemedIcons'
 import { SceneContainer } from '../layout/SceneContainer'
+import { ConfirmContinueModal } from '../modals/ConfirmContinueModal'
 import {
   WalletListModal,
   type WalletListResult
 } from '../modals/WalletListModal'
-import { Airship, showToast, showWarning } from '../services/AirshipInstance'
+import {
+  Airship,
+  showError,
+  showToast,
+  showWarning
+} from '../services/AirshipInstance'
 import { useTheme } from '../services/ThemeContext'
+import { SettingsSwitchRow } from '../settings/SettingsSwitchRow'
 import { UnscaledText } from '../text/UnscaledText'
 import { LineTextDivider } from '../themed/LineTextDivider'
 import {
@@ -95,6 +108,14 @@ export const SwapCreateScene: React.FC<Props> = props => {
     'from' | 'to'
   >('from')
 
+  // When enabled, the swap routes privately through Houdini's swap-to-address
+  // path (depositing to the destination wallet's address) instead of the normal
+  // multi-provider wallet-to-wallet flow.
+  const [isPrivateSwap, setIsPrivateSwap] = useState(false)
+  // Guards the async private-swap flow so a double-tap cannot launch two
+  // concurrent quote/approve/broadcast sequences.
+  const [privateSwapPending, setPrivateSwapPending] = useState(false)
+
   const fromInputRef = React.useRef<SwapInputCardInputRef>(null)
   const toInputRef = React.useRef<SwapInputCardInputRef>(null)
 
@@ -103,6 +124,9 @@ export const SwapCreateScene: React.FC<Props> = props => {
   const account = useSelector(state => state.core.account)
   const currencyWallets = useWatch(account, 'currencyWallets')
   const exchangeInfo = useSelector(state => state.ui.exchangeInfo)
+  const disablePlugins = useSelector(
+    state => state.ui.exchangeInfo.swap.disablePlugins
+  )
 
   const toWallet: EdgeCurrencyWallet | undefined =
     toWalletId == null ? undefined : currencyWallets[toWalletId]
@@ -130,6 +154,18 @@ export const SwapCreateScene: React.FC<Props> = props => {
   const hasMaxSpend =
     fromWallet != null && fromWalletSpecialCurrencyInfo.noMaxSpend !== true
 
+  // Houdini can only privately route to the NATIVE asset of the chains in its
+  // destination set, so a token destination (toTokenId != null) is unsupported
+  // even when its chain appears in the set. A server-side Houdini disable also
+  // hides the toggle, since the private path is Houdini-only.
+  const isPrivateSwapSupported =
+    toWallet != null &&
+    toTokenId == null &&
+    !isPluginDisabled(disablePlugins, 'houdini') &&
+    HOUDINI_DESTINATION_ASSETS.some(
+      asset => asset.pluginId === toWallet.currencyInfo.pluginId
+    )
+
   const isNextHidden =
     // Don't show next button if the wallets haven't been selected:
     fromWallet == null ||
@@ -149,6 +185,12 @@ export const SwapCreateScene: React.FC<Props> = props => {
     })
   }, [dispatch, navigation])
 
+  // Keep the private toggle from getting stuck "on" for a destination Houdini
+  // cannot privately route to (e.g. after the user changes the receive wallet).
+  React.useEffect(() => {
+    if (isPrivateSwap && !isPrivateSwapSupported) setIsPrivateSwap(false)
+  }, [isPrivateSwap, isPrivateSwapSupported])
+
   //
   // Callbacks
   //
@@ -381,7 +423,121 @@ export const SwapCreateScene: React.FC<Props> = props => {
     }
   )
 
+  /**
+   * Route the current amounts through Houdini's swap-to-address path: derive
+   * the destination address from the chosen receiving wallet, fetch a
+   * Houdini-only private quote, confirm, approve, then land on the success
+   * scene. The normal `swapProcessing`/`swapConfirmation` scenes assume a
+   * destination wallet, so the private path runs its own confirm + approve.
+   */
+  const executePrivateSwap = useHandler(async (): Promise<void> => {
+    if (privateSwapPending) return
+    if (fromWallet == null || toWallet == null) return
+
+    if (zeroString(inputNativeAmount)) {
+      showToast(
+        `${lstrings.no_exchange_amount}. ${lstrings.select_exchange_amount}.`
+      )
+      return
+    }
+    if (checkAmountExceedsBalance()) return
+    // Houdini quotes only off the send amount, so a "to" amount cannot drive a
+    // private quote.
+    if (inputNativeAmountFor !== 'from') {
+      showWarning(lstrings.houdini_swap_from_amount_only, { trackError: false })
+      return
+    }
+
+    // Mirror getQuote: honor the exchange-info asset disables for the private
+    // path too, so a disabled source/destination asset cannot start a swap.
+    const disableSrc = checkDisableAsset(
+      exchangeInfo.swap.disableAssets.source,
+      fromWallet.id,
+      fromTokenId
+    )
+    if (disableSrc) {
+      showToast(
+        sprintf(
+          lstrings.swap_token_no_enabled_exchanges_2s,
+          fromCurrencyCode,
+          fromWallet.currencyInfo.displayName
+        )
+      )
+      return
+    }
+    const disableDest = checkDisableAsset(
+      exchangeInfo.swap.disableAssets.destination,
+      toWallet.id,
+      toTokenId
+    )
+    if (disableDest) {
+      showToast(
+        sprintf(
+          lstrings.swap_token_no_enabled_exchanges_2s,
+          toCurrencyCode,
+          toWallet.currencyInfo.displayName
+        )
+      )
+      return
+    }
+
+    setPrivateSwapPending(true)
+    try {
+      const toAddresses = await toWallet.getAddresses({ tokenId: null })
+      const toAddress = toAddresses[0]?.publicAddress
+      if (toAddress == null) {
+        showError(lstrings.houdini_swap_no_dest_address)
+        return
+      }
+
+      const quote = await fetchHoudiniPrivateQuote(account, {
+        fromWallet,
+        fromTokenId,
+        toPluginId: toWallet.currencyInfo.pluginId,
+        toTokenId,
+        toAddress,
+        nativeAmount: inputNativeAmount,
+        disablePlugins
+      })
+
+      const fromMultiplier = getExchangeDenom(
+        fromWallet.currencyConfig,
+        fromTokenId
+      ).multiplier
+      const toMultiplier = getExchangeDenom(
+        toWallet.currencyConfig,
+        toTokenId
+      ).multiplier
+      const fromDisplay = div(quote.fromNativeAmount, fromMultiplier, 8)
+      const toDisplay = div(quote.toNativeAmount, toMultiplier, 8)
+
+      const confirmed = await Airship.show<boolean>(bridge => (
+        <ConfirmContinueModal
+          bridge={bridge}
+          title={lstrings.houdini_ps_confirm_send}
+          body={`${fromDisplay} ${fromCurrencyCode} → ~${toDisplay} ${toCurrencyCode}\n\n${lstrings.houdini_ps_confirm_body}`}
+          warning
+        />
+      ))
+      if (!confirmed) return
+
+      const result = await quote.approve()
+      resetState()
+      navigation.push('swapSuccess', {
+        edgeTransaction: result.transaction,
+        walletId: fromWallet.id
+      })
+    } finally {
+      setPrivateSwapPending(false)
+    }
+  })
+
   const handleMaxPress = useHandler(() => {
+    if (isPrivateSwap) {
+      showWarning(lstrings.houdini_swap_from_amount_only, { trackError: false })
+      return
+    }
+
     if (toWallet == null) {
       showWarning(lstrings.exchange_select_receiving_wallet, {
         trackError: false
@@ -410,10 +566,24 @@ export const SwapCreateScene: React.FC<Props> = props => {
     getQuote(request)
   })
 
+  const handleTogglePrivateSwap = useHandler(() => {
+    setIsPrivateSwap(value => !value)
+  })
+
   const handleNext = useHandler(() => {
     // Should only happen if the user initiated the swap from the keyboard
     if (fromWallet == null || toWallet == null) return
 
+    if (isPrivateSwap) {
+      // handleNext feeds the void-typed button onPress, so it must stay
+      // synchronous; executePrivateSwap owns its own error display, and this
+      // .catch is the required floating-promise guard.
+      executePrivateSwap().catch((error: unknown) => {
+        showError(error)
+      })
+      return
+    }
+
     if (zeroString(inputNativeAmount)) {
       showToast(
         `${lstrings.no_exchange_amount}. ${lstrings.select_exchange_amount}.`
@@ -530,7 +700,7 @@ export const SwapCreateScene: React.FC<Props> = props => {
             primary={{
               label: lstrings.string_next_capitalized,
               onPress: handleNext,
-              disabled: isNextHidden
+              disabled: isNextHidden || privateSwapPending
             }}
             tertiary={{
               label: lstrings.string_cancel_cap,
@@ -614,12 +784,23 @@ export const SwapCreateScene: React.FC<Props> = props => {
             )}
           </EdgeAnim>
           <EdgeAnim enter={fadeInDown60}>{renderAlert()}</EdgeAnim>
+          {isPrivateSwapSupported ? (
+            <EdgeAnim enter={fadeInDown90}>
+              <SettingsSwitchRow
+                label={lstrings.houdini_swap_private_label}
+                value={isPrivateSwap}
+                onPress={handleTogglePrivateSwap}
+              />
+            </EdgeAnim>
+          ) : null}
           <EdgeAnim enter={fadeInDown90}>
             {isNextHidden || isKeyboardOpen ? null : (
               <SceneButtons
                 primary={{
                   label: lstrings.string_next_capitalized,
-                  onPress: handleNext
+                  onPress: handleNext,
+                  disabled: privateSwapPending,
+                  spinner: privateSwapPending
                 }}
               />
             )}

src/locales/en_US.ts

@@ -1852,6 +1852,11 @@ const strings = {
     'Select a source wallet, destination asset, address, and amount first',
   houdini_ps_pick_dest_asset_first: 'Select a destination asset first',
   houdini_ps_pick_source_first: 'Select a source wallet first',
+  houdini_swap_private_label: 'Private swap',
+  houdini_swap_from_amount_only:
+    'Private swaps quote from the send amount only',
+  houdini_swap_no_dest_address:
+    'Could not get a destination address for the selected wallet',
   deposit_to_bank: 'Deposit to Bank',
   your_wallets: 'Your Wallets',
   pause_wallet_toast: