diff --git a/src/components/HotspotConfigurationPicker.tsx b/src/components/HotspotConfigurationPicker.tsx
index 12ae8ea1..3623570c 100644
--- a/src/components/HotspotConfigurationPicker.tsx
+++ b/src/components/HotspotConfigurationPicker.tsx
@@ -17,12 +17,41 @@ import { useColors } from '../theme/themeHooks'
 import { AntennaModelKeys, AntennaModels } from '../makers'
 import { MakerAntenna } from '../makers/antennaMakerTypes'
 
+function gainFloatToString(gainFloat?: number): string {
+  return gainFloat != null
+    ? gainFloat.toLocaleString(locale, {
+        maximumFractionDigits: 1,
+        minimumFractionDigits: 1,
+      })
+    : ''
+}
+function gainStringToFloat(gainStr?: string): number | undefined {
+  return gainStr
+    ? parseFloat(
+        gainStr.replace(groupSeparator, '').replace(decimalSeparator, '.'),
+      )
+    : undefined
+}
+function elevationStringToInt(elevationStr?: string): number | undefined {
+  return elevationStr
+    ? parseInt(
+        elevationStr.replace(groupSeparator, '').replace(decimalSeparator, '.'),
+        10,
+      )
+    : undefined
+}
+function elevationIntToString(elevationInt?: number): string {
+  return elevationInt != null ? elevationInt.toLocaleString(locale) : ''
+}
+
 type Props = {
   onAntennaUpdated: (antenna: MakerAntenna) => void
-  onGainUpdated: (gain: number) => void
-  onElevationUpdated: (elevation: number) => void
+  onGainUpdated: (gain: number | undefined) => void
+  onElevationUpdated: (elevation: number | undefined) => void
   selectedAntenna?: MakerAntenna
   outline?: boolean
+  gain?: number
+  elevation?: number
 }
 const HotspotConfigurationPicker = ({
   selectedAntenna,
@@ -30,6 +59,8 @@ const HotspotConfigurationPicker = ({
   onGainUpdated,
   onElevationUpdated,
   outline,
+  gain,
+  elevation,
 }: Props) => {
   const { t } = useTranslation()
   const colors = useColors()
@@ -37,13 +68,17 @@ const HotspotConfigurationPicker = ({
   const gainInputRef = useRef<TextInput | null>(null)
   const elevationInputRef = useRef<TextInput | null>(null)
 
-  const [gain, setGain] = useState<string | undefined>(
-    selectedAntenna
-      ? selectedAntenna.gain.toLocaleString(locale, {
-          maximumFractionDigits: 1,
-          minimumFractionDigits: 1,
-        })
-      : undefined,
+  // Use state to track temporary raw edits for gain and elevation so that we can delay actual
+  // updates (delegated to parent component) until the user has finished editing. This prevents
+  // the need to reformat input as the user is actively typing, while ensuring the parent component
+  // only receives updates when the user has finished.
+  const [isEditingGain, setIsEditingGain] = useState(false)
+  const [isEditingElevation, setIsEditingElevation] = useState(false)
+  const [tmpGain, setTmpGain] = useState<string | undefined>(
+    gain != null ? gainFloatToString(gain) : undefined,
+  )
+  const [tmpElevation, setTmpElevation] = useState<string | undefined>(
+    elevation != null ? elevationIntToString(elevation) : undefined,
   )
 
   const antennas = useMemo(
@@ -62,12 +97,7 @@ const HotspotConfigurationPicker = ({
     const antenna = antennas[index]
     onAntennaUpdated(antenna)
     onGainUpdated(antenna.gain)
-    setGain(
-      antenna.gain.toLocaleString(locale, {
-        maximumFractionDigits: 1,
-        minimumFractionDigits: 1,
-      }),
-    )
+    setTmpGain(gainFloatToString(antenna.gain))
   }
 
   const showElevationInfo = () =>
@@ -91,69 +121,43 @@ const HotspotConfigurationPicker = ({
     elevationInputRef.current?.focus()
   }
 
-  const parseGainFloat = (floatString?: string) =>
-    floatString
-      ? parseFloat(
-          floatString
-            .replace(groupSeparator, '')
-            .replace(decimalSeparator, '.'),
-        )
-      : 0
-
   const onChangeGain = (text: string) => {
-    let gainFloat = parseGainFloat(text)
-    if (!gainFloat || gainFloat <= 1) {
-      gainFloat = 1
-    } else if (gainFloat >= 15) {
-      gainFloat = 15
-    }
-    setGain(text)
-    onGainUpdated(gainFloat)
+    if (!isEditingGain) setIsEditingGain(true)
+    setTmpGain(text)
   }
-
   const onDoneEditingGain = () => {
-    const gainFloat = parseGainFloat(gain)
-    let gainString
-    if (!gainFloat || gainFloat <= 1) {
-      gainString = '1'
-    } else if (gainFloat >= 15) {
-      gainString = '15'
-    } else {
-      gainString = gainFloat.toLocaleString(locale, {
-        maximumFractionDigits: 1,
-      })
+    setIsEditingGain(false)
+    const gainStrRaw = tmpGain
+    let gainFloat = gainStringToFloat(gainStrRaw)
+    if (gainFloat) {
+      if (gainFloat <= 1) gainFloat = 1
+      if (gainFloat >= 15) gainFloat = 15
     }
-    setGain(gainString)
+    const gainStr = gainFloatToString(gainFloat)
+    setTmpGain(gainStr)
     onGainUpdated(gainFloat)
     Keyboard.dismiss()
   }
-
   const onChangeElevation = (text: string) => {
-    const elevationInteger = text
-      ? parseInt(
-          text.replace(groupSeparator, '').replace(decimalSeparator, '.'),
-          10,
-        )
-      : 0
-    let stringElevation
-    if (!elevationInteger) {
-      stringElevation = '0'
-    } else {
-      stringElevation = elevationInteger.toString()
-    }
-    onElevationUpdated(parseInt(stringElevation, 10))
+    if (!isEditingElevation) setIsEditingElevation(true)
+    setTmpElevation(text)
+  }
+  const onDoneEditingElevation = () => {
+    setIsEditingElevation(false)
+    const elevationStrRaw = tmpElevation
+    const elevationInt = elevationStringToInt(elevationStrRaw)
+    const elevationStr = elevationIntToString(elevationInt)
+    setTmpElevation(elevationStr)
+    onElevationUpdated(elevationInt)
+    Keyboard.dismiss()
   }
 
   useEffect(() => {
     if (selectedAntenna) {
-      setGain(
-        selectedAntenna.gain.toLocaleString(locale, {
-          maximumFractionDigits: 1,
-          minimumFractionDigits: 1,
-        }),
-      )
+      onGainUpdated(selectedAntenna.gain)
+      setTmpGain(gainFloatToString(selectedAntenna.gain))
     }
-  }, [selectedAntenna])
+  }, [selectedAntenna, onGainUpdated])
 
   return (
     <Box
@@ -205,7 +209,7 @@ const HotspotConfigurationPicker = ({
               style={styles.textInput}
               ref={gainInputRef}
               keyboardType="numeric"
-              value={gain}
+              value={isEditingGain ? tmpGain : gainFloatToString(gain)}
               returnKeyType="done"
               maxFontSizeMultiplier={1.2}
               onChangeText={onChangeGain}
@@ -245,7 +249,12 @@ const HotspotConfigurationPicker = ({
             returnKeyType="done"
             maxFontSizeMultiplier={1.2}
             onChangeText={onChangeElevation}
-            onEndEditing={Keyboard.dismiss}
+            onEndEditing={onDoneEditingElevation}
+            value={
+              isEditingElevation
+                ? tmpElevation
+                : elevationIntToString(elevation)
+            }
           />
         </Box>
       </TouchableWithoutFeedback>
diff --git a/src/features/hotspots/root/HotspotAntennaUpdateScreen.tsx b/src/features/hotspots/root/HotspotAntennaUpdateScreen.tsx
new file mode 100644
index 00000000..b2a52a18
--- /dev/null
+++ b/src/features/hotspots/root/HotspotAntennaUpdateScreen.tsx
@@ -0,0 +1,83 @@
+import React from 'react'
+import { KeyboardAvoidingView, Modal, Platform } from 'react-native'
+import { RouteProp, useNavigation } from '@react-navigation/native'
+import { useSelector } from 'react-redux'
+
+import BlurBox from '../../../components/BlurBox'
+import Box from '../../../components/Box'
+import Card from '../../../components/Card'
+import SafeAreaBox from '../../../components/SafeAreaBox'
+
+import { HotspotStackParamList } from './hotspotTypes'
+import { RootState } from '../../../store/rootReducer'
+import UpdateHotspotConfig from '../settings/updateHotspot/UpdateHotspotConfig'
+
+type Route = RouteProp<HotspotStackParamList, 'HotspotAntennaUpdateScreen'>
+
+type Props = {
+  route: Route
+}
+
+/**
+ * HotspotAntennaUpdateScreen allows users to update the antenna of one of their hotspots within
+ * a single view. It simply renders the "UpdateHotspotConfig" component in "antenna" state with
+ * prefilled values for gain and elevation (as provided in the route parameters).
+ */
+function HotspotAntennaUpdateScreen({ route }: Props) {
+  const { hotspotAddress, gain, elevation } = route.params
+  const hotspots = useSelector(
+    (state: RootState) => state.hotspots.hotspots.data,
+  )
+  const hotspot = hotspots.find((h) => h.address === hotspotAddress)
+
+  const navigation = useNavigation()
+  const onClose = () => navigation.goBack()
+
+  return (
+    <Modal
+      presentationStyle="overFullScreen"
+      transparent
+      visible
+      animationType="fade"
+      statusBarTranslucent
+    >
+      <BlurBox
+        top={0}
+        left={0}
+        bottom={0}
+        right={0}
+        blurAmount={70}
+        blurType="dark"
+        position="absolute"
+      />
+      <SafeAreaBox flex={1} flexDirection="column" marginBottom="m">
+        <Box
+          marginTop="none"
+          marginBottom="ms"
+          justifyContent="flex-end"
+          flex={1}
+          marginHorizontal="none"
+        >
+          <KeyboardAvoidingView
+            behavior={Platform.OS === 'ios' ? 'padding' : undefined}
+          >
+            <Card variant="modal" backgroundColor="white" overflow="hidden">
+              {!!hotspot && (
+                <UpdateHotspotConfig
+                  antennaElevation={elevation}
+                  antennaGain={gain}
+                  hotspot={hotspot}
+                  initState="confirm"
+                  onClose={onClose}
+                  onCloseSettings={onClose}
+                />
+              )}
+            </Card>
+          </KeyboardAvoidingView>
+        </Box>
+      </SafeAreaBox>
+    </Modal>
+  )
+}
+
+export default HotspotAntennaUpdateScreen
diff --git a/src/features/hotspots/root/HotspotsNavigator.tsx b/src/features/hotspots/root/HotspotsNavigator.tsx
index d10b6a92..3f3a9100 100644
--- a/src/features/hotspots/root/HotspotsNavigator.tsx
+++ b/src/features/hotspots/root/HotspotsNavigator.tsx
@@ -3,6 +3,7 @@ import { createStackNavigator } from '@react-navigation/stack'
 import defaultScreenOptions from '../../../navigation/defaultScreenOptions'
 import HotspotsScreen from './HotspotsScreen'
 import HotspotLocationUpdateScreen from './HotspotLocationUpdateScreen'
+import HotspotAntennaUpdateScreen from './HotspotAntennaUpdateScreen'
 import { HotspotStackParamList } from './hotspotTypes'
 
 const HotspotsStack = createStackNavigator<HotspotStackParamList>()
@@ -18,6 +19,10 @@ const Hotspots = () => {
         name="HotspotLocationUpdateScreen"
         component={HotspotLocationUpdateScreen}
       />
+      <HotspotsStack.Screen
+        name="HotspotAntennaUpdateScreen"
+        component={HotspotAntennaUpdateScreen}
+      />
     </HotspotsStack.Navigator>
   )
 }
diff --git a/src/features/hotspots/root/hotspotTypes.tsx b/src/features/hotspots/root/hotspotTypes.tsx
index a0ea3c29..cf0ff093 100644
--- a/src/features/hotspots/root/hotspotTypes.tsx
+++ b/src/features/hotspots/root/hotspotTypes.tsx
@@ -8,6 +8,11 @@ export type HotspotStackParamList = {
     hotspotAddress: string
     location: { longitude: number; latitude: number }
   }
+  HotspotAntennaUpdateScreen: {
+    hotspotAddress: string
+    gain?: number
+    elevation?: number
+  }
 }
 
 export type HotspotNavigationProp = StackNavigationProp<HotspotStackParamList>
diff --git a/src/features/hotspots/settings/updateHotspot/UpdateHotspotConfig.tsx b/src/features/hotspots/settings/updateHotspot/UpdateHotspotConfig.tsx
index 70dc0d78..221a6202 100644
--- a/src/features/hotspots/settings/updateHotspot/UpdateHotspotConfig.tsx
+++ b/src/features/hotspots/settings/updateHotspot/UpdateHotspotConfig.tsx
@@ -47,21 +47,37 @@ type Props = {
   onClose: () => void
   onCloseSettings: () => void
   hotspot: Hotspot | Witness
+  antennaGain?: number
+  antennaElevation?: number
+  initState?: State
 }
 
 type State = 'antenna' | 'location' | 'confirm'
 
-const UpdateHotspotConfig = ({ onClose, onCloseSettings, hotspot }: Props) => {
+const UpdateHotspotConfig = ({
+  onClose,
+  onCloseSettings,
+  hotspot,
+  antennaGain,
+  antennaElevation,
+  initState,
+}: Props) => {
   const { t } = useTranslation()
   const submitTxn = useSubmitTxn()
   const navigation = useNavigation()
   const dispatch = useAppDispatch()
   const [state, setState] = useState<State>(
-    isDataOnly(hotspot) ? 'location' : 'antenna',
+    initState ?? (isDataOnly(hotspot) ? 'location' : 'antenna'),
+  )
+  const [antenna, setAntenna] = useState<MakerAntenna | undefined>(
+    antennaGain != null
+      ? ({ name: 'Custom Antenna', gain: antennaGain } as MakerAntenna)
+      : undefined,
+  )
+  const [gain, setGain] = useState<number | undefined>(antennaGain)
+  const [elevation, setElevation] = useState<number | undefined>(
+    antennaElevation,
   )
-  const [antenna, setAntenna] = useState<MakerAntenna>()
-  const [gain, setGain] = useState<number>()
-  const [elevation, setElevation] = useState<number>(0)
   const [location, setLocation] = useState<Coords>()
   const [locationName, setLocationName] = useState<string>()
   const [fullScreen, setFullScreen] = useState(false)
@@ -79,6 +95,24 @@ const UpdateHotspotConfig = ({ onClose, onCloseSettings, hotspot }: Props) => {
     enableBack(onClose)
   }, [enableBack, onClose])
 
+  useEffect(() => {
+    if (!!(antennaGain || antennaElevation) && initState === 'confirm') {
+      updateLocationFeeForUpdatingAntenna()
+      setIsLocationChange(false)
+    }
+  }, [antennaGain, antennaElevation, initState])
+
+  const updateLocationFeeForUpdatingAntenna = () => {
+    const feeData = calculateAssertLocFee(undefined, undefined, undefined)
+    const feeDc = new Balance(feeData.fee, CurrencyType.dataCredit)
+    setLocationFee(
+      feeDc.toString(0, {
+        groupSeparator,
+        decimalSeparator,
+      }),
+    )
+  }
+
   const toggleUpdateAntenna = () => {
     animateTransition('UpdateHotspotConfig.ToggleUpdateAntenna', {
       enabledOnAndroid: false,
@@ -97,14 +131,7 @@ const UpdateHotspotConfig = ({ onClose, onCloseSettings, hotspot }: Props) => {
     animateTransition('UpdateHotspotConfig.OnConfirm', {
       enabledOnAndroid: false,
     })
-    const feeData = calculateAssertLocFee(undefined, undefined, undefined)
-    const feeDc = new Balance(feeData.fee, CurrencyType.dataCredit)
-    setLocationFee(
-      feeDc.toString(0, {
-        groupSeparator,
-        decimalSeparator,
-      }),
-    )
+    updateLocationFeeForUpdatingAntenna()
     setState('confirm')
   }
   const updatingAntenna = useMemo(() => state === 'antenna', [state])
@@ -418,6 +445,8 @@ const UpdateHotspotConfig = ({ onClose, onCloseSettings, hotspot }: Props) => {
               onGainUpdated={setGain}
               onElevationUpdated={setElevation}
               selectedAntenna={antenna}
+              gain={gain}
+              elevation={elevation}
             />
             <Button
               title={t('hotspot_settings.reassert.update_antenna')}
diff --git a/src/features/wallet/scan/ScanView.tsx b/src/features/wallet/scan/ScanView.tsx
index 944821c5..95784272 100644
--- a/src/features/wallet/scan/ScanView.tsx
+++ b/src/features/wallet/scan/ScanView.tsx
@@ -24,6 +24,7 @@ import {
   useAppLinkContext,
 } from '../../../providers/AppLinkProvider'
 import {
+  AppLinkAntenna,
   AppLinkCategoryType,
   AppLinkLocation,
 } from '../../../providers/appLinkTypes'
@@ -67,8 +68,14 @@ const ScanView = ({ scanType = 'payment', showBottomSheet = true }: Props) => {
 
     try {
       await handleBarCode(result, scanType, undefined, (scanResult) => {
-        if (scanResult.type === 'hotspot_location') {
-          const { hotspotAddress } = scanResult as AppLinkLocation
+        const shouldAssertHotspotOwnership = [
+          'hotspot_location',
+          'hotspot_antenna',
+        ].includes(scanResult.type)
+        if (shouldAssertHotspotOwnership) {
+          const { hotspotAddress } = scanResult as
+            | AppLinkLocation
+            | AppLinkAntenna
           const hotspot = hotspots.find((h) => h.address === hotspotAddress)
           if (!hotspot) throw new InvalidAddressError()
         }
@@ -77,7 +84,7 @@ const ScanView = ({ scanType = 'payment', showBottomSheet = true }: Props) => {
       setScanned(true)
       triggerNotification('success')
     } catch (error) {
-      handleFailedScan(error)
+      handleFailedScan(error as Error)
     }
   }
 
diff --git a/src/features/wallet/send/SendScreen.tsx b/src/features/wallet/send/SendScreen.tsx
index 30d35b58..0993266f 100644
--- a/src/features/wallet/send/SendScreen.tsx
+++ b/src/features/wallet/send/SendScreen.tsx
@@ -22,9 +22,15 @@ const SendScreen = ({ route }: Props) => {
   const rootNavigation = useNavigation<RootNavigationProp>()
   const tabNavigation = useNavigation<MainTabNavigationProp>()
   const scanResult = route?.params?.scanResult
-  const hotspotAddress = route?.params?.hotspotAddress
-  const isSeller = route?.params?.isSeller
   const isPinVerified = route?.params?.pinVerified
+
+  let { hotspotAddress, isSeller, type } = route?.params ?? {}
+  if (scanResult?.hotspotAddress) {
+    hotspotAddress = scanResult.hotspotAddress as string
+  }
+  if (scanResult?.isSeller) isSeller = scanResult.isSeller as boolean
+  if (scanResult?.type) type = scanResult.type
+
   const isPinRequiredForPayment = useSelector(
     (state: RootState) => state.app.isPinRequiredForPayment,
   )
@@ -34,8 +40,9 @@ const SendScreen = ({ route }: Props) => {
   const permanentPaymentAddress = useSelector(
     (state: RootState) => state.app.permanentPaymentAddress,
   )
+
   // If "Deploy Mode" is enabled, only allow payment transactions
-  const type = isDeployModeEnabled ? 'payment' : route?.params?.type
+  if (isDeployModeEnabled) type = 'payment'
   // If "Deploy Mode" is enabled without a permanent payment address, disable all payments
   const isDeployModePaymentsDisabled =
     isDeployModeEnabled && !permanentPaymentAddress
diff --git a/src/features/wallet/send/SendView.tsx b/src/features/wallet/send/SendView.tsx
index 1f83e94e..86db5861 100644
--- a/src/features/wallet/send/SendView.tsx
+++ b/src/features/wallet/send/SendView.tsx
@@ -62,6 +62,7 @@ import {
   AppLink,
   AppLinkPayment,
   AppLinkCategoryType,
+  AppLinkTransfer,
 } from '../../../providers/appLinkTypes'
 import { MainTabNavigationProp } from '../../../navigation/main/tabTypes'
 import { isDataOnly } from '../../../utils/hotspotUtils'
@@ -160,7 +161,9 @@ const SendView = ({
   useAsync(async () => {
     if (type === 'transfer' && hotspotAddress && blockHeight) {
       const gateway = await getHotspotDetails(hotspotAddress)
-      if (isDataOnly(gateway)) {
+      const canSkipActivityCheck =
+        isDataOnly(gateway) || scanResult?.skipActivityCheck
+      if (canSkipActivityCheck) {
         setLastReportedActivity('')
         setHasValidActivity(true)
         setStalePocBlockCount(0)
@@ -237,6 +240,11 @@ const SendView = ({
     ): scanRes is AppLinkPayment => {
       return scanRes.type === 'payment' && scanRes.payees !== undefined
     }
+    const isAppLinkTransfer = (
+      scanRes: AppLink | AppLinkPayment | AppLinkTransfer,
+    ): scanRes is AppLinkTransfer => {
+      return scanRes.type === 'transfer'
+    }
     if (isAppLinkPayment(scanResult)) {
       scannedSendDetails = scanResult.payees.map(
         ({ address, amount: scanAmount, memo = '' }, i) => {
@@ -259,7 +267,10 @@ const SendView = ({
       scannedSendDetails = [
         {
           id: 'transfer0',
-          address: scanResult.address,
+          address:
+            isAppLinkTransfer(scanResult) && scanResult.newOwnerAddress
+              ? scanResult.newOwnerAddress
+              : scanResult.address,
           addressAlias: '',
           addressLoading: false,
           amount,
diff --git a/src/navigation/navigator.ts b/src/navigation/navigator.ts
index 52e6805b..83b402b6 100644
--- a/src/navigation/navigator.ts
+++ b/src/navigation/navigator.ts
@@ -1,9 +1,11 @@
 import React from 'react'
 import { NavigationContainerRef } from '@react-navigation/native'
+import { HotspotStackParamList } from 'src/features/hotspots/root/hotspotTypes'
 import { LockScreenRequestType } from './main/tabTypes'
 import {
   AppLink,
   AppLinkPayment,
+  AppLinkTransfer,
   LinkWalletRequest,
   SignHotspotRequest,
 } from '../providers/appLinkTypes'
@@ -17,7 +19,9 @@ const lock = (params: {
   navigationRef.current?.navigate('LockScreen', params)
 }
 
-const send = (params: { scanResult: AppLink | AppLinkPayment }) => {
+const send = (params: {
+  scanResult: AppLink | AppLinkPayment | AppLinkTransfer
+}) => {
   navigationRef.current?.navigate('Send', params)
 }
 
@@ -42,6 +46,12 @@ const updateHotspotLocation = (params: {
   navigationRef.current?.navigate('HotspotLocationUpdateScreen', params)
 }
 
+const updateHotspotAntenna = (
+  params: HotspotStackParamList['HotspotAntennaUpdateScreen'],
+) => {
+  navigationRef.current?.navigate('HotspotAntennaUpdateScreen', params)
+}
+
 const confirmAddGateway = (addGatewayTxn: string) => {
   const params = {
     addGatewayTxn,
@@ -70,4 +80,5 @@ export default {
   updateHotspotLocation,
   linkWallet,
   signHotspot,
+  updateHotspotAntenna,
 }
diff --git a/src/providers/AppLinkProvider.tsx b/src/providers/AppLinkProvider.tsx
index f154fd17..ba84f89a 100644
--- a/src/providers/AppLinkProvider.tsx
+++ b/src/providers/AppLinkProvider.tsx
@@ -22,8 +22,9 @@ import {
   AppLinkCategories,
   AppLinkCategoryType,
   AppLinkPayment,
-  Payee,
   AppLinkLocation,
+  AppLinkTransfer,
+  AppLinkAntenna,
   LinkWalletRequest,
   SignHotspotRequest,
 } from './appLinkTypes'
@@ -76,6 +77,152 @@ const assertCurrentSenderAddress = async (senderAddress: string) => {
     throw new MismatchedAddressError(AddressType.SenderAddress)
   }
 }
+async function assertPaymentAddresses(data: AppLinkPayment) {
+  if (data.senderAddress) {
+    // If a senderAddress is provided, ensure that it's both a valid wallet address and that
+    // it matches the current wallet address
+    assertValidAddress(data.senderAddress, AddressType.SenderAddress)
+    await assertCurrentSenderAddress(data.senderAddress)
+  }
+  if (data.payees?.length > 0) {
+    data.payees.forEach(({ address }) =>
+      assertValidAddress(address, AddressType.ReceiverAddress),
+    )
+  }
+}
+
+// ScanDataType describes both the scanned data format as well as intended use.
+// For example, multiple types are intended to pre-fill the payment "send" form but can provide
+// varying levels of information (like single or multiple recipients, optional memo fields, etc).
+enum ScanDataType {
+  // Deeplink to somewhere in the app
+  DEEPLINK,
+  // Hotspot address update
+  LOCATION_UPDATE,
+  // DC burn
+  DC_BURN,
+  // Hotspot transfer
+  TRANSFER,
+  // Hotspot transfer with only address provided
+  TRANSFER_ADDRESS_ONLY,
+  // Payment
+  PAYMENT,
+  // Payment with only address provided
+  PAYMENT_ADDRESS_ONLY,
+  // Payment to multiple recipients
+  PAYMENT_MULTI,
+  // Payment to multiple recipients and optional memos
+  PAYMENT_MULTI_MEMO,
+  // Assert the gain/elevation of a hotspot's antenna
+  ANTENNA_GAIN_ASSERT,
+}
+
+function isDeeplink(data: string) {
+  try {
+    const parsed = queryString.parseUrl(data)
+    return (
+      parsed.url.includes(APP_LINK_PROTOCOL) &&
+      parsed.url.includes(UNIVERSAL_LINK_BASE) &&
+      parsed.url.includes(UNIVERSAL_LINK_WWW_BASE)
+    )
+  } catch (err) {}
+}
+
+function isLocationUpdate(data: string) {
+  try {
+    const dataObj = JSON.parse(data)
+    return dataObj.lat && dataObj.lng && dataObj.address
+  } catch (err) {}
+}
+
+function isDcBurn(data: string, scanType?: AppLinkCategoryType) {
+  try {
+    const dataObj = JSON.parse(data)
+    const type = dataObj.type || scanType
+    return type === 'dc_burn' && dataObj.address
+  } catch (err) {}
+}
+
+function isTransfer(data: string, scanType?: AppLinkCategoryType) {
+  try {
+    const dataObj = JSON.parse(data)
+    const type = dataObj.type || scanType
+    return type === 'transfer' && dataObj.newOwnerAddress
+  } catch (err) {}
+}
+
+function isTransferAddressOnly(data: string, scanType?: AppLinkCategoryType) {
+  return scanType === 'transfer' && Address.isValid(data)
+}
+
+function isPayment(data: string, scanType?: AppLinkCategoryType) {
+  try {
+    const dataObj = JSON.parse(data)
+    const type = dataObj.type || scanType
+    return type === 'payment' && dataObj.address
+  } catch (err) {}
+}
+
+function isPaymentAddressOnly(data: string, scanType?: AppLinkCategoryType) {
+  return scanType === 'payment' && Address.isValid(data)
+}
+
+function isPaymentMulti(data: string, scanType?: AppLinkCategoryType) {
+  // data = { payees: { [payeeAddress]: amount } }
+  type Payees = Record<string, number>
+
+  try {
+    const dataObj = JSON.parse(data)
+    const type = dataObj.type || scanType
+    return (
+      type === 'payment' &&
+      dataObj.payees &&
+      typeof Object.values(dataObj.payees as Payees)[0] === 'number'
+    )
+  } catch (err) {}
+}
+
+function isPaymentMultiMemo(data: string, scanType?: AppLinkCategoryType) {
+  // data = { payees: { [payeeAddress]: { amount: number, memo?: string } } }
+  type Payees = Record<string, { amount: number; memo?: string }>
+
+  try {
+    const dataObj = JSON.parse(data)
+    const type = dataObj.type || scanType
+    return (
+      type === 'payment' &&
+      dataObj.payees &&
+      typeof Object.values(dataObj.payees as Payees)[0]?.amount === 'number'
+    )
+  } catch (err) {}
+}
+
+function isAntennaGainAssert(data: string, scanType?: AppLinkCategoryType) {
+  try {
+    const dataObj = JSON.parse(data)
+    const type = dataObj.type || scanType
+    return type === 'hotspot_antenna'
+  } catch (err) {}
+}
+
+function getDataScanType(
+  data: string,
+  scanType?: AppLinkCategoryType,
+): ScanDataType | undefined {
+  if (isDeeplink(data)) return ScanDataType.DEEPLINK
+  if (isLocationUpdate(data)) return ScanDataType.LOCATION_UPDATE
+  if (isDcBurn(data, scanType)) return ScanDataType.DC_BURN
+  if (isTransfer(data, scanType)) return ScanDataType.TRANSFER
+  if (isTransferAddressOnly(data, scanType))
+    return ScanDataType.TRANSFER_ADDRESS_ONLY
+  if (isPayment(data, scanType)) return ScanDataType.PAYMENT
+  if (isPaymentAddressOnly(data, scanType))
+    return ScanDataType.PAYMENT_ADDRESS_ONLY
+  if (isPaymentMulti(data, scanType)) return ScanDataType.PAYMENT_MULTI
+  if (isPaymentMultiMemo(data, scanType)) return ScanDataType.PAYMENT_MULTI_MEMO
+  if (isAntennaGainAssert(data, scanType))
+    return ScanDataType.ANTENNA_GAIN_ASSERT
+}
 
 export const createAppLink = (
   resource: AppLinkCategoryType,
@@ -117,6 +264,8 @@ const useAppLink = () => {
         | AppLink
         | AppLinkPayment
         | AppLinkLocation
+        | AppLinkAntenna
+        | AppLinkTransfer
         | LinkWalletRequest
         | SignHotspotRequest,
     ) => {
@@ -137,7 +286,9 @@ const useAppLink = () => {
         case 'dc_burn':
         case 'payment':
         case 'transfer':
-          navigator.send({ scanResult: record as AppLink | AppLinkPayment })
+          navigator.send({
+            scanResult: record as AppLink | AppLinkPayment | AppLinkTransfer,
+          })
           break
 
         case 'add_gateway': {
@@ -166,6 +317,15 @@ const useAppLink = () => {
         case 'sign_hotspot':
           navigator.signHotspot(record as SignHotspotRequest)
           break
+        case 'hotspot_antenna': {
+          const { hotspotAddress, gain, elevation } = record as AppLinkAntenna
+          navigator.updateHotspotAntenna({
+            hotspotAddress,
+            gain,
+            elevation,
+          })
+          break
+        }
       }
     },
     [isLocked, isBackedUp],
@@ -229,123 +389,146 @@ const useAppLink = () => {
     } catch (err) {}
   }
 
-  /**
-   * The data scanned from the QR code is expected to be one of these possibilities:
-   * (1) A helium deeplink URL
-   * (2) A lat/lng pair + hotspot address for hotspot location updates
-   * (3) address string
-   * (4) stringified JSON object { type, senderAddress?, address, amount?, memo? }
-   * (5) stringified JSON object { type, senderAddress?, payees: {[payeeAddress]: amount} }
-   * (6) stringified JSON object { type, senderAddress?, payees: {[payeeAddress]: { amount, memo? }} }
-   */
   const parseBarCodeData = useCallback(
     async (
       data: string,
       scanType: AppLinkCategoryType,
-    ): Promise<AppLink | AppLinkPayment | AppLinkLocation> => {
-      // Case (1) helium deeplink URL
-      const urlParams = parseUrl(data)
-      if (urlParams) {
-        return urlParams
+    ): Promise<
+      | AppLink
+      | AppLinkPayment
+      | AppLinkLocation
+      | AppLinkAntenna
+      | AppLinkTransfer
+    > => {
+      if (!data) throw new Error('Missing required data')
+      const scanDataType = getDataScanType(data, scanType)
+
+      if (scanDataType === ScanDataType.DEEPLINK) {
+        return parseUrl(data) as AppLink
       }
 
-      // Case (2) lat/lng pair
-      const location = parseLocation(data)
-      if (location) {
-        assertValidAddress(location.hotspotAddress)
+      if (scanDataType === ScanDataType.LOCATION_UPDATE) {
+        const location = parseLocation(data) as AppLinkLocation
+        assertValidAddress(location.hotspotAddress, AddressType.HotspotAddress)
         return location
       }
 
-      // Case (3) address string
-      if (Address.isValid(data)) {
-        if (scanType === 'transfer') {
-          return {
-            type: scanType,
-            address: data,
-          }
-        }
-        return {
-          type: scanType,
-          payees: [{ address: data }],
-        }
-      }
-
-      const rawScanResult = JSON.parse(data)
-      const type = rawScanResult.type || scanType
-
-      if (type === 'dc_burn') {
-        // Case (4) stringified JSON { type, address, amount?, memo? }
+      if (scanDataType === ScanDataType.DC_BURN) {
+        const rawScanResult = JSON.parse(data)
         const scanResult: AppLink = {
-          type,
+          type: 'dc_burn',
           address: rawScanResult.address,
           amount: rawScanResult.amount,
           memo: rawScanResult.memo,
         }
+        // TODO: Validate sender ownership?
         assertValidAddress(scanResult.address, AddressType.SenderAddress)
         return scanResult
       }
 
-      if (type === 'payment') {
-        let scanResult: AppLinkPayment
-        if (rawScanResult.address) {
-          // Case (4) stringified JSON { type, senderAddress?, address, amount?, memo? }
-          scanResult = {
-            type,
-            senderAddress: rawScanResult.senderAddress,
-            payees: [
-              {
-                address: rawScanResult.address,
-                amount: rawScanResult.amount,
-                memo: rawScanResult.memo,
-              },
-            ],
-          }
-        } else if (rawScanResult.payees) {
-          scanResult = {
-            type,
-            senderAddress: rawScanResult.senderAddress,
-            payees: Object.entries(rawScanResult.payees).map((entries) => {
-              let amount
-              let memo
-              if (entries[1]) {
-                if (typeof entries[1] === 'number') {
-                  // Case (5) stringified JSON object { type, senderAddress?, payees: {[payeeAddress]: amount} }
-                  amount = entries[1] as number
-                } else if (typeof entries[1] === 'object') {
-                  // Case (6) stringified JSON object { type, senderAddress?, payees: {[payeeAddress]: { amount, memo? }} }
-                  const scanData = entries[1] as {
-                    amount: string
-                    memo?: string
-                  }
-                  amount = scanData.amount
-                  memo = scanData.memo
-                }
-              }
-              return {
-                address: entries[0],
-                amount: `${amount}`,
-                memo,
-              } as Payee
-            }),
-          }
-        } else {
-          throw new Error('Unrecognized payload for payment scan')
+      if (scanDataType === ScanDataType.TRANSFER) {
+        const rawScanResult = JSON.parse(data)
+        const scanResult: AppLinkTransfer = {
+          type: 'transfer',
+          newOwnerAddress: rawScanResult.newOwnerAddress,
+          hotspotAddress: rawScanResult.hotspotAddress,
+          skipActivityCheck: rawScanResult.skipActivityCheck,
+          isSeller: rawScanResult.isSeller,
         }
-
-        if (scanResult.senderAddress) {
-          // If a senderAddress is provided, ensure that it's both a valid wallet address and that
-          // it matches the current wallet address
+        // TODO: Validate sender ownership?
+        assertValidAddress(
+          scanResult.newOwnerAddress,
+          AddressType.ReceiverAddress,
+        )
+        if (scanResult.hotspotAddress) {
           assertValidAddress(
-            scanResult.senderAddress,
-            AddressType.SenderAddress,
+            scanResult.hotspotAddress,
+            AddressType.HotspotAddress,
           )
-          await assertCurrentSenderAddress(scanResult.senderAddress)
         }
-        scanResult.payees.forEach(({ address }) =>
-          assertValidAddress(address, AddressType.ReceiverAddress),
+        return scanResult
+      }
+
+      if (scanDataType === ScanDataType.TRANSFER_ADDRESS_ONLY) {
+        const scanResult: AppLinkTransfer = {
+          type: 'transfer',
+          newOwnerAddress: data,
+        }
+        // TODO: Validate sender ownership?
+        assertValidAddress(
+          scanResult.newOwnerAddress,
+          AddressType.ReceiverAddress,
         )
         return scanResult
       }
+
+      if (scanDataType === ScanDataType.PAYMENT) {
+        const rawScanResult = JSON.parse(data)
+        const scanResult: AppLinkPayment = {
+          type: 'payment',
+          senderAddress: rawScanResult.senderAddress,
+          payees: [
+            {
+              address: rawScanResult.address,
+              amount: rawScanResult.amount,
+              memo: rawScanResult.memo,
+            },
+          ],
+        }
+        await assertPaymentAddresses(scanResult)
+        return scanResult
+      }
+
+      if (scanDataType === ScanDataType.PAYMENT_ADDRESS_ONLY) {
+        const scanResult: AppLinkPayment = {
+          type: scanType,
+          payees: [{ address: data }],
+        }
+        await assertPaymentAddresses(scanResult)
+        return scanResult
+      }
+
+      if (scanDataType === ScanDataType.PAYMENT_MULTI) {
+        const rawScanResult = JSON.parse(data)
+        const scanResult: AppLinkPayment = {
+          type: 'payment',
+          senderAddress: rawScanResult.senderAddress,
+          payees: Object.entries(rawScanResult.payees).map((entries) => ({
+            address: entries[0],
+            amount: entries[1] as number,
+          })),
+        }
+        await assertPaymentAddresses(scanResult)
+        return scanResult
+      }
+
+      if (scanDataType === ScanDataType.PAYMENT_MULTI_MEMO) {
+        const rawScanResult = JSON.parse(data)
+        const scanResult: AppLinkPayment = {
+          type: 'payment',
+          senderAddress: rawScanResult.senderAddress,
+          payees: Object.entries(rawScanResult.payees).map((entries) => ({
+            address: entries[0],
+            amount: (entries[1] as { amount?: number; memo?: string }).amount,
+            memo: (entries[1] as { amount?: number; memo?: string }).memo,
+          })),
+        }
+        await assertPaymentAddresses(scanResult)
+        return scanResult
+      }
+
+      if (scanDataType === ScanDataType.ANTENNA_GAIN_ASSERT) {
+        const rawScanResult = JSON.parse(data)
+        const scanResult: AppLinkAntenna = {
+          type: 'hotspot_antenna',
+          hotspotAddress: rawScanResult.hotspotAddress,
+          gain: rawScanResult.gain,
+          elevation: rawScanResult.elevation,
+        }
+        assertValidAddress(scanResult.hotspotAddress)
+        return scanResult
+      }
+
       throw new Error('Unknown scan type')
     },
     [parseUrl],
@@ -357,7 +540,12 @@ const useAppLink = () => {
       scanType: AppLinkCategoryType,
       opts?: Record<string, string>,
       assertScanResult?: (
-        scanResult: AppLink | AppLinkPayment | AppLinkLocation,
+        scanResult:
+          | AppLink
+          | AppLinkPayment
+          | AppLinkLocation
+          | AppLinkAntenna
+          | AppLinkTransfer,
       ) => void,
     ) => {
       const scanResult = await parseBarCodeData(data, scanType)
diff --git a/src/providers/appLinkTypes.ts b/src/providers/appLinkTypes.ts
index 0f56b3c0..83566034 100644
--- a/src/providers/appLinkTypes.ts
+++ b/src/providers/appLinkTypes.ts
@@ -13,6 +13,7 @@ export const AppLinkCategories = [
   'hotspot_location',
   'link_wallet',
   'sign_hotspot',
+  'hotspot_antenna',
 ] as const
 export type AppLinkCategoryType = typeof AppLinkCategories[number]
 
@@ -23,7 +24,15 @@ export type AppLink = {
   address: string
   amount?: string | number
   memo?: string
-  [key: string]: string | number | undefined
+  [key: string]: string | number | boolean | undefined
+}
+
+export type AppLinkTransfer = {
+  type: 'transfer'
+  newOwnerAddress: string
+  hotspotAddress?: string
+  skipActivityCheck?: boolean
+  isSeller?: boolean
 }
 
 export type AppLinkPayment = {
@@ -53,3 +62,10 @@ export type LinkWalletRequest = {
 export type SignHotspotRequest = {
   type: AppLinkCategoryType
 } & Sign
+
+export type AppLinkAntenna = {
+  type: AppLinkCategoryType
+  hotspotAddress: string
+  gain: number
+  elevation?: number
+}