DeepLinkingActions.tsx

import type { EdgeParsedUri, EdgeTokenId } from 'edge-core-js'
import * as React from 'react'
import { Linking } from 'react-native'
import { sprintf } from 'sprintf-js'

import { ButtonsModal } from '../components/modals/ButtonsModal'
import { ConfirmContinueModal } from '../components/modals/ConfirmContinueModal'
import { FundAccountModal } from '../components/modals/FundAccountModal'
import { pickWallet } from '../components/modals/WalletListModal'
import {
  Airship,
  showError,
  showToast,
  showToastSpinner
} from '../components/services/AirshipInstance'
import { guiPlugins } from '../constants/plugins/GuiPlugins'
import { SPECIAL_CURRENCY_INFO } from '../constants/WalletAndCurrencyConstants'
import { lstrings } from '../locales/strings'
import {
  executePlugin,
  fiatProviderDeeplinkHandler
} from '../plugins/gui/fiatPlugin'
import { rampDeeplinkManager } from '../plugins/ramps/rampDeeplinkHandler'
import { config } from '../theme/appConfig'
import type { DeepLink } from '../types/DeepLinkTypes'
import type { Dispatch, RootState, ThunkAction } from '../types/reduxTypes'
import type { NavigationBase } from '../types/routerTypes'
import type { EdgeAsset } from '../types/types'
import { logEvent } from '../util/tracking'
import { base58ToUuid, isEmail } from '../util/utils'
import { activatePromotion } from './AccountReferralActions'
import { checkAndShowLightBackupModal } from './BackupModalActions'
import { logoutRequest } from './LoginActions'
import { launchPaymentProto } from './PaymentProtoActions'
import { doRequestAddress, handleWalletUris } from './ScanActions'

// These are the asset types that we'll manually check for when deep linking with a
// URI for the format edge://pay/bitcoin/[privateKey]
// Such assets will allow the user to auto create a wallet if they don't have one
const CREATE_WALLET_ASSETS: Record<string, EdgeAsset> = {
  bitcoin: { pluginId: 'bitcoin', tokenId: null },
  bitcoincash: { pluginId: 'bitcoincash', tokenId: null },
  litecoin: { pluginId: 'litecoin', tokenId: null },
  dogecoin: { pluginId: 'dogecoin', tokenId: null },
  dash: { pluginId: 'dash', tokenId: null }
}

/**
 * The app has just received some of link,
 * so try to follow it if possible, or save it for later if not.
 */
export function launchDeepLink(
  navigation: NavigationBase,
  link: DeepLink
): ThunkAction<Promise<void>> {
  return async (dispatch, getState) => {
    const state = getState()
    await handleLink(navigation, dispatch, state, link)
  }
}

/**
 * Launches a link if it app is able to do so.
 * @returns true if the link is handled,
 * or false if the app is in the wrong state to handle this link.
 */
async function handleLink(
  navigation: NavigationBase,
  dispatch: Dispatch,
  state: RootState,
  link: DeepLink
): Promise<void> {
  const { account, context, disklet } = state.core
  const { defaultIsoFiat } = state.ui.settings
  const { currencyWallets } = account
  const deviceId = base58ToUuid(context.clientId)

  switch (link.type) {
    case 'edgeLogin':
      navigation.push('edgeLogin', {
        lobbyId: link.lobbyId
      })
      break

    case 'passwordRecovery':
      await dispatch(
        logoutRequest(navigation, {
          passwordRecoveryKey: link.passwordRecoveryKey
        })
      )
      break

    case 'plugin': {
      const { pluginId, path, query } = link
      const plugin = guiPlugins[pluginId]
      if (plugin?.pluginId == null || plugin?.pluginId === 'custom') {
        showError(`No plugin named "${pluginId}" exists`)
        break
      }

      // Check the disabled status:
      if (
        state.ui.exchangeInfo.buy.disablePlugins[pluginId] === true ||
        state.ui.exchangeInfo.sell.disablePlugins[pluginId] === true
      ) {
        showError(`Plugin "${pluginId}" is disabled`)
        break
      }

      navigation.push('pluginView', {
        plugin,
        deepPath: path,
        deepQuery: query
      })
      break
    }

    case 'fiatPlugin': {
      const {
        direction = 'buy',
        paymentType = 'credit',
        pluginId,
        providerId
      } = link
      const plugin = guiPlugins[pluginId]
      if (plugin?.nativePlugin == null) {
        showError(new Error(`No fiat plugin named "${pluginId}" exists`))
        break
      }

      // Check the disabled status:
      const disableProviders =
        state.ui.exchangeInfo[direction].disablePlugins[pluginId] ?? {}
      if (disableProviders === true) {
        showError(`Plugin "${pluginId}" is disabled`)
        break
      }

      await executePlugin({
        account,
        defaultIsoFiat,
        deviceId,
        disablePlugins: disableProviders,
        disklet,
        guiPlugin: plugin,
        direction,
        regionCode: { countryCode: state.ui.settings.countryCode },
        paymentType,
        providerId,
        navigation,
        onLogEvent: (event, values) => {
          dispatch(logEvent(event, values))
        },
        dispatch
      })
      break
    }

    // NOTE: We MUST keep 'fiatProvider' case around indefinitely for backwards compatibility
    // because some buy/sell providers manage the callback URL state (e.g. Simplex).
    // This means we can never really change the callback URL for those providers without
    // breaking the older versions of the app which do not have the ramp plugins.
    // Only until those providers become deprecated or accept parameterized callback URLs,
    // can we remove this deeplink handling.
    case 'fiatProvider': {
      // Handle with ramp deeplink manager first for backward compatibility
      // of some fiat providers (e.g. Simplex) because we cannot upgrade those
      // providers to use the new `/ramp/` deeplink format..
      const result = rampDeeplinkManager.handleDeeplink({
        ...link,
        type: 'ramp'
      })
      if (result.success) {
        break
      }
      // Handle with legacy fiat plugin handler
      fiatProviderDeeplinkHandler(link)
      break
    }

    case 'promotion':
      await dispatch(activatePromotion(link.installerId ?? ''))
      break

    case 'affiliate':
      await dispatch(activatePromotion(link.installerId))
      await handleLink(navigation, dispatch, state, link.link)
      break

    case 'requestAddress':
      await doRequestAddress(navigation, state.core.account, dispatch, link)
      break

    case 'swap':
      navigation.navigate('swapTab', { screen: 'swapCreate' })
      break

    case 'azteco': {
      const result = await pickWallet({
        account,
        assets: [{ pluginId: 'bitcoin', tokenId: null }],
        navigation,
        showCreateWallet: true
      })
      if (result?.type !== 'wallet') break
      const wallet = account.currencyWallets[result.walletId]
      if (wallet == null) break

      if (checkAndShowLightBackupModal(account, navigation)) break

      const address = await wallet.getReceiveAddress({ tokenId: null })
      const response = await fetch(`${link.uri}${address.publicAddress}`)
      if (response.ok) {
        showToast(lstrings.azteco_success)
      } else if (response.status === 400) {
        showError(lstrings.azteco_invalid_code)
      } else {
        showError(lstrings.azteco_service_unavailable)
      }
      navigation.navigate('home')
      break
    }

    case 'walletConnect':
      navigation.push('wcConnections', {
        uri: link.uri
      })
      break

    case 'paymentProto':
      await launchPaymentProto(navigation, account, link.uri, {
        hideScamWarning: false
      })
      break

    case 'price-change': {
      const { pluginId, body } = link
      const currencyCode =
        account.currencyConfig[pluginId].currencyInfo.currencyCode
      let result
      if (config.disableSwaps === true) {
        result = await Airship.show<'buy' | 'sell' | undefined>(bridge => (
          <ButtonsModal
            bridge={bridge}
            title={lstrings.price_change_notification}
            message={`${body} ${sprintf(
              lstrings.price_change_buy_sell_trade,
              currencyCode
            )}`}
            buttons={{
              buy: { label: lstrings.title_buy, type: 'secondary' },
              sell: { label: lstrings.title_sell }
            }}
          />
        ))
      } else {
        result = await Airship.show<'buy' | 'sell' | 'exchange' | undefined>(
          bridge => (
            <ButtonsModal
              bridge={bridge}
              title={lstrings.price_change_notification}
              message={`${body} ${sprintf(
                lstrings.price_change_buy_sell_trade,
                currencyCode
              )}`}
              buttons={{
                buy: { label: lstrings.title_buy, type: 'secondary' },
                sell: { label: lstrings.title_sell },
                exchange: { label: lstrings.buy_crypto_modal_exchange }
              }}
            />
          )
        )
      }

      if (result === 'buy') {
        navigation.navigate('buyTab', { screen: 'pluginListBuy', params: {} })
      } else if (result === 'sell') {
        navigation.navigate('sellTab', { screen: 'pluginListSell', params: {} })
      } else if (result === 'exchange') {
        navigation.navigate('swapTab', { screen: 'swapCreate' })
      }

      break
    }

    case 'marketing': {
      // The user opened the app from a marketing push. Report it so the
      // campaign's open rate can be tracked. The send UI lives in the internal
      // tools project; the campaignId rides in the push notification payload.
      dispatch(
        logEvent('Marketing_Notification_Opened', {
          campaignId: link.campaignId
        })
      )
      // Optional navigation: delegate to the shared handler, mirroring the
      // affiliate link. Unsupported targets fall through its existing guards.
      if (link.link != null) {
        await handleLink(navigation, dispatch, state, link.link)
      }
      break
    }

    case 'other': {
      const matchingWalletIdsAndUris: Array<{
        walletId: string
        parsedUri: EdgeParsedUri
        tokenId: EdgeTokenId
      }> = []
      const assets: EdgeAsset[] = []

      const parseWallets = async (): Promise<void> => {
        // Try to parse with all wallets
        for (const wallet of Object.values(currencyWallets)) {
          const { pluginId } = wallet.currencyInfo
          // Ignore disabled wallets:
          const { keysOnlyMode = false } = SPECIAL_CURRENCY_INFO[pluginId] ?? {}
          if (keysOnlyMode) continue
          const parsedUri = await wallet
            .parseUri(link.uri)
            .catch((_: unknown) => undefined)
          if (parsedUri != null) {
            const { tokenId = null } = parsedUri
            matchingWalletIdsAndUris.push({
              walletId: wallet.id,
              parsedUri,
              tokenId
            })
            assets.push({ pluginId, tokenId })
          }
        }
      }

      const promise = parseWallets()
      await showToastSpinner(lstrings.scan_parsing_link, promise)

      // Check if this is an email for Tron USDT and show warning for potential
      // PIX send
      if (
        isEmail(link.uri) &&
        assets.find(
          asset =>
            asset.pluginId === 'tron' &&
            asset.tokenId === 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t'
        ) != null
      ) {
        const approved = await Airship.show<boolean>(bridge => (
          <ConfirmContinueModal
            bridge={bridge}
            title={lstrings.warning_sending_pix_to_email_title}
            body={lstrings.warning_sending_pix_to_email_body}
            warning
            isSkippable
          />
        ))
        if (!approved) {
          return
        }
      }

      // Check if the uri matches one of the wallet types that we could create. In such a case, link.uri
      // would be of the format 'dogecoin:QUE1U9n3kMYR...'
      const [linkCurrency] = link.uri.split(':')
      const createWalletAsset = CREATE_WALLET_ASSETS[linkCurrency]

      if (matchingWalletIdsAndUris.length === 0 && createWalletAsset == null) {
        showToast(lstrings.alert_deep_link_no_wallet_for_uri)
        break
      }

      if (matchingWalletIdsAndUris.length === 1) {
        const { walletId, parsedUri } = matchingWalletIdsAndUris[0]
        await dispatch(
          handleWalletUris(navigation, currencyWallets[walletId], parsedUri)
        )
        break
      }

      if (createWalletAsset != null) {
        assets.push(createWalletAsset)
      }

      const result = await pickWallet({
        account,
        assets,
        navigation,
        showCreateWallet: true
      })
      if (result?.type !== 'wallet') break
      const wallet = account.currencyWallets[result.walletId]
      if (wallet == null) break

      // Re-parse the uri with the final chosen wallet
      // just in case this was a URI for a wallet we didn't have:
      const finalParsedUri = await wallet.parseUri(link.uri)
      await dispatch(handleWalletUris(navigation, wallet, finalParsedUri))
      break
    }

    case 'scene': {
      try {
        navigation.navigate(link.sceneName as any, link.query as any)
      } catch (e) {
        showError(
          `Deep link failed. Unable to navigate to: '${link.sceneName}'`
        )
      }
      break
    }

    case 'modal': {
      switch (link.modalName) {
        case 'fundAccount':
          await Airship.show(bridge => (
            <FundAccountModal bridge={bridge} navigation={navigation} />
          ))
          break
        default:
          showError(`Unknown modal: '${link.modalName}'`)
      }
      break
    }

    case 'ramp': {
      const result = rampDeeplinkManager.handleDeeplink(link)
      if (!result.success) {
        showError(result.error)
      }
      break
    }

    case 'rewards': {
      const { pluginId, tokenId } = link

      // Choose wallet:
      const walletListResult = await pickWallet({
        account,
        assets: [{ pluginId, tokenId }],
        navigation,
        showCreateWallet: true
      })
      if (walletListResult?.type !== 'wallet') break
      const { walletId } = walletListResult
      const wallet = account.currencyWallets[walletId]
      const { publicAddress } = (await wallet.getAddresses({ tokenId }))[0]
      const { currencyCode } =
        tokenId == null
          ? account.currencyConfig[pluginId].currencyInfo
          : account.currencyConfig[pluginId].allTokens[tokenId]

      // Encode data:
      const data = btoa(`edgerewards|${publicAddress}|${currencyCode}`)

      // Open URL:
      await Linking.openURL(`https://edge.app/rewards/?data=${data}`)
      break
    }

    default:
      break
  }
}