Some fixes for xeddsa pr (#9610)

* fix: add null check for getMeshNode() in NodeInfoModule

getMeshNode() can return nullptr for unknown nodes. Dereferencing
without a check crashes the firmware when receiving NodeInfo from
a node not yet in the database.

* fix: enforce XEdDSA signature verification and prevent stripping

Previously, failed signature verification still allowed the packet
through, making signatures purely cosmetic. Now:

- Failed verification drops the packet (DECODE_FAILURE)
- Successfully verified nodes get HAS_XEDDSA_SIGNED bitfield set
- Unsigned packets from previously-signing nodes are rejected
- Log levels reduced from WARN/ERROR to DEBUG/WARN as appropriate

* fix: include packet metadata in XEdDSA signature

The signature now covers [fromNode | packetId | portnum | payload]
instead of just the payload bytes. This prevents:
- Replay attacks (different packetId fails verification)
- Reattribution (different fromNode fails verification)
- Portnum redirection (different portnum fails verification)

Also adds a key initialization check to xeddsa_sign (returns false
if XEdDSA keys are all zeros) and checks the return value in the
encode path.

* fix: handle existing key pair in AdminModule security config

When a user provides both a valid private key and public key via
admin config, the crypto engine's DH private key and owner public
key were never loaded. DMs and XEdDSA signing would silently break.

Add an else branch to load both keys into the crypto engine.

* perf: cache Ed25519 public key conversion in xeddsa_verify

curve_to_ed_pub() performs field element parsing, inversion, and
multiplication on every call. Since packets from the same node
tend to arrive in bursts, a single-entry cache avoids repeating
this expensive conversion for consecutive packets from one sender.

* fix: skip identity cleanup when node number is unchanged

createNewIdentity() was called on every generateCryptoKeyPair(),
including normal boots where the same key is regenerated. This
caused unnecessary NodeDB writes and old-node cleanup logic to
run when the node number hadn't actually changed.

Also fixes only zeroing byte[0] of the old node's public key
instead of clearing the entire array.

* fix: replace hardcoded 120 with derived XEDDSA_SIGNATURE_SIZE constant

The payload size check for XEdDSA signing used a magic number (120).
Replace with a derivation from DATA_PAYLOAD_LEN and XEDDSA_SIGNATURE_SIZE
so the limit adjusts automatically if constants change. This also
increases the max signable payload from 120 to 169 bytes, which is
still safe since the actual encoded size is checked after pb_encode.

* fix: add const qualifiers to XEdDSA verify and curve_to_ed_pub inputs

pubKey, payload, and signature parameters in xeddsa_verify are
input-only and should not be modified. Same for curve_pubkey in
curve_to_ed_pub.

* chore: remove commented-out old Crypto dependency in portduino.ini

* Leave out the admin module change for now

---------

Co-authored-by: Jonathan Bennett <jbennett@incomsystems.biz>

.github/workflows/build_one_arch.yml

@@ -1,176 +0,0 @@
-name: Build One Arch
-
-on:
-  workflow_dispatch:
-    inputs:
-      # trunk-ignore(checkov/CKV_GHA_7)
-      arch:
-        type: choice
-        options:
-          - esp32
-          - esp32s3
-          - esp32c3
-          - esp32c6
-          - nrf52840
-          - rp2040
-          - rp2350
-          - stm32
-          - native
-
-permissions: read-all
-
-env:
-  INPUT_ARCH: ${{ github.event.inputs.arch }}
-
-jobs:
-  setup:
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-python@v6
-        with:
-          python-version: 3.x
-          cache: pip
-      - run: pip install -U platformio
-      - name: Generate matrix
-        id: jsonStep
-        run: |
-          TARGETS=$(./bin/generate_ci_matrix.py $INPUT_ARCH --level extra)
-          echo "Name: $GITHUB_REF_NAME Base: $GITHUB_BASE_REF Ref: $GITHUB_REF"
-          echo "selected_arch=$TARGETS" >> $GITHUB_OUTPUT
-    outputs:
-      selected_arch: ${{ steps.jsonStep.outputs.selected_arch }}
-
-  version:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - name: Get release version string
-        run: |
-          echo "long=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
-          echo "deb=$(./bin/buildinfo.py deb)" >> $GITHUB_OUTPUT
-        id: version
-        env:
-          BUILD_LOCATION: local
-    outputs:
-      long: ${{ steps.version.outputs.long }}
-      deb: ${{ steps.version.outputs.deb }}
-
-  build:
-    if: ${{ github.event_name != 'workflow_dispatch' }}
-    needs: [setup, version]
-    strategy:
-      fail-fast: false
-      matrix:
-        build: ${{ fromJson(needs.setup.outputs.selected_arch) }}
-    uses: ./.github/workflows/build_firmware.yml
-    with:
-      version: ${{ needs.version.outputs.long }}
-      pio_env: ${{ matrix.build.board }}
-      platform: ${{ matrix.build.arch }}
-
-  build-debian-src:
-    if: ${{ github.repository == 'meshtastic/firmware' && github.event_name != 'workflow_dispatch' || inputs.arch == 'native' }}
-    uses: ./.github/workflows/build_debian_src.yml
-    with:
-      series: UNRELEASED
-      build_location: local
-    secrets: inherit
-
-  package-pio-deps-native-tft:
-    if: ${{ inputs.arch == 'native' }}
-    uses: ./.github/workflows/package_pio_deps.yml
-    with:
-      pio_env: native-tft
-    secrets: inherit
-
-  test-native:
-    if: ${{ !contains(github.ref_name, 'event/') && github.event_name != 'workflow_dispatch' ||  !contains(github.ref_name, 'event/') && inputs.arch == 'native' }}
-    uses: ./.github/workflows/test_native.yml
-
-  gather-artifacts:
-    permissions:
-      contents: write
-      pull-requests: write
-    strategy:
-      fail-fast: false
-      matrix:
-        arch:
-          - esp32
-          - esp32s3
-          - esp32c3
-          - esp32c6
-          - nrf52840
-          - rp2040
-          - rp2350
-          - stm32
-    runs-on: ubuntu-latest
-    needs: [version, build]
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v6
-        with:
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}
-
-      - uses: actions/download-artifact@v6
-        with:
-          path: ./
-          pattern: firmware-${{inputs.arch}}-*
-          merge-multiple: true
-
-      - name: Display structure of downloaded files
-        run: ls -R
-
-      - name: Move files up
-        run: mv -b -t ./ ./bin/device-*.sh ./bin/device-*.bat
-
-      - name: Repackage in single firmware zip
-        uses: actions/upload-artifact@v5
-        with:
-          name: firmware-${{inputs.arch}}-${{ needs.version.outputs.long }}
-          overwrite: true
-          path: |
-            ./firmware-*.bin
-            ./firmware-*.uf2
-            ./firmware-*.hex
-            ./firmware-*-ota.zip
-            ./device-*.sh
-            ./device-*.bat
-            ./littlefs-*.bin
-            ./bleota*bin
-            ./Meshtastic_nRF52_factory_erase*.uf2
-          retention-days: 30
-
-      - uses: actions/download-artifact@v6
-        with:
-          name: firmware-${{inputs.arch}}-${{ needs.version.outputs.long }}
-          merge-multiple: true
-          path: ./output
-
-      # For diagnostics
-      - name: Show artifacts
-        run: ls -lR
-
-      - name: Device scripts permissions
-        run: |
-          chmod +x ./output/device-install.sh
-          chmod +x ./output/device-update.sh
-
-      - name: Zip firmware
-        run: zip -j -9 -r ./firmware-${{inputs.arch}}-${{ needs.version.outputs.long }}.zip ./output
-
-      - name: Repackage in single elfs zip
-        uses: actions/upload-artifact@v5
-        with:
-          name: debug-elfs-${{inputs.arch}}-${{ needs.version.outputs.long }}.zip
-          overwrite: true
-          path: ./*.elf
-          retention-days: 30
-
-      - uses: scruplelesswizard/comment-artifact@main
-        if: ${{ github.event_name == 'pull_request' }}
-        with:
-          name: firmware-${{inputs.arch}}-${{ needs.version.outputs.long }}
-          description: "Download firmware-${{inputs.arch}}-${{ needs.version.outputs.long }}.zip. This artifact will be available for 90 days from creation"
-          github-token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/build_one_target.yml

@@ -15,7 +15,6 @@ on:
           - rp2040
           - rp2350
           - stm32
-          - native
       target:
         type: string
         required: false
@@ -42,7 +41,6 @@ jobs:
           - rp2040
           - rp2350
           - stm32
-
     runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v6
@@ -60,7 +58,7 @@ jobs:
           echo "Arch: ${{matrix.arch}}" >> $GITHUB_STEP_SUMMARY
           echo "Ref: $GITHUB_REF" >> $GITHUB_STEP_SUMMARY
           echo "Targets:" >> $GITHUB_STEP_SUMMARY
-          echo $TARGETS >> $GITHUB_STEP_SUMMARY
+          echo $TARGETS | jq -r 'sort_by(.board) |.[] | "- " + .board' >> $GITHUB_STEP_SUMMARY
 
   version:
     if: ${{ inputs.target != '' }}
@@ -87,25 +85,6 @@ jobs:
       pio_env: ${{ inputs.target }}
       platform: ${{ inputs.arch }}
 
-  build-debian-src:
-    if: ${{ github.repository == 'meshtastic/firmware' && inputs.arch == 'native' }}
-    uses: ./.github/workflows/build_debian_src.yml
-    with:
-      series: UNRELEASED
-      build_location: local
-    secrets: inherit
-
-  package-pio-deps-native-tft:
-    if: ${{ inputs.arch == 'native' }}
-    uses: ./.github/workflows/package_pio_deps.yml
-    with:
-      pio_env: native-tft
-    secrets: inherit
-
-  test-native:
-    if: ${{ !contains(github.ref_name, 'event/') && github.event_name != 'workflow_dispatch' ||  !contains(github.ref_name, 'event/') && inputs.arch == 'native' && inputs.target != '' }}
-    uses: ./.github/workflows/test_native.yml
-
   gather-artifacts:
     permissions:
       contents: write

.trunk/trunk.yaml

@@ -4,31 +4,31 @@ cli:
 plugins:
   sources:
     - id: trunk
-      ref: v1.7.3
+      ref: v1.7.4
       uri: https://github.com/trunk-io/plugins
 lint:
   enabled:
-    - checkov@3.2.492
-    - renovate@42.5.4
+    - checkov@3.2.495
+    - renovate@42.24.1
     - prettier@3.6.2
-    - trufflehog@3.90.13
+    - trufflehog@3.91.1
     - yamllint@1.37.1
-    - bandit@1.8.6
+    - bandit@1.9.2
     - trivy@0.67.2
     - taplo@0.10.0
-    - ruff@0.14.4
+    - ruff@0.14.6
     - isort@7.0.0
-    - markdownlint@0.45.0
+    - markdownlint@0.46.0
     - oxipng@9.1.5
     - svgo@4.0.0
-    - actionlint@1.7.8
+    - actionlint@1.7.9
     - flake8@7.3.0
     - hadolint@2.14.0
     - shfmt@3.6.0
     - shellcheck@0.11.0
     - black@25.11.0
     - git-diff-check
-    - gitleaks@8.29.0
+    - gitleaks@8.30.0
     - clang-format@16.0.3
   ignore:
     - linters: [ALL]

arch/esp32/esp32.ini

@@ -61,7 +61,7 @@ lib_deps =
   # renovate: datasource=git-refs depName=meshtastic-ESP32_Codec2 packageName=https://github.com/meshtastic/ESP32_Codec2 gitBranch=master
   https://github.com/meshtastic/ESP32_Codec2/archive/633326c78ac251c059ab3a8c430fcdf25b41672f.zip
   # renovate: datasource=custom.pio depName=rweather/Crypto packageName=rweather/library/Crypto
-  rweather/Crypto@0.4.0
+  https://github.com/meshtastic/Crypto/archive/1aa30eb536bd52a576fde6dfa393bf7349cf102d.zip
 
 lib_ignore = 
   segger_rtt

arch/esp32/esp32c6.ini

@@ -32,7 +32,7 @@ lib_deps =
   # renovate: datasource=git-refs depName=meshtastic-ESP32_Codec2 packageName=https://github.com/meshtastic/ESP32_Codec2 gitBranch=master
   https://github.com/meshtastic/ESP32_Codec2/archive/633326c78ac251c059ab3a8c430fcdf25b41672f.zip
   # renovate: datasource=custom.pio depName=rweather/Crypto packageName=rweather/library/Crypto
-  rweather/Crypto@0.4.0
+  https://github.com/meshtastic/Crypto/archive/1aa30eb536bd52a576fde6dfa393bf7349cf102d.zip
 
 build_src_filter = 
  ${esp32_base.build_src_filter} -<mesh/http> 

arch/nrf52/nrf52.ini

@@ -29,7 +29,7 @@ lib_deps=
   ${arduino_base.lib_deps}
   ${radiolib_base.lib_deps}
   # renovate: datasource=custom.pio depName=rweather/Crypto packageName=rweather/library/Crypto
-  rweather/Crypto@0.4.0
+  https://github.com/meshtastic/Crypto/archive/1aa30eb536bd52a576fde6dfa393bf7349cf102d.zip
 
 lib_ignore =
   BluetoothOTA

arch/portduino/portduino.ini

@@ -24,7 +24,7 @@ lib_deps =
   ${radiolib_base.lib_deps}
   ${environmental_base.lib_deps}
   # renovate: datasource=custom.pio depName=rweather/Crypto packageName=rweather/library/Crypto
-  rweather/Crypto@0.4.0
+  https://github.com/meshtastic/Crypto/archive/1aa30eb536bd52a576fde6dfa393bf7349cf102d.zip
   # renovate: datasource=custom.pio depName=LovyanGFX packageName=lovyan03/library/LovyanGFX
   lovyan03/LovyanGFX@^1.2.0
   # renovate: datasource=git-refs depName=libch341-spi-userspace packageName=https://github.com/pine64/libch341-spi-userspace gitBranch=main

arch/rp2xx0/rp2040.ini

@@ -31,4 +31,4 @@ lib_deps =
   ${environmental_extra.lib_deps}
   ${radiolib_base.lib_deps}
   # renovate: datasource=custom.pio depName=rweather/Crypto packageName=rweather/library/Crypto
-  rweather/Crypto@0.4.0
+  https://github.com/meshtastic/Crypto/archive/1aa30eb536bd52a576fde6dfa393bf7349cf102d.zip

arch/rp2xx0/rp2350.ini

@@ -28,4 +28,4 @@ lib_deps =
   ${environmental_extra.lib_deps}
   ${radiolib_base.lib_deps}
   # renovate: datasource=custom.pio depName=rweather/Crypto packageName=rweather/library/Crypto
-  rweather/Crypto@0.4.0
+  https://github.com/meshtastic/Crypto/archive/1aa30eb536bd52a576fde6dfa393bf7349cf102d.zip

arch/stm32/stm32.ini

@@ -2,7 +2,7 @@
 extends = arduino_base
 platform =
   # renovate: datasource=custom.pio depName=platformio/ststm32 packageName=platformio/platform/ststm32
-  platformio/ststm32@19.3.0
+  platformio/ststm32@19.4.0
 platform_packages =
   # TODO renovate
   platformio/framework-arduinoststm32@https://github.com/stm32duino/Arduino_Core_STM32/archive/2.10.1.zip
@@ -53,7 +53,7 @@ lib_deps =
   ${radiolib_base.lib_deps}
 
   # renovate: datasource=git-refs depName=caveman99-stm32-Crypto packageName=https://github.com/caveman99/Crypto gitBranch=main
-  https://github.com/caveman99/Crypto/archive/1aa30eb536bd52a576fde6dfa393bf7349cf102d.zip
+  https://github.com/meshtastic/Crypto/archive/1aa30eb536bd52a576fde6dfa393bf7349cf102d.zip
 
 lib_ignore =
   OneButton

boards/ThinkNode-M3.json

@@ -0,0 +1,53 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "nrf52840_s140_v6.ld"
+    },
+    "core": "nRF5",
+    "cpu": "cortex-m4",
+    "extra_flags": "-DNRF52840_XXAA",
+    "f_cpu": "64000000L",
+    "hwids": [
+      ["0x239A", "0x4405"],
+      ["0x239A", "0x0029"],
+      ["0x239A", "0x002A"]
+    ],
+    "usb_product": "elecrow_eink",
+    "mcu": "nrf52840",
+    "variant": "ELECROW-ThinkNode-M3",
+    "variants_dir": "variants",
+    "bsp": {
+      "name": "adafruit"
+    },
+    "softdevice": {
+      "sd_flags": "-DS140",
+      "sd_name": "s140",
+      "sd_version": "6.1.1",
+      "sd_fwid": "0x00B6"
+    },
+    "bootloader": {
+      "settings_addr": "0xFF000"
+    }
+  },
+  "connectivity": ["bluetooth"],
+  "debug": {
+    "jlink_device": "nRF52840_xxAA",
+    "onboard_tools": ["jlink"],
+    "svd_path": "nrf52840.svd",
+    "openocd_target": "nrf52840-mdk-rs"
+  },
+  "frameworks": ["arduino"],
+  "name": "elecrow nrf",
+  "upload": {
+    "maximum_ram_size": 248832,
+    "maximum_size": 815104,
+    "speed": 115200,
+    "protocol": "nrfutil",
+    "protocols": ["jlink", "nrfjprog", "nrfutil", "stlink"],
+    "use_1200bps_touch": true,
+    "require_upload_port": true,
+    "wait_for_upload_port": true
+  },
+  "url": "",
+  "vendor": "ELECROW"
+}

boards/hackaday-communicator.json

@@ -0,0 +1,41 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "esp32s3_out.ld",
+      "memory_type": "qio_opi"
+    },
+    "core": "esp32",
+    "extra_flags": [
+      "-DBOARD_HAS_PSRAM",
+      "-DARDUINO_USB_CDC_ON_BOOT=1",
+      "-DARDUINO_USB_MODE=0",
+      "-DARDUINO_RUNNING_CORE=1",
+      "-DARDUINO_EVENT_RUNNING_CORE=1"
+    ],
+    "f_cpu": "240000000L",
+    "f_flash": "80000000L",
+    "flash_mode": "qio",
+    "hwids": [["0x303A", "0x1001"]],
+    "mcu": "esp32s3",
+    "variant": "hackaday-communicator"
+  },
+  "connectivity": ["wifi", "bluetooth", "lora"],
+  "debug": {
+    "default_tool": "esp-builtin",
+    "onboard_tools": ["esp-builtin"],
+    "openocd_target": "esp32s3.cfg"
+  },
+  "frameworks": ["arduino", "espidf"],
+  "name": "hackaday-communicator (16 MB FLASH, 8 MB PSRAM)",
+  "upload": {
+    "flash_size": "16MB",
+    "maximum_ram_size": 327680,
+    "maximum_size": 16777216,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": true,
+    "require_upload_port": true,
+    "speed": 1500000
+  },
+  "url": "hackaday.com",
+  "vendor": "hackaday"
+}

boards/muzi-base.json

@@ -0,0 +1,56 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "nrf52840_s140_v6.ld"
+    },
+    "core": "nRF5",
+    "cpu": "cortex-m4",
+    "extra_flags": "-DARDUINO_NRF52840_MUZI_BASE -DNRF52840_XXAA",
+    "f_cpu": "64000000L",
+    "hwids": [["0x239A", "0xcafe"]],
+    "mcu": "nrf52840",
+    "variant": "muzi-base",
+    "variants_dir": "variants",
+    "bsp": {
+      "name": "adafruit"
+    },
+    "softdevice": {
+      "sd_flags": "-DS140",
+      "sd_name": "s140",
+      "sd_version": "6.1.1",
+      "sd_fwid": "0x00B6"
+    },
+    "bootloader": {
+      "settings_addr": "0xFF000"
+    }
+  },
+  "connectivity": ["bluetooth"],
+  "debug": {
+    "jlink_device": "nRF52840_xxAA",
+    "onboard_tools": ["jlink"],
+    "svd_path": "nrf52840.svd",
+    "openocd_target": "nrf52840-mdk-rs"
+  },
+  "frameworks": ["arduino"],
+  "name": "Muzi Base",
+  "url": "https://muzi.works/",
+  "vendor": "MuziWorks",
+  "upload": {
+    "maximum_ram_size": 248832,
+    "maximum_size": 815104,
+    "speed": 115200,
+    "protocol": "nrfutil",
+    "protocols": [
+      "jlink",
+      "nrfjprog",
+      "nrfutil",
+      "blackmagic",
+      "cmsis-dap",
+      "mbed",
+      "stlink"
+    ],
+    "use_1200bps_touch": true,
+    "require_upload_port": true,
+    "wait_for_upload_port": true
+  }
+}

platformio.ini

@@ -90,7 +90,7 @@ framework = arduino
 lib_deps =
 	${env.lib_deps}
 	# renovate: datasource=custom.pio depName=NonBlockingRTTTL packageName=end2endzone/library/NonBlockingRTTTL
-	end2endzone/NonBlockingRTTTL@1.3.0
+	end2endzone/NonBlockingRTTTL@1.4.0
 build_flags = ${env.build_flags} -Os
 build_src_filter = ${env.build_src_filter} -<platform/portduino/> -<graphics/niche/>
 
@@ -169,7 +169,7 @@ lib_deps =
 	# renovate: datasource=git-refs depName=DFRobot_RainfallSensor packageName=https://github.com/DFRobot/DFRobot_RainfallSensor gitBranch=master
 	https://github.com/DFRobot/DFRobot_RainfallSensor/archive/38fea5e02b40a5430be6dab39a99a6f6347d667e.zip
 	# renovate: datasource=custom.pio depName=INA226 packageName=robtillaart/library/INA226
-	robtillaart/INA226@0.6.4
+	robtillaart/INA226@0.6.5
 	# renovate: datasource=custom.pio depName=SparkFun MAX3010x packageName=sparkfun/library/SparkFun MAX3010x Pulse and Proximity Sensor Library
 	sparkfun/SparkFun MAX3010x Pulse and Proximity Sensor Library@1.1.2
 	# renovate: datasource=custom.pio depName=SparkFun 9DoF IMU Breakout ICM 20948 packageName=sparkfun/library/SparkFun 9DoF IMU Breakout - ICM 20948 - Arduino Library
@@ -213,6 +213,6 @@ lib_deps =
 	# renovate: datasource=git-refs depName=meshtastic-DFRobot_LarkWeatherStation packageName=https://github.com/meshtastic/DFRobot_LarkWeatherStation gitBranch=master
 	https://github.com/meshtastic/DFRobot_LarkWeatherStation/archive/4de3a9cadef0f6a5220a8a906cf9775b02b0040d.zip
 	# renovate: datasource=custom.pio depName=Sensirion Core packageName=sensirion/library/Sensirion Core
-	sensirion/Sensirion Core@0.7.1
+	sensirion/Sensirion Core@0.7.2
 	# renovate: datasource=custom.pio depName=Sensirion I2C SCD4x packageName=sensirion/library/Sensirion I2C SCD4x
 	sensirion/Sensirion I2C SCD4x@1.1.0

src/GPSStatus.h

@@ -53,8 +53,8 @@ class GPSStatus : public Status
     int32_t getLatitude() const
     {
         if (config.position.fixed_position) {
-            meshtastic_NodeDetail *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
-            return node ? node->latitude_i : 0;
+            meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
+            return node->position.latitude_i;
         } else {
             return p.latitude_i;
         }
@@ -63,8 +63,8 @@ class GPSStatus : public Status
     int32_t getLongitude() const
     {
         if (config.position.fixed_position) {
-            meshtastic_NodeDetail *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
-            return node ? node->longitude_i : 0;
+            meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
+            return node->position.longitude_i;
         } else {
             return p.longitude_i;
         }
@@ -73,8 +73,8 @@ class GPSStatus : public Status
     int32_t getAltitude() const
     {
         if (config.position.fixed_position) {
-            meshtastic_NodeDetail *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
-            return node ? node->altitude : 0;
+            meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
+            return node->position.altitude;
         } else {
             return p.altitude;
         }

src/Power.cpp

@@ -278,6 +278,11 @@ class AnalogBatteryLevel : public HasBatteryLevel
                 break;
             }
         }
+#if defined(BATTERY_CHARGING_INV)
+        // bit of trickery to show 99% up until the charge finishes
+        if (!digitalRead(BATTERY_CHARGING_INV) && battery_SOC > 99)
+            battery_SOC = 99;
+#endif
         return clamp((int)(battery_SOC), 0, 100);
     }
 
@@ -455,6 +460,8 @@ class AnalogBatteryLevel : public HasBatteryLevel
         }
         // if it's not HIGH - check the battery
 #endif
+#elif defined(MUZI_BASE)
+        return NRF_POWER->USBREGSTATUS & POWER_USBREGSTATUS_VBUSDETECT_Msk;
 #endif
         return getBattVoltage() > chargingVolt;
     }
@@ -470,6 +477,8 @@ class AnalogBatteryLevel : public HasBatteryLevel
 #endif
 #ifdef EXT_CHRG_DETECT
         return digitalRead(EXT_CHRG_DETECT) == ext_chrg_detect_value;
+#elif defined(BATTERY_CHARGING_INV)
+        return !digitalRead(BATTERY_CHARGING_INV);
 #else
 #if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && !defined(DISABLE_INA_CHARGING_DETECTION)
         if (hasINA()) {
@@ -698,11 +707,18 @@ bool Power::setup()
         []() {
             power->setIntervalFromNow(0);
             runASAP = true;
-            BaseType_t higherWake = 0;
         },
         CHANGE);
 #endif
-
+#ifdef BATTERY_CHARGING_INV
+    attachInterrupt(
+        BATTERY_CHARGING_INV,
+        []() {
+            power->setIntervalFromNow(0);
+            runASAP = true;
+        },
+        CHANGE);
+#endif
     enabled = found;
     low_voltage_counter = 0;
 
@@ -759,6 +775,8 @@ void Power::shutdown()
     if (screen) {
 #ifdef T_DECK_PRO
         screen->showSimpleBanner("Device is powered off.\nConnect USB to start!", 0); // T-Deck Pro has no power button
+#elif defined(USE_EINK)
+        screen->showSimpleBanner("Shutting Down...", 2250); // dismiss after 3 seconds to avoid the banner on the sleep screen
 #else
         screen->showSimpleBanner("Shutting Down...", 0); // stays on screen
 #endif
@@ -1435,7 +1453,7 @@ class LipoCharger : public HasBatteryLevel
     /**
      * return true if there is an external power source detected
      */
-    virtual bool isVbusIn() override { return PPM->getVbusVoltage() > 0; }
+    virtual bool isVbusIn() override { return PPM->isVbusIn(); }
 
     /**
      * return true if the battery is currently charging

src/PowerFSM.cpp

@@ -57,21 +57,21 @@ static bool isPowered()
 
 static void sdsEnter()
 {
-    LOG_DEBUG("State: SDS");
+    LOG_POWERFSM("State: SDS");
     // FIXME - make sure GPS and LORA radio are off first - because we want close to zero current draw
     doDeepSleep(Default::getConfiguredOrDefaultMs(config.power.sds_secs), false, false);
 }
 
 static void lowBattSDSEnter()
 {
-    LOG_DEBUG("State: Lower batt SDS");
+    LOG_POWERFSM("State: Lower batt SDS");
     doDeepSleep(Default::getConfiguredOrDefaultMs(config.power.sds_secs), false, true);
 }
 extern Power *power;
 
 static void shutdownEnter()
 {
-    LOG_DEBUG("State: SHUTDOWN");
+    LOG_POWERFSM("State: SHUTDOWN");
     shutdownAtMsec = millis();
 }
 
@@ -81,7 +81,7 @@ static uint32_t secsSlept;
 
 static void lsEnter()
 {
-    LOG_INFO("lsEnter begin, ls_secs=%u", config.power.ls_secs);
+    LOG_POWERFSM("lsEnter begin, ls_secs=%u", config.power.ls_secs);
     if (screen)
         screen->setOn(false);
     secsSlept = 0; // How long have we been sleeping this time
@@ -155,12 +155,12 @@ static void lsIdle()
 
 static void lsExit()
 {
-    LOG_INFO("Exit state: LS");
+    LOG_POWERFSM("State: lsExit");
 }
 
 static void nbEnter()
 {
-    LOG_DEBUG("State: NB");
+    LOG_POWERFSM("State: nbEnter");
     if (screen)
         screen->setOn(false);
 #ifdef ARCH_ESP32
@@ -173,6 +173,7 @@ static void nbEnter()
 
 static void darkEnter()
 {
+    LOG_POWERFSM("State: darkEnter");
     setBluetoothEnable(true);
     if (screen)
         screen->setOn(false);
@@ -180,7 +181,7 @@ static void darkEnter()
 
 static void serialEnter()
 {
-    LOG_DEBUG("State: SERIAL");
+    LOG_POWERFSM("State: serialEnter");
     setBluetoothEnable(false);
     if (screen) {
         screen->setOn(true);
@@ -189,13 +190,14 @@ static void serialEnter()
 
 static void serialExit()
 {
+    LOG_POWERFSM("State: serialExit");
     // Turn bluetooth back on when we leave serial stream API
     setBluetoothEnable(true);
 }
 
 static void powerEnter()
 {
-    // LOG_DEBUG("State: POWER");
+    LOG_POWERFSM("State: powerEnter");
     if (!isPowered()) {
         // If we got here, we are in the wrong state - we should be in powered, let that state handle things
         LOG_INFO("Loss of power in Powered");
@@ -210,6 +212,7 @@ static void powerEnter()
 
 static void powerIdle()
 {
+    // LOG_POWERFSM("State: powerIdle"); // very chatty
     if (!isPowered()) {
         // If we got here, we are in the wrong state
         LOG_INFO("Loss of power in Powered");
@@ -219,14 +222,13 @@ static void powerIdle()
 
 static void powerExit()
 {
-    if (screen)
-        screen->setOn(true);
+    LOG_POWERFSM("State: powerExit");
     setBluetoothEnable(true);
 }
 
 static void onEnter()
 {
-    LOG_DEBUG("State: ON");
+    LOG_POWERFSM("State: onEnter");
     if (screen)
         screen->setOn(true);
     setBluetoothEnable(true);
@@ -234,6 +236,7 @@ static void onEnter()
 
 static void onIdle()
 {
+    LOG_POWERFSM("State: onIdle");
     if (isPowered()) {
         // If we got here, we are in the wrong state - we should be in powered, let that state handle things
         powerFSM.trigger(EVENT_POWER_CONNECTED);
@@ -242,7 +245,7 @@ static void onIdle()
 
 static void bootEnter()
 {
-    LOG_DEBUG("State: BOOT");
+    LOG_POWERFSM("State: bootEnter");
 }
 
 State stateSHUTDOWN(shutdownEnter, NULL, NULL, "SHUTDOWN");
@@ -319,11 +322,6 @@ void PowerFSM_setup()
         // if any packet destined for phone arrives, turn on bluetooth at least
         powerFSM.add_transition(&stateNB, &stateDARK, EVENT_PACKET_FOR_PHONE, NULL, "Packet for phone");
 
-        // Removed 2.7: we don't show the nodes individually for every node on the screen anymore
-        // powerFSM.add_transition(&stateNB, &stateON, EVENT_NODEDB_UPDATED, NULL, "NodeDB update");
-        // powerFSM.add_transition(&stateDARK, &stateON, EVENT_NODEDB_UPDATED, NULL, "NodeDB update");
-        // powerFSM.add_transition(&stateON, &stateON, EVENT_NODEDB_UPDATED, NULL, "NodeDB update");
-
         // Show the received text message
         powerFSM.add_transition(&stateLS, &stateON, EVENT_RECEIVED_MSG, NULL, "Received text");
         powerFSM.add_transition(&stateNB, &stateON, EVENT_RECEIVED_MSG, NULL, "Received text");
@@ -372,7 +370,7 @@ void PowerFSM_setup()
     // Don't add power saving transitions if we are a power saving tracker or sensor or have Wifi enabled. Sleep will be initiated
     // through the modules
 
-#if HAS_WIFI || !defined(MESHTASTIC_EXCLUDE_WIFI)
+#if HAS_WIFI && !defined(MESHTASTIC_EXCLUDE_WIFI)
     bool isTrackerOrSensor = config.device.role == meshtastic_Config_DeviceConfig_Role_TRACKER ||
                              config.device.role == meshtastic_Config_DeviceConfig_Role_TAK_TRACKER ||
                              config.device.role == meshtastic_Config_DeviceConfig_Role_SENSOR;

src/PowerFSM.h

@@ -2,6 +2,12 @@
 
 #include "configuration.h"
 
+#ifdef PowerFSMDebug
+#define LOG_POWERFSM(...) LOG_DEBUG(__VA_ARGS__)
+#else
+#define LOG_POWERFSM(...)
+#endif
+
 // See sw-design.md for documentation
 
 #define EVENT_PRESS 1

src/configuration.h

@@ -250,8 +250,9 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // Touchscreen
 // -----------------------------------------------------------------------------
 #define FT6336U_ADDR 0x48
-#define CST328_ADDR 0x1A
+#define CST328_ADDR 0x1A // same address as CST226SE
 #define CHSC6X_ADDR 0x2E
+#define CST226SE_ADDR_ALT 0x5A
 
 // -----------------------------------------------------------------------------
 // RAK12035VB Soil Monitor (using RAK12023 up to 3 RAK12035 monitors can be connected)
@@ -396,6 +397,13 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define HAS_RGB_LED
 #endif
 
+#ifndef LED_STATE_OFF
+#define LED_STATE_OFF 0
+#endif
+#ifndef LED_STATE_ON
+#define LED_STATE_ON 1
+#endif
+
 // default mapping of pins
 #if defined(PIN_BUTTON2) && !defined(CANCEL_BUTTON_PIN)
 #define ALT_BUTTON_PIN PIN_BUTTON2

src/detect/ScanI2C.h

@@ -85,7 +85,8 @@ class ScanI2C
         DRV2605,
         BH1750,
         DA217,
-        CHSC6X
+        CHSC6X,
+        CST226SE
     } DeviceType;
 
     // typedef uint8_t DeviceAddress;

src/detect/ScanI2CTwoWire.cpp

@@ -499,7 +499,18 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                 SCAN_SIMPLE_CASE(DFROBOT_RAIN_ADDR, DFROBOT_RAIN, "DFRobot Rain Gauge", (uint8_t)addr.address);
                 SCAN_SIMPLE_CASE(LTR390UV_ADDR, LTR390UV, "LTR390UV", (uint8_t)addr.address);
                 SCAN_SIMPLE_CASE(PCT2075_ADDR, PCT2075, "PCT2075", (uint8_t)addr.address);
-                SCAN_SIMPLE_CASE(CST328_ADDR, CST328, "CST328", (uint8_t)addr.address);
+            case CST328_ADDR:
+                // Do we have the CST328 or the CST226SE
+                registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0xAB), 1);
+                if (registerValue == 0xA9) {
+                    type = CST226SE;
+                    logFoundDevice("CST226SE", (uint8_t)addr.address);
+                } else {
+                    type = CST328;
+                    logFoundDevice("CST328", (uint8_t)addr.address);
+                }
+                break;
+
                 SCAN_SIMPLE_CASE(CHSC6X_ADDR, CHSC6X, "CHSC6X", (uint8_t)addr.address);
             case LTR553ALS_ADDR:
                 registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x86), 1); // Part ID register
@@ -528,8 +539,12 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
 #endif
 
             case MLX90614_ADDR_DEF:
-                registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x0e), 1);
-                if (registerValue == 0x5a) {
+                // Do we have the MLX90614 or the MPR121KB or the CST226SE
+                registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x06), 1);
+                if (registerValue == 0xAB) {
+                    type = CST226SE;
+                    logFoundDevice("CST226SE", (uint8_t)addr.address);
+                } else if (getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x0e), 1) == 0x5a) {
                     type = MLX90614;
                     logFoundDevice("MLX90614", (uint8_t)addr.address);
                 } else {
@@ -547,6 +562,11 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
             case ICM20948_ADDR:     // same as BMX160_ADDR
             case ICM20948_ADDR_ALT: // same as MPU6050_ADDR
                 registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x00), 1);
+#ifdef HAS_ICM20948
+                type = ICM20948;
+                logFoundDevice("ICM20948", (uint8_t)addr.address);
+                break;
+#endif
                 if (registerValue == 0xEA) {
                     type = ICM20948;
                     logFoundDevice("ICM20948", (uint8_t)addr.address);

src/gps/GPS.cpp

@@ -38,14 +38,16 @@ template <typename T, std::size_t N> std::size_t array_count(const T (&)[N])
     return N;
 }
 
-#if defined(NRF52840_XXAA) || defined(NRF52833_XXAA) || defined(ARCH_ESP32) || defined(ARCH_PORTDUINO) || defined(ARCH_STM32WL)
-#if defined(GPS_SERIAL_PORT)
-HardwareSerial *GPS::_serial_gps = &GPS_SERIAL_PORT;
-#else
-HardwareSerial *GPS::_serial_gps = &Serial1;
+#ifndef GPS_SERIAL_PORT
+#define GPS_SERIAL_PORT Serial1
 #endif
+
+#if defined(ARCH_NRF52)
+Uart *GPS::_serial_gps = &GPS_SERIAL_PORT;
+#elif defined(ARCH_ESP32) || defined(ARCH_PORTDUINO) || defined(ARCH_STM32WL)
+HardwareSerial *GPS::_serial_gps = &GPS_SERIAL_PORT;
 #elif defined(ARCH_RP2040)
-SerialUART *GPS::_serial_gps = &Serial1;
+SerialUART *GPS::_serial_gps = &GPS_SERIAL_PORT;
 #else
 HardwareSerial *GPS::_serial_gps = nullptr;
 #endif
@@ -1525,10 +1527,7 @@ GPS *GPS::createGps()
     int8_t _rx_gpio = config.position.rx_gpio;
     int8_t _tx_gpio = config.position.tx_gpio;
     int8_t _en_gpio = config.position.gps_en_gpio;
-#if HAS_GPS && !defined(ARCH_ESP32)
-    _rx_gpio = 1; // We only specify GPS serial ports on ESP32. Otherwise, these are just flags.
-    _tx_gpio = 1;
-#endif
+
 #if defined(GPS_RX_PIN)
     if (!_rx_gpio)
         _rx_gpio = GPS_RX_PIN;
@@ -1602,16 +1601,28 @@ GPS *GPS::createGps()
         _serial_gps->setRxBufferSize(SERIAL_BUFFER_SIZE); // the default is 256
 #endif
 
-//  ESP32 has a special set of parameters vs other arduino ports
-#if defined(ARCH_ESP32)
         LOG_DEBUG("Use GPIO%d for GPS RX", new_gps->rx_gpio);
         LOG_DEBUG("Use GPIO%d for GPS TX", new_gps->tx_gpio);
+
+//  ESP32 has a special set of parameters vs other arduino ports
+#if defined(ARCH_ESP32)
         _serial_gps->begin(GPS_BAUDRATE, SERIAL_8N1, new_gps->rx_gpio, new_gps->tx_gpio);
 #elif defined(ARCH_RP2040)
+        _serial_gps->setPinout(new_gps->tx_gpio, new_gps->rx_gpio);
         _serial_gps->setFIFOSize(256);
         _serial_gps->begin(GPS_BAUDRATE);
-#else
+#elif defined(ARCH_NRF52)
+        _serial_gps->setPins(new_gps->rx_gpio, new_gps->tx_gpio);
         _serial_gps->begin(GPS_BAUDRATE);
+#elif defined(ARCH_STM32WL)
+        _serial_gps->setTx(new_gps->tx_gpio);
+        _serial_gps->setRx(new_gps->rx_gpio);
+        _serial_gps->begin(GPS_BAUDRATE);
+#elif defined(ARCH_PORTDUINO)
+        // Portduino can't set the GPS pins directly.
+        _serial_gps->begin(GPS_BAUDRATE);
+#else
+#error Unsupported architecture!
 #endif
     }
     return new_gps;

src/gps/GPS.h

@@ -194,6 +194,8 @@ class GPS : private concurrency::OSThread
     /** If !NULL we will use this serial port to construct our GPS */
 #if defined(ARCH_RP2040)
     static SerialUART *_serial_gps;
+#elif defined(ARCH_NRF52)
+    static Uart *_serial_gps;
 #else
     static HardwareSerial *_serial_gps;
 #endif

src/gps/RTC.cpp

@@ -112,7 +112,11 @@ RTCSetResult readFromRTC()
 #elif defined(RX8130CE_RTC)
     if (rtc_found.address == RX8130CE_RTC) {
         uint32_t now = millis();
+#ifdef MUZI_BASE
+        ArtronShop_RX8130CE rtc(&Wire1);
+#else
         ArtronShop_RX8130CE rtc(&Wire);
+#endif
         tm t;
         if (rtc.getTime(&t)) {
             tv.tv_sec = gm_mktime(&t);
@@ -245,7 +249,11 @@ RTCSetResult perhapsSetRTC(RTCQuality q, const struct timeval *tv, bool forceUpd
         }
 #elif defined(RX8130CE_RTC)
         if (rtc_found.address == RX8130CE_RTC) {
+#ifdef MUZI_BASE
+            ArtronShop_RX8130CE rtc(&Wire1);
+#else
             ArtronShop_RX8130CE rtc(&Wire);
+#endif
             tm *t = gmtime(&tv->tv_sec);
             if (rtc.setTime(*t)) {
                 LOG_DEBUG("RX8130CE setDateTime %02d-%02d-%02d %02d:%02d:%02d (%ld)", t->tm_year + 1900, t->tm_mon + 1,

src/graphics/Screen.cpp

@@ -324,7 +324,7 @@ static int8_t prevFrame = -1;
 // Combined dynamic node list frame cycling through LastHeard, HopSignal, and Distance modes
 // Uses a single frame and changes data every few seconds (E-Ink variant is separate)
 
-#if defined(ESP_PLATFORM) && defined(USE_ST7789)
+#if defined(ESP_PLATFORM) && (defined(USE_ST7789) || defined(USE_ST7796))
 SPIClass SPI1(HSPI);
 #endif
 
@@ -356,7 +356,13 @@ Screen::Screen(ScanI2C::DeviceAddress address, meshtastic_Config_DisplayConfig_O
 #else
     dispdev = new ST7789Spi(&SPI1, ST7789_RESET, ST7789_RS, ST7789_NSS, GEOMETRY_RAWMODE, TFT_WIDTH, TFT_HEIGHT);
 #endif
-    static_cast<ST7789Spi *>(dispdev)->setRGB(TFT_MESH);
+#elif defined(USE_ST7796)
+#ifdef ESP_PLATFORM
+    dispdev = new ST7796Spi(&SPI1, ST7796_RESET, ST7796_RS, ST7796_NSS, GEOMETRY_RAWMODE, TFT_WIDTH, TFT_HEIGHT, ST7796_SDA,
+                            ST7796_MISO, ST7796_SCK, TFT_SPI_FREQUENCY);
+#else
+    dispdev = new ST7796Spi(&SPI1, ST7796_RESET, ST7796_RS, ST7796_NSS, GEOMETRY_RAWMODE, TFT_WIDTH, TFT_HEIGHT);
+#endif
 #elif defined(USE_SSD1306)
     dispdev = new SSD1306Wire(address.address, -1, -1, geometry,
                               (address.port == ScanI2C::I2CPort::WIRE1) ? HW_I2C::I2C_TWO : HW_I2C::I2C_ONE);
@@ -369,7 +375,7 @@ Screen::Screen(ScanI2C::DeviceAddress address, meshtastic_Config_DisplayConfig_O
         LOG_INFO("SSD1306 init success");
     }
 #elif defined(ST7735_CS) || defined(ILI9341_DRIVER) || defined(ILI9342_DRIVER) || defined(ST7701_CS) || defined(ST7789_CS) ||    \
-    defined(RAK14014) || defined(HX8357_CS) || defined(ILI9488_CS) || defined(ST7796_CS)
+    defined(RAK14014) || defined(HX8357_CS) || defined(ILI9488_CS) || defined(ST7796_CS) || defined(HACKADAY_COMMUNICATOR)
     dispdev = new TFTDisplay(address.address, -1, -1, geometry,
                              (address.port == ScanI2C::I2CPort::WIRE1) ? HW_I2C::I2C_TWO : HW_I2C::I2C_ONE);
 #elif defined(USE_EINK) && !defined(USE_EINK_DYNAMICDISPLAY)
@@ -399,6 +405,12 @@ Screen::Screen(ScanI2C::DeviceAddress address, meshtastic_Config_DisplayConfig_O
     isAUTOOled = true;
 #endif
 
+#if defined(USE_ST7789)
+    static_cast<ST7789Spi *>(dispdev)->setRGB(TFT_MESH);
+#elif defined(USE_ST7796)
+    static_cast<ST7796Spi *>(dispdev)->setRGB(TFT_MESH);
+#endif
+
     ui = new OLEDDisplayUi(dispdev);
     cmdQueue.setReader(this);
 }
@@ -435,6 +447,14 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
             PMU->enablePowerOutput(XPOWERS_ALDO2);
 #endif
 
+#if defined(MUZI_BASE)
+            dispdev->init();
+            dispdev->setBrightness(brightness);
+            dispdev->flipScreenVertically();
+            dispdev->resetDisplay();
+            digitalWrite(SCREEN_12V_ENABLE, HIGH);
+            delay(100);
+#endif
 #if !ARCH_PORTDUINO
             dispdev->displayOn();
 #endif
@@ -466,6 +486,15 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
             pinMode(VTFT_LEDA, OUTPUT);
             digitalWrite(VTFT_LEDA, TFT_BACKLIGHT_ON);
 #endif
+#endif
+#ifdef USE_ST7796
+            ui->init();
+#ifdef ESP_PLATFORM
+            analogWrite(VTFT_LEDA, BRIGHTNESS_DEFAULT);
+#else
+            pinMode(VTFT_LEDA, OUTPUT);
+            digitalWrite(VTFT_LEDA, TFT_BACKLIGHT_ON);
+#endif
 #endif
             enabled = true;
             setInterval(0); // Draw ASAP
@@ -484,6 +513,10 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
 #endif
 
             dispdev->displayOff();
+
+#ifdef SCREEN_12V_ENABLE
+            digitalWrite(SCREEN_12V_ENABLE, LOW);
+#endif
 #ifdef USE_ST7789
             SPI1.end();
 #if defined(ARCH_ESP32)
@@ -500,6 +533,21 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
             nrf_gpio_cfg_default(ST7789_NSS);
 #endif
 #endif
+#ifdef USE_ST7796
+            SPI1.end();
+#if defined(ARCH_ESP32)
+            pinMode(VTFT_LEDA, OUTPUT);
+            digitalWrite(VTFT_LEDA, LOW);
+            pinMode(ST7796_RESET, ANALOG);
+            pinMode(ST7796_RS, ANALOG);
+            pinMode(ST7796_NSS, ANALOG);
+#else
+            nrf_gpio_cfg_default(VTFT_LEDA);
+            nrf_gpio_cfg_default(ST7796_RESET);
+            nrf_gpio_cfg_default(ST7796_RS);
+            nrf_gpio_cfg_default(ST7796_NSS);
+#endif
+#endif
 
 #ifdef T_WATCH_S3
             PMU->disablePowerOutput(XPOWERS_ALDO2);
@@ -534,7 +582,7 @@ void Screen::setup()
         static_cast<AutoOLEDWire *>(dispdev)->setDetected(model);
 #endif
 
-#ifdef USE_SH1107_128_64
+#if defined(USE_SH1107_128_64) || defined(USE_SH1107)
     static_cast<SH1106Wire *>(dispdev)->setSubtype(7);
 #endif
 
@@ -542,6 +590,13 @@ void Screen::setup()
     // Apply custom RGB color (e.g. Heltec T114/T190)
     static_cast<ST7789Spi *>(dispdev)->setRGB(TFT_MESH);
 #endif
+#if defined(MUZI_BASE)
+    dispdev->delayPoweron = true;
+#endif
+#if defined(USE_ST7796) && defined(TFT_MESH)
+    // Custom text color, if defined in variant.h
+    static_cast<ST7796Spi *>(dispdev)->setRGB(TFT_MESH);
+#endif
 
     // === Initialize display and UI system ===
     ui->init();
@@ -601,10 +656,12 @@ void Screen::setup()
 #else
     if (!config.display.flip_screen) {
 #if defined(ST7701_CS) || defined(ST7735_CS) || defined(ILI9341_DRIVER) || defined(ILI9342_DRIVER) || defined(ST7789_CS) ||      \
-    defined(RAK14014) || defined(HX8357_CS) || defined(ILI9488_CS) || defined(ST7796_CS)
+    defined(RAK14014) || defined(HX8357_CS) || defined(ILI9488_CS) || defined(ST7796_CS) || defined(HACKADAY_COMMUNICATOR)
         static_cast<TFTDisplay *>(dispdev)->flipScreenVertically();
 #elif defined(USE_ST7789)
         static_cast<ST7789Spi *>(dispdev)->flipScreenVertically();
+#elif defined(USE_ST7796)
+        static_cast<ST7796Spi *>(dispdev)->mirrorScreen();
 #elif !defined(M5STACK_UNITC6L)
         dispdev->flipScreenVertically();
 #endif
@@ -637,7 +694,7 @@ void Screen::setup()
             touchScreenImpl1->init();
         }
     }
-#elif HAS_TOUCHSCREEN && !defined(USE_EINK)
+#elif HAS_TOUCHSCREEN && !defined(USE_EINK) && !HAS_CST226SE
     touchScreenImpl1 =
         new TouchScreenImpl1(dispdev->getWidth(), dispdev->getHeight(), static_cast<TFTDisplay *>(dispdev)->getTouch);
     touchScreenImpl1->init();
@@ -1106,8 +1163,8 @@ void Screen::setFrames(FrameFocus focus)
         std::vector<FrameCallback> favoriteFrames;
 
         for (size_t i = 0; i < nodeDB->getNumMeshNodes(); i++) {
-            const meshtastic_NodeDetail *nodeDetail = nodeDB->getMeshNodeByIndex(i);
-            if (nodeDetail && nodeDetail->num != nodeDB->getNodeNum() && detailIsFavorite(*nodeDetail)) {
+            const meshtastic_NodeInfoLite *n = nodeDB->getMeshNodeByIndex(i);
+            if (n && n->num != nodeDB->getNodeNum() && n->is_favorite) {
                 favoriteFrames.push_back(graphics::UIRenderer::drawNodeInfo);
             }
         }
@@ -1460,10 +1517,10 @@ int Screen::handleTextMessage(const meshtastic_MeshPacket *packet)
                 forceDisplay(); // Forces screen redraw
             }
             // === Prepare banner content ===
-            const meshtastic_NodeDetail *node = nodeDB->getMeshNode(packet->from);
+            const meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(packet->from);
             const meshtastic_Channel channel =
                 channels.getByIndex(packet->channel ? packet->channel : channels.getPrimaryIndex());
-            const char *longName = (node && detailHasFlag(*node, NODEDETAIL_FLAG_HAS_USER)) ? node->long_name : nullptr;
+            const char *longName = (node && node->has_user) ? node->user.long_name : nullptr;
 
             const char *msgRaw = reinterpret_cast<const char *>(packet->decoded.payload.bytes);
 
@@ -1549,6 +1606,7 @@ int Screen::handleUIFrameEvent(const UIFrameEvent *event)
 
 int Screen::handleInputEvent(const InputEvent *event)
 {
+    LOG_INPUT("Screen Input event %u! kb %u", event->inputEvent, event->kbchar);
     if (!screenOn)
         return 0;
 

src/graphics/Screen.h

@@ -83,6 +83,8 @@ class Screen
 #include <ST7789Spi.h>
 #elif defined(USE_SPISSD1306)
 #include <SSD1306Spi.h>
+#elif defined(USE_ST7796)
+#include <ST7796Spi.h>
 #else
 // the SH1106/SSD1306 variant is auto-detected
 #include <AutoOLEDWire.h>
@@ -249,6 +251,8 @@ class Screen : public concurrency::OSThread
 
     bool isOverlayBannerShowing();
 
+    bool isScreenOn() { return screenOn; }
+
     // Stores the last 4 of our hardware ID, to make finding the device for pairing easier
     // FIXME: Needs refactoring and getMacAddr needs to be moved to a utility class
     char ourId[5];

src/graphics/ScreenFonts.h

@@ -73,7 +73,8 @@
 #endif
 
 #if (defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ILI9342_DRIVER) || defined(ST7701_CS) || defined(ST7735_CS) ||      \
-     defined(ST7789_CS) || defined(USE_ST7789) || defined(HX8357_CS) || defined(ILI9488_CS) || defined(ST7796_CS)) &&            \
+     defined(ST7789_CS) || defined(USE_ST7789) || defined(HX8357_CS) || defined(ILI9488_CS) || defined(ST7796_CS) ||             \
+     defined(HACKADAY_COMMUNICATOR) || defined(USE_ST7796)) &&                                                                   \
     !defined(DISPLAY_FORCE_SMALL_FONTS)
 // The screen is bigger so use bigger fonts
 #define FONT_SMALL FONT_MEDIUM_LOCAL // Height: 19

src/graphics/SharedUIDisplay.cpp

@@ -17,6 +17,12 @@ namespace graphics
 
 void determineResolution(int16_t screenheight, int16_t screenwidth)
 {
+
+#ifdef FORCE_LOW_RES
+    isHighResolution = false;
+    return;
+#endif
+
     if (screenwidth > 128) {
         isHighResolution = true;
     }
@@ -24,11 +30,6 @@ void determineResolution(int16_t screenheight, int16_t screenwidth)
     if (screenwidth > 128 && screenheight <= 64) {
         isHighResolution = false;
     }
-
-    // Special case for Heltec Wireless Tracker v1.1
-    if (screenwidth == 160 && screenheight == 80) {
-        isHighResolution = false;
-    }
 }
 
 // === Shared External State ===

src/graphics/TFTDisplay.cpp

@@ -123,6 +123,11 @@ static void rak14014_tpIntHandle(void)
     _rak14014_touch_int = true;
 }
 
+#elif defined(HACKADAY_COMMUNICATOR)
+#include <Arduino_GFX_Library.h>
+Arduino_DataBus *bus = nullptr;
+Arduino_GFX *tft = nullptr;
+
 #elif defined(ST72xx_DE)
 #include <LovyanGFX.hpp>
 #include <TCA9534.h>
@@ -1135,7 +1140,7 @@ static LGFX *tft = nullptr;
 
 #if defined(ST7701_CS) || defined(ST7735_CS) || defined(ST7789_CS) || defined(ST7796_CS) || defined(ILI9341_DRIVER) ||           \
     defined(ILI9342_DRIVER) || defined(RAK14014) || defined(HX8357_CS) || defined(ILI9488_CS) || defined(ST72xx_DE) ||           \
-    (ARCH_PORTDUINO && HAS_SCREEN != 0)
+    (ARCH_PORTDUINO && HAS_SCREEN != 0) || defined(HACKADAY_COMMUNICATOR)
 #include "SPILock.h"
 #include "TFTDisplay.h"
 #include <SPI.h>
@@ -1271,12 +1276,15 @@ void TFTDisplay::display(bool fromBlank)
                     x_LastPixelUpdate = x;
                 }
             }
-
+#if defined(HACKADAY_COMMUNICATOR)
+            tft->draw16bitBeRGBBitmap(x_FirstPixelUpdate, y, &linePixelBuffer[x_FirstPixelUpdate],
+                                      (x_LastPixelUpdate - x_FirstPixelUpdate + 1), 1);
+#else
             // Step 4: Send the changed pixels on this line to the screen as a single block transfer.
             // This function accepts pixel data MSB first so it can dump the memory straight out the SPI port.
             tft->pushRect(x_FirstPixelUpdate, y, (x_LastPixelUpdate - x_FirstPixelUpdate + 1), 1,
                           &linePixelBuffer[x_FirstPixelUpdate]);
-
+#endif
             somethingChanged = true;
         }
         y++;
@@ -1340,6 +1348,8 @@ void TFTDisplay::sendCommand(uint8_t com)
         display(true);
         if (portduino_config.displayBacklight.pin > 0)
             digitalWrite(portduino_config.displayBacklight.pin, TFT_BACKLIGHT_ON);
+#elif defined(HACKADAY_COMMUNICATOR)
+        tft->displayOn();
 #elif !defined(RAK14014) && !defined(M5STACK) && !defined(UNPHONE)
         tft->wakeup();
         tft->powerSaveOff();
@@ -1352,7 +1362,8 @@ void TFTDisplay::sendCommand(uint8_t com)
         unphone.backlight(true); // using unPhone library
 #endif
 #ifdef RAK14014
-#elif !defined(M5STACK) && !defined(ST7789_CS) // T-Deck gets brightness set in Screen.cpp in the handleSetOn function
+#elif !defined(M5STACK) && !defined(ST7789_CS) &&                                                                                \
+    !defined(HACKADAY_COMMUNICATOR) // T-Deck gets brightness set in Screen.cpp in the handleSetOn function
         tft->setBrightness(172);
 #endif
         break;
@@ -1364,6 +1375,8 @@ void TFTDisplay::sendCommand(uint8_t com)
         tft->clear();
         if (portduino_config.displayBacklight.pin > 0)
             digitalWrite(portduino_config.displayBacklight.pin, !TFT_BACKLIGHT_ON);
+#elif defined(HACKADAY_COMMUNICATOR)
+        tft->displayOff();
 #elif !defined(RAK14014) && !defined(M5STACK) && !defined(UNPHONE)
         tft->sleep();
         tft->powerSaveOn();
@@ -1376,7 +1389,7 @@ void TFTDisplay::sendCommand(uint8_t com)
         unphone.backlight(false); // using unPhone library
 #endif
 #ifdef RAK14014
-#elif !defined(M5STACK)
+#elif !defined(M5STACK) && !defined(HACKADAY_COMMUNICATOR)
         tft->setBrightness(0);
 #endif
         break;
@@ -1392,7 +1405,7 @@ void TFTDisplay::setDisplayBrightness(uint8_t _brightness)
 {
 #ifdef RAK14014
     // todo
-#else
+#elif !defined(HACKADAY_COMMUNICATOR)
     tft->setBrightness(_brightness);
     LOG_DEBUG("Brightness is set to value: %i ", _brightness);
 #endif
@@ -1410,7 +1423,7 @@ bool TFTDisplay::hasTouch(void)
 {
 #ifdef RAK14014
     return true;
-#elif !defined(M5STACK)
+#elif !defined(M5STACK) && !defined(HACKADAY_COMMUNICATOR)
     return tft->touch() != nullptr;
 #else
     return false;
@@ -1429,7 +1442,7 @@ bool TFTDisplay::getTouch(int16_t *x, int16_t *y)
     } else {
         return false;
     }
-#elif !defined(M5STACK)
+#elif !defined(M5STACK) && !defined(HACKADAY_COMMUNICATOR)
     return tft->getTouch(x, y);
 #else
     return false;
@@ -1448,6 +1461,12 @@ bool TFTDisplay::connect()
     LOG_INFO("Do TFT init");
 #ifdef RAK14014
     tft = new TFT_eSPI;
+#elif defined(HACKADAY_COMMUNICATOR)
+    bus = new Arduino_ESP32SPI(TFT_DC, TFT_CS, 38 /* SCK */, 21 /* MOSI */, GFX_NOT_DEFINED /* MISO */, HSPI /* spi_num */);
+    tft = new Arduino_NV3007(bus, 40, 0 /* rotation */, false /* IPS */, 142 /* width */, 428 /* height */, 12 /* col offset 1 */,
+                             0 /* row offset 1 */, 14 /* col offset 2 */, 0 /* row offset 2 */, nv3007_279_init_operations,
+                             sizeof(nv3007_279_init_operations));
+
 #else
     tft = new LGFX;
 #endif
@@ -1458,8 +1477,15 @@ bool TFTDisplay::connect()
 #ifdef UNPHONE
     unphone.backlight(true); // using unPhone library
 #endif
-
+#ifdef HACKADAY_COMMUNICATOR
+    bool beginStatus = tft->begin();
+    if (beginStatus)
+        LOG_DEBUG("TFT Success!");
+    else
+        LOG_ERROR("TFT Fail!");
+#else
     tft->init();
+#endif
 
 #if defined(M5STACK)
     tft->setRotation(0);

src/graphics/draw/DebugRenderer.cpp

@@ -97,7 +97,7 @@ void drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16
                                           (storeForwardModule->heartbeatInterval * 1200))) { // no heartbeat, overlap a bit
 #if (defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ILI9342_DRIVER) || defined(ST7701_CS) || defined(ST7735_CS) ||      \
      defined(ST7789_CS) || defined(USE_ST7789) || defined(ILI9488_CS) || defined(HX8357_CS) || defined(ST7796_CS) ||             \
-     ARCH_PORTDUINO) &&                                                                                                          \
+     defined(HACKADAY_COMMUNICATOR) || defined(USE_ST7796) || ARCH_PORTDUINO) &&                                                 \
     !defined(DISPLAY_FORCE_SMALL_FONTS)
             display->drawFastImage(x + SCREEN_WIDTH - 14 - display->getStringWidth(screen->ourId), y + 3 + FONT_HEIGHT_SMALL, 12,
                                    8, imgQuestionL1);
@@ -109,7 +109,8 @@ void drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16
 #endif
         } else {
 #if (defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ILI9342_DRIVER) || defined(ST7701_CS) || defined(ST7735_CS) ||      \
-     defined(ST7789_CS) || defined(USE_ST7789) || defined(ILI9488_CS) || defined(HX8357_CS) || defined(ST7796_CS)) &&            \
+     defined(ST7789_CS) || defined(USE_ST7789) || defined(ILI9488_CS) || defined(HX8357_CS) || defined(ST7796_CS) ||             \
+     defined(HACKADAY_COMMUNICATOR) || defined(USE_ST7796)) &&                                                                   \
     !defined(DISPLAY_FORCE_SMALL_FONTS)
             display->drawFastImage(x + SCREEN_WIDTH - 18 - display->getStringWidth(screen->ourId), y + 3 + FONT_HEIGHT_SMALL, 16,
                                    8, imgSFL1);
@@ -125,7 +126,7 @@ void drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16
         // TODO: Raspberry Pi supports more than just the one screen size
 #if (defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ILI9342_DRIVER) || defined(ST7701_CS) || defined(ST7735_CS) ||      \
      defined(ST7789_CS) || defined(USE_ST7789) || defined(ILI9488_CS) || defined(HX8357_CS) || defined(ST7796_CS) ||             \
-     ARCH_PORTDUINO) &&                                                                                                          \
+     defined(HACKADAY_COMMUNICATOR) || defined(USE_ST7796) || ARCH_PORTDUINO) &&                                                 \
     !defined(DISPLAY_FORCE_SMALL_FONTS)
         display->drawFastImage(x + SCREEN_WIDTH - 14 - display->getStringWidth(screen->ourId), y + 3 + FONT_HEIGHT_SMALL, 12, 8,
                                imgInfoL1);

src/graphics/draw/MenuHandler.cpp

@@ -119,28 +119,8 @@ void menuHandler::LoraRegionPicker(uint32_t duration)
             auto changes = SEGMENT_CONFIG;
 
             // This is needed as we wait til picking the LoRa region to generate keys for the first time.
-#if !(MESHTASTIC_EXCLUDE_PKI_KEYGEN || MESHTASTIC_EXCLUDE_PKI)
-            if (!owner.is_licensed) {
-                bool keygenSuccess = false;
-                if (config.security.private_key.size == 32) {
-                    // public key is derived from private, so this will always have the same result.
-                    if (crypto->regeneratePublicKey(config.security.public_key.bytes, config.security.private_key.bytes)) {
-                        keygenSuccess = true;
-                    }
-
-                } else {
-                    LOG_INFO("Generate new PKI keys");
-                    crypto->generateKeyPair(config.security.public_key.bytes, config.security.private_key.bytes);
-                    keygenSuccess = true;
-                }
-                if (keygenSuccess) {
-                    config.security.public_key.size = 32;
-                    config.security.private_key.size = 32;
-                    owner.public_key.size = 32;
-                    memcpy(owner.public_key.bytes, config.security.public_key.bytes, 32);
-                }
-            }
-#endif
+            // Use consolidated key generation function
+            nodeDB->generateCryptoKeyPair();
             config.lora.tx_enabled = true;
             initRegion();
             if (myRegion->dutyCycle < 100) {
@@ -576,7 +556,7 @@ void menuHandler::textMessageBaseMenu()
 
 void menuHandler::systemBaseMenu()
 {
-    enum optionsNumbers { Back, Notifications, ScreenOptions, Bluetooth, PowerMenu, Test, enumEnd };
+    enum optionsNumbers { Back, Notifications, ScreenOptions, Bluetooth, WiFiToggle, PowerMenu, Test, enumEnd };
     static const char *optionsArray[enumEnd] = {"Back"};
     static int optionsEnumArray[enumEnd] = {Back};
     int options = 1;
@@ -592,6 +572,10 @@ void menuHandler::systemBaseMenu()
     optionsArray[options] = "Bluetooth Toggle";
 #endif
     optionsEnumArray[options++] = Bluetooth;
+#if HAS_WIFI && !defined(ARCH_PORTDUINO)
+    optionsArray[options] = "WiFi Toggle";
+    optionsEnumArray[options++] = WiFiToggle;
+#endif
 #if defined(M5STACK_UNITC6L)
     optionsArray[options] = "Power";
 #else
@@ -629,6 +613,11 @@ void menuHandler::systemBaseMenu()
         } else if (selected == Bluetooth) {
             menuQueue = bluetooth_toggle_menu;
             screen->runNow();
+#if HAS_WIFI && !defined(ARCH_PORTDUINO)
+        } else if (selected == WiFiToggle) {
+            menuQueue = wifi_toggle_menu;
+            screen->runNow();
+#endif
         } else if (selected == Back && !test_enabled) {
             test_count++;
             if (test_count > 4) {
@@ -1038,7 +1027,8 @@ void menuHandler::TFTColorPickerMenu(OLEDDisplay *display)
     bannerOptions.optionsArrayPtr = optionsArray;
     bannerOptions.optionsCount = 10;
     bannerOptions.bannerCallback = [display](int selected) -> void {
-#if defined(HELTEC_MESH_NODE_T114) || defined(HELTEC_VISION_MASTER_T190) || defined(T_DECK) || defined(T_LORA_PAGER) || HAS_TFT
+#if defined(HELTEC_MESH_NODE_T114) || defined(HELTEC_VISION_MASTER_T190) || defined(T_DECK) || defined(T_LORA_PAGER) ||          \
+    HAS_TFT || defined(HACKADAY_COMMUNICATOR)
         uint8_t TFT_MESH_r = 0;
         uint8_t TFT_MESH_g = 0;
         uint8_t TFT_MESH_b = 0;
@@ -1191,8 +1181,8 @@ void menuHandler::removeFavoriteMenu()
     BannerOverlayOptions bannerOptions;
     std::string message = "Unfavorite This Node?\n";
     auto node = nodeDB->getMeshNode(graphics::UIRenderer::currentFavoriteNodeNum);
-    if (node && detailHasFlag(*node, NODEDETAIL_FLAG_HAS_USER)) {
-        message += sanitizeString(node->long_name).substr(0, 15);
+    if (node && node->has_user) {
+        message += sanitizeString(node->user.long_name).substr(0, 15);
     }
     bannerOptions.message = message.c_str();
     bannerOptions.optionsArrayPtr = optionsArray;
@@ -1278,19 +1268,28 @@ void menuHandler::wifiBaseMenu()
 
 void menuHandler::wifiToggleMenu()
 {
-    enum optionsNumbers { Back, Wifi_toggle };
+    enum optionsNumbers { Back, Wifi_disable, Wifi_enable };
 
-    static const char *optionsArray[] = {"Back", "Disable"};
+    static const char *optionsArray[] = {"Back", "WiFi Disabled", "WiFi Enabled"};
     BannerOverlayOptions bannerOptions;
-    bannerOptions.message = "Disable Wifi and\nEnable Bluetooth?";
+    bannerOptions.message = "WiFi Actions";
     bannerOptions.optionsArrayPtr = optionsArray;
-    bannerOptions.optionsCount = 2;
+    bannerOptions.optionsCount = 3;
+    if (config.network.wifi_enabled == true)
+        bannerOptions.InitialSelected = 2;
+    else
+        bannerOptions.InitialSelected = 1;
     bannerOptions.bannerCallback = [](int selected) -> void {
-        if (selected == Wifi_toggle) {
+        if (selected == Wifi_disable) {
             config.network.wifi_enabled = false;
             config.bluetooth.enabled = true;
             service->reloadConfig(SEGMENT_CONFIG);
             rebootAtMsec = (millis() + DEFAULT_REBOOT_SECONDS * 1000);
+        } else if (selected == Wifi_enable) {
+            config.network.wifi_enabled = true;
+            config.bluetooth.enabled = false;
+            service->reloadConfig(SEGMENT_CONFIG);
+            rebootAtMsec = (millis() + DEFAULT_REBOOT_SECONDS * 1000);
         }
     };
     screen->showOverlayBanner(bannerOptions);
@@ -1338,7 +1337,7 @@ void menuHandler::screenOptionsMenu()
     static int optionsEnumArray[5] = {Back};
     int options = 1;
 
-#if defined(T_DECK) || defined(T_LORA_PAGER)
+#if defined(T_DECK) || defined(T_LORA_PAGER) || defined(HACKADAY_COMMUNICATOR)
     optionsArray[options] = "Show Long/Short Name";
     optionsEnumArray[options++] = NodeNameLength;
 #endif
@@ -1350,7 +1349,8 @@ void menuHandler::screenOptionsMenu()
     }
 
     // Only show screen color for TFT displays
-#if defined(HELTEC_MESH_NODE_T114) || defined(HELTEC_VISION_MASTER_T190) || defined(T_DECK) || defined(T_LORA_PAGER) || HAS_TFT
+#if defined(HELTEC_MESH_NODE_T114) || defined(HELTEC_VISION_MASTER_T190) || defined(T_DECK) || defined(T_LORA_PAGER) ||          \
+    HAS_TFT || defined(HACKADAY_COMMUNICATOR)
     optionsArray[options] = "Screen Color";
     optionsEnumArray[options++] = ScreenColor;
 #endif
@@ -1459,10 +1459,8 @@ void menuHandler::keyVerificationFinalPrompt()
         options.notificationType = graphics::notificationTypeEnum::selection_picker;
         options.bannerCallback = [=](int selected) {
             if (selected == 1) {
-                meshtastic_NodeDetail *remoteNodePtr = nodeDB->getMeshNode(keyVerificationModule->getCurrentRemoteNode());
-                if (remoteNodePtr) {
-                    detailSetFlag(*remoteNodePtr, NODEDETAIL_FLAG_IS_KEY_MANUALLY_VERIFIED, true);
-                }
+                auto remoteNodePtr = nodeDB->getMeshNode(keyVerificationModule->getCurrentRemoteNode());
+                remoteNodePtr->bitfield |= NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_MASK;
             }
         };
         screen->showOverlayBanner(options);

src/graphics/draw/MessageRenderer.cpp

@@ -218,18 +218,18 @@ void drawTextMessageFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
     }
 
     // === Header Construction ===
-    const meshtastic_NodeDetail *node = nodeDB->getMeshNode(getFrom(&mp));
+    meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(getFrom(&mp));
     char headerStr[80];
     const char *sender = "???";
 #if defined(M5STACK_UNITC6L)
-    if (node && detailHasFlag(*node, NODEDETAIL_FLAG_HAS_USER))
-        sender = node->short_name;
+    if (node && node->has_user)
+        sender = node->user.short_name;
 #else
-    if (node && detailHasFlag(*node, NODEDETAIL_FLAG_HAS_USER)) {
-        if (SCREEN_WIDTH >= 200 && node->long_name[0] != '\0') {
-            sender = node->long_name;
+    if (node && node->has_user) {
+        if (SCREEN_WIDTH >= 200 && strlen(node->user.long_name) > 0) {
+            sender = node->user.long_name;
         } else {
-            sender = node->short_name;
+            sender = node->user.short_name;
         }
     }
 #endif

src/graphics/draw/NodeListRenderer.cpp

@@ -53,29 +53,23 @@ static int scrollIndex = 0;
 // Utility Functions
 // =============================
 
-const char *getSafeNodeName(OLEDDisplay *display, const meshtastic_NodeDetail *node)
+const char *getSafeNodeName(OLEDDisplay *display, meshtastic_NodeInfoLite *node)
 {
+    const char *name = NULL;
     static char nodeName[16] = "?";
-    if (!node) {
-        strncpy(nodeName, "?", sizeof(nodeName));
-        return nodeName;
-    }
-
-    const bool hasUser = detailHasFlag(*node, NODEDETAIL_FLAG_HAS_USER);
-    const char *name = nullptr;
-    if (config.display.use_long_node_name) {
-        if (hasUser && node->long_name[0] != '\0') {
-            name = node->long_name;
+    if (config.display.use_long_node_name == true) {
+        if (node->has_user && strlen(node->user.long_name) > 0) {
+            name = node->user.long_name;
+        } else {
+            snprintf(nodeName, sizeof(nodeName), "(%04X)", (uint16_t)(node->num & 0xFFFF));
         }
     } else {
-        if (hasUser && node->short_name[0] != '\0') {
-            name = node->short_name;
+        if (node->has_user && strlen(node->user.short_name) > 0) {
+            name = node->user.short_name;
+        } else {
+            snprintf(nodeName, sizeof(nodeName), "(%04X)", (uint16_t)(node->num & 0xFFFF));
         }
     }
-    if (!name) {
-        snprintf(nodeName, sizeof(nodeName), "(%04X)", static_cast<uint16_t>(node->num & 0xFFFF));
-        name = nodeName;
-    }
 
     // Use sanitizeString() function and copy directly into nodeName
     std::string sanitized_name = sanitizeString(name ? name : "");
@@ -170,7 +164,7 @@ void drawScrollbar(OLEDDisplay *display, int visibleNodeRows, int totalEntries,
 // Entry Renderers
 // =============================
 
-void drawEntryLastHeard(OLEDDisplay *display, meshtastic_NodeDetail *node, int16_t x, int16_t y, int columnWidth)
+void drawEntryLastHeard(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16_t x, int16_t y, int columnWidth)
 {
     bool isLeftCol = (x < SCREEN_WIDTH / 2);
     int timeOffset = (isHighResolution) ? (isLeftCol ? 7 : 10) : (isLeftCol ? 3 : 7);
@@ -195,7 +189,7 @@ void drawEntryLastHeard(OLEDDisplay *display, meshtastic_NodeDetail *node, int16
     display->setTextAlignment(TEXT_ALIGN_LEFT);
     display->setFont(FONT_SMALL);
     display->drawString(x + ((isHighResolution) ? 6 : 3), y, nodeName);
-    if (node && detailIsFavorite(*node)) {
+    if (node->is_favorite) {
         if (isHighResolution) {
             drawScaledXBitmap16x16(x, y + 6, smallbulletpoint_width, smallbulletpoint_height, smallbulletpoint, display);
         } else {
@@ -210,7 +204,7 @@ void drawEntryLastHeard(OLEDDisplay *display, meshtastic_NodeDetail *node, int16
     display->drawString(rightEdge - textWidth, y, timeStr);
 }
 
-void drawEntryHopSignal(OLEDDisplay *display, meshtastic_NodeDetail *node, int16_t x, int16_t y, int columnWidth)
+void drawEntryHopSignal(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16_t x, int16_t y, int columnWidth)
 {
     bool isLeftCol = (x < SCREEN_WIDTH / 2);
 
@@ -226,7 +220,7 @@ void drawEntryHopSignal(OLEDDisplay *display, meshtastic_NodeDetail *node, int16
     display->setFont(FONT_SMALL);
 
     display->drawStringMaxWidth(x + ((isHighResolution) ? 6 : 3), y, nameMaxWidth, nodeName);
-    if (node && detailIsFavorite(*node)) {
+    if (node->is_favorite) {
         if (isHighResolution) {
             drawScaledXBitmap16x16(x, y + 6, smallbulletpoint_width, smallbulletpoint_height, smallbulletpoint, display);
         } else {
@@ -249,7 +243,7 @@ void drawEntryHopSignal(OLEDDisplay *display, meshtastic_NodeDetail *node, int16
 
     // Draw hop count
     char hopStr[6] = "";
-    if (detailHasFlag(*node, NODEDETAIL_FLAG_HAS_HOPS_AWAY) && node->hops_away > 0)
+    if (node->has_hops_away && node->hops_away > 0)
         snprintf(hopStr, sizeof(hopStr), "[%d]", node->hops_away);
 
     if (hopStr[0] != '\0') {
@@ -259,7 +253,7 @@ void drawEntryHopSignal(OLEDDisplay *display, meshtastic_NodeDetail *node, int16
     }
 }
 
-void drawNodeDistance(OLEDDisplay *display, meshtastic_NodeDetail *node, int16_t x, int16_t y, int columnWidth)
+void drawNodeDistance(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16_t x, int16_t y, int columnWidth)
 {
     bool isLeftCol = (x < SCREEN_WIDTH / 2);
     int nameMaxWidth = columnWidth - (isHighResolution ? (isLeftCol ? 25 : 28) : (isLeftCol ? 20 : 22));
@@ -267,12 +261,12 @@ void drawNodeDistance(OLEDDisplay *display, meshtastic_NodeDetail *node, int16_t
     const char *nodeName = getSafeNodeName(display, node);
     char distStr[10] = "";
 
-    meshtastic_NodeDetail *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
+    meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
     if (nodeDB->hasValidPosition(ourNode) && nodeDB->hasValidPosition(node)) {
-        double lat1 = ourNode->latitude_i * 1e-7;
-        double lon1 = ourNode->longitude_i * 1e-7;
-        double lat2 = node->latitude_i * 1e-7;
-        double lon2 = node->longitude_i * 1e-7;
+        double lat1 = ourNode->position.latitude_i * 1e-7;
+        double lon1 = ourNode->position.longitude_i * 1e-7;
+        double lat2 = node->position.latitude_i * 1e-7;
+        double lon2 = node->position.longitude_i * 1e-7;
 
         double earthRadiusKm = 6371.0;
         double dLat = (lat2 - lat1) * DEG_TO_RAD;
@@ -318,7 +312,7 @@ void drawNodeDistance(OLEDDisplay *display, meshtastic_NodeDetail *node, int16_t
     display->setTextAlignment(TEXT_ALIGN_LEFT);
     display->setFont(FONT_SMALL);
     display->drawStringMaxWidth(x + ((isHighResolution) ? 6 : 3), y, nameMaxWidth, nodeName);
-    if (node && detailIsFavorite(*node)) {
+    if (node->is_favorite) {
         if (isHighResolution) {
             drawScaledXBitmap16x16(x, y + 6, smallbulletpoint_width, smallbulletpoint_height, smallbulletpoint, display);
         } else {
@@ -335,7 +329,7 @@ void drawNodeDistance(OLEDDisplay *display, meshtastic_NodeDetail *node, int16_t
     }
 }
 
-void drawEntryDynamic(OLEDDisplay *display, meshtastic_NodeDetail *node, int16_t x, int16_t y, int columnWidth)
+void drawEntryDynamic(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16_t x, int16_t y, int columnWidth)
 {
     switch (currentMode) {
     case MODE_LAST_HEARD:
@@ -352,7 +346,7 @@ void drawEntryDynamic(OLEDDisplay *display, meshtastic_NodeDetail *node, int16_t
     }
 }
 
-void drawEntryCompass(OLEDDisplay *display, meshtastic_NodeDetail *node, int16_t x, int16_t y, int columnWidth)
+void drawEntryCompass(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16_t x, int16_t y, int columnWidth)
 {
     bool isLeftCol = (x < SCREEN_WIDTH / 2);
 
@@ -364,7 +358,7 @@ void drawEntryCompass(OLEDDisplay *display, meshtastic_NodeDetail *node, int16_t
     display->setTextAlignment(TEXT_ALIGN_LEFT);
     display->setFont(FONT_SMALL);
     display->drawStringMaxWidth(x + ((isHighResolution) ? 6 : 3), y, nameMaxWidth, nodeName);
-    if (node && detailIsFavorite(*node)) {
+    if (node->is_favorite) {
         if (isHighResolution) {
             drawScaledXBitmap16x16(x, y + 6, smallbulletpoint_width, smallbulletpoint_height, smallbulletpoint, display);
         } else {
@@ -373,7 +367,7 @@ void drawEntryCompass(OLEDDisplay *display, meshtastic_NodeDetail *node, int16_t
     }
 }
 
-void drawCompassArrow(OLEDDisplay *display, meshtastic_NodeDetail *node, int16_t x, int16_t y, int columnWidth, float myHeading,
+void drawCompassArrow(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16_t x, int16_t y, int columnWidth, float myHeading,
                       double userLat, double userLon)
 {
     if (!nodeDB->hasValidPosition(node))
@@ -385,8 +379,8 @@ void drawCompassArrow(OLEDDisplay *display, meshtastic_NodeDetail *node, int16_t
     int centerX = x + columnWidth - arrowXOffset;
     int centerY = y + FONT_HEIGHT_SMALL / 2;
 
-    double nodeLat = node->latitude_i * 1e-7;
-    double nodeLon = node->longitude_i * 1e-7;
+    double nodeLat = node->position.latitude_i * 1e-7;
+    double nodeLon = node->position.longitude_i * 1e-7;
     float bearing = GeoCoord::bearing(userLat, userLon, nodeLat, nodeLon);
     float bearingToNode = RAD_TO_DEG * bearing;
     float relativeBearing = fmod((bearingToNode - myHeading + 360), 360);
@@ -472,17 +466,16 @@ void drawNodeListScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t
     int rowCount = 0;
 
     for (int i = startIndex; i < endIndex; ++i) {
-        meshtastic_NodeDetail *candidate = nodeDB->getMeshNodeByIndex(i);
-        if (locationScreen && candidate && !detailHasFlag(*candidate, NODEDETAIL_FLAG_HAS_POSITION)) {
+        if (locationScreen && !nodeDB->getMeshNodeByIndex(i)->has_position) {
             numskipped++;
             continue;
         }
         int xPos = x + (col * columnWidth);
         int yPos = y + yOffset;
-        renderer(display, candidate, xPos, yPos, columnWidth);
+        renderer(display, nodeDB->getMeshNodeByIndex(i), xPos, yPos, columnWidth);
 
         if (extras) {
-            extras(display, candidate, xPos, yPos, columnWidth, heading, lat, lon);
+            extras(display, nodeDB->getMeshNodeByIndex(i), xPos, yPos, columnWidth, heading, lat, lon);
         }
 
         lastNodeY = std::max(lastNodeY, yPos + FONT_HEIGHT_SMALL);
@@ -585,12 +578,9 @@ void drawNodeListWithCompasses(OLEDDisplay *display, OLEDDisplayUiState *state,
 {
     float heading = 0;
     bool validHeading = false;
-    meshtastic_NodeDetail *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
-    if (!ourNode || !nodeDB->hasValidPosition(ourNode)) {
-        return;
-    }
-    double lat = DegD(ourNode->latitude_i);
-    double lon = DegD(ourNode->longitude_i);
+    auto ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
+    double lat = DegD(ourNode->position.latitude_i);
+    double lon = DegD(ourNode->position.longitude_i);
 
 #if defined(M5STACK_UNITC6L)
     display->clear();

src/graphics/draw/NodeListRenderer.h

@@ -20,8 +20,8 @@ class Screen;
 namespace NodeListRenderer
 {
 // Entry renderer function types
-typedef void (*EntryRenderer)(OLEDDisplay *, meshtastic_NodeDetail *, int16_t, int16_t, int);
-typedef void (*NodeExtrasRenderer)(OLEDDisplay *, meshtastic_NodeDetail *, int16_t, int16_t, int, float, double, double);
+typedef void (*EntryRenderer)(OLEDDisplay *, meshtastic_NodeInfoLite *, int16_t, int16_t, int);
+typedef void (*NodeExtrasRenderer)(OLEDDisplay *, meshtastic_NodeInfoLite *, int16_t, int16_t, int, float, double, double);
 
 // Node list mode enumeration
 enum NodeListMode { MODE_LAST_HEARD = 0, MODE_HOP_SIGNAL = 1, MODE_DISTANCE = 2, MODE_COUNT = 3 };
@@ -32,14 +32,14 @@ void drawNodeListScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t
                         double lon = 0);
 
 // Entry renderers
-void drawEntryLastHeard(OLEDDisplay *display, meshtastic_NodeDetail *node, int16_t x, int16_t y, int columnWidth);
-void drawEntryHopSignal(OLEDDisplay *display, meshtastic_NodeDetail *node, int16_t x, int16_t y, int columnWidth);
-void drawNodeDistance(OLEDDisplay *display, meshtastic_NodeDetail *node, int16_t x, int16_t y, int columnWidth);
-void drawEntryDynamic(OLEDDisplay *display, meshtastic_NodeDetail *node, int16_t x, int16_t y, int columnWidth);
-void drawEntryCompass(OLEDDisplay *display, meshtastic_NodeDetail *node, int16_t x, int16_t y, int columnWidth);
+void drawEntryLastHeard(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16_t x, int16_t y, int columnWidth);
+void drawEntryHopSignal(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16_t x, int16_t y, int columnWidth);
+void drawNodeDistance(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16_t x, int16_t y, int columnWidth);
+void drawEntryDynamic(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16_t x, int16_t y, int columnWidth);
+void drawEntryCompass(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16_t x, int16_t y, int columnWidth);
 
 // Extras renderers
-void drawCompassArrow(OLEDDisplay *display, meshtastic_NodeDetail *node, int16_t x, int16_t y, int columnWidth, float myHeading,
+void drawCompassArrow(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16_t x, int16_t y, int columnWidth, float myHeading,
                       double userLat, double userLon);
 
 // Screen frame functions
@@ -51,7 +51,7 @@ void drawNodeListWithCompasses(OLEDDisplay *display, OLEDDisplayUiState *state,
 
 // Utility functions
 const char *getCurrentModeTitle(int screenWidth);
-const char *getSafeNodeName(OLEDDisplay *display, const meshtastic_NodeDetail *node);
+const char *getSafeNodeName(meshtastic_NodeInfoLite *node);
 void drawColumns(OLEDDisplay *display, int16_t x, int16_t y, const char **fields);
 
 // Bitmap drawing function

src/graphics/draw/NotificationRenderer.cpp

@@ -300,17 +300,14 @@ void NotificationRenderer::drawNodePicker(OLEDDisplay *display, OLEDDisplayUiSta
     int scratchLineNum = 0;
     for (int i = firstOptionToShow; i < alertBannerOptions && linesShown < visibleTotalLines; i++, linesShown++) {
         char temp_name[16] = {0};
-        meshtastic_NodeDetail *candidate = nodeDB->getMeshNodeByIndex(i + 1);
-        if (candidate && detailHasFlag(*candidate, NODEDETAIL_FLAG_HAS_USER) && candidate->long_name[0] != '\0') {
-            std::string sanitized = sanitizeString(candidate->long_name);
+        if (nodeDB->getMeshNodeByIndex(i + 1)->has_user) {
+            std::string sanitized = sanitizeString(nodeDB->getMeshNodeByIndex(i + 1)->user.long_name);
             strncpy(temp_name, sanitized.c_str(), sizeof(temp_name) - 1);
-        } else if (candidate) {
-            snprintf(temp_name, sizeof(temp_name), "(%04X)", static_cast<uint16_t>(candidate->num & 0xFFFF));
         } else {
-            strncpy(temp_name, "(?)", sizeof(temp_name) - 1);
+            snprintf(temp_name, sizeof(temp_name), "(%04X)", (uint16_t)(nodeDB->getMeshNodeByIndex(i + 1)->num & 0xFFFF));
         }
-        if (candidate && i == curSelected) {
-            selectedNodenum = candidate->num;
+        if (i == curSelected) {
+            selectedNodenum = nodeDB->getMeshNodeByIndex(i + 1)->num;
             if (isHighResolution) {
                 strncpy(scratchLineBuffer[scratchLineNum], "> ", 3);
                 strncpy(scratchLineBuffer[scratchLineNum] + 2, temp_name, 36);

src/graphics/draw/UIRenderer.cpp

@@ -27,22 +27,22 @@ static uint32_t lastSwitchTime = 0;
 namespace graphics
 {
 NodeNum UIRenderer::currentFavoriteNodeNum = 0;
-std::vector<meshtastic_NodeDetail *> graphics::UIRenderer::favoritedNodes;
+std::vector<meshtastic_NodeInfoLite *> graphics::UIRenderer::favoritedNodes;
 
 void graphics::UIRenderer::rebuildFavoritedNodes()
 {
     favoritedNodes.clear();
     size_t total = nodeDB->getNumMeshNodes();
     for (size_t i = 0; i < total; i++) {
-        meshtastic_NodeDetail *n = nodeDB->getMeshNodeByIndex(i);
+        meshtastic_NodeInfoLite *n = nodeDB->getMeshNodeByIndex(i);
         if (!n || n->num == nodeDB->getNodeNum())
             continue;
-        if (detailIsFavorite(*n))
+        if (n->is_favorite)
             favoritedNodes.push_back(n);
     }
 
     std::sort(favoritedNodes.begin(), favoritedNodes.end(),
-              [](const meshtastic_NodeDetail *a, const meshtastic_NodeDetail *b) { return a->num < b->num; });
+              [](const meshtastic_NodeInfoLite *a, const meshtastic_NodeInfoLite *b) { return a->num < b->num; });
 }
 
 #if !MESHTASTIC_EXCLUDE_GPS
@@ -257,7 +257,8 @@ void UIRenderer::drawNodes(OLEDDisplay *display, int16_t x, int16_t y, const mes
     }
 
 #if (defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ILI9342_DRIVER) || defined(ST7701_CS) || defined(ST7735_CS) ||      \
-     defined(ST7789_CS) || defined(USE_ST7789) || defined(ILI9488_CS) || defined(HX8357_CS) || defined(ST7796_CS)) &&            \
+     defined(ST7789_CS) || defined(USE_ST7789) || defined(ILI9488_CS) || defined(HX8357_CS) || defined(ST7796_CS) ||             \
+     defined(HACKADAY_COMMUNICATOR) || defined(USE_ST7796)) &&                                                                   \
     !defined(DISPLAY_FORCE_SMALL_FONTS)
 
     if (isHighResolution) {
@@ -289,8 +290,8 @@ void UIRenderer::drawNodeInfo(OLEDDisplay *display, const OLEDDisplayUiState *st
     if (nodeIndex < 0 || nodeIndex >= (int)favoritedNodes.size())
         return;
 
-    meshtastic_NodeDetail *node = favoritedNodes[nodeIndex];
-    if (!node || node->num == nodeDB->getNodeNum() || !detailIsFavorite(*node))
+    meshtastic_NodeInfoLite *node = favoritedNodes[nodeIndex];
+    if (!node || node->num == nodeDB->getNodeNum() || !node->is_favorite)
         return;
     display->clear();
 #if defined(M5STACK_UNITC6L)
@@ -303,9 +304,7 @@ void UIRenderer::drawNodeInfo(OLEDDisplay *display, const OLEDDisplayUiState *st
 #endif
     currentFavoriteNodeNum = node->num;
     // === Create the shortName and title string ===
-    const bool hasUser = detailHasFlag(*node, NODEDETAIL_FLAG_HAS_USER);
-    const char *shortNameCandidate = (hasUser && node->short_name[0] != '\0') ? node->short_name : nullptr;
-    const char *shortName = (shortNameCandidate && haveGlyphs(shortNameCandidate)) ? shortNameCandidate : "Node";
+    const char *shortName = (node->has_user && haveGlyphs(node->user.short_name)) ? node->user.short_name : "Node";
     char titlestr[32] = {0};
     snprintf(titlestr, sizeof(titlestr), "Fav: %s", shortName);
 
@@ -323,9 +322,9 @@ void UIRenderer::drawNodeInfo(OLEDDisplay *display, const OLEDDisplayUiState *st
     std::string usernameStr;
     // === 1. Long Name (always try to show first) ===
 #if defined(M5STACK_UNITC6L)
-    const char *username = (hasUser && node->long_name[0]) ? node->short_name : nullptr;
+    const char *username = (node->has_user && node->user.long_name[0]) ? node->user.short_name : nullptr;
 #else
-    const char *username = (hasUser && node->long_name[0]) ? node->long_name : nullptr;
+    const char *username = (node->has_user && node->user.long_name[0]) ? node->user.long_name : nullptr;
 #endif
 
     if (username) {
@@ -351,7 +350,7 @@ void UIRenderer::drawNodeInfo(OLEDDisplay *display, const OLEDDisplayUiState *st
         haveSignal = true;
     }
     // If hops is valid (>0), show right after signal
-    if (detailHasFlag(*node, NODEDETAIL_FLAG_HAS_HOPS_AWAY) && node->hops_away > 0) {
+    if (node->hops_away > 0) {
         size_t len = strlen(signalHopsStr);
         // Decide between "1 Hop" and "N Hops"
         if (haveSignal) {
@@ -385,23 +384,23 @@ void UIRenderer::drawNodeInfo(OLEDDisplay *display, const OLEDDisplayUiState *st
 #if !defined(M5STACK_UNITC6L)
     // === 4. Uptime (only show if metric is present) ===
     char uptimeStr[32] = "";
-    if (detailHasFlag(*node, NODEDETAIL_FLAG_HAS_UPTIME)) {
-        getUptimeStr(node->uptime_seconds * 1000, " Up", uptimeStr, sizeof(uptimeStr));
+    if (node->has_device_metrics && node->device_metrics.has_uptime_seconds) {
+        getUptimeStr(node->device_metrics.uptime_seconds * 1000, " Up", uptimeStr, sizeof(uptimeStr));
     }
     if (uptimeStr[0] && line < 5) {
         display->drawString(x, getTextPositions(display)[line++], uptimeStr);
     }
 
     // === 5. Distance (only if both nodes have GPS position) ===
-    meshtastic_NodeDetail *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
+    meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
     char distStr[24] = ""; // Make buffer big enough for any string
     bool haveDistance = false;
 
     if (nodeDB->hasValidPosition(ourNode) && nodeDB->hasValidPosition(node)) {
-        double lat1 = ourNode->latitude_i * 1e-7;
-        double lon1 = ourNode->longitude_i * 1e-7;
-        double lat2 = node->latitude_i * 1e-7;
-        double lon2 = node->longitude_i * 1e-7;
+        double lat1 = ourNode->position.latitude_i * 1e-7;
+        double lon1 = ourNode->position.longitude_i * 1e-7;
+        double lat2 = node->position.latitude_i * 1e-7;
+        double lon2 = node->position.longitude_i * 1e-7;
         double earthRadiusKm = 6371.0;
         double dLat = (lat2 - lat1) * DEG_TO_RAD;
         double dLon = (lon2 - lon1) * DEG_TO_RAD;
@@ -459,10 +458,6 @@ void UIRenderer::drawNodeInfo(OLEDDisplay *display, const OLEDDisplayUiState *st
             showCompass = true;
         }
         if (showCompass) {
-            const double ourLatDeg = DegD(ourNode->latitude_i);
-            const double ourLonDeg = DegD(ourNode->longitude_i);
-            const double nodeLatDeg = DegD(node->latitude_i);
-            const double nodeLonDeg = DegD(node->longitude_i);
             const int16_t topY = getTextPositions(display)[1];
             const int16_t bottomY = SCREEN_HEIGHT - (FONT_HEIGHT_SMALL - 1);
             const int16_t usableHeight = bottomY - topY - 5;
@@ -473,10 +468,16 @@ void UIRenderer::drawNodeInfo(OLEDDisplay *display, const OLEDDisplayUiState *st
             const int16_t compassX = x + SCREEN_WIDTH - compassRadius - 8;
             const int16_t compassY = topY + (usableHeight / 2) + ((FONT_HEIGHT_SMALL - 1) / 2) + 2;
 
-            float myHeading =
-                screen->hasHeading() ? screen->getHeading() * PI / 180 : screen->estimatedHeading(ourLatDeg, ourLonDeg);
+            const auto &op = ourNode->position;
+            float myHeading = screen->hasHeading() ? screen->getHeading() * PI / 180
+                                                   : screen->estimatedHeading(DegD(op.latitude_i), DegD(op.longitude_i));
 
-            float bearing = GeoCoord::bearing(ourLatDeg, ourLonDeg, nodeLatDeg, nodeLonDeg);
+            const auto &p = node->position;
+            /* unused
+            float d =
+                GeoCoord::latLongToMeter(DegD(p.latitude_i), DegD(p.longitude_i), DegD(op.latitude_i), DegD(op.longitude_i));
+            */
+            float bearing = GeoCoord::bearing(DegD(op.latitude_i), DegD(op.longitude_i), DegD(p.latitude_i), DegD(p.longitude_i));
             if (uiconfig.compass_mode == meshtastic_CompassMode_FREEZE_HEADING) {
                 myHeading = 0;
             } else {
@@ -520,21 +521,20 @@ void UIRenderer::drawNodeInfo(OLEDDisplay *display, const OLEDDisplayUiState *st
             int compassX = x + SCREEN_WIDTH / 2;
             int compassY = yBelowContent + availableHeight / 2;
 
-            const double ourLatDeg = DegD(ourNode->latitude_i);
-            const double ourLonDeg = DegD(ourNode->longitude_i);
+            const auto &op = ourNode->position;
             float myHeading = 0;
             if (uiconfig.compass_mode != meshtastic_CompassMode_FREEZE_HEADING) {
-                myHeading =
-                    screen->hasHeading() ? screen->getHeading() * PI / 180 : screen->estimatedHeading(ourLatDeg, ourLonDeg);
+                myHeading = screen->hasHeading() ? screen->getHeading() * PI / 180
+                                                 : screen->estimatedHeading(DegD(op.latitude_i), DegD(op.longitude_i));
             }
             graphics::CompassRenderer::drawCompassNorth(display, compassX, compassY, myHeading, compassRadius);
 
-            const double nodeLatDeg = DegD(node->latitude_i);
-            const double nodeLonDeg = DegD(node->longitude_i);
+            const auto &p = node->position;
             /* unused
-            float d = GeoCoord::latLongToMeter(nodeLatDeg, nodeLonDeg, ourLatDeg, ourLonDeg);
+            float d =
+                GeoCoord::latLongToMeter(DegD(p.latitude_i), DegD(p.longitude_i), DegD(op.latitude_i), DegD(op.longitude_i));
             */
-            float bearing = GeoCoord::bearing(ourLatDeg, ourLonDeg, nodeLatDeg, nodeLonDeg);
+            float bearing = GeoCoord::bearing(DegD(op.latitude_i), DegD(op.longitude_i), DegD(p.latitude_i), DegD(p.longitude_i));
             if (uiconfig.compass_mode != meshtastic_CompassMode_FREEZE_HEADING)
                 bearing -= myHeading;
             graphics::CompassRenderer::drawNodeHeading(display, compassX, compassY, compassRadius * 2, bearing);
@@ -556,7 +556,7 @@ void UIRenderer::drawDeviceFocused(OLEDDisplay *display, OLEDDisplayUiState *sta
     display->setTextAlignment(TEXT_ALIGN_LEFT);
     display->setFont(FONT_SMALL);
     int line = 1;
-    meshtastic_NodeDetail *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
+    meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
 
     // === Header ===
 #if defined(M5STACK_UNITC6L)
@@ -724,8 +724,8 @@ void UIRenderer::drawDeviceFocused(OLEDDisplay *display, OLEDDisplayUiState *sta
     int yOffset = (isHighResolution) ? 0 : 5;
     std::string longNameStr;
 
-    if (ourNode && detailHasFlag(*ourNode, NODEDETAIL_FLAG_HAS_USER) && ourNode->long_name[0] != '\0') {
-        longNameStr = sanitizeString(ourNode->long_name);
+    if (ourNode && ourNode->has_user && strlen(ourNode->user.long_name) > 0) {
+        longNameStr = sanitizeString(ourNode->user.long_name);
     }
     char shortnameble[35];
     snprintf(shortnameble, sizeof(shortnameble), "%s",
@@ -982,6 +982,8 @@ void UIRenderer::drawCompassAndLocationScreen(OLEDDisplay *display, OLEDDisplayU
     config.display.heading_bold = false;
 
     const char *displayLine = ""; // Initialize to empty string by default
+    meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
+
     if (config.position.gps_mode != meshtastic_Config_PositionConfig_GpsMode_ENABLED) {
         if (config.position.fixed_position) {
             displayLine = "Fixed GPS";

src/graphics/draw/UIRenderer.h

@@ -63,7 +63,7 @@ class UIRenderer
     static void drawCompassAndLocationScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
 
     static NodeNum currentFavoriteNodeNum;
-    static std::vector<meshtastic_NodeDetail *> favoritedNodes;
+    static std::vector<meshtastic_NodeInfoLite *> favoritedNodes;
     static void rebuildFavoritedNodes();
 
 // OEM screens

src/graphics/images.h

@@ -28,7 +28,7 @@ const uint8_t bluetoothConnectedIcon[36] PROGMEM = {0xfe, 0x01, 0xff, 0x03, 0x03
 
 #if (defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ILI9342_DRIVER) || defined(ST7701_CS) || defined(ST7735_CS) ||      \
      defined(ST7789_CS) || defined(USE_ST7789) || defined(HX8357_CS) || defined(ILI9488_CS) || defined(ST7796_CS) ||             \
-     ARCH_PORTDUINO) &&                                                                                                          \
+     defined(USE_ST7796) || defined(HACKADAY_COMMUNICATOR) || ARCH_PORTDUINO) &&                                                 \
     !defined(DISPLAY_FORCE_SMALL_FONTS)
 const uint8_t imgQuestionL1[] PROGMEM = {0xff, 0x01, 0x01, 0x32, 0x7b, 0x49, 0x49, 0x6f, 0x26, 0x01, 0x01, 0xff};
 const uint8_t imgQuestionL2[] PROGMEM = {0x0f, 0x08, 0x08, 0x08, 0x06, 0x0f, 0x0f, 0x06, 0x08, 0x08, 0x08, 0x0f};

src/graphics/niche/InkHUD/Applet.cpp

@@ -5,7 +5,6 @@
 #include "main.h"
 
 #include "RTC.h"
-#include "mesh/NodeDB.h"
 
 using namespace NicheGraphics;
 
@@ -334,13 +333,13 @@ std::string InkHUD::Applet::parse(std::string text)
 // Get the best version of a node's short name available to us
 // Parses any non-ascii chars
 // Swaps for last-four of node-id if the real short name is unknown or can't be rendered (emoji)
-std::string InkHUD::Applet::parseShortName(meshtastic_NodeDetail *node)
+std::string InkHUD::Applet::parseShortName(meshtastic_NodeInfoLite *node)
 {
     assert(node);
 
     // Use the true shortname if known, and doesn't contain any unprintable characters (emoji, etc.)
-    if (detailHasFlag(*node, NODEDETAIL_FLAG_HAS_USER) && node->short_name[0] != '\0') {
-        std::string parsed = parse(node->short_name);
+    if (node->has_user) {
+        std::string parsed = parse(node->user.short_name);
         if (isPrintable(parsed))
             return parsed;
     }
@@ -641,9 +640,7 @@ uint16_t InkHUD::Applet::getActiveNodeCount()
 
     // For each node in db
     for (uint16_t i = 0; i < nodeDB->getNumMeshNodes(); i++) {
-        const meshtastic_NodeDetail *node = nodeDB->getMeshNodeByIndex(i);
-        if (!node)
-            continue;
+        meshtastic_NodeInfoLite *node = nodeDB->getMeshNodeByIndex(i);
 
         // Check if heard recently, and not our own node
         if (sinceLastSeen(node) < settings->recentlyActiveSeconds && node->num != nodeDB->getNodeNum())

src/graphics/niche/InkHUD/Applet.h

@@ -16,7 +16,6 @@
 #include <GFX.h> // GFXRoot drawing lib
 
 #include "mesh/MeshTypes.h"
-#include "mesh/generated/meshtastic/deviceonly.pb.h"
 
 #include "./AppletFont.h"
 #include "./Applets/System/Notification/Notification.h" // The notification object, not the applet
@@ -134,15 +133,15 @@ class Applet : public GFX
     void drawLogo(int16_t centerX, int16_t centerY, uint16_t width, uint16_t height,
                   Color color = BLACK); // Draw the Meshtastic logo
 
-    std::string hexifyNodeNum(NodeNum num);                  // Style as !0123abdc
-    SignalStrength getSignalStrength(float snr, float rssi); // Interpret SNR and RSSI, as an easy to understand value
-    std::string getTimeString(uint32_t epochSeconds);        // Human readable
-    std::string getTimeString();                             // Current time, human readable
-    uint16_t getActiveNodeCount();                           // Duration determined by user, in onscreen menu
-    std::string localizeDistance(uint32_t meters);           // Human readable distance, imperial or metric
-    std::string parse(std::string text);                     // Handle text which might contain special chars
-    std::string parseShortName(meshtastic_NodeDetail *node); // Get the shortname, or a substitute if has unprintable chars
-    bool isPrintable(std::string);                           // Check for characters which the font can't print
+    std::string hexifyNodeNum(NodeNum num);                    // Style as !0123abdc
+    SignalStrength getSignalStrength(float snr, float rssi);   // Interpret SNR and RSSI, as an easy to understand value
+    std::string getTimeString(uint32_t epochSeconds);          // Human readable
+    std::string getTimeString();                               // Current time, human readable
+    uint16_t getActiveNodeCount();                             // Duration determined by user, in onscreen menu
+    std::string localizeDistance(uint32_t meters);             // Human readable distance, imperial or metric
+    std::string parse(std::string text);                       // Handle text which might contain special chars
+    std::string parseShortName(meshtastic_NodeInfoLite *node); // Get the shortname, or a substitute if has unprintable chars
+    bool isPrintable(std::string);                             // Check for characters which the font can't print
 
     // Convenient references
 

src/graphics/niche/InkHUD/Applets/Bases/Map/MapApplet.cpp

@@ -2,8 +2,6 @@
 
 #include "./MapApplet.h"
 
-#include "mesh/NodeDB.h"
-
 using namespace NicheGraphics;
 
 void InkHUD::MapApplet::onRender()
@@ -138,9 +136,9 @@ void InkHUD::MapApplet::onRender()
     printAt(vertBarX + (bottomLabelW / 2) + 1, bottomLabelY + (bottomLabelH / 2), vertBottomLabel, CENTER, MIDDLE);
 
     // Draw our node LAST with full white fill + outline
-    meshtastic_NodeDetail *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
+    meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
     if (ourNode && nodeDB->hasValidPosition(ourNode)) {
-        Marker self = calculateMarker(ourNode->latitude_i * 1e-7f, ourNode->longitude_i * 1e-7f, false, 0);
+        Marker self = calculateMarker(ourNode->position.latitude_i * 1e-7, ourNode->position.longitude_i * 1e-7, false, 0);
 
         int16_t centerX = X(0.5) + (self.eastMeters * metersToPx);
         int16_t centerY = Y(0.5) - (self.northMeters * metersToPx);
@@ -168,10 +166,10 @@ void InkHUD::MapApplet::onRender()
 void InkHUD::MapApplet::getMapCenter(float *lat, float *lng)
 {
     // If we have a valid position for our own node, use that as the anchor
-    meshtastic_NodeDetail *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
+    meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
     if (ourNode && nodeDB->hasValidPosition(ourNode)) {
-        *lat = ourNode->latitude_i * 1e-7f;
-        *lng = ourNode->longitude_i * 1e-7f;
+        *lat = ourNode->position.latitude_i * 1e-7;
+        *lng = ourNode->position.longitude_i * 1e-7;
     } else {
         // Find mean lat long coords
         // ============================
@@ -191,7 +189,7 @@ void InkHUD::MapApplet::getMapCenter(float *lat, float *lng)
 
         // For each node in db
         for (uint32_t i = 0; i < nodeDB->getNumMeshNodes(); i++) {
-            meshtastic_NodeDetail *node = nodeDB->getMeshNodeByIndex(i);
+            meshtastic_NodeInfoLite *node = nodeDB->getMeshNodeByIndex(i);
 
             // Skip if no position
             if (!nodeDB->hasValidPosition(node))
@@ -202,8 +200,8 @@ void InkHUD::MapApplet::getMapCenter(float *lat, float *lng)
                 continue;
 
             // Latitude and Longitude of node, in radians
-            float latRad = node->latitude_i * (1e-7f) * DEG_TO_RAD;
-            float lngRad = node->longitude_i * (1e-7f) * DEG_TO_RAD;
+            float latRad = node->position.latitude_i * (1e-7) * DEG_TO_RAD;
+            float lngRad = node->position.longitude_i * (1e-7) * DEG_TO_RAD;
 
             // Convert to cartesian points, with center of earth at 0, 0, 0
             // Exact distance from center is irrelevant, as we're only interested in the vector
@@ -290,7 +288,7 @@ void InkHUD::MapApplet::getMapCenter(float *lat, float *lng)
     float westernmost = lngCenter;
 
     for (size_t i = 0; i < nodeDB->getNumMeshNodes(); i++) {
-        meshtastic_NodeDetail *node = nodeDB->getMeshNodeByIndex(i);
+        meshtastic_NodeInfoLite *node = nodeDB->getMeshNodeByIndex(i);
 
         // Skip if no position
         if (!nodeDB->hasValidPosition(node))
@@ -301,12 +299,12 @@ void InkHUD::MapApplet::getMapCenter(float *lat, float *lng)
             continue;
 
         // Check for a new top or bottom latitude
-        float latNode = node->latitude_i * 1e-7f;
+        float latNode = node->position.latitude_i * 1e-7;
         northernmost = max(northernmost, latNode);
         southernmost = min(southernmost, latNode);
 
         // Longitude is trickier
-        float lngNode = node->longitude_i * 1e-7f;
+        float lngNode = node->position.longitude_i * 1e-7;
         float degEastward = fmod(((lngNode - lngCenter) + 360), 360);      // Degrees traveled east from lngCenter to reach node
         float degWestward = abs(fmod(((lngNode - lngCenter) - 360), 360)); // Degrees traveled west from lngCenter to reach node
         if (degEastward < degWestward)
@@ -368,14 +366,14 @@ InkHUD::MapApplet::Marker InkHUD::MapApplet::calculateMarker(float lat, float ln
     return m;
 }
 // Draw a marker on the map for a node, with a shortname label, and backing box
-void InkHUD::MapApplet::drawLabeledMarker(meshtastic_NodeDetail *node)
+void InkHUD::MapApplet::drawLabeledMarker(meshtastic_NodeInfoLite *node)
 {
     // Find x and y position based on node's position in nodeDB
     assert(nodeDB->hasValidPosition(node));
-    Marker m = calculateMarker(node->latitude_i * 1e-7f,  // Lat, converted from Meshtastic's internal int32 style
-                               node->longitude_i * 1e-7f, // Long, converted from Meshtastic's internal int32 style
-                               detailHasFlag(*node, NODEDETAIL_FLAG_HAS_HOPS_AWAY), // Is the hopsAway number valid
-                               node->hops_away                                      // Hops away
+    Marker m = calculateMarker(node->position.latitude_i * 1e-7,  // Lat, converted from Meshtastic's internal int32 style
+                               node->position.longitude_i * 1e-7, // Long, converted from Meshtastic's internal int32 style
+                               node->has_hops_away,               // Is the hopsAway number valid
+                               node->hops_away                    // Hops away
     );
 
     // Convert to pixel coords
@@ -398,9 +396,9 @@ void InkHUD::MapApplet::drawLabeledMarker(meshtastic_NodeDetail *node)
     uint16_t labelH;
     uint8_t markerSize;
 
-    bool tooManyHops = detailHasFlag(*node, NODEDETAIL_FLAG_HAS_HOPS_AWAY) && node->hops_away > config.lora.hop_limit;
+    bool tooManyHops = node->hops_away > config.lora.hop_limit;
     bool isOurNode = node->num == nodeDB->getNodeNum();
-    bool unknownHops = !detailHasFlag(*node, NODEDETAIL_FLAG_HAS_HOPS_AWAY) && !isOurNode;
+    bool unknownHops = !node->has_hops_away && !isOurNode;
 
     // Parse any non-ascii chars in the short name,
     // and use last 4 instead if unknown / can't render
@@ -478,7 +476,7 @@ bool InkHUD::MapApplet::enoughMarkers()
 {
     size_t count = 0;
     for (size_t i = 0; i < nodeDB->getNumMeshNodes(); i++) {
-        meshtastic_NodeDetail *node = nodeDB->getMeshNodeByIndex(i);
+        meshtastic_NodeInfoLite *node = nodeDB->getMeshNodeByIndex(i);
 
         // Count nodes
         if (nodeDB->hasValidPosition(node) && shouldDrawNode(node))
@@ -501,7 +499,7 @@ void InkHUD::MapApplet::calculateAllMarkers()
 
     // For each node in db
     for (uint32_t i = 0; i < nodeDB->getNumMeshNodes(); i++) {
-        meshtastic_NodeDetail *node = nodeDB->getMeshNodeByIndex(i);
+        meshtastic_NodeInfoLite *node = nodeDB->getMeshNodeByIndex(i);
 
         // Skip if no position
         if (!nodeDB->hasValidPosition(node))
@@ -517,11 +515,12 @@ void InkHUD::MapApplet::calculateAllMarkers()
             continue;
 
         // Calculate marker and store it
-        markers.push_back(calculateMarker(node->latitude_i * 1e-7f,  // Lat, converted from Meshtastic's internal int32 style
-                                          node->longitude_i * 1e-7f, // Long, converted from Meshtastic's internal int32 style
-                                          detailHasFlag(*node, NODEDETAIL_FLAG_HAS_HOPS_AWAY), // Is the hopsAway number valid
-                                          node->hops_away                                      // Hops away
-                                          ));
+        markers.push_back(
+            calculateMarker(node->position.latitude_i * 1e-7,  // Lat, converted from Meshtastic's internal int32 style
+                            node->position.longitude_i * 1e-7, // Long, converted from Meshtastic's internal int32 style
+                            node->has_hops_away,               // Is the hopsAway number valid
+                            node->hops_away                    // Hops away
+                            ));
     }
 }
 

src/graphics/niche/InkHUD/Applets/Bases/Map/MapApplet.h

@@ -30,12 +30,12 @@ class MapApplet : public Applet
     void onRender() override;
 
   protected:
-    virtual bool shouldDrawNode(meshtastic_NodeDetail *node) { return true; } // Allow derived applets to filter the nodes
+    virtual bool shouldDrawNode(meshtastic_NodeInfoLite *node) { return true; } // Allow derived applets to filter the nodes
     virtual void getMapCenter(float *lat, float *lng);
     virtual void getMapSize(uint32_t *widthMeters, uint32_t *heightMeters);
 
-    bool enoughMarkers();                                // Anything to draw?
-    void drawLabeledMarker(meshtastic_NodeDetail *node); // Highlight a specific marker
+    bool enoughMarkers();                                  // Anything to draw?
+    void drawLabeledMarker(meshtastic_NodeInfoLite *node); // Highlight a specific marker
 
   private:
     // Position and size of a marker to be drawn

src/graphics/niche/InkHUD/Applets/Bases/NodeList/NodeListApplet.cpp

@@ -3,7 +3,7 @@
 #include "RTC.h"
 
 #include "GeoCoord.h"
-#include "mesh/NodeDB.h"
+#include "NodeDB.h"
 
 #include "./NodeListApplet.h"
 
@@ -50,19 +50,19 @@ ProcessMessage InkHUD::NodeListApplet::handleReceived(const meshtastic_MeshPacke
     c.signal = getSignalStrength(mp.rx_snr, mp.rx_rssi);
 
     // Assemble info: from nodeDB (needed to detect changes)
-    meshtastic_NodeDetail *node = nodeDB->getMeshNode(c.nodeNum);
-    meshtastic_NodeDetail *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
+    meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(c.nodeNum);
+    meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
     if (node) {
-        if (detailHasFlag(*node, NODEDETAIL_FLAG_HAS_HOPS_AWAY))
+        if (node->has_hops_away)
             c.hopsAway = node->hops_away;
 
         if (nodeDB->hasValidPosition(node) && nodeDB->hasValidPosition(ourNode)) {
             // Get lat and long as float
             // Meshtastic stores these as integers internally
-            float ourLat = ourNode->latitude_i * 1e-7f;
-            float ourLong = ourNode->longitude_i * 1e-7f;
-            float theirLat = node->latitude_i * 1e-7f;
-            float theirLong = node->longitude_i * 1e-7f;
+            float ourLat = ourNode->position.latitude_i * 1e-7;
+            float ourLong = ourNode->position.longitude_i * 1e-7;
+            float theirLat = node->position.latitude_i * 1e-7;
+            float theirLong = node->position.longitude_i * 1e-7;
 
             c.distanceMeters = (int32_t)GeoCoord::latLongToMeter(theirLat, theirLong, ourLat, ourLong);
         }
@@ -144,7 +144,7 @@ void InkHUD::NodeListApplet::onRender()
         std::string distance;  // handled below;
         uint8_t &hopsAway = card->hopsAway;
 
-        meshtastic_NodeDetail *node = nodeDB->getMeshNode(nodeNum);
+        meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(nodeNum);
 
         // Skip deleted nodes
         if (!node) {
@@ -162,8 +162,8 @@ void InkHUD::NodeListApplet::onRender()
         // -- Longname --
         // Parse special chars in long name
         // Use node id if unknown
-        if (node && detailHasFlag(*node, NODEDETAIL_FLAG_HAS_USER))
-            longName = parse(node->long_name); // Found in nodeDB
+        if (node && node->has_user)
+            longName = parse(node->user.long_name); // Found in nodeDB
         else {
             // Not found in nodeDB, show a hex nodeid instead
             longName = hexifyNodeNum(nodeNum);

src/graphics/niche/InkHUD/Applets/System/Logo/LogoApplet.cpp

@@ -14,10 +14,10 @@ InkHUD::LogoApplet::LogoApplet() : concurrency::OSThread("LogoApplet")
     // During onboarding, show the default short name as well as the version string
     // This behavior assists manufacturers during mass production, and should not be modified without good reason
     if (!settings->tips.safeShutdownSeen) {
-        meshtastic_NodeDetail *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
+        meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
         fontTitle = fontMedium;
         textLeft = xstr(APP_VERSION_SHORT);
-        textRight = ourNode ? parseShortName(ourNode) : "";
+        textRight = parseShortName(ourNode);
         textTitle = "Meshtastic";
     } else {
         fontTitle = fontSmall;
@@ -146,10 +146,10 @@ void InkHUD::LogoApplet::onShutdown()
 
     // Prepare for the powered-off screen now
     // We can change these values because the initial "shutting down" screen has already rendered at this point
-    meshtastic_NodeDetail *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
+    meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
     textLeft = "";
     textRight = "";
-    textTitle = ourNode ? parseShortName(ourNode) : "";
+    textTitle = parseShortName(ourNode);
     fontTitle = fontMedium;
 
     // This is then drawn by InkHUD::Events::onShutdown, with a blocking FULL update, after InkHUD's flash write is complete

src/graphics/niche/InkHUD/Applets/System/Menu/MenuApplet.cpp

@@ -8,7 +8,6 @@
 #include "Router.h"
 #include "airtime.h"
 #include "main.h"
-#include "mesh/NodeDB.h"
 #include "power.h"
 
 #if !MESHTASTIC_EXCLUDE_GPS
@@ -617,8 +616,7 @@ void InkHUD::MenuApplet::populateRecipientPage()
 
     // Count favorites
     for (uint32_t i = 0; i < nodeCount; i++) {
-        const meshtastic_NodeDetail *detail = nodeDB->getMeshNodeByIndex(i);
-        if (detail && detailIsFavorite(*detail))
+        if (nodeDB->getMeshNodeByIndex(i)->is_favorite)
             favoriteCount++;
     }
 
@@ -626,12 +624,10 @@ void InkHUD::MenuApplet::populateRecipientPage()
     // Don't want some monstrous list that takes 100 clicks to reach exit
     if (favoriteCount < 20) {
         for (uint32_t i = 0; i < nodeCount; i++) {
-            const meshtastic_NodeDetail *node = nodeDB->getMeshNodeByIndex(i);
-            if (!node)
-                continue;
+            meshtastic_NodeInfoLite *node = nodeDB->getMeshNodeByIndex(i);
 
             // Skip node if not a favorite
-            if (!detailIsFavorite(*node))
+            if (!node->is_favorite)
                 continue;
 
             CannedMessages::RecipientItem r;
@@ -641,8 +637,8 @@ void InkHUD::MenuApplet::populateRecipientPage()
 
             // Set a label for the menu item
             r.label = "DM: ";
-            if (detailHasFlag(*node, NODEDETAIL_FLAG_HAS_USER) && node->long_name[0] != '\0')
-                r.label += parse(node->long_name);
+            if (node->has_user)
+                r.label += parse(node->user.long_name);
             else
                 r.label += hexifyNodeNum(node->num); // Unsure if it's possible to favorite a node without NodeInfo?
 

src/graphics/niche/InkHUD/Applets/System/Notification/NotificationApplet.cpp

@@ -5,7 +5,6 @@
 #include "./Notification.h"
 #include "graphics/niche/InkHUD/Persistence.h"
 
-#include "mesh/NodeDB.h"
 #include "meshUtils.h"
 #include "modules/TextMessageModule.h"
 
@@ -207,13 +206,13 @@ std::string InkHUD::NotificationApplet::getNotificationText(uint16_t widthAvaila
             isBroadcast ? &inkhud->persistence->latestMessage.broadcast : &inkhud->persistence->latestMessage.dm;
 
         // Find info about the sender
-        meshtastic_NodeDetail *node = nodeDB->getMeshNode(message->sender);
+        meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(message->sender);
 
         // Leading tag (channel vs. DM)
         text += isBroadcast ? "From:" : "DM: ";
 
         // Sender id
-        if (node && detailHasFlag(*node, NODEDETAIL_FLAG_HAS_USER))
+        if (node && node->has_user)
             text += parseShortName(node);
         else
             text += hexifyNodeNum(message->sender);
@@ -227,7 +226,7 @@ std::string InkHUD::NotificationApplet::getNotificationText(uint16_t widthAvaila
             text += isBroadcast ? "Msg from " : "DM from ";
 
             // Sender id
-            if (node && detailHasFlag(*node, NODEDETAIL_FLAG_HAS_USER))
+            if (node && node->has_user)
                 text += parseShortName(node);
             else
                 text += hexifyNodeNum(message->sender);

src/graphics/niche/InkHUD/Applets/User/AllMessage/AllMessageApplet.cpp

@@ -69,11 +69,11 @@ void InkHUD::AllMessageApplet::onRender()
     // Sender's id
     // - short name and long name, if available, or
     // - node id
-    meshtastic_NodeDetail *sender = nodeDB->getMeshNode(message->sender);
-    if (sender && detailHasFlag(*sender, NODEDETAIL_FLAG_HAS_USER)) {
+    meshtastic_NodeInfoLite *sender = nodeDB->getMeshNode(message->sender);
+    if (sender && sender->has_user) {
         header += parseShortName(sender); // May be last-four of node if unprintable (emoji, etc)
         header += " (";
-        header += parse(sender->long_name);
+        header += parse(sender->user.long_name);
         header += ")";
     } else
         header += hexifyNodeNum(message->sender);

src/graphics/niche/InkHUD/Applets/User/DM/DMApplet.cpp

@@ -65,11 +65,11 @@ void InkHUD::DMApplet::onRender()
     // Sender's id
     // - shortname and long name, if available, or
     // - node id
-    meshtastic_NodeDetail *sender = nodeDB->getMeshNode(latestMessage->dm.sender);
-    if (sender && detailHasFlag(*sender, NODEDETAIL_FLAG_HAS_USER)) {
+    meshtastic_NodeInfoLite *sender = nodeDB->getMeshNode(latestMessage->dm.sender);
+    if (sender && sender->has_user) {
         header += parseShortName(sender); // May be last-four of node if unprintable (emoji, etc)
         header += " (";
-        header += parse(sender->long_name);
+        header += parse(sender->user.long_name);
         header += ")";
     } else
         header += hexifyNodeNum(latestMessage->dm.sender);

src/graphics/niche/InkHUD/Applets/User/Heard/HeardApplet.cpp

@@ -6,8 +6,6 @@
 
 #include "./HeardApplet.h"
 
-#include "mesh/NodeDB.h"
-
 using namespace NicheGraphics;
 
 void InkHUD::HeardApplet::onActivate()
@@ -63,7 +61,7 @@ void InkHUD::HeardApplet::handleParsed(CardInfo c)
 void InkHUD::HeardApplet::populateFromNodeDB()
 {
     // Fill a collection with pointers to each node in db
-    std::vector<meshtastic_NodeDetail *> ordered;
+    std::vector<meshtastic_NodeInfoLite *> ordered;
     for (auto mn = nodeDB->meshNodes->begin(); mn != nodeDB->meshNodes->end(); ++mn) {
         // Only copy if valid, and not our own node
         if (mn->num != 0 && mn->num != nodeDB->getNodeNum())
@@ -71,7 +69,7 @@ void InkHUD::HeardApplet::populateFromNodeDB()
     }
 
     // Sort the collection by age
-    std::sort(ordered.begin(), ordered.end(), [](const meshtastic_NodeDetail *top, const meshtastic_NodeDetail *bottom) -> bool {
+    std::sort(ordered.begin(), ordered.end(), [](meshtastic_NodeInfoLite *top, meshtastic_NodeInfoLite *bottom) -> bool {
         return (top->last_heard > bottom->last_heard);
     });
 
@@ -81,21 +79,21 @@ void InkHUD::HeardApplet::populateFromNodeDB()
         ordered.resize(maxCards());
 
     // Create card info for these (stale) node observations
-    meshtastic_NodeDetail *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
-    for (meshtastic_NodeDetail *node : ordered) {
+    meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
+    for (meshtastic_NodeInfoLite *node : ordered) {
         CardInfo c;
         c.nodeNum = node->num;
 
-        if (detailHasFlag(*node, NODEDETAIL_FLAG_HAS_HOPS_AWAY))
+        if (node->has_hops_away)
             c.hopsAway = node->hops_away;
 
         if (nodeDB->hasValidPosition(node) && nodeDB->hasValidPosition(ourNode)) {
             // Get lat and long as float
             // Meshtastic stores these as integers internally
-            float ourLat = ourNode->latitude_i * 1e-7f;
-            float ourLong = ourNode->longitude_i * 1e-7f;
-            float theirLat = node->latitude_i * 1e-7f;
-            float theirLong = node->longitude_i * 1e-7f;
+            float ourLat = ourNode->position.latitude_i * 1e-7;
+            float ourLong = ourNode->position.longitude_i * 1e-7;
+            float theirLat = node->position.latitude_i * 1e-7;
+            float theirLong = node->position.longitude_i * 1e-7;
 
             c.distanceMeters = (int32_t)GeoCoord::latLongToMeter(theirLat, theirLong, ourLat, ourLong);
         }

src/graphics/niche/InkHUD/Applets/User/Positions/PositionsApplet.cpp

@@ -14,9 +14,9 @@ void InkHUD::PositionsApplet::onRender()
     // We might be rendering because we got a position packet from them
     // We might be rendering because our own position updated
     // Either way, we still highlight which node most recently sent us a position packet
-    const meshtastic_NodeDetail *node = nodeDB->getMeshNode(lastFrom);
+    meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(lastFrom);
     if (node && nodeDB->hasValidPosition(node) && enoughMarkers())
-        drawLabeledMarker(const_cast<meshtastic_NodeDetail *>(node));
+        drawLabeledMarker(node);
 }
 
 // Determine if we need to redraw the map, when we receive a new position packet

src/graphics/niche/InkHUD/Applets/User/ThreadedMessage/ThreadedMessageApplet.cpp

@@ -108,8 +108,8 @@ void InkHUD::ThreadedMessageApplet::onRender()
             info += "Me";
         else {
             // Check if sender is node db
-            meshtastic_NodeDetail *sender = nodeDB->getMeshNode(m.sender);
-            if (sender && detailHasFlag(*sender, NODEDETAIL_FLAG_HAS_USER))
+            meshtastic_NodeInfoLite *sender = nodeDB->getMeshNode(m.sender);
+            if (sender)
                 info += parseShortName(sender); // Handle any unprintable chars in short name
             else
                 info += hexifyNodeNum(m.sender); // No node info at all. Print the node num

src/input/HackadayCommunicatorKeyboard.cpp

@@ -0,0 +1,217 @@
+#if defined(HACKADAY_COMMUNICATOR)
+
+#include "HackadayCommunicatorKeyboard.h"
+#include "main.h"
+
+#define _TCA8418_COLS 10
+#define _TCA8418_ROWS 8
+#define _TCA8418_NUM_KEYS 80
+
+#define _TCA8418_MULTI_TAP_THRESHOLD 1500
+
+using Key = TCA8418KeyboardBase::TCA8418Key;
+
+constexpr uint8_t modifierRightShiftKey = 30;
+constexpr uint8_t modifierRightShift = 0b0001;
+constexpr uint8_t modifierLeftShiftKey = 76; // keynum -1
+constexpr uint8_t modifierLeftShift = 0b0001;
+// constexpr uint8_t modifierSymKey = 42;
+// constexpr uint8_t modifierSym = 0b0010;
+
+// Num chars per key, Modulus for rotating through characters
+static uint8_t HackadayCommunicatorTapMod[_TCA8418_NUM_KEYS] = {
+    0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+    0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 2, 2, 2, 2, 2, 2, 0, 0, 0, 1, 2, 2, 2, 1, 2, 2, 0, 0, 0, 2, 1, 2, 2, 0, 1, 1, 0,
+};
+
+static unsigned char HackadayCommunicatorTapMap[_TCA8418_NUM_KEYS][2] = {{},
+                                                                         {},
+                                                                         {'+'},
+                                                                         {'9'},
+                                                                         {'8'},
+                                                                         {'7'},
+                                                                         {'2'},
+                                                                         {'3'},
+                                                                         {'4'},
+                                                                         {'5'},
+                                                                         {Key::ESC},
+                                                                         {'q', 'Q'},
+                                                                         {'w', 'W'},
+                                                                         {'e', 'E'},
+                                                                         {'r', 'R'},
+                                                                         {'t', 'T'},
+                                                                         {'y', 'Y'},
+                                                                         {'u', 'U'},
+                                                                         {'i', 'I'},
+                                                                         {'o', 'O'},
+                                                                         {Key::TAB},
+                                                                         {'a', 'A'},
+                                                                         {'s', 'S'},
+                                                                         {'d', 'D'},
+                                                                         {'f', 'F'},
+                                                                         {'g', 'G'},
+                                                                         {'h', 'H'},
+                                                                         {'j', 'J'},
+                                                                         {'k', 'K'},
+                                                                         {'l', 'L'},
+                                                                         {},
+                                                                         {'z', 'Z'},
+                                                                         {'x', 'X'},
+                                                                         {'c', 'C'},
+                                                                         {'v', 'V'},
+                                                                         {'b', 'B'},
+                                                                         {'n', 'N'},
+                                                                         {'m', 'M'},
+                                                                         {',', '<'},
+                                                                         {'.', '>'},
+                                                                         {},
+                                                                         {},
+                                                                         {},
+                                                                         {'\\'},
+                                                                         {' '},
+                                                                         {},
+                                                                         {Key::RIGHT},
+                                                                         {Key::DOWN},
+                                                                         {Key::LEFT},
+                                                                         {},
+                                                                         {},
+                                                                         {},
+                                                                         {'-'},
+                                                                         {'6', '^'},
+                                                                         {'5', '%'},
+                                                                         {'4', '$'},
+                                                                         {'[', '{'},
+                                                                         {']', '}'},
+                                                                         {'p', 'P'},
+                                                                         {},
+                                                                         {},
+                                                                         {},
+                                                                         {'*'},
+                                                                         {'3', '#'},
+                                                                         {'2', '@'},
+                                                                         {'1', '!'},
+                                                                         {Key::SELECT},
+                                                                         {'\'', '"'},
+                                                                         {';', ':'},
+                                                                         {},
+                                                                         {},
+                                                                         {},
+                                                                         {'/', '?'},
+                                                                         {'='},
+                                                                         {'.', '>'},
+                                                                         {'0', ')'},
+                                                                         {},
+                                                                         {Key::UP},
+                                                                         {Key::BSP},
+                                                                         {}};
+
+HackadayCommunicatorKeyboard::HackadayCommunicatorKeyboard()
+    : TCA8418KeyboardBase(_TCA8418_ROWS, _TCA8418_COLS), modifierFlag(0), last_modifier_time(0), last_key(-1), next_key(-1),
+      last_tap(0L), char_idx(0), tap_interval(0)
+{
+    reset();
+}
+
+void HackadayCommunicatorKeyboard::reset(void)
+{
+    TCA8418KeyboardBase::reset();
+    enableInterrupts();
+}
+
+// handle multi-key presses (shift and alt)
+void HackadayCommunicatorKeyboard::trigger()
+{
+    uint8_t count = keyCount();
+    if (count == 0)
+        return;
+    for (uint8_t i = 0; i < count; ++i) {
+        uint8_t k = readRegister(TCA8418_REG_KEY_EVENT_A + i);
+        uint8_t key = k & 0x7F;
+        if (k & 0x80) {
+            pressed(key);
+        } else {
+            released();
+            state = Idle;
+        }
+    }
+}
+
+void HackadayCommunicatorKeyboard::pressed(uint8_t key)
+{
+    if (state == Init || state == Busy) {
+        return;
+    }
+
+    if (modifierFlag && (millis() - last_modifier_time > _TCA8418_MULTI_TAP_THRESHOLD)) {
+        modifierFlag = 0;
+    }
+
+    uint8_t next_key = 0;
+    int row = (key - 1) / 10;
+    int col = (key - 1) % 10;
+    if (row >= _TCA8418_ROWS || col >= _TCA8418_COLS) {
+        return; // Invalid key
+    }
+
+    next_key = row * _TCA8418_COLS + col;
+    state = Held;
+
+    uint32_t now = millis();
+    tap_interval = now - last_tap;
+
+    updateModifierFlag(next_key);
+    if (isModifierKey(next_key)) {
+        last_modifier_time = now;
+    }
+
+    if (tap_interval < 0) {
+        last_tap = 0;
+        state = Busy;
+        return;
+    }
+
+    if (next_key != last_key || tap_interval > _TCA8418_MULTI_TAP_THRESHOLD) {
+        char_idx = 0;
+    } else {
+        char_idx += 1;
+    }
+
+    last_key = next_key;
+    last_tap = now;
+}
+
+void HackadayCommunicatorKeyboard::released()
+{
+    if (state != Held) {
+        return;
+    }
+
+    if (last_key < 0 || last_key >= _TCA8418_NUM_KEYS) {
+        last_key = -1;
+        state = Idle;
+        return;
+    }
+
+    uint32_t now = millis();
+    last_tap = now;
+    if (HackadayCommunicatorTapMod[last_key])
+        queueEvent(HackadayCommunicatorTapMap[last_key][modifierFlag % HackadayCommunicatorTapMod[last_key]]);
+    if (isModifierKey(last_key) == false)
+        modifierFlag = 0;
+}
+
+void HackadayCommunicatorKeyboard::updateModifierFlag(uint8_t key)
+{
+    if (key == modifierRightShiftKey) {
+        modifierFlag ^= modifierRightShift;
+    } else if (key == modifierLeftShiftKey) {
+        modifierFlag ^= modifierLeftShift;
+    }
+}
+
+bool HackadayCommunicatorKeyboard::isModifierKey(uint8_t key)
+{
+    return (key == modifierRightShiftKey || key == modifierLeftShiftKey);
+}
+
+#endif

src/input/HackadayCommunicatorKeyboard.h

@@ -0,0 +1,26 @@
+#include "TCA8418KeyboardBase.h"
+
+class HackadayCommunicatorKeyboard : public TCA8418KeyboardBase
+{
+  public:
+    HackadayCommunicatorKeyboard();
+    void reset(void);
+    void trigger(void) override;
+    virtual ~HackadayCommunicatorKeyboard() {}
+
+  protected:
+    void pressed(uint8_t key) override;
+    void released(void) override;
+
+    void updateModifierFlag(uint8_t key);
+    bool isModifierKey(uint8_t key);
+
+  private:
+    uint8_t modifierFlag;        // Flag to indicate if a modifier key is pressed
+    uint32_t last_modifier_time; // Timestamp of the last modifier key press
+    int8_t last_key;
+    int8_t next_key;
+    uint32_t last_tap;
+    uint8_t char_idx;
+    int32_t tap_interval;
+};

src/input/InputBroker.h

@@ -3,6 +3,12 @@
 #include "Observer.h"
 #include "freertosinc.h"
 
+#ifdef InputBrokerDebug
+#define LOG_INPUT(...) LOG_DEBUG(__VA_ARGS__)
+#else
+#define LOG_INPUT(...)
+#endif
+
 enum input_broker_event {
     INPUT_BROKER_NONE = 0,
     INPUT_BROKER_SELECT = 10,

src/input/SerialKeyboard.cpp

@@ -2,6 +2,8 @@
 #include "configuration.h"
 #include <Throttle.h>
 
+SerialKeyboard *globalSerialKeyboard = nullptr;
+
 #ifdef INPUTBROKER_SERIAL_TYPE
 #define CANNED_MESSAGE_MODULE_ENABLE 1 // in case it's not set in the variant file
 
@@ -25,6 +27,8 @@ unsigned char KeyMap[3][4][10] = {{{'.', 'a', 'd', 'g', 'j', 'm', 'p', 't', 'w',
 SerialKeyboard::SerialKeyboard(const char *name) : concurrency::OSThread(name)
 {
     this->_originName = name;
+
+    globalSerialKeyboard = this;
 }
 
 void SerialKeyboard::erase()
@@ -85,9 +89,21 @@ int32_t SerialKeyboard::runOnce()
             e.source = this->_originName;
             // SELECT OR SEND OR CANCEL EVENT
             if (!(shiftRegister2 & (1 << 3))) {
-                e.inputEvent = INPUT_BROKER_UP;
+                if (shift > 0) {
+                    e.inputEvent = INPUT_BROKER_ANYKEY; // REQUIRED
+                    e.kbchar = 0x09;                    // TAB
+                    shift = 0;                          // reset shift after TAB
+                } else {
+                    e.inputEvent = INPUT_BROKER_LEFT;
+                }
             } else if (!(shiftRegister2 & (1 << 2))) {
-                e.inputEvent = INPUT_BROKER_RIGHT;
+                if (shift > 0) {
+                    e.inputEvent = INPUT_BROKER_ANYKEY; // REQUIRED
+                    e.kbchar = 0x09;                    // TAB
+                    shift = 0;                          // reset shift after TAB
+                } else {
+                    e.inputEvent = INPUT_BROKER_RIGHT;
+                }
                 e.kbchar = 0;
             } else if (!(shiftRegister2 & (1 << 1))) {
                 e.inputEvent = INPUT_BROKER_SELECT;

src/input/SerialKeyboard.h

@@ -8,6 +8,8 @@ class SerialKeyboard : public Observable<const InputEvent *>, public concurrency
   public:
     explicit SerialKeyboard(const char *name);
 
+    uint8_t getShift() const { return shift; }
+
   protected:
     virtual int32_t runOnce() override;
     void erase();
@@ -22,4 +24,6 @@ class SerialKeyboard : public Observable<const InputEvent *>, public concurrency
     int lastKeyPressed = 13;
     int quickPress = 0;
     unsigned long lastPressTime = 0;
-};
+};
+
+extern SerialKeyboard *globalSerialKeyboard;

src/input/kbI2cBase.cpp

@@ -7,6 +7,8 @@
 #include "TDeckProKeyboard.h"
 #elif defined(T_LORA_PAGER)
 #include "TLoraPagerKeyboard.h"
+#elif defined(HACKADAY_COMMUNICATOR)
+#include "HackadayCommunicatorKeyboard.h"
 #else
 #include "TCA8418Keyboard.h"
 #endif
@@ -20,6 +22,8 @@ KbI2cBase::KbI2cBase(const char *name)
       TCAKeyboard(*(new TDeckProKeyboard()))
 #elif defined(T_LORA_PAGER)
       TCAKeyboard(*(new TLoraPagerKeyboard()))
+#elif defined(HACKADAY_COMMUNICATOR)
+      TCAKeyboard(*(new HackadayCommunicatorKeyboard()))
 #else
       TCAKeyboard(*(new TCA8418Keyboard()))
 #endif
@@ -328,7 +332,7 @@ int32_t KbI2cBase::runOnce()
                 break;
             }
             if (e.inputEvent != INPUT_BROKER_NONE) {
-                LOG_DEBUG("TCA8418 Notifying: %i Char: %c", e.inputEvent, e.kbchar);
+                // LOG_DEBUG("TCA8418 Notifying: %i Char: %c", e.inputEvent, e.kbchar);
                 this->notifyObservers(&e);
             }
             TCAKeyboard.trigger();

src/main.cpp

@@ -394,7 +394,10 @@ void setup()
     io.pinMode(EXPANDS_GPIO_EN, OUTPUT);
     io.digitalWrite(EXPANDS_GPIO_EN, HIGH);
     io.pinMode(EXPANDS_SD_PULLEN, INPUT);
+#elif defined(HACKADAY_COMMUNICATOR)
+    pinMode(KB_INT, INPUT);
 #endif
+
     concurrency::hasBeenSetup = true;
 #if ARCH_PORTDUINO
     SPISettings spiSettings(portduino_config.spiSpeed, MSBFIRST, SPI_MODE0);
@@ -878,7 +881,7 @@ void setup()
 
 #if defined(ST7701_CS) || defined(ST7735_CS) || defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ILI9342_DRIVER) ||       \
     defined(ST7789_CS) || defined(HX8357_CS) || defined(USE_ST7789) || defined(ILI9488_CS) || defined(ST7796_CS) ||              \
-    defined(USE_SPISSD1306)
+    defined(USE_SPISSD1306) || defined(USE_ST7796) || defined(HACKADAY_COMMUNICATOR)
         screen = new graphics::Screen(screen_found, screen_model, screen_geometry);
 #elif defined(ARCH_PORTDUINO)
         if ((screen_found.port != ScanI2C::I2CPort::NO_I2C || portduino_config.displayPanel) &&
@@ -1155,7 +1158,7 @@ void setup()
 // the current region name)
 #if defined(ST7701_CS) || defined(ST7735_CS) || defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ILI9342_DRIVER) ||       \
     defined(ST7789_CS) || defined(HX8357_CS) || defined(USE_ST7789) || defined(ILI9488_CS) || defined(ST7796_CS) ||              \
-    defined(USE_SPISSD1306)
+    defined(USE_ST7796) || defined(USE_SPISSD1306) || defined(HACKADAY_COMMUNICATOR)
     if (screen)
         screen->setup();
 #elif defined(ARCH_PORTDUINO)

src/mesh/CryptoEngine.cpp

@@ -4,17 +4,22 @@
 
 #if !(MESHTASTIC_EXCLUDE_PKI)
 #include "NodeDB.h"
+#include "XEdDSA.h"
 #include "aes-ccm.h"
 #include "meshUtils.h"
 #include <Crypto.h>
 #include <Curve25519.h>
+#include <Ed25519.h>
 #include <RNG.h>
 #include <SHA256.h>
-#if !(MESHTASTIC_EXCLUDE_PKI_KEYGEN)
-#if !defined(ARCH_STM32WL)
-#define CryptRNG RNG
+
+#ifndef NUM_LIMBS_256BIT
+#define NUM_LIMBS_BITS(n) (((n) + sizeof(limb_t) * 8 - 1) / (8 * sizeof(limb_t)))
+#define NUM_LIMBS_256BIT NUM_LIMBS_BITS(256)
 #endif
 
+#if !(MESHTASTIC_EXCLUDE_PKI_KEYGEN)
+
 /**
  * Create a public/private key pair with Curve25519.
  *
@@ -35,6 +40,7 @@ void CryptoEngine::generateKeyPair(uint8_t *pubKey, uint8_t *privKey)
     Curve25519::dh1(public_key, private_key);
     memcpy(pubKey, public_key, sizeof(public_key));
     memcpy(privKey, private_key, sizeof(private_key));
+    XEdDSA::priv_curve_to_ed_keys(private_key, xeddsa_private_key, xeddsa_public_key);
 }
 
 /**
@@ -54,12 +60,99 @@ bool CryptoEngine::regeneratePublicKey(uint8_t *pubKey, uint8_t *privKey)
         }
         memcpy(private_key, privKey, sizeof(private_key));
         memcpy(public_key, pubKey, sizeof(public_key));
+        XEdDSA::priv_curve_to_ed_keys(private_key, xeddsa_private_key, xeddsa_public_key);
     } else {
         LOG_WARN("X25519 key generation failed due to blank private key");
         return false;
     }
     return true;
 }
+
+/**
+ * Build a signing buffer that covers packet metadata and payload:
+ *   [fromNode(4) | packetId(4) | portnum(4) | payload(N)]
+ * This prevents replay, reattribution, and portnum redirection attacks.
+ */
+static size_t buildSigningBuffer(uint8_t *buf, size_t bufSize, uint32_t fromNode, uint32_t packetId, uint32_t portnum,
+                                 const uint8_t *payload, size_t payloadLen)
+{
+    const size_t headerLen = sizeof(uint32_t) * 3;
+    size_t totalLen = headerLen + payloadLen;
+    if (totalLen > bufSize)
+        return 0;
+    memcpy(buf, &fromNode, sizeof(uint32_t));
+    memcpy(buf + sizeof(uint32_t), &packetId, sizeof(uint32_t));
+    memcpy(buf + sizeof(uint32_t) * 2, &portnum, sizeof(uint32_t));
+    memcpy(buf + headerLen, payload, payloadLen);
+    return totalLen;
+}
+
+bool CryptoEngine::xeddsa_sign(uint32_t fromNode, uint32_t packetId, uint32_t portnum, const uint8_t *payload, size_t payloadLen,
+                               uint8_t *signature)
+{
+    if (memfll(xeddsa_private_key, 0, sizeof(xeddsa_private_key)))
+        return false;
+    uint8_t sigBuf[MAX_BLOCKSIZE];
+    size_t sigLen = buildSigningBuffer(sigBuf, sizeof(sigBuf), fromNode, packetId, portnum, payload, payloadLen);
+    if (sigLen == 0)
+        return false;
+    XEdDSA::sign(signature, xeddsa_private_key, xeddsa_public_key, sigBuf, sigLen);
+    return true;
+}
+
+bool CryptoEngine::xeddsa_verify(const uint8_t *pubKey, uint32_t fromNode, uint32_t packetId, uint32_t portnum,
+                                 const uint8_t *payload, size_t payloadLen, const uint8_t *signature)
+{
+    // Use cached Ed25519 key if the Curve25519 key matches, avoiding expensive field inversion
+    if (memcmp(pubKey, cached_curve_pubkey, 32) != 0) {
+        curve_to_ed_pub(pubKey, cached_ed_pubkey);
+        memcpy(cached_curve_pubkey, pubKey, 32);
+    }
+    uint8_t sigBuf[MAX_BLOCKSIZE];
+    size_t sigLen = buildSigningBuffer(sigBuf, sizeof(sigBuf), fromNode, packetId, portnum, payload, payloadLen);
+    if (sigLen == 0)
+        return false;
+    return XEdDSA::verify(signature, cached_ed_pubkey, sigBuf, sigLen);
+}
+
+void CryptoEngine::curve_to_ed_pub(const uint8_t *curve_pubkey, uint8_t *ed_pubkey)
+{
+
+    // Apply the birational map defined in RFC 7748, section 4.1 "Curve25519" to calculate an Ed25519 public
+    // key from a Curve25519 public key. Because the serialization format of Curve25519 public keys only
+    // contains the u coordinate, the x coordinate of the corresponding Ed25519 public key can't be uniquely
+    // calculated as defined by the birational map. The x coordinate is represented in the serialization
+    // format of Ed25519 public keys only in a single sign bit. This function assumes that the sign bit is
+    // known to the user and is passed accordingly.
+    fe u, y;
+    fe one;
+    fe u_minus_one, u_plus_one, u_plus_one_inv;
+
+    // Parse the Curve25519 public key input as a field element containing the u coordinate. RFC 7748,
+    // section 5 "The X25519 and X448 Functions", mandates that the most significant bit of the Curve25519
+    // public key has to be zeroized. This is handled by fe_frombytes internally.
+    fe_frombytes(u, curve_pubkey);
+
+    // Calculate the parameters (u - 1) and (u + 1)
+    fe_1(one);
+    fe_sub(u_minus_one, u, one);
+    fe_add(u_plus_one, u, one);
+
+    // Invert u + 1
+    fe_invert(u_plus_one_inv, u_plus_one);
+
+    // Calculate y = (u - 1) * inv(u + 1) (mod p)
+    fe_mul(y, u_minus_one, u_plus_one_inv);
+
+    // Serialize the field element containing the y coordinate to the Ed25519 public key output
+    fe_tobytes(ed_pubkey, y);
+
+    // Set the sign bit to zero
+    ed_pubkey[31] &= 0x7f;
+
+    // need to convert the pubkey y = ( u - 1) * inv( u + 1) (mod p).
+}
+
 #endif
 void CryptoEngine::clearKeys()
 {

src/mesh/CryptoEngine.h

@@ -22,6 +22,7 @@ struct CryptoKey {
 
 #define MAX_BLOCKSIZE 256
 #define TEST_CURVE25519_FIELD_OPS // Exposes Curve25519::isWeakPoint() for testing keys
+#define XEDDSA_SIGNATURE_SIZE 64
 
 class CryptoEngine
 {
@@ -35,6 +36,10 @@ class CryptoEngine
 #if !(MESHTASTIC_EXCLUDE_PKI_KEYGEN)
     virtual void generateKeyPair(uint8_t *pubKey, uint8_t *privKey);
     virtual bool regeneratePublicKey(uint8_t *pubKey, uint8_t *privKey);
+    bool xeddsa_sign(uint32_t fromNode, uint32_t packetId, uint32_t portnum, const uint8_t *payload, size_t payloadLen,
+                     uint8_t *signature);
+    bool xeddsa_verify(const uint8_t *pubKey, uint32_t fromNode, uint32_t packetId, uint32_t portnum, const uint8_t *payload,
+                       size_t payloadLen, const uint8_t *signature);
 
 #endif
     void clearKeys();
@@ -82,6 +87,12 @@ class CryptoEngine
 #if !(MESHTASTIC_EXCLUDE_PKI)
     uint8_t shared_key[32] = {0};
     uint8_t private_key[32] = {0};
+    uint8_t xeddsa_public_key[32] = {0};
+    uint8_t xeddsa_private_key[32] = {0};
+    void curve_to_ed_pub(const uint8_t *curve_pubkey, uint8_t *ed_pubkey);
+    // Single-entry cache for curve_to_ed_pub conversion (avoids expensive field inversion per packet)
+    uint8_t cached_curve_pubkey[32] = {0};
+    uint8_t cached_ed_pubkey[32] = {0};
 #endif
     /**
      * Init our 128 bit nonce for a new packet

src/mesh/MeshService.cpp

@@ -86,15 +86,12 @@ int MeshService::handleFromRadio(const meshtastic_MeshPacket *mp)
 
     nodeDB->updateFrom(*mp); // update our DB state based off sniffing every RX packet from the radio
     bool isPreferredRebroadcaster = config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER;
-    meshtastic_NodeDetail *fromNode = nodeDB->getMeshNode(mp->from);
-
     if (mp->which_payload_variant == meshtastic_MeshPacket_decoded_tag &&
         mp->decoded.portnum == meshtastic_PortNum_TELEMETRY_APP && mp->decoded.request_id > 0) {
         LOG_DEBUG("Received telemetry response. Skip sending our NodeInfo");
         //  ignore our request for its NodeInfo
-    } else if (mp->which_payload_variant == meshtastic_MeshPacket_decoded_tag && fromNode &&
-               !detailHasFlag(*fromNode, NODEDETAIL_FLAG_HAS_USER) && nodeInfoModule && !isPreferredRebroadcaster &&
-               !nodeDB->isFull()) {
+    } else if (mp->which_payload_variant == meshtastic_MeshPacket_decoded_tag && !nodeDB->getMeshNode(mp->from)->has_user &&
+               nodeInfoModule && !isPreferredRebroadcaster && !nodeDB->isFull()) {
         if (airTime->isTxAllowedChannelUtil(true)) {
             // Hops used by the request. If somebody in between running modified firmware modified it, ignore it
             auto hopStart = mp->hop_start;
@@ -272,7 +269,7 @@ void MeshService::sendToMesh(meshtastic_MeshPacket *p, RxSource src, bool ccToPh
 
 bool MeshService::trySendPosition(NodeNum dest, bool wantReplies)
 {
-    meshtastic_NodeDetail *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
+    meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
 
     assert(node);
 
@@ -379,25 +376,24 @@ void MeshService::sendClientNotification(meshtastic_ClientNotification *n)
     fromNum++;
 }
 
-meshtastic_NodeDetail *MeshService::refreshLocalMeshNode()
+meshtastic_NodeInfoLite *MeshService::refreshLocalMeshNode()
 {
-    meshtastic_NodeDetail *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
+    meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
     assert(node);
 
-    // Ensure we have a position container so time fields stay fresh even without GPS fixes
-    if (!detailHasFlag(*node, NODEDETAIL_FLAG_HAS_POSITION)) {
-        detailSetFlag(*node, NODEDETAIL_FLAG_HAS_POSITION, true);
-        node->latitude_i = 0;
-        node->longitude_i = 0;
-        node->altitude = 0;
-        node->position_source = _meshtastic_Position_LocSource_MIN;
+    // We might not have a position yet for our local node, in that case, at least try to send the time
+    if (!node->has_position) {
+        memset(&node->position, 0, sizeof(node->position));
+        node->has_position = true;
     }
 
+    meshtastic_PositionLite &position = node->position;
+
     // Update our local node info with our time (even if we don't decide to update anyone else)
     node->last_heard =
         getValidTime(RTCQualityFromNet); // This nodedb timestamp might be stale, so update it if our clock is kinda valid
 
-    node->position_time = getValidTime(RTCQualityFromNet);
+    position.time = getValidTime(RTCQualityFromNet);
 
     if (powerStatus->getHasBattery() == 1) {
         updateBatteryLevel(powerStatus->getBatteryChargePercent());
@@ -410,7 +406,7 @@ meshtastic_NodeDetail *MeshService::refreshLocalMeshNode()
 int MeshService::onGPSChanged(const meshtastic::GPSStatus *newStatus)
 {
     // Update our local node info with our position (even if we don't decide to update anyone else)
-    const meshtastic_NodeDetail *node = refreshLocalMeshNode();
+    const meshtastic_NodeInfoLite *node = refreshLocalMeshNode();
     meshtastic_Position pos = meshtastic_Position_init_default;
 
     if (newStatus->getHasLock()) {
@@ -425,7 +421,7 @@ int MeshService::onGPSChanged(const meshtastic::GPSStatus *newStatus)
     // Used fixed position if configured regardless of GPS lock
     if (config.position.fixed_position) {
         LOG_WARN("Use fixed position");
-        pos = TypeConversions::ConvertToPosition(detailToPositionLite(*node));
+        pos = TypeConversions::ConvertToPosition(node->position);
     }
 
     // Add a fresh timestamp

src/mesh/MeshService.h

@@ -170,7 +170,7 @@ class MeshService
     bool cancelSending(PacketId id);
 
     /// Pull the latest power and time info into my nodeinfo
-    meshtastic_NodeDetail *refreshLocalMeshNode();
+    meshtastic_NodeInfoLite *refreshLocalMeshNode();
 
     /// Send a packet to the phone
     void sendToPhone(meshtastic_MeshPacket *p);

src/mesh/NextHopRouter.cpp

@@ -94,7 +94,7 @@ void NextHopRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtast
         // is not 0 (means implicit ACK) and original packet was also relayed by this node, or we sent it directly to the
         // destination
         if (p->from != 0) {
-            meshtastic_NodeDetail *origTx = nodeDB->getMeshNode(p->from);
+            meshtastic_NodeInfoLite *origTx = nodeDB->getMeshNode(p->from);
             if (origTx) {
                 // Either relayer of ACK was also a relayer of the packet, or we were the *only* relayer and the ACK came
                 // directly from the destination
@@ -176,7 +176,7 @@ uint8_t NextHopRouter::getNextHop(NodeNum to, uint8_t relay_node)
     if (isBroadcast(to))
         return NO_NEXT_HOP_PREFERENCE;
 
-    meshtastic_NodeDetail *node = nodeDB->getMeshNode(to);
+    meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(to);
     if (node && node->next_hop) {
         // We are careful not to return the relay node as the next hop
         if (node->next_hop != relay_node) {
@@ -296,7 +296,7 @@ int32_t NextHopRouter::doRetransmissions()
                         // Last retransmission, reset next_hop (fallback to FloodingRouter)
                         p.packet->next_hop = NO_NEXT_HOP_PREFERENCE;
                         // Also reset it in the nodeDB
-                        meshtastic_NodeDetail *sentTo = nodeDB->getMeshNode(p.packet->to);
+                        meshtastic_NodeInfoLite *sentTo = nodeDB->getMeshNode(p.packet->to);
                         if (sentTo) {
                             LOG_INFO("Resetting next hop for packet with dest 0x%x\n", p.packet->to);
                             sentTo->next_hop = NO_NEXT_HOP_PREFERENCE;

src/mesh/NodeDB.cpp

@@ -24,7 +24,6 @@
 #include "modules/NeighborInfoModule.h"
 #include <ErriezCRC32.h>
 #include <algorithm>
-#include <cmath>
 #include <pb_decode.h>
 #include <pb_encode.h>
 #include <vector>
@@ -153,19 +152,18 @@ uint32_t get_st7789_id(uint8_t cs, uint8_t sck, uint8_t mosi, uint8_t dc, uint8_
 bool meshtastic_NodeDatabase_callback(pb_istream_t *istream, pb_ostream_t *ostream, const pb_field_iter_t *field)
 {
     if (ostream) {
-        const auto *vec = reinterpret_cast<const std::vector<meshtastic_NodeDetail> *>(field->pData);
-        for (const auto &item : *vec) {
+        std::vector<meshtastic_NodeInfoLite> const *vec = (std::vector<meshtastic_NodeInfoLite> *)field->pData;
+        for (auto item : *vec) {
             if (!pb_encode_tag_for_field(ostream, field))
                 return false;
-            if (!pb_encode_submessage(ostream, meshtastic_NodeDetail_fields, &item))
-                return false;
+            pb_encode_submessage(ostream, meshtastic_NodeInfoLite_fields, &item);
         }
     }
     if (istream) {
-        meshtastic_NodeDetail node = meshtastic_NodeDetail_init_default; // this gets good data
-        auto *vec = reinterpret_cast<std::vector<meshtastic_NodeDetail> *>(field->pData);
+        meshtastic_NodeInfoLite node; // this gets good data
+        std::vector<meshtastic_NodeInfoLite> *vec = (std::vector<meshtastic_NodeInfoLite> *)field->pData;
 
-        if (istream->bytes_left && pb_decode(istream, meshtastic_NodeDetail_fields, &node))
+        if (istream->bytes_left && pb_decode(istream, meshtastic_NodeInfoLite_fields, &node))
             vec->push_back(node);
     }
     return true;
@@ -248,8 +246,6 @@ NodeDB::NodeDB()
 
     // likewise - we always want the app requirements to come from the running appload
     myNodeInfo.min_app_version = 30200; // format is Mmmss (where M is 1+the numeric major number. i.e. 30200 means 2.2.00
-    // Note! We do this after loading saved settings, so that if somehow an invalid nodenum was stored in preferences we won't
-    // keep using that nodenum forever. Crummy guess at our nodenum (but we will check against the nodedb to avoid conflicts)
     pickNewNodeNum();
 
     // Set our board type so we can share it with others
@@ -269,36 +265,24 @@ NodeDB::NodeDB()
     }
 
 #if !(MESHTASTIC_EXCLUDE_PKI_KEYGEN || MESHTASTIC_EXCLUDE_PKI)
-
-    if (!owner.is_licensed && config.lora.region != meshtastic_Config_LoRaConfig_RegionCode_UNSET) {
-        bool keygenSuccess = false;
-        keyIsLowEntropy = checkLowEntropyPublicKey(config.security.public_key);
-        if (config.security.private_key.size == 32 && !keyIsLowEntropy) {
-            if (crypto->regeneratePublicKey(config.security.public_key.bytes, config.security.private_key.bytes)) {
-                keygenSuccess = true;
-            }
-        } else {
-            crypto->generateKeyPair(config.security.public_key.bytes, config.security.private_key.bytes);
-            keygenSuccess = true;
-        }
-        if (keygenSuccess) {
-            config.security.public_key.size = 32;
-            config.security.private_key.size = 32;
-            owner.public_key.size = 32;
-            memcpy(owner.public_key.bytes, config.security.public_key.bytes, 32);
-        }
-    }
+    // Generate crypto keys if needed using consolidated function
+    // Set my node num uint32 value to bytes from the public key (if we have one)
+    // Generate identity and crypto keys if needed; this will create a new identity if one does not exist
+    generateCryptoKeyPair(nullptr);
 #elif !(MESHTASTIC_EXCLUDE_PKI)
     // Calculate Curve25519 public and private keys
     if (config.security.private_key.size == 32 && config.security.public_key.size == 32) {
         owner.public_key.size = config.security.public_key.size;
         memcpy(owner.public_key.bytes, config.security.public_key.bytes, config.security.public_key.size);
         crypto->setDHPrivateKey(config.security.private_key.bytes);
+        // Set my node num uint32 value to bytes from the new public key
+        myNodeInfo.my_node_num = crc32Buffer(config.security.public_key.bytes, config.security.public_key.size);
     }
 #endif
     // Include our owner in the node db under our nodenum
-    meshtastic_NodeDetail *info = getOrCreateMeshNode(getNodeNum());
-    applyUserToDetail(*info, owner);
+    meshtastic_NodeInfoLite *info = getOrCreateMeshNode(getNodeNum());
+    info->user = TypeConversions::ConvertToUserLite(owner);
+    info->has_user = true;
 
     // If node database has not been saved for the first time, save it now
 #ifdef FSCom
@@ -521,7 +505,7 @@ void NodeDB::installDefaultNodeDatabase()
 {
     LOG_DEBUG("Install default NodeDatabase");
     nodeDatabase.version = DEVICESTATE_CUR_VER;
-    nodeDatabase.nodes = std::vector<meshtastic_NodeDetail>(MAX_NUM_NODES, makeDefaultDetail());
+    nodeDatabase.nodes = std::vector<meshtastic_NodeInfoLite>(MAX_NUM_NODES);
     numMeshNodes = 0;
     meshNodes = &nodeDatabase.nodes;
 }
@@ -665,7 +649,8 @@ void NodeDB::installDefaultConfig(bool preserveKey = false)
     config.bluetooth.fixed_pin = defaultBLEPin;
 
 #if defined(ST7735_CS) || defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ILI9342_DRIVER) || defined(ST7789_CS) ||       \
-    defined(HX8357_CS) || defined(USE_ST7789) || defined(ILI9488_CS) || defined(ST7796_CS) || defined(USE_SPISSD1306)
+    defined(HX8357_CS) || defined(USE_ST7789) || defined(ILI9488_CS) || defined(ST7796_CS) || defined(USE_SPISSD1306) ||         \
+    defined(USE_ST7796) || defined(HACKADAY_COMMUNICATOR)
     bool hasScreen = true;
 #ifdef HELTEC_MESH_NODE_T114
     uint32_t st7789_id = get_st7789_id(ST7789_NSS, ST7789_SCK, ST7789_SDA, ST7789_RS, ST7789_RESET);
@@ -735,6 +720,9 @@ void NodeDB::installDefaultConfig(bool preserveKey = false)
     config.display.screen_on_secs = 30;
     config.display.wake_on_tap_or_motion = true;
 #endif
+#ifdef COMPASS_ORIENTATION
+    config.display.compass_orientation = COMPASS_ORIENTATION;
+#endif
 #if defined(ARCH_ESP32) && !MESHTASTIC_EXCLUDE_WIFI
     if (WiFiOTA::isUpdated()) {
         WiFiOTA::recoverConfig(&config.network);
@@ -993,16 +981,16 @@ void NodeDB::resetNodes(bool keepFavorites)
     if (keepFavorites) {
         LOG_INFO("Clearing node database - preserving favorites");
         for (size_t i = 0; i < meshNodes->size(); i++) {
-            meshtastic_NodeDetail &detail = meshNodes->at(i);
-            if (i > 0 && !detailIsFavorite(detail)) {
-                detail = makeDefaultDetail();
+            meshtastic_NodeInfoLite &node = meshNodes->at(i);
+            if (i > 0 && !node.is_favorite) {
+                node = meshtastic_NodeInfoLite();
             } else {
                 numMeshNodes += 1;
             }
         };
     } else {
         LOG_INFO("Clearing node database - removing favorites");
-        std::fill(nodeDatabase.nodes.begin() + 1, nodeDatabase.nodes.end(), makeDefaultDetail());
+        std::fill(nodeDatabase.nodes.begin() + 1, nodeDatabase.nodes.end(), meshtastic_NodeInfoLite());
     }
     devicestate.has_rx_text_message = false;
     devicestate.has_rx_waypoint = false;
@@ -1022,17 +1010,19 @@ void NodeDB::removeNodeByNum(NodeNum nodeNum)
             removed++;
     }
     numMeshNodes -= removed;
-    std::fill(nodeDatabase.nodes.begin() + numMeshNodes, nodeDatabase.nodes.begin() + numMeshNodes + 1, makeDefaultDetail());
+    std::fill(nodeDatabase.nodes.begin() + numMeshNodes, nodeDatabase.nodes.begin() + numMeshNodes + 1,
+              meshtastic_NodeInfoLite());
     LOG_DEBUG("NodeDB::removeNodeByNum purged %d entries. Save changes", removed);
     saveNodeDatabaseToDisk();
 }
 
 void NodeDB::clearLocalPosition()
 {
-    meshtastic_NodeDetail *detail = getMeshNode(nodeDB->getNodeNum());
-    if (detail) {
-        clearPositionFromDetail(*detail);
-    }
+    meshtastic_NodeInfoLite *node = getMeshNode(nodeDB->getNodeNum());
+    node->position.latitude_i = 0;
+    node->position.longitude_i = 0;
+    node->position.altitude = 0;
+    node->position.time = 0;
     setLocalPosition(meshtastic_Position_init_default);
 }
 
@@ -1040,10 +1030,10 @@ void NodeDB::cleanupMeshDB()
 {
     int newPos = 0, removed = 0;
     for (int i = 0; i < numMeshNodes; i++) {
-        if (detailHasFlag(meshNodes->at(i), NODEDETAIL_FLAG_HAS_USER)) {
-            if (meshNodes->at(i).public_key.size > 0) {
-                if (memfll(meshNodes->at(i).public_key.bytes, 0, meshNodes->at(i).public_key.size)) {
-                    meshNodes->at(i).public_key.size = 0;
+        if (meshNodes->at(i).has_user) {
+            if (meshNodes->at(i).user.public_key.size > 0) {
+                if (memfll(meshNodes->at(i).user.public_key.bytes, 0, meshNodes->at(i).user.public_key.size)) {
+                    meshNodes->at(i).user.public_key.size = 0;
                 }
             }
             if (newPos != i)
@@ -1056,7 +1046,7 @@ void NodeDB::cleanupMeshDB()
     }
     numMeshNodes -= removed;
     std::fill(nodeDatabase.nodes.begin() + numMeshNodes, nodeDatabase.nodes.begin() + numMeshNodes + removed,
-              makeDefaultDetail());
+              meshtastic_NodeInfoLite());
     LOG_DEBUG("cleanupMeshDB purged %d entries", removed);
 }
 
@@ -1108,14 +1098,14 @@ void NodeDB::pickNewNodeNum()
         nodeNum = (ourMacAddr[2] << 24) | (ourMacAddr[3] << 16) | (ourMacAddr[4] << 8) | ourMacAddr[5];
     }
 
-    meshtastic_NodeDetail *found;
-    while (((found = getMeshNode(nodeNum)) && memcmp(found->macaddr, ourMacAddr, sizeof(ourMacAddr)) != 0) ||
+    meshtastic_NodeInfoLite *found;
+    while (((found = getMeshNode(nodeNum)) && memcmp(found->user.macaddr, ourMacAddr, sizeof(ourMacAddr)) != 0) ||
            (nodeNum == NODENUM_BROADCAST || nodeNum < NUM_RESERVED)) {
         NodeNum candidate = random(NUM_RESERVED, LONG_MAX); // try a new random choice
         if (found)
             LOG_WARN("NOTE! Our desired nodenum 0x%x is invalid or in use, by MAC ending in 0x%02x%02x vs our 0x%02x%02x, so "
                      "trying for 0x%x",
-                     nodeNum, found->macaddr[4], found->macaddr[5], ourMacAddr[4], ourMacAddr[5], candidate);
+                     nodeNum, found->user.macaddr[4], found->user.macaddr[5], ourMacAddr[4], ourMacAddr[5], candidate);
         nodeNum = candidate;
     }
     LOG_DEBUG("Use nodenum 0x%x ", nodeNum);
@@ -1414,7 +1404,7 @@ bool NodeDB::saveDeviceStateToDisk()
     FSCom.mkdir("/prefs");
     spiLock->unlock();
 #endif
-    // Note: if MAX_NUM_NODES=100 and meshtastic_NodeDetail_size=182, node storage alone is roughly 18KB of data
+    // Note: if MAX_NUM_NODES=100 and meshtastic_NodeInfoLite_size=166, so will be approximately 17KB
     // Because so huge we _must_ not use fullAtomic, because the filesystem is probably too small to hold two copies of this
     return saveProto(deviceStateFileName, meshtastic_DeviceState_size, &meshtastic_DeviceState_msg, &devicestate, true);
 }
@@ -1507,7 +1497,7 @@ bool NodeDB::saveToDisk(int saveWhat)
     return success;
 }
 
-const meshtastic_NodeDetail *NodeDB::readNextMeshNode(uint32_t &readIndex)
+const meshtastic_NodeInfoLite *NodeDB::readNextMeshNode(uint32_t &readIndex)
 {
     if (readIndex < numMeshNodes)
         return &meshNodes->at(readIndex++);
@@ -1516,7 +1506,7 @@ const meshtastic_NodeDetail *NodeDB::readNextMeshNode(uint32_t &readIndex)
 }
 
 /// Given a node, return how many seconds in the past (vs now) that we last heard from it
-uint32_t sinceLastSeen(const meshtastic_NodeDetail *n)
+uint32_t sinceLastSeen(const meshtastic_NodeInfoLite *n)
 {
     uint32_t now = getTime();
 
@@ -1546,10 +1536,9 @@ size_t NodeDB::getNumOnlineMeshNodes(bool localOnly)
 
     // FIXME this implementation is kinda expensive
     for (int i = 0; i < numMeshNodes; i++) {
-        const auto &detail = meshNodes->at(i);
-        if (localOnly && detailViaMqtt(detail))
+        if (localOnly && meshNodes->at(i).via_mqtt)
             continue;
-        if (sinceLastSeen(&detail) < NUM_ONLINE_SECS)
+        if (sinceLastSeen(&meshNodes->at(i)) < NUM_ONLINE_SECS)
             numseen++;
     }
 
@@ -1563,8 +1552,8 @@ size_t NodeDB::getNumOnlineMeshNodes(bool localOnly)
  */
 void NodeDB::updatePosition(uint32_t nodeId, const meshtastic_Position &p, RxSource src)
 {
-    meshtastic_NodeDetail *detail = getOrCreateMeshNode(nodeId);
-    if (!detail) {
+    meshtastic_NodeInfoLite *info = getOrCreateMeshNode(nodeId);
+    if (!info) {
         return;
     }
 
@@ -1574,13 +1563,12 @@ void NodeDB::updatePosition(uint32_t nodeId, const meshtastic_Position &p, RxSou
                  p.altitude);
 
         setLocalPosition(p);
-        applyPositionToDetail(*detail, p);
+        info->position = TypeConversions::ConvertToPositionLite(p);
     } else if ((p.time > 0) && !p.latitude_i && !p.longitude_i && !p.timestamp && !p.location_source) {
         // FIXME SPECIAL TIME SETTING PACKET FROM EUD TO RADIO
         // (stop-gap fix for issue #900)
         LOG_DEBUG("updatePosition SPECIAL time setting time=%u", p.time);
-        detailSetFlag(*detail, NODEDETAIL_FLAG_HAS_POSITION, true);
-        detail->position_time = p.time;
+        info->position.time = p.time;
     } else {
         // Be careful to only update fields that have been set by the REMOTE sender
         // A lot of position reports don't have time populated.  In that case, be careful to not blow away the time we
@@ -1590,16 +1578,17 @@ void NodeDB::updatePosition(uint32_t nodeId, const meshtastic_Position &p, RxSou
         LOG_INFO("updatePosition REMOTE node=0x%x time=%u lat=%d lon=%d", nodeId, p.time, p.latitude_i, p.longitude_i);
 
         // First, back up fields that we want to protect from overwrite
-        uint32_t tmp_time = detail->position_time;
+        uint32_t tmp_time = info->position.time;
 
         // Next, update atomically
-        applyPositionToDetail(*detail, p);
+        info->position = TypeConversions::ConvertToPositionLite(p);
 
         // Last, restore any fields that may have been overwritten
-        if (!detail->position_time)
-            detail->position_time = tmp_time;
+        if (!info->position.time)
+            info->position.time = tmp_time;
     }
-    updateGUIforNode = detail;
+    info->has_position = true;
+    updateGUIforNode = info;
     notifyObservers(true); // Force an update whether or not our node counts have changed
 }
 
@@ -1608,9 +1597,9 @@ void NodeDB::updatePosition(uint32_t nodeId, const meshtastic_Position &p, RxSou
  */
 void NodeDB::updateTelemetry(uint32_t nodeId, const meshtastic_Telemetry &t, RxSource src)
 {
-    meshtastic_NodeDetail *detail = getOrCreateMeshNode(nodeId);
+    meshtastic_NodeInfoLite *info = getOrCreateMeshNode(nodeId);
     // Environment metrics should never go to NodeDb but we'll safegaurd anyway
-    if (!detail || t.which_variant != meshtastic_Telemetry_device_metrics_tag) {
+    if (!info || t.which_variant != meshtastic_Telemetry_device_metrics_tag) {
         return;
     }
 
@@ -1620,8 +1609,9 @@ void NodeDB::updateTelemetry(uint32_t nodeId, const meshtastic_Telemetry &t, RxS
     } else {
         LOG_DEBUG("updateTelemetry REMOTE node=0x%x ", nodeId);
     }
-    applyMetricsToDetail(*detail, t.variant.device_metrics);
-    updateGUIforNode = detail;
+    info->device_metrics = t.variant.device_metrics;
+    info->has_device_metrics = true;
+    updateGUIforNode = info;
     notifyObservers(true); // Force an update whether or not our node counts have changed
 }
 
@@ -1630,32 +1620,32 @@ void NodeDB::updateTelemetry(uint32_t nodeId, const meshtastic_Telemetry &t, RxS
  */
 void NodeDB::addFromContact(meshtastic_SharedContact contact)
 {
-    meshtastic_NodeDetail *detail = getOrCreateMeshNode(contact.node_num);
-    if (!detail || !contact.has_user) {
+    meshtastic_NodeInfoLite *info = getOrCreateMeshNode(contact.node_num);
+    if (!info || !contact.has_user) {
         return;
     }
     // If the local node has this node marked as manually verified
     // and the client does not, do not allow the client to update the
     // saved public key.
-    if (detailHasFlag(*detail, NODEDETAIL_FLAG_IS_KEY_MANUALLY_VERIFIED) && !contact.manually_verified) {
-        if (contact.user.public_key.size != detail->public_key.size ||
-            memcmp(contact.user.public_key.bytes, detail->public_key.bytes, detail->public_key.size) != 0) {
+    if ((info->bitfield & NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_MASK) && !contact.manually_verified) {
+        if (contact.user.public_key.size != info->user.public_key.size ||
+            memcmp(contact.user.public_key.bytes, info->user.public_key.bytes, info->user.public_key.size) != 0) {
             return;
         }
     }
-    detail->num = contact.node_num;
-    applyUserToDetail(*detail, contact.user);
+    info->num = contact.node_num;
+    info->has_user = true;
+    info->user = TypeConversions::ConvertToUserLite(contact.user);
     if (contact.should_ignore) {
         // If should_ignore is set,
         // we need to clear the public key and other cruft, in addition to setting the node as ignored
-        detailSetFlag(*detail, NODEDETAIL_FLAG_IS_IGNORED, true);
-        detailSetFlag(*detail, NODEDETAIL_FLAG_IS_FAVORITE, false);
-        clearMetricsFromDetail(*detail);
-        clearPositionFromDetail(*detail);
-        detail->public_key.size = 0;
-        memset(detail->public_key.bytes, 0, sizeof(detail->public_key.bytes));
+        info->is_ignored = true;
+        info->is_favorite = false;
+        info->has_device_metrics = false;
+        info->has_position = false;
+        info->user.public_key.size = 0;
+        info->user.public_key.bytes[0] = 0;
     } else {
-        detailSetFlag(*detail, NODEDETAIL_FLAG_IS_IGNORED, false);
         /* Clients are sending add_contact before every text message DM (because clients may hold a larger node database with
          * public keys than the radio holds). However, we don't want to update last_heard just because we sent someone a DM!
          */
@@ -1669,19 +1659,19 @@ void NodeDB::addFromContact(meshtastic_SharedContact contact)
             // without the user doing so deliberately. We don't normally expect users to use a CLIENT_BASE to send DMs or to add
             // contacts, but we should make sure it doesn't auto-favorite in case they do. Instead, as a workaround, we'll set
             // last_heard to now, so that the add_contact node doesn't immediately get evicted.
-            detail->last_heard = getTime();
+            info->last_heard = getTime();
         } else {
             // Normal case: set is_favorite to prevent expiration.
             // last_heard will remain as-is (or remain 0 if this entry wasn't in the nodeDB).
-            detailSetFlag(*detail, NODEDETAIL_FLAG_IS_FAVORITE, true);
+            info->is_favorite = true;
         }
 
         // As the clients will begin sending the contact with DMs, we want to strictly check if the node is manually verified
         if (contact.manually_verified) {
-            detailSetFlag(*detail, NODEDETAIL_FLAG_IS_KEY_MANUALLY_VERIFIED, true);
+            info->bitfield |= NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_MASK;
         }
         // Mark the node's key as manually verified to indicate trustworthiness.
-        updateGUIforNode = detail;
+        updateGUIforNode = info;
         sortMeshDB();
         notifyObservers(true); // Force an update whether or not our node counts have changed
     }
@@ -1692,8 +1682,8 @@ void NodeDB::addFromContact(meshtastic_SharedContact contact)
  */
 bool NodeDB::updateUser(uint32_t nodeId, meshtastic_User &p, uint8_t channelIndex)
 {
-    meshtastic_NodeDetail *detail = getOrCreateMeshNode(nodeId);
-    if (!detail) {
+    meshtastic_NodeInfoLite *info = getOrCreateMeshNode(nodeId);
+    if (!info) {
         return false;
     }
 
@@ -1718,9 +1708,9 @@ bool NodeDB::updateUser(uint32_t nodeId, meshtastic_User &p, uint8_t channelInde
             return false;
         }
     }
-    if (detail->public_key.size == 32) { // if we have a key for this user already, don't overwrite with a new one
+    if (info->user.public_key.size == 32) { // if we have a key for this user already, don't overwrite with a new one
         // if the key doesn't match, don't update nodeDB at all.
-        if (p.public_key.size != 32 || (memcmp(p.public_key.bytes, detail->public_key.bytes, 32) != 0)) {
+        if (p.public_key.size != 32 || (memcmp(p.public_key.bytes, info->user.public_key.bytes, 32) != 0)) {
             LOG_WARN("Public Key mismatch, dropping NodeInfo");
             return false;
         }
@@ -1733,38 +1723,22 @@ bool NodeDB::updateUser(uint32_t nodeId, meshtastic_User &p, uint8_t channelInde
     // Always ensure user.id is derived from nodeId, regardless of what was received
     snprintf(p.id, sizeof(p.id), "!%08x", nodeId);
 
-    meshtastic_NodeDetail before = *detail;
+    // Both of info->user and p start as filled with zero so I think this is okay
+    auto lite = TypeConversions::ConvertToUserLite(p);
+    bool changed = memcmp(&info->user, &lite, sizeof(info->user)) || (info->channel != channelIndex);
 
-    applyUserToDetail(*detail, p);
-
-    if (detail->public_key.size == 32) {
-        printBytes("Saved Pubkey: ", detail->public_key.bytes, 32);
+    info->user = lite;
+    if (info->user.public_key.size == 32) {
+        printBytes("Saved Pubkey: ", info->user.public_key.bytes, 32);
     }
-
-    if (nodeId != getNodeNum()) {
-        detail->channel = channelIndex; // Set channel we need to use to reach this node (but don't set our own channel)
-    }
-
-    bool userChanged = strncmp(before.long_name, detail->long_name, sizeof(detail->long_name)) != 0 ||
-                       strncmp(before.short_name, detail->short_name, sizeof(detail->short_name)) != 0 ||
-                       memcmp(before.macaddr, detail->macaddr, sizeof(detail->macaddr)) != 0 ||
-                       before.hw_model != detail->hw_model || before.role != detail->role ||
-                       before.public_key.size != detail->public_key.size ||
-                       memcmp(before.public_key.bytes, detail->public_key.bytes, detail->public_key.size) != 0;
-
-    uint32_t flagDelta = before.flags ^ detail->flags;
-    bool flagChange =
-        (flagDelta & (NODEDETAIL_FLAG_IS_LICENSED | NODEDETAIL_FLAG_HAS_UNMESSAGABLE | NODEDETAIL_FLAG_IS_UNMESSAGABLE)) != 0;
-
-    bool channelChanged = (nodeId != getNodeNum()) && (before.channel != detail->channel);
-
-    bool changed = userChanged || flagChange || channelChanged;
-
-    LOG_DEBUG("Update changed=%d user %s/%s, id=0x%08x, channel=%d", changed, detail->long_name, detail->short_name, nodeId,
-              detail->channel);
+    if (nodeId != getNodeNum())
+        info->channel = channelIndex; // Set channel we need to use to reach this node (but don't set our own channel)
+    LOG_DEBUG("Update changed=%d user %s/%s, id=0x%08x, channel=%d", changed, info->user.long_name, info->user.short_name, nodeId,
+              info->channel);
+    info->has_user = true;
 
     if (changed) {
-        updateGUIforNode = detail;
+        updateGUIforNode = info;
         notifyObservers(true); // Force an update whether or not our node counts have changed
 
         // We just changed something about a User,
@@ -1792,24 +1766,23 @@ void NodeDB::updateFrom(const meshtastic_MeshPacket &mp)
     if (mp.which_payload_variant == meshtastic_MeshPacket_decoded_tag && mp.from) {
         LOG_DEBUG("Update DB node 0x%x, rx_time=%u", mp.from, mp.rx_time);
 
-        meshtastic_NodeDetail *detail = getOrCreateMeshNode(getFrom(&mp));
-        if (!detail) {
+        meshtastic_NodeInfoLite *info = getOrCreateMeshNode(getFrom(&mp));
+        if (!info) {
             return;
         }
 
         if (mp.rx_time) // if the packet has a valid timestamp use it to update our last_heard
-            detail->last_heard = mp.rx_time;
+            info->last_heard = mp.rx_time;
 
         if (mp.rx_snr)
-            detail->snr = mp.rx_snr; // keep the most recent SNR we received for this node.
+            info->snr = mp.rx_snr; // keep the most recent SNR we received for this node.
 
-        detailSetFlag(*detail, NODEDETAIL_FLAG_VIA_MQTT, mp.via_mqtt); // Store if we received this packet via MQTT
+        info->via_mqtt = mp.via_mqtt; // Store if we received this packet via MQTT
 
         // If hopStart was set and there wasn't someone messing with the limit in the middle, add hopsAway
         if (mp.hop_start != 0 && mp.hop_limit <= mp.hop_start) {
-            detailSetFlag(*detail, NODEDETAIL_FLAG_HAS_HOPS_AWAY, true);
-            uint32_t hopDelta = mp.hop_start - mp.hop_limit;
-            detail->hops_away = static_cast<uint8_t>(std::min<uint32_t>(hopDelta, UINT8_MAX));
+            info->has_hops_away = true;
+            info->hops_away = mp.hop_start - mp.hop_limit;
         }
         sortMeshDB();
     }
@@ -1817,9 +1790,9 @@ void NodeDB::updateFrom(const meshtastic_MeshPacket &mp)
 
 void NodeDB::set_favorite(bool is_favorite, uint32_t nodeId)
 {
-    meshtastic_NodeDetail *detail = getMeshNode(nodeId);
-    if (detail && detailIsFavorite(*detail) != is_favorite) {
-        detailSetFlag(*detail, NODEDETAIL_FLAG_IS_FAVORITE, is_favorite);
+    meshtastic_NodeInfoLite *lite = getMeshNode(nodeId);
+    if (lite && lite->is_favorite != is_favorite) {
+        lite->is_favorite = is_favorite;
         sortMeshDB();
         saveNodeDatabaseToDisk();
     }
@@ -1833,10 +1806,10 @@ bool NodeDB::isFavorite(uint32_t nodeId)
     if (nodeId == NODENUM_BROADCAST)
         return false;
 
-    meshtastic_NodeDetail *detail = getMeshNode(nodeId);
+    meshtastic_NodeInfoLite *lite = getMeshNode(nodeId);
 
-    if (detail) {
-        return detailIsFavorite(*detail);
+    if (lite) {
+        return lite->is_favorite;
     }
     return false;
 }
@@ -1852,21 +1825,23 @@ bool NodeDB::isFromOrToFavoritedNode(const meshtastic_MeshPacket &p)
     if (p.to == NODENUM_BROADCAST)
         return isFavorite(p.from); // we never store NODENUM_BROADCAST in the DB, so we only need to check p.from
 
+    meshtastic_NodeInfoLite *lite = NULL;
+
     bool seenFrom = false;
     bool seenTo = false;
 
     for (int i = 0; i < numMeshNodes; i++) {
-        auto *detail = &meshNodes->at(i);
+        lite = &meshNodes->at(i);
 
-        if (detail->num == p.from) {
-            if (detailIsFavorite(*detail))
+        if (lite->num == p.from) {
+            if (lite->is_favorite)
                 return true;
 
             seenFrom = true;
         }
 
-        if (detail->num == p.to) {
-            if (detailIsFavorite(*detail))
+        if (lite->num == p.to) {
+            if (lite->is_favorite)
                 return true;
 
             seenTo = true;
@@ -1902,10 +1877,10 @@ void NodeDB::sortMeshDB()
                     // TODO: Look for at(i-1) also matching own node num, and throw the DB in the trash
                     std::swap(meshNodes->at(i), meshNodes->at(i - 1));
                     changed = true;
-                } else if (detailIsFavorite(meshNodes->at(i)) && !detailIsFavorite(meshNodes->at(i - 1))) {
+                } else if (meshNodes->at(i).is_favorite && !meshNodes->at(i - 1).is_favorite) {
                     std::swap(meshNodes->at(i), meshNodes->at(i - 1));
                     changed = true;
-                } else if (!detailIsFavorite(meshNodes->at(i)) && detailIsFavorite(meshNodes->at(i - 1))) {
+                } else if (!meshNodes->at(i).is_favorite && meshNodes->at(i - 1).is_favorite) {
                     // noop
                 } else if (meshNodes->at(i).last_heard > meshNodes->at(i - 1).last_heard) {
                     std::swap(meshNodes->at(i), meshNodes->at(i - 1));
@@ -1919,11 +1894,11 @@ void NodeDB::sortMeshDB()
 
 uint8_t NodeDB::getMeshNodeChannel(NodeNum n)
 {
-    const meshtastic_NodeDetail *detail = getMeshNode(n);
-    if (!detail) {
+    const meshtastic_NodeInfoLite *info = getMeshNode(n);
+    if (!info) {
         return 0; // defaults to PRIMARY
     }
-    return detail->channel;
+    return info->channel;
 }
 
 std::string NodeDB::getNodeId() const
@@ -1935,7 +1910,7 @@ std::string NodeDB::getNodeId() const
 
 /// Find a node in our DB, return null for missing
 /// NOTE: This function might be called from an ISR
-meshtastic_NodeDetail *NodeDB::getMeshNode(NodeNum n)
+meshtastic_NodeInfoLite *NodeDB::getMeshNode(NodeNum n)
 {
     for (int i = 0; i < numMeshNodes; i++)
         if (meshNodes->at(i).num == n)
@@ -1951,11 +1926,11 @@ bool NodeDB::isFull()
 }
 
 /// Find a node in our DB, create an empty NodeInfo if missing
-meshtastic_NodeDetail *NodeDB::getOrCreateMeshNode(NodeNum n)
+meshtastic_NodeInfoLite *NodeDB::getOrCreateMeshNode(NodeNum n)
 {
-    meshtastic_NodeDetail *detail = getMeshNode(n);
+    meshtastic_NodeInfoLite *lite = getMeshNode(n);
 
-    if (!detail) {
+    if (!lite) {
         if (isFull()) {
             LOG_INFO("Node database full with %i nodes and %u bytes free. Erasing oldest entry", numMeshNodes,
                      memGet.getFreeHeap());
@@ -1966,14 +1941,14 @@ meshtastic_NodeDetail *NodeDB::getOrCreateMeshNode(NodeNum n)
             int oldestBoringIndex = -1;
             for (int i = 1; i < numMeshNodes; i++) {
                 // Simply the oldest non-favorite, non-ignored, non-verified node
-                const auto &candidate = meshNodes->at(i);
-                if (!detailIsFavorite(candidate) && !detailIsIgnored(candidate) &&
-                    !detailHasFlag(candidate, NODEDETAIL_FLAG_IS_KEY_MANUALLY_VERIFIED) && meshNodes->at(i).last_heard < oldest) {
+                if (!meshNodes->at(i).is_favorite && !meshNodes->at(i).is_ignored &&
+                    !(meshNodes->at(i).bitfield & NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_MASK) &&
+                    meshNodes->at(i).last_heard < oldest) {
                     oldest = meshNodes->at(i).last_heard;
                     oldestIndex = i;
                 }
                 // The oldest "boring" node
-                if (!detailIsFavorite(candidate) && !detailIsIgnored(candidate) && candidate.public_key.size == 0 &&
+                if (!meshNodes->at(i).is_favorite && !meshNodes->at(i).is_ignored && meshNodes->at(i).user.public_key.size == 0 &&
                     meshNodes->at(i).last_heard < oldestBoring) {
                     oldestBoring = meshNodes->at(i).last_heard;
                     oldestBoringIndex = i;
@@ -1993,33 +1968,33 @@ meshtastic_NodeDetail *NodeDB::getOrCreateMeshNode(NodeNum n)
             }
         }
         // add the node at the end
-        detail = &meshNodes->at((numMeshNodes)++);
+        lite = &meshNodes->at((numMeshNodes)++);
 
         // everything is missing except the nodenum
-        *detail = makeDefaultDetail();
-        detail->num = n;
+        memset(lite, 0, sizeof(*lite));
+        lite->num = n;
         LOG_INFO("Adding node to database with %i nodes and %u bytes free!", numMeshNodes, memGet.getFreeHeap());
     }
 
-    return detail;
+    return lite;
 }
 
 /// Sometimes we will have Position objects that only have a time, so check for
 /// valid lat/lon
-bool NodeDB::hasValidPosition(const meshtastic_NodeDetail *n)
+bool NodeDB::hasValidPosition(const meshtastic_NodeInfoLite *n)
 {
-    return detailHasFlag(*n, NODEDETAIL_FLAG_HAS_POSITION) && (n->latitude_i != 0 || n->longitude_i != 0);
+    return n->has_position && (n->position.latitude_i != 0 || n->position.longitude_i != 0);
 }
 
 /// If we have a node / user and they report is_licensed = true
 /// we consider them licensed
 UserLicenseStatus NodeDB::getLicenseStatus(uint32_t nodeNum)
 {
-    meshtastic_NodeDetail *detail = getMeshNode(nodeNum);
-    if (!detail || !detailHasFlag(*detail, NODEDETAIL_FLAG_HAS_USER)) {
+    meshtastic_NodeInfoLite *info = getMeshNode(nodeNum);
+    if (!info || !info->has_user) {
         return UserLicenseStatus::NotKnown;
     }
-    return detailHasFlag(*detail, NODEDETAIL_FLAG_IS_LICENSED) ? UserLicenseStatus::Licensed : UserLicenseStatus::NotLicensed;
+    return info->user.is_licensed ? UserLicenseStatus::Licensed : UserLicenseStatus::NotLicensed;
 }
 
 #if !defined(MESHTASTIC_EXCLUDE_PKI)
@@ -2039,6 +2014,98 @@ bool NodeDB::checkLowEntropyPublicKey(const meshtastic_Config_SecurityConfig_pub
 }
 #endif
 
+bool NodeDB::generateCryptoKeyPair(const uint8_t *privateKey)
+{
+#if !(MESHTASTIC_EXCLUDE_PKI_KEYGEN || MESHTASTIC_EXCLUDE_PKI)
+    // Only generate keys for non-licensed users and if LoRa region is set
+    if (owner.is_licensed || config.lora.region == meshtastic_Config_LoRaConfig_RegionCode_UNSET) {
+        return false;
+    }
+
+    bool keygenSuccess = false;
+    bool lowEntropy = checkLowEntropyPublicKey(config.security.public_key);
+
+    // If a specific private key was provided, use it
+    if (privateKey != nullptr) {
+        LOG_INFO("Using provided private key for PKI");
+        memcpy(config.security.private_key.bytes, privateKey, 32);
+        config.security.private_key.size = 32;
+        config.security.public_key.size = 32;
+
+        // Generate public key from the provided private key
+        if (crypto->regeneratePublicKey(config.security.public_key.bytes, config.security.private_key.bytes)) {
+            keygenSuccess = true;
+        } else {
+            LOG_ERROR("Failed to generate public key from provided private key");
+            return false;
+        }
+    }
+    // Try to regenerate public key from existing private key if it's valid and not low entropy
+    else if (config.security.private_key.size == 32 && !lowEntropy) {
+        config.security.public_key.size = 32;
+        LOG_DEBUG("Regenerate PKI public key from existing private key");
+        if (crypto->regeneratePublicKey(config.security.public_key.bytes, config.security.private_key.bytes)) {
+            keygenSuccess = true;
+        }
+    } else {
+        // Generate a new key pair
+        LOG_INFO("Generate new PKI keys");
+        config.security.public_key.size = 32;
+        config.security.private_key.size = 32;
+        crypto->generateKeyPair(config.security.public_key.bytes, config.security.private_key.bytes);
+        keygenSuccess = true;
+    }
+
+    // Update sizes and copy to owner if successful
+    if (keygenSuccess) {
+        owner.public_key.size = 32;
+        memcpy(owner.public_key.bytes, config.security.public_key.bytes, 32);
+
+        // Update global entropy flag for UI display
+        keyIsLowEntropy = false;
+
+        // Set the DH private key for crypto operations
+        LOG_DEBUG("Set DH private key for crypto operations");
+        crypto->setDHPrivateKey(config.security.private_key.bytes);
+
+        // Conditionally create new identity based on parameter
+        createNewIdentity();
+    }
+    return keygenSuccess;
+#else
+    return false;
+#endif
+}
+
+bool NodeDB::createNewIdentity()
+{
+    uint32_t oldNodeNum = getNodeNum();
+    uint32_t newNodeNum = crc32Buffer(config.security.public_key.bytes, config.security.public_key.size);
+
+    // If the key hasn't changed, nothing to do
+    if (newNodeNum == oldNodeNum)
+        return false;
+
+    // Retire the old node entry
+    meshtastic_NodeInfoLite *node = getMeshNode(oldNodeNum);
+    if (node != NULL) {
+        LOG_DEBUG("Old node num %u is now %u", oldNodeNum, newNodeNum);
+        node->is_ignored = true;
+        node->has_device_metrics = false;
+        node->has_position = false;
+        node->user.public_key.size = 0;
+        memset(node->user.public_key.bytes, 0, sizeof(node->user.public_key.bytes));
+    }
+
+    myNodeInfo.my_node_num = newNodeNum;
+
+    meshtastic_NodeInfoLite *info = getOrCreateMeshNode(getNodeNum());
+    info->user = TypeConversions::ConvertToUserLite(owner);
+    info->has_user = true;
+
+    return true;
+}
+
 bool NodeDB::backupPreferences(meshtastic_AdminMessage_BackupLocation location)
 {
     bool success = false;

src/mesh/NodeDB.h

@@ -4,8 +4,6 @@
 #include <Arduino.h>
 #include <algorithm>
 #include <assert.h>
-#include <cmath>
-#include <cstring>
 #include <pb_encode.h>
 #include <string>
 #include <vector>
@@ -106,13 +104,8 @@ static constexpr const char *moduleConfigFileName = "/prefs/module.proto";
 static constexpr const char *channelFileName = "/prefs/channels.proto";
 static constexpr const char *backupFileName = "/backups/backup.proto";
 
-template <typename T> inline T clampValue(T value, T low, T high)
-{
-    return std::max(low, std::min(value, high));
-}
-
 /// Given a node, return how many seconds in the past (vs now) that we last heard from it
-uint32_t sinceLastSeen(const meshtastic_NodeDetail *n);
+uint32_t sinceLastSeen(const meshtastic_NodeInfoLite *n);
 
 /// Given a packet, return how many seconds in the past (vs now) it was received
 uint32_t sinceReceived(const meshtastic_MeshPacket *p);
@@ -142,9 +135,9 @@ class NodeDB
     // Note: these two references just point into our static array we serialize to/from disk
 
   public:
-    std::vector<meshtastic_NodeDetail> *meshNodes;
+    std::vector<meshtastic_NodeInfoLite> *meshNodes;
     bool updateGUI = false; // we think the gui should definitely be redrawn, screen will clear this once handled
-    meshtastic_NodeDetail *updateGUIforNode = NULL; // if currently showing this node, we think you should update the GUI
+    meshtastic_NodeInfoLite *updateGUIforNode = NULL; // if currently showing this node, we think you should update the GUI
     Observable<const meshtastic::NodeStatus *> newStatus;
     pb_size_t numMeshNodes;
 
@@ -248,15 +241,15 @@ class NodeDB
 
     void installRoleDefaults(meshtastic_Config_DeviceConfig_Role role);
 
-    const meshtastic_NodeDetail *readNextMeshNode(uint32_t &readIndex);
+    const meshtastic_NodeInfoLite *readNextMeshNode(uint32_t &readIndex);
 
-    meshtastic_NodeDetail *getMeshNodeByIndex(size_t x)
+    meshtastic_NodeInfoLite *getMeshNodeByIndex(size_t x)
     {
         assert(x < numMeshNodes);
         return &meshNodes->at(x);
     }
 
-    virtual meshtastic_NodeDetail *getMeshNode(NodeNum n);
+    virtual meshtastic_NodeInfoLite *getMeshNode(NodeNum n);
     size_t getNumMeshNodes() { return numMeshNodes; }
 
     UserLicenseStatus getLicenseStatus(uint32_t nodeNum);
@@ -267,7 +260,7 @@ class NodeDB
         emptyNodeDatabase.version = DEVICESTATE_CUR_VER;
         size_t nodeDatabaseSize;
         pb_get_encoded_size(&nodeDatabaseSize, meshtastic_NodeDatabase_fields, &emptyNodeDatabase);
-        return nodeDatabaseSize + (MAX_NUM_NODES * meshtastic_NodeDetail_size);
+        return nodeDatabaseSize + (MAX_NUM_NODES * meshtastic_NodeInfoLite_size);
     }
 
     // returns true if the maximum number of nodes is reached or we are running low on memory
@@ -288,12 +281,18 @@ class NodeDB
         localPosition = position;
     }
 
-    bool hasValidPosition(const meshtastic_NodeDetail *n);
+    bool hasValidPosition(const meshtastic_NodeInfoLite *n);
 
 #if !defined(MESHTASTIC_EXCLUDE_PKI)
     bool checkLowEntropyPublicKey(const meshtastic_Config_SecurityConfig_public_key_t &keyToTest);
 #endif
 
+    /// Consolidate crypto key generation logic used across multiple modules
+    /// @param privateKey Optional 32-byte private key to use. If nullptr, generates new random keys.
+    bool generateCryptoKeyPair(const uint8_t *privateKey = nullptr);
+
+    bool createNewIdentity();
+
     bool backupPreferences(meshtastic_AdminMessage_BackupLocation location);
     bool restorePreferences(meshtastic_AdminMessage_BackupLocation location,
                             int restoreWhat = SEGMENT_CONFIG | SEGMENT_MODULECONFIG | SEGMENT_DEVICESTATE | SEGMENT_CHANNELS);
@@ -311,8 +310,8 @@ class NodeDB
     uint32_t lastNodeDbSave = 0;    // when we last saved our db to flash
     uint32_t lastBackupAttempt = 0; // when we last tried a backup automatically or manually
     uint32_t lastSort = 0;          // When last sorted the nodeDB
-    /// Find a node in our DB, create an empty NodeDetail if missing
-    meshtastic_NodeDetail *getOrCreateMeshNode(NodeNum n);
+    /// Find a node in our DB, create an empty NodeInfoLite if missing
+    meshtastic_NodeInfoLite *getOrCreateMeshNode(NodeNum n);
 
     /*
      * Internal boolean to track sorting paused
@@ -377,261 +376,8 @@ extern uint32_t error_address;
 #define NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_SHIFT 0
 #define NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_MASK (1 << NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_SHIFT)
 
-enum NodeDetailFlag : uint32_t {
-    NODEDETAIL_FLAG_IS_KEY_MANUALLY_VERIFIED = 1u << 0,
-    NODEDETAIL_FLAG_HAS_USER = 1u << 1,
-    NODEDETAIL_FLAG_HAS_POSITION = 1u << 2,
-    NODEDETAIL_FLAG_HAS_DEVICE_METRICS = 1u << 3,
-    NODEDETAIL_FLAG_VIA_MQTT = 1u << 4,
-    NODEDETAIL_FLAG_IS_FAVORITE = 1u << 5,
-    NODEDETAIL_FLAG_IS_IGNORED = 1u << 6,
-    NODEDETAIL_FLAG_HAS_HOPS_AWAY = 1u << 7,
-    NODEDETAIL_FLAG_IS_LICENSED = 1u << 8,
-    NODEDETAIL_FLAG_HAS_UNMESSAGABLE = 1u << 9,
-    NODEDETAIL_FLAG_IS_UNMESSAGABLE = 1u << 10,
-    NODEDETAIL_FLAG_HAS_BATTERY_LEVEL = 1u << 11,
-    NODEDETAIL_FLAG_HAS_VOLTAGE = 1u << 12,
-    NODEDETAIL_FLAG_HAS_CHANNEL_UTIL = 1u << 13,
-    NODEDETAIL_FLAG_HAS_AIR_UTIL_TX = 1u << 14,
-    NODEDETAIL_FLAG_HAS_UPTIME = 1u << 15
-};
-
-inline bool detailHasFlag(const meshtastic_NodeDetail &detail, NodeDetailFlag flag)
-{
-    return (detail.flags & static_cast<uint32_t>(flag)) != 0;
-}
-
-inline void detailSetFlag(meshtastic_NodeDetail &detail, NodeDetailFlag flag, bool value = true)
-{
-    if (value) {
-        detail.flags |= static_cast<uint32_t>(flag);
-    } else {
-        detail.flags &= ~static_cast<uint32_t>(flag);
-    }
-}
-
-inline meshtastic_NodeDetail makeDefaultDetail()
-{
-    meshtastic_NodeDetail detail = meshtastic_NodeDetail_init_default;
-    return detail;
-}
-
-inline void clearUserFromDetail(meshtastic_NodeDetail &detail)
-{
-    detailSetFlag(detail, NODEDETAIL_FLAG_HAS_USER, false);
-    detailSetFlag(detail, NODEDETAIL_FLAG_IS_LICENSED, false);
-    detailSetFlag(detail, NODEDETAIL_FLAG_HAS_UNMESSAGABLE, false);
-    detailSetFlag(detail, NODEDETAIL_FLAG_IS_UNMESSAGABLE, false);
-    detail.long_name[0] = '\0';
-    detail.short_name[0] = '\0';
-    memset(detail.macaddr, 0, sizeof(detail.macaddr));
-    detail.hw_model = _meshtastic_HardwareModel_MIN;
-    detail.role = _meshtastic_Config_DeviceConfig_Role_MIN;
-    detail.public_key.size = 0;
-    memset(detail.public_key.bytes, 0, sizeof(detail.public_key.bytes));
-}
-
-inline void applyUserLiteToDetail(meshtastic_NodeDetail &detail, const meshtastic_UserLite &userLite)
-{
-    detailSetFlag(detail, NODEDETAIL_FLAG_HAS_USER, true);
-    strncpy(detail.long_name, userLite.long_name, sizeof(detail.long_name));
-    detail.long_name[sizeof(detail.long_name) - 1] = '\0';
-    strncpy(detail.short_name, userLite.short_name, sizeof(detail.short_name));
-    detail.short_name[sizeof(detail.short_name) - 1] = '\0';
-    memcpy(detail.macaddr, userLite.macaddr, sizeof(detail.macaddr));
-    detail.hw_model = userLite.hw_model;
-    detail.role = userLite.role;
-
-    const pb_size_t keySize = std::min(userLite.public_key.size, static_cast<pb_size_t>(sizeof(detail.public_key.bytes)));
-    memcpy(detail.public_key.bytes, userLite.public_key.bytes, keySize);
-    detail.public_key.size = keySize;
-
-    detailSetFlag(detail, NODEDETAIL_FLAG_IS_LICENSED, userLite.is_licensed);
-
-    if (userLite.has_is_unmessagable) {
-        detailSetFlag(detail, NODEDETAIL_FLAG_HAS_UNMESSAGABLE, true);
-        detailSetFlag(detail, NODEDETAIL_FLAG_IS_UNMESSAGABLE, userLite.is_unmessagable);
-    } else {
-        detailSetFlag(detail, NODEDETAIL_FLAG_HAS_UNMESSAGABLE, false);
-        detailSetFlag(detail, NODEDETAIL_FLAG_IS_UNMESSAGABLE, false);
-    }
-}
-
-inline void applyUserToDetail(meshtastic_NodeDetail &detail, const meshtastic_User &user)
-{
-    meshtastic_UserLite lite = meshtastic_UserLite_init_default;
-    strncpy(lite.long_name, user.long_name, sizeof(lite.long_name));
-    lite.long_name[sizeof(lite.long_name) - 1] = '\0';
-    strncpy(lite.short_name, user.short_name, sizeof(lite.short_name));
-    lite.short_name[sizeof(lite.short_name) - 1] = '\0';
-    lite.hw_model = user.hw_model;
-    lite.role = user.role;
-    lite.is_licensed = user.is_licensed;
-    memcpy(lite.macaddr, user.macaddr, sizeof(lite.macaddr));
-    const pb_size_t keySize = std::min(user.public_key.size, static_cast<pb_size_t>(sizeof(lite.public_key.bytes)));
-    memcpy(lite.public_key.bytes, user.public_key.bytes, keySize);
-    lite.public_key.size = keySize;
-    lite.has_is_unmessagable = user.has_is_unmessagable;
-    lite.is_unmessagable = user.is_unmessagable;
-    applyUserLiteToDetail(detail, lite);
-}
-
-inline void clearPositionFromDetail(meshtastic_NodeDetail &detail)
-{
-    detailSetFlag(detail, NODEDETAIL_FLAG_HAS_POSITION, false);
-    detail.latitude_i = 0;
-    detail.longitude_i = 0;
-    detail.altitude = 0;
-    detail.position_time = 0;
-    detail.position_source = _meshtastic_Position_LocSource_MIN;
-}
-
-inline void applyPositionLiteToDetail(meshtastic_NodeDetail &detail, const meshtastic_PositionLite &positionLite)
-{
-    detailSetFlag(detail, NODEDETAIL_FLAG_HAS_POSITION, true);
-    detail.latitude_i = positionLite.latitude_i;
-    detail.longitude_i = positionLite.longitude_i;
-    detail.altitude = positionLite.altitude;
-    detail.position_time = positionLite.time;
-    detail.position_source = positionLite.location_source;
-}
-
-inline void applyPositionToDetail(meshtastic_NodeDetail &detail, const meshtastic_Position &position)
-{
-    meshtastic_PositionLite lite = meshtastic_PositionLite_init_default;
-    lite.latitude_i = position.latitude_i;
-    lite.longitude_i = position.longitude_i;
-    lite.altitude = position.altitude;
-    lite.location_source = position.location_source;
-    lite.time = position.time;
-    applyPositionLiteToDetail(detail, lite);
-}
-
-inline void clearMetricsFromDetail(meshtastic_NodeDetail &detail)
-{
-    detailSetFlag(detail, NODEDETAIL_FLAG_HAS_DEVICE_METRICS, false);
-    detailSetFlag(detail, NODEDETAIL_FLAG_HAS_BATTERY_LEVEL, false);
-    detailSetFlag(detail, NODEDETAIL_FLAG_HAS_VOLTAGE, false);
-    detailSetFlag(detail, NODEDETAIL_FLAG_HAS_CHANNEL_UTIL, false);
-    detailSetFlag(detail, NODEDETAIL_FLAG_HAS_AIR_UTIL_TX, false);
-    detailSetFlag(detail, NODEDETAIL_FLAG_HAS_UPTIME, false);
-    detail.battery_level = 0;
-    detail.voltage_millivolts = 0;
-    detail.channel_utilization_permille = 0;
-    detail.air_util_tx_permille = 0;
-    detail.uptime_seconds = 0;
-}
-
-inline void applyMetricsToDetail(meshtastic_NodeDetail &detail, const meshtastic_DeviceMetrics &metrics)
-{
-    detailSetFlag(detail, NODEDETAIL_FLAG_HAS_DEVICE_METRICS, true);
-
-    if (metrics.has_battery_level) {
-        detailSetFlag(detail, NODEDETAIL_FLAG_HAS_BATTERY_LEVEL, true);
-        uint32_t battery = metrics.battery_level;
-        if (battery > 255u) {
-            battery = 255u;
-        }
-        detail.battery_level = static_cast<uint8_t>(battery);
-    } else {
-        detailSetFlag(detail, NODEDETAIL_FLAG_HAS_BATTERY_LEVEL, false);
-    }
-
-    if (metrics.has_voltage) {
-        detailSetFlag(detail, NODEDETAIL_FLAG_HAS_VOLTAGE, true);
-        double limitedVoltage = clampValue(static_cast<double>(metrics.voltage), 0.0, 65.535);
-        int millivolts = static_cast<int>(std::lround(limitedVoltage * 1000.0));
-        millivolts = clampValue<int>(millivolts, 0, 0xFFFF);
-        detail.voltage_millivolts = static_cast<uint16_t>(millivolts);
-    } else {
-        detailSetFlag(detail, NODEDETAIL_FLAG_HAS_VOLTAGE, false);
-        detail.voltage_millivolts = 0;
-    }
-
-    if (metrics.has_channel_utilization) {
-        detailSetFlag(detail, NODEDETAIL_FLAG_HAS_CHANNEL_UTIL, true);
-        double limitedUtil = clampValue(static_cast<double>(metrics.channel_utilization), 0.0, 100.0);
-        int permille = static_cast<int>(std::lround(limitedUtil * 10.0));
-        permille = clampValue<int>(permille, 0, 1000);
-        detail.channel_utilization_permille = static_cast<uint16_t>(permille);
-    } else {
-        detailSetFlag(detail, NODEDETAIL_FLAG_HAS_CHANNEL_UTIL, false);
-        detail.channel_utilization_permille = 0;
-    }
-
-    if (metrics.has_air_util_tx) {
-        detailSetFlag(detail, NODEDETAIL_FLAG_HAS_AIR_UTIL_TX, true);
-        double limitedAirUtil = clampValue(static_cast<double>(metrics.air_util_tx), 0.0, 100.0);
-        int permille = static_cast<int>(std::lround(limitedAirUtil * 10.0));
-        permille = clampValue<int>(permille, 0, 1000);
-        detail.air_util_tx_permille = static_cast<uint16_t>(permille);
-    } else {
-        detailSetFlag(detail, NODEDETAIL_FLAG_HAS_AIR_UTIL_TX, false);
-        detail.air_util_tx_permille = 0;
-    }
-
-    if (metrics.has_uptime_seconds) {
-        detailSetFlag(detail, NODEDETAIL_FLAG_HAS_UPTIME, true);
-        detail.uptime_seconds = metrics.uptime_seconds;
-    } else {
-        detailSetFlag(detail, NODEDETAIL_FLAG_HAS_UPTIME, false);
-        detail.uptime_seconds = 0;
-    }
-}
-
-inline bool detailIsFavorite(const meshtastic_NodeDetail &detail)
-{
-    return detailHasFlag(detail, NODEDETAIL_FLAG_IS_FAVORITE);
-}
-
-inline bool detailIsIgnored(const meshtastic_NodeDetail &detail)
-{
-    return detailHasFlag(detail, NODEDETAIL_FLAG_IS_IGNORED);
-}
-
-inline bool detailViaMqtt(const meshtastic_NodeDetail &detail)
-{
-    return detailHasFlag(detail, NODEDETAIL_FLAG_VIA_MQTT);
-}
-
-inline meshtastic_PositionLite detailToPositionLite(const meshtastic_NodeDetail &detail)
-{
-    meshtastic_PositionLite lite = meshtastic_PositionLite_init_default;
-    if (!detailHasFlag(detail, NODEDETAIL_FLAG_HAS_POSITION)) {
-        return lite;
-    }
-
-    lite.latitude_i = detail.latitude_i;
-    lite.longitude_i = detail.longitude_i;
-    lite.altitude = detail.altitude;
-    lite.time = detail.position_time;
-    lite.location_source = detail.position_source;
-    return lite;
-}
-
-inline meshtastic_UserLite detailToUserLite(const meshtastic_NodeDetail &detail)
-{
-    meshtastic_UserLite lite = meshtastic_UserLite_init_default;
-    if (!detailHasFlag(detail, NODEDETAIL_FLAG_HAS_USER)) {
-        return lite;
-    }
-
-    strncpy(lite.long_name, detail.long_name, sizeof(lite.long_name));
-    lite.long_name[sizeof(lite.long_name) - 1] = '\0';
-    strncpy(lite.short_name, detail.short_name, sizeof(lite.short_name));
-    lite.short_name[sizeof(lite.short_name) - 1] = '\0';
-    lite.hw_model = detail.hw_model;
-    lite.role = detail.role;
-    lite.is_licensed = detailHasFlag(detail, NODEDETAIL_FLAG_IS_LICENSED);
-    memcpy(lite.macaddr, detail.macaddr, sizeof(lite.macaddr));
-    lite.public_key.size = std::min(static_cast<pb_size_t>(sizeof(lite.public_key.bytes)), detail.public_key.size);
-    memcpy(lite.public_key.bytes, detail.public_key.bytes, lite.public_key.size);
-    if (detailHasFlag(detail, NODEDETAIL_FLAG_HAS_UNMESSAGABLE)) {
-        lite.has_is_unmessagable = true;
-        lite.is_unmessagable = detailHasFlag(detail, NODEDETAIL_FLAG_IS_UNMESSAGABLE);
-    }
-    return lite;
-}
+#define NODEINFO_BITFIELD_HAS_XEDDSA_SIGNED_SHIFT 1
+#define NODEINFO_BITFIELD_HAS_XEDDSA_SIGNED_MASK (1 << NODEINFO_BITFIELD_HAS_XEDDSA_SIGNED_SHIFT)
 
 #define Module_Config_size                                                                                                       \
     (ModuleConfig_CannedMessageConfig_size + ModuleConfig_ExternalNotificationConfig_size + ModuleConfig_MQTTConfig_size +       \

src/mesh/PhoneAPI.cpp

@@ -267,9 +267,9 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
 
     case STATE_SEND_OWN_NODEINFO: {
         LOG_DEBUG("Send My NodeInfo");
-        const meshtastic_NodeDetail *us = nodeDB->readNextMeshNode(readIndex);
+        auto us = nodeDB->readNextMeshNode(readIndex);
         if (us) {
-            auto info = TypeConversions::ConvertToNodeInfo(*us);
+            auto info = TypeConversions::ConvertToNodeInfo(us);
             info.has_hops_away = false;
             info.is_favorite = true;
             {
@@ -633,11 +633,11 @@ void PhoneAPI::prefetchNodeInfos()
     {
         concurrency::LockGuard guard(&nodeInfoMutex);
         while (nodeInfoQueue.size() < kNodePrefetchDepth) {
-            const meshtastic_NodeDetail *nextNode = nodeDB->readNextMeshNode(readIndex);
+            auto nextNode = nodeDB->readNextMeshNode(readIndex);
             if (!nextNode)
                 break;
 
-            auto info = TypeConversions::ConvertToNodeInfo(*nextNode);
+            auto info = TypeConversions::ConvertToNodeInfo(nextNode);
             bool isUs = info.num == nodeDB->getNodeNum();
             info.hops_away = isUs ? 0 : info.hops_away;
             info.last_heard = isUs ? getValidTime(RTCQualityFromNet) : info.last_heard;

src/mesh/ProtobufModule.h

@@ -58,7 +58,7 @@ template <class T> class ProtobufModule : protected SinglePortModule
     const char *getSenderShortName(const meshtastic_MeshPacket &mp)
     {
         auto node = nodeDB->getMeshNode(getFrom(&mp));
-        const char *sender = (node) ? node->short_name : "???";
+        const char *sender = (node) ? node->user.short_name : "???";
         return sender;
     }
 

src/mesh/ReliableRouter.cpp

@@ -119,16 +119,11 @@ void ReliableRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtas
                         // stop the immediate relayer's retransmissions.
                         sendAckNak(meshtastic_Routing_Error_NONE, getFrom(p), p->id, p->channel, 0);
                     }
-                } else if (p->which_payload_variant == meshtastic_MeshPacket_encrypted_tag && p->channel == 0) {
-                    const meshtastic_NodeDetail *fromDetail = nodeDB->getMeshNode(p->from);
-                    if (!fromDetail || fromDetail->public_key.size == 0) {
-                        LOG_INFO("PKI packet from unknown node, send PKI_UNKNOWN_PUBKEY");
-                        sendAckNak(meshtastic_Routing_Error_PKI_UNKNOWN_PUBKEY, getFrom(p), p->id, channels.getPrimaryIndex(),
-                                   routingModule->getHopLimitForResponse(p->hop_start, p->hop_limit));
-                    } else {
-                        sendAckNak(meshtastic_Routing_Error_NO_CHANNEL, getFrom(p), p->id, channels.getPrimaryIndex(),
-                                   routingModule->getHopLimitForResponse(p->hop_start, p->hop_limit));
-                    }
+                } else if (p->which_payload_variant == meshtastic_MeshPacket_encrypted_tag && p->channel == 0 &&
+                           (nodeDB->getMeshNode(p->from) == nullptr || nodeDB->getMeshNode(p->from)->user.public_key.size == 0)) {
+                    LOG_INFO("PKI packet from unknown node, send PKI_UNKNOWN_PUBKEY");
+                    sendAckNak(meshtastic_Routing_Error_PKI_UNKNOWN_PUBKEY, getFrom(p), p->id, channels.getPrimaryIndex(),
+                               routingModule->getHopLimitForResponse(p->hop_start, p->hop_limit));
                 } else {
                     // Send a 'NO_CHANNEL' error on the primary channel if want_ack packet destined for us cannot be decoded
                     sendAckNak(meshtastic_Routing_Error_NO_CHANNEL, getFrom(p), p->id, channels.getPrimaryIndex(),

src/mesh/Router.cpp

@@ -100,20 +100,21 @@ bool Router::shouldDecrementHopLimit(const meshtastic_MeshPacket *p)
     // Optimized search for favorite routers with matching last byte
     // Check ordering optimized for IoT devices (cheapest checks first)
     for (size_t i = 0; i < nodeDB->getNumMeshNodes(); i++) {
-        const meshtastic_NodeDetail *node = nodeDB->getMeshNodeByIndex(i);
+        meshtastic_NodeInfoLite *node = nodeDB->getMeshNodeByIndex(i);
         if (!node)
             continue;
 
         // Check 1: is_favorite (cheapest - single bool)
-        if (!detailIsFavorite(*node))
+        if (!node->is_favorite)
             continue;
 
         // Check 2: has_user (cheap - single bool)
-        if (!detailHasFlag(*node, NODEDETAIL_FLAG_HAS_USER))
+        if (!node->has_user)
             continue;
 
         // Check 3: role check (moderate cost - multiple comparisons)
-        if (!IS_ONE_OF(node->role, meshtastic_Config_DeviceConfig_Role_ROUTER, meshtastic_Config_DeviceConfig_Role_ROUTER_LATE)) {
+        if (!IS_ONE_OF(node->user.role, meshtastic_Config_DeviceConfig_Role_ROUTER,
+                       meshtastic_Config_DeviceConfig_Role_ROUTER_LATE)) {
             continue;
         }
 
@@ -260,7 +261,7 @@ ErrorCode Router::sendLocal(meshtastic_MeshPacket *p, RxSource src)
 
         // don't override if a channel was requested and no need to set it when PKI is enforced
         if (!p->channel && !p->pki_encrypted && !isBroadcast(p->to)) {
-            const meshtastic_NodeDetail *node = nodeDB->getMeshNode(p->to);
+            meshtastic_NodeInfoLite const *node = nodeDB->getMeshNode(p->to);
             if (node) {
                 p->channel = node->channel;
                 LOG_DEBUG("localSend to channel %d", p->channel);
@@ -408,11 +409,8 @@ DecodeState perhapsDecode(meshtastic_MeshPacket *p)
 {
     concurrency::LockGuard g(cryptLock);
 
-    const meshtastic_NodeDetail *fromDetail = nodeDB->getMeshNode(p->from);
-    const meshtastic_NodeDetail *toDetail = nodeDB->getMeshNode(p->to);
-
     if (config.device.rebroadcast_mode == meshtastic_Config_DeviceConfig_RebroadcastMode_KNOWN_ONLY &&
-        (!fromDetail || !detailHasFlag(*fromDetail, NODEDETAIL_FLAG_HAS_USER))) {
+        (nodeDB->getMeshNode(p->from) == NULL || !nodeDB->getMeshNode(p->from)->has_user)) {
         LOG_DEBUG("Node 0x%x not in nodeDB-> Rebroadcast mode KNOWN_ONLY will ignore packet", p->from);
         return DecodeState::DECODE_FAILURE;
     }
@@ -429,38 +427,33 @@ DecodeState perhapsDecode(meshtastic_MeshPacket *p)
     ChannelIndex chIndex = 0;
 #if !(MESHTASTIC_EXCLUDE_PKI)
     // Attempt PKI decryption first
-    if (p->channel == 0 && isToUs(p) && p->to > 0 && !isBroadcast(p->to) && fromDetail != nullptr && toDetail != nullptr &&
+    if (p->channel == 0 && isToUs(p) && p->to > 0 && !isBroadcast(p->to) && nodeDB->getMeshNode(p->from) != nullptr &&
+        nodeDB->getMeshNode(p->from)->user.public_key.size > 0 && nodeDB->getMeshNode(p->to)->user.public_key.size > 0 &&
         rawSize > MESHTASTIC_PKC_OVERHEAD) {
-        meshtastic_UserLite fromLite = meshtastic_UserLite_init_default;
-        meshtastic_UserLite toLite = meshtastic_UserLite_init_default;
-        fromLite = detailToUserLite(*fromDetail);
-        toLite = detailToUserLite(*toDetail);
+        LOG_DEBUG("Attempt PKI decryption");
 
-        if (fromLite.public_key.size == 32 && toLite.public_key.size == 32) {
-            LOG_DEBUG("Attempt PKI decryption");
+        if (crypto->decryptCurve25519(p->from, nodeDB->getMeshNode(p->from)->user.public_key, p->id, rawSize, p->encrypted.bytes,
+                                      bytes)) {
+            LOG_INFO("PKI Decryption worked!");
 
-            if (crypto->decryptCurve25519(p->from, fromLite.public_key, p->id, rawSize, p->encrypted.bytes, bytes)) {
-                LOG_INFO("PKI Decryption worked!");
-
-                meshtastic_Data decodedtmp;
-                memset(&decodedtmp, 0, sizeof(decodedtmp));
-                rawSize -= MESHTASTIC_PKC_OVERHEAD;
-                if (pb_decode_from_bytes(bytes, rawSize, &meshtastic_Data_msg, &decodedtmp) &&
-                    decodedtmp.portnum != meshtastic_PortNum_UNKNOWN_APP) {
-                    decrypted = true;
-                    LOG_INFO("Packet decrypted using PKI!");
-                    p->pki_encrypted = true;
-                    memcpy(&p->public_key.bytes, fromLite.public_key.bytes, 32);
-                    p->public_key.size = 32;
-                    p->decoded = decodedtmp;
-                    p->which_payload_variant = meshtastic_MeshPacket_decoded_tag; // change type to decoded
-                } else {
-                    LOG_ERROR("PKC Decrypted, but pb_decode failed!");
-                    return DecodeState::DECODE_FAILURE;
-                }
+            meshtastic_Data decodedtmp;
+            memset(&decodedtmp, 0, sizeof(decodedtmp));
+            rawSize -= MESHTASTIC_PKC_OVERHEAD;
+            if (pb_decode_from_bytes(bytes, rawSize, &meshtastic_Data_msg, &decodedtmp) &&
+                decodedtmp.portnum != meshtastic_PortNum_UNKNOWN_APP) {
+                decrypted = true;
+                LOG_INFO("Packet decrypted using PKI!");
+                p->pki_encrypted = true;
+                memcpy(&p->public_key.bytes, nodeDB->getMeshNode(p->from)->user.public_key.bytes, 32);
+                p->public_key.size = 32;
+                p->decoded = decodedtmp;
+                p->which_payload_variant = meshtastic_MeshPacket_decoded_tag; // change type to decoded
             } else {
-                LOG_WARN("PKC decrypt attempted but failed!");
+                LOG_ERROR("PKC Decrypted, but pb_decode failed!");
+                return DecodeState::DECODE_FAILURE;
             }
+        } else {
+            LOG_WARN("PKC decrypt attempted but failed!");
         }
     }
 #endif
@@ -507,6 +500,32 @@ DecodeState perhapsDecode(meshtastic_MeshPacket *p)
         if (p->decoded.has_bitfield)
             p->decoded.want_response |= p->decoded.bitfield & BITFIELD_WANT_RESPONSE_MASK;
 
+        if (p->decoded.has_xeddsa_signature) {
+            meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(p->from);
+            if (node && node->user.public_key.size == 32) {
+                p->xeddsa_signed =
+                    crypto->xeddsa_verify(node->user.public_key.bytes, p->from, p->id, p->decoded.portnum,
+                                          p->decoded.payload.bytes, p->decoded.payload.size, p->decoded.xeddsa_signature.bytes);
+                if (p->xeddsa_signed) {
+                    // Mark this node as a signer so future unsigned packets from it are rejected
+                    node->bitfield |= NODEINFO_BITFIELD_HAS_XEDDSA_SIGNED_MASK;
+                    LOG_DEBUG("Verified XEdDSA signature from 0x%08x", p->from);
+                } else {
+                    LOG_WARN("XEdDSA signature verification failed from 0x%08x, dropping", p->from);
+                    return DecodeState::DECODE_FAILURE;
+                }
+            } else {
+                LOG_DEBUG("No public key for 0x%08x, cannot verify XEdDSA signature", p->from);
+            }
+        } else {
+            // Unsigned packet — reject if this node previously sent signed packets
+            meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(p->from);
+            if (node && (node->bitfield & NODEINFO_BITFIELD_HAS_XEDDSA_SIGNED_MASK)) {
+                LOG_WARN("Dropping unsigned packet from 0x%08x that previously signed", p->from);
+                return DecodeState::DECODE_FAILURE;
+            }
+        }
+
         /* Not actually ever used.
         // Decompress if needed. jm
         if (p->decoded.portnum == meshtastic_PortNum_TEXT_MESSAGE_COMPRESSED_APP) {
@@ -556,6 +575,17 @@ meshtastic_Routing_Error perhapsEncode(meshtastic_MeshPacket *p)
             p->decoded.has_bitfield = true;
             p->decoded.bitfield |= (config.lora.config_ok_to_mqtt << BITFIELD_OK_TO_MQTT_SHIFT);
             p->decoded.bitfield |= (p->decoded.want_response << BITFIELD_WANT_RESPONSE_SHIFT);
+            // Sign broadcast packets if payload + signature fits within the max Data payload.
+            // The actual encoded size is checked after pb_encode (TOO_LARGE).
+            if (!p->pki_encrypted && isBroadcast(p->to) &&
+                p->decoded.payload.size + XEDDSA_SIGNATURE_SIZE < meshtastic_Constants_DATA_PAYLOAD_LEN) {
+                if (crypto->xeddsa_sign(p->from, p->id, p->decoded.portnum, p->decoded.payload.bytes, p->decoded.payload.size,
+                                        p->decoded.xeddsa_signature.bytes)) {
+                    p->decoded.xeddsa_signature.size = XEDDSA_SIGNATURE_SIZE;
+                    p->decoded.has_xeddsa_signature = true;
+                    LOG_DEBUG("XEdDSA signed packet 0x%08x", p->id);
+                }
+            }
         }
 
         size_t numbytes = pb_encode_to_bytes(bytes, sizeof(bytes), &meshtastic_Data_msg, &p->decoded);
@@ -603,11 +633,7 @@ meshtastic_Routing_Error perhapsEncode(meshtastic_MeshPacket *p)
         ChannelIndex chIndex = p->channel; // keep as a local because we are about to change it
 
 #if !(MESHTASTIC_EXCLUDE_PKI)
-        const meshtastic_NodeDetail *node = nodeDB->getMeshNode(p->to);
-        meshtastic_UserLite destLite = meshtastic_UserLite_init_default;
-        if (node) {
-            destLite = detailToUserLite(*node);
-        }
+        meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(p->to);
         // We may want to retool things so we can send a PKC packet when the client specifies a key and nodenum, even if the node
         // is not in the local nodedb
         // First, only PKC encrypt packets we are originating
@@ -624,7 +650,7 @@ meshtastic_Routing_Error perhapsEncode(meshtastic_MeshPacket *p)
             // Check for valid keys and single node destination
             config.security.private_key.size == 32 && !isBroadcast(p->to) && node != nullptr &&
             // Check for a known public key for the destination
-            (destLite.public_key.size == 32) &&
+            (node->user.public_key.size == 32) &&
             // Some portnums either make no sense to send with PKC
             p->decoded.portnum != meshtastic_PortNum_TRACEROUTE_APP && p->decoded.portnum != meshtastic_PortNum_NODEINFO_APP &&
             p->decoded.portnum != meshtastic_PortNum_ROUTING_APP && p->decoded.portnum != meshtastic_PortNum_POSITION_APP) {
@@ -632,12 +658,12 @@ meshtastic_Routing_Error perhapsEncode(meshtastic_MeshPacket *p)
             if (numbytes + MESHTASTIC_HEADER_LENGTH + MESHTASTIC_PKC_OVERHEAD > MAX_LORA_PAYLOAD_LEN)
                 return meshtastic_Routing_Error_TOO_LARGE;
             if (p->pki_encrypted && !memfll(p->public_key.bytes, 0, 32) &&
-                memcmp(p->public_key.bytes, destLite.public_key.bytes, 32) != 0) {
+                memcmp(p->public_key.bytes, node->user.public_key.bytes, 32) != 0) {
                 LOG_WARN("Client public key differs from requested: 0x%02x, stored key begins 0x%02x", *p->public_key.bytes,
-                         *destLite.public_key.bytes);
+                         *node->user.public_key.bytes);
                 return meshtastic_Routing_Error_PKI_FAILED;
             }
-            crypto->encryptCurve25519(p->to, getFrom(p), destLite.public_key, p->id, numbytes, bytes, p->encrypted.bytes);
+            crypto->encryptCurve25519(p->to, getFrom(p), node->user.public_key, p->id, numbytes, bytes, p->encrypted.bytes);
             numbytes += MESHTASTIC_PKC_OVERHEAD;
             p->channel = 0;
             p->pki_encrypted = true;
@@ -787,8 +813,8 @@ void Router::perhapsHandleReceived(meshtastic_MeshPacket *p)
         return;
     }
 
-    const meshtastic_NodeDetail *node = nodeDB->getMeshNode(p->from);
-    if (node != NULL && detailIsIgnored(*node)) {
+    meshtastic_NodeInfoLite const *node = nodeDB->getMeshNode(p->from);
+    if (node != NULL && node->is_ignored) {
         LOG_DEBUG("Ignore msg, 0x%x is ignored", p->from);
         packetPool.release(p);
         return;

src/mesh/TypeConversions.cpp

@@ -1,9 +1,6 @@
 #include "TypeConversions.h"
 #include "mesh/generated/meshtastic/deviceonly.pb.h"
 #include "mesh/generated/meshtastic/mesh.pb.h"
-#include <algorithm>
-#include <cmath>
-#include <cstring>
 
 meshtastic_NodeInfo TypeConversions::ConvertToNodeInfo(const meshtastic_NodeInfoLite *lite)
 {
@@ -17,6 +14,7 @@ meshtastic_NodeInfo TypeConversions::ConvertToNodeInfo(const meshtastic_NodeInfo
     info.is_favorite = lite->is_favorite;
     info.is_ignored = lite->is_ignored;
     info.is_key_manually_verified = lite->bitfield & NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_MASK;
+    info.has_xeddsa_signed = lite->bitfield & NODEINFO_BITFIELD_HAS_XEDDSA_SIGNED_MASK;
 
     if (lite->has_hops_away) {
         info.has_hops_away = true;
@@ -48,196 +46,6 @@ meshtastic_NodeInfo TypeConversions::ConvertToNodeInfo(const meshtastic_NodeInfo
     return info;
 }
 
-meshtastic_NodeInfo TypeConversions::ConvertToNodeInfo(const meshtastic_NodeDetail &detail)
-{
-    meshtastic_NodeInfo info = meshtastic_NodeInfo_init_default;
-
-    info.num = detail.num;
-    info.snr = detail.snr;
-    info.last_heard = detail.last_heard;
-    info.channel = detail.channel;
-    info.via_mqtt = detail.flags & NODEDETAIL_FLAG_VIA_MQTT;
-    info.is_favorite = detail.flags & NODEDETAIL_FLAG_IS_FAVORITE;
-    info.is_ignored = detail.flags & NODEDETAIL_FLAG_IS_IGNORED;
-    info.is_key_manually_verified = detail.flags & NODEDETAIL_FLAG_IS_KEY_MANUALLY_VERIFIED;
-
-    if (detail.flags & NODEDETAIL_FLAG_HAS_HOPS_AWAY) {
-        info.has_hops_away = true;
-        info.hops_away = detail.hops_away;
-    }
-
-    if (detail.flags & NODEDETAIL_FLAG_HAS_POSITION) {
-        info.has_position = true;
-        info.position = meshtastic_Position_init_default;
-        if (detail.latitude_i != 0) {
-            info.position.has_latitude_i = true;
-        }
-        info.position.latitude_i = detail.latitude_i;
-        if (detail.longitude_i != 0) {
-            info.position.has_longitude_i = true;
-        }
-        info.position.longitude_i = detail.longitude_i;
-        if (detail.altitude != 0) {
-            info.position.has_altitude = true;
-        }
-        info.position.altitude = detail.altitude;
-        info.position.location_source = detail.position_source;
-        info.position.time = detail.position_time;
-    }
-
-    if (detail.flags & NODEDETAIL_FLAG_HAS_USER) {
-        info.has_user = true;
-        meshtastic_User user = meshtastic_User_init_default;
-        snprintf(user.id, sizeof(user.id), "!%08x", detail.num);
-        strncpy(user.long_name, detail.long_name, sizeof(user.long_name));
-        user.long_name[sizeof(user.long_name) - 1] = '\0';
-        strncpy(user.short_name, detail.short_name, sizeof(user.short_name));
-        user.short_name[sizeof(user.short_name) - 1] = '\0';
-        user.hw_model = detail.hw_model;
-        user.role = detail.role;
-        user.is_licensed = detail.flags & NODEDETAIL_FLAG_IS_LICENSED;
-        memcpy(user.macaddr, detail.macaddr, sizeof(user.macaddr));
-        const pb_size_t keySize = std::min(detail.public_key.size, static_cast<pb_size_t>(sizeof(user.public_key.bytes)));
-        memcpy(user.public_key.bytes, detail.public_key.bytes, keySize);
-        user.public_key.size = keySize;
-        if (detail.flags & NODEDETAIL_FLAG_HAS_UNMESSAGABLE) {
-            user.has_is_unmessagable = true;
-            user.is_unmessagable = detail.flags & NODEDETAIL_FLAG_IS_UNMESSAGABLE;
-        }
-        info.user = user;
-    }
-
-    if (detail.flags & NODEDETAIL_FLAG_HAS_DEVICE_METRICS) {
-        info.has_device_metrics = true;
-        meshtastic_DeviceMetrics metrics = meshtastic_DeviceMetrics_init_default;
-
-        if (detail.flags & NODEDETAIL_FLAG_HAS_BATTERY_LEVEL) {
-            metrics.has_battery_level = true;
-            metrics.battery_level = detail.battery_level;
-        }
-        if (detail.flags & NODEDETAIL_FLAG_HAS_VOLTAGE) {
-            metrics.has_voltage = true;
-            metrics.voltage = static_cast<float>(detail.voltage_millivolts) / 1000.0f;
-        }
-        if (detail.flags & NODEDETAIL_FLAG_HAS_CHANNEL_UTIL) {
-            metrics.has_channel_utilization = true;
-            metrics.channel_utilization = static_cast<float>(detail.channel_utilization_permille) / 10.0f;
-        }
-        if (detail.flags & NODEDETAIL_FLAG_HAS_AIR_UTIL_TX) {
-            metrics.has_air_util_tx = true;
-            metrics.air_util_tx = static_cast<float>(detail.air_util_tx_permille) / 10.0f;
-        }
-        if (detail.flags & NODEDETAIL_FLAG_HAS_UPTIME) {
-            metrics.has_uptime_seconds = true;
-            metrics.uptime_seconds = detail.uptime_seconds;
-        }
-
-        info.device_metrics = metrics;
-    }
-
-    return info;
-}
-
-meshtastic_NodeDetail TypeConversions::ConvertToNodeDetail(const meshtastic_NodeInfoLite &lite)
-{
-    meshtastic_NodeDetail detail = meshtastic_NodeDetail_init_default;
-
-    detail.num = lite.num;
-    detail.snr = lite.snr;
-    detail.last_heard = lite.last_heard;
-    detail.channel = lite.channel;
-    detail.next_hop = lite.next_hop;
-    if (lite.has_hops_away) {
-        detail.flags |= NODEDETAIL_FLAG_HAS_HOPS_AWAY;
-        detail.hops_away = lite.hops_away;
-    }
-    if (lite.via_mqtt) {
-        detail.flags |= NODEDETAIL_FLAG_VIA_MQTT;
-    }
-    if (lite.is_favorite) {
-        detail.flags |= NODEDETAIL_FLAG_IS_FAVORITE;
-    }
-    if (lite.is_ignored) {
-        detail.flags |= NODEDETAIL_FLAG_IS_IGNORED;
-    }
-    if (lite.bitfield & NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_MASK) {
-        detail.flags |= NODEDETAIL_FLAG_IS_KEY_MANUALLY_VERIFIED;
-    }
-
-    if (lite.has_user) {
-        detail.flags |= NODEDETAIL_FLAG_HAS_USER;
-        strncpy(detail.long_name, lite.user.long_name, sizeof(detail.long_name));
-        detail.long_name[sizeof(detail.long_name) - 1] = '\0';
-        strncpy(detail.short_name, lite.user.short_name, sizeof(detail.short_name));
-        detail.short_name[sizeof(detail.short_name) - 1] = '\0';
-        detail.hw_model = lite.user.hw_model;
-        detail.role = lite.user.role;
-        memcpy(detail.macaddr, lite.user.macaddr, sizeof(detail.macaddr));
-        const pb_size_t keySize = std::min(lite.user.public_key.size, static_cast<pb_size_t>(sizeof(detail.public_key.bytes)));
-        memcpy(detail.public_key.bytes, lite.user.public_key.bytes, keySize);
-        detail.public_key.size = keySize;
-        if (lite.user.is_licensed) {
-            detail.flags |= NODEDETAIL_FLAG_IS_LICENSED;
-        }
-        if (lite.user.has_is_unmessagable) {
-            detail.flags |= NODEDETAIL_FLAG_HAS_UNMESSAGABLE;
-            if (lite.user.is_unmessagable) {
-                detail.flags |= NODEDETAIL_FLAG_IS_UNMESSAGABLE;
-            }
-        }
-    }
-
-    if (lite.has_position) {
-        detail.flags |= NODEDETAIL_FLAG_HAS_POSITION;
-        detail.latitude_i = lite.position.latitude_i;
-        detail.longitude_i = lite.position.longitude_i;
-        detail.altitude = lite.position.altitude;
-        detail.position_time = lite.position.time;
-        detail.position_source = lite.position.location_source;
-    }
-
-    if (lite.has_device_metrics) {
-        detail.flags |= NODEDETAIL_FLAG_HAS_DEVICE_METRICS;
-        const meshtastic_DeviceMetrics &metrics = lite.device_metrics;
-
-        if (metrics.has_battery_level) {
-            detail.flags |= NODEDETAIL_FLAG_HAS_BATTERY_LEVEL;
-            uint32_t battery = metrics.battery_level;
-            if (battery > 255u) {
-                battery = 255u;
-            }
-            detail.battery_level = static_cast<uint8_t>(battery);
-        }
-        if (metrics.has_voltage) {
-            detail.flags |= NODEDETAIL_FLAG_HAS_VOLTAGE;
-            double limitedVoltage = clampValue(static_cast<double>(metrics.voltage), 0.0, 65.535);
-            int millivolts = static_cast<int>(std::lround(limitedVoltage * 1000.0));
-            millivolts = clampValue<int>(millivolts, 0, 0xFFFF);
-            detail.voltage_millivolts = static_cast<uint16_t>(millivolts);
-        }
-        if (metrics.has_channel_utilization) {
-            detail.flags |= NODEDETAIL_FLAG_HAS_CHANNEL_UTIL;
-            double limitedUtil = clampValue(static_cast<double>(metrics.channel_utilization), 0.0, 100.0);
-            int permille = static_cast<int>(std::lround(limitedUtil * 10.0));
-            permille = clampValue<int>(permille, 0, 1000);
-            detail.channel_utilization_permille = static_cast<uint16_t>(permille);
-        }
-        if (metrics.has_air_util_tx) {
-            detail.flags |= NODEDETAIL_FLAG_HAS_AIR_UTIL_TX;
-            double limitedAirUtil = clampValue(static_cast<double>(metrics.air_util_tx), 0.0, 100.0);
-            int permille = static_cast<int>(std::lround(limitedAirUtil * 10.0));
-            permille = clampValue<int>(permille, 0, 1000);
-            detail.air_util_tx_permille = static_cast<uint16_t>(permille);
-        }
-        if (metrics.has_uptime_seconds) {
-            detail.flags |= NODEDETAIL_FLAG_HAS_UPTIME;
-            detail.uptime_seconds = metrics.uptime_seconds;
-        }
-    }
-
-    return detail;
-}
-
 meshtastic_PositionLite TypeConversions::ConvertToPositionLite(meshtastic_Position position)
 {
     meshtastic_PositionLite lite = meshtastic_PositionLite_init_default;

src/mesh/TypeConversions.h

@@ -8,8 +8,6 @@ class TypeConversions
 {
   public:
     static meshtastic_NodeInfo ConvertToNodeInfo(const meshtastic_NodeInfoLite *lite);
-    static meshtastic_NodeInfo ConvertToNodeInfo(const meshtastic_NodeDetail &detail);
-    static meshtastic_NodeDetail ConvertToNodeDetail(const meshtastic_NodeInfoLite &lite);
     static meshtastic_PositionLite ConvertToPositionLite(meshtastic_Position position);
     static meshtastic_Position ConvertToPosition(meshtastic_PositionLite lite);
     static meshtastic_UserLite ConvertToUserLite(meshtastic_User user);

src/mesh/generated/meshtastic/deviceonly.pb.cpp

@@ -15,9 +15,6 @@ PB_BIND(meshtastic_UserLite, meshtastic_UserLite, AUTO)
 PB_BIND(meshtastic_NodeInfoLite, meshtastic_NodeInfoLite, AUTO)
 
 
-PB_BIND(meshtastic_NodeDetail, meshtastic_NodeDetail, AUTO)
-
-
 PB_BIND(meshtastic_DeviceState, meshtastic_DeviceState, 2)
 
 

src/mesh/generated/meshtastic/deviceonly.pb.h

@@ -101,49 +101,6 @@ typedef struct _meshtastic_NodeInfoLite {
     uint32_t bitfield;
 } meshtastic_NodeInfoLite;
 
-typedef PB_BYTES_ARRAY_T(32) meshtastic_NodeDetail_public_key_t;
-/* Flattened node representation used for the compact NodeDB rewrite.
- Uses integer scaling where possible and a single flags bitfield for booleans. */
-typedef struct _meshtastic_NodeDetail {
-    /* The node number */
-    uint32_t num;
-    /* 48-bit hardware identifier copied from the radio */
-    pb_byte_t macaddr[6];
-    /* Cached long display name */
-    char long_name[40];
-    /* Cached short display name */
-    char short_name[5];
-    /* Hardware model reported by the node */
-    meshtastic_HardwareModel hw_model;
-    /* Role assigned to the node */
-    meshtastic_Config_DeviceConfig_Role role;
-    /* Public key broadcast by the node */
-    meshtastic_NodeDetail_public_key_t public_key;
-    /* Position data flattened from PositionLite */
-    int32_t latitude_i;
-    int32_t longitude_i;
-    int32_t altitude;
-    uint32_t position_time;
-    meshtastic_Position_LocSource position_source;
-    /* Radio performance metrics */
-    float snr;
-    /* Last packet timestamp */
-    uint32_t last_heard;
-    /* Mesh routing metadata */
-    uint8_t channel;
-    uint8_t hops_away;
-    uint8_t next_hop;
-    /* Device metrics cached using integer scaling */
-    uint8_t battery_level;
-    uint32_t uptime_seconds;
-    uint16_t channel_utilization_permille;
-    uint16_t air_util_tx_permille;
-    uint16_t voltage_millivolts;
-    /* Bitset storing boolean flags and presence markers.
- See NodeDetailFlag shifts for decoded meaning. */
-    uint32_t flags;
-} meshtastic_NodeDetail;
-
 /* This message is never sent over the wire, but it is used for serializing DB
  state to flash in the device code
  FIXME, since we write this each time we enter deep sleep (and have infinite
@@ -191,7 +148,7 @@ typedef struct _meshtastic_NodeDatabase {
  NodeDB.cpp in the device code. */
     uint32_t version;
     /* New lite version of NodeDB to decrease memory footprint */
-    std::vector<meshtastic_NodeDetail> nodes;
+    std::vector<meshtastic_NodeInfoLite> nodes;
 } meshtastic_NodeDatabase;
 
 /* The on-disk saved channels */
@@ -234,7 +191,6 @@ extern "C" {
 #define meshtastic_PositionLite_init_default     {0, 0, 0, 0, _meshtastic_Position_LocSource_MIN}
 #define meshtastic_UserLite_init_default         {{0}, "", "", _meshtastic_HardwareModel_MIN, 0, _meshtastic_Config_DeviceConfig_Role_MIN, {0, {0}}, false, 0}
 #define meshtastic_NodeInfoLite_init_default     {0, false, meshtastic_UserLite_init_default, false, meshtastic_PositionLite_init_default, 0, 0, false, meshtastic_DeviceMetrics_init_default, 0, 0, false, 0, 0, 0, 0, 0}
-#define meshtastic_NodeDetail_init_default       {0, {0}, "", "", _meshtastic_HardwareModel_MIN, _meshtastic_Config_DeviceConfig_Role_MIN, {0, {0}}, 0, 0, 0, 0, _meshtastic_Position_LocSource_MIN, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_DeviceState_init_default      {false, meshtastic_MyNodeInfo_init_default, false, meshtastic_User_init_default, 0, {meshtastic_MeshPacket_init_default}, false, meshtastic_MeshPacket_init_default, 0, 0, 0, false, meshtastic_MeshPacket_init_default, 0, {meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default}}
 #define meshtastic_NodeDatabase_init_default     {0, {0}}
 #define meshtastic_ChannelFile_init_default      {0, {meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default}, 0}
@@ -242,7 +198,6 @@ extern "C" {
 #define meshtastic_PositionLite_init_zero        {0, 0, 0, 0, _meshtastic_Position_LocSource_MIN}
 #define meshtastic_UserLite_init_zero            {{0}, "", "", _meshtastic_HardwareModel_MIN, 0, _meshtastic_Config_DeviceConfig_Role_MIN, {0, {0}}, false, 0}
 #define meshtastic_NodeInfoLite_init_zero        {0, false, meshtastic_UserLite_init_zero, false, meshtastic_PositionLite_init_zero, 0, 0, false, meshtastic_DeviceMetrics_init_zero, 0, 0, false, 0, 0, 0, 0, 0}
-#define meshtastic_NodeDetail_init_zero          {0, {0}, "", "", _meshtastic_HardwareModel_MIN, _meshtastic_Config_DeviceConfig_Role_MIN, {0, {0}}, 0, 0, 0, 0, _meshtastic_Position_LocSource_MIN, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_DeviceState_init_zero         {false, meshtastic_MyNodeInfo_init_zero, false, meshtastic_User_init_zero, 0, {meshtastic_MeshPacket_init_zero}, false, meshtastic_MeshPacket_init_zero, 0, 0, 0, false, meshtastic_MeshPacket_init_zero, 0, {meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero}}
 #define meshtastic_NodeDatabase_init_zero        {0, {0}}
 #define meshtastic_ChannelFile_init_zero         {0, {meshtastic_Channel_init_zero, meshtastic_Channel_init_zero, meshtastic_Channel_init_zero, meshtastic_Channel_init_zero, meshtastic_Channel_init_zero, meshtastic_Channel_init_zero, meshtastic_Channel_init_zero, meshtastic_Channel_init_zero}, 0}
@@ -275,29 +230,6 @@ extern "C" {
 #define meshtastic_NodeInfoLite_is_ignored_tag   11
 #define meshtastic_NodeInfoLite_next_hop_tag     12
 #define meshtastic_NodeInfoLite_bitfield_tag     13
-#define meshtastic_NodeDetail_num_tag            1
-#define meshtastic_NodeDetail_macaddr_tag        2
-#define meshtastic_NodeDetail_long_name_tag      3
-#define meshtastic_NodeDetail_short_name_tag     4
-#define meshtastic_NodeDetail_hw_model_tag       5
-#define meshtastic_NodeDetail_role_tag           6
-#define meshtastic_NodeDetail_public_key_tag     7
-#define meshtastic_NodeDetail_latitude_i_tag     8
-#define meshtastic_NodeDetail_longitude_i_tag    9
-#define meshtastic_NodeDetail_altitude_tag       10
-#define meshtastic_NodeDetail_position_time_tag  11
-#define meshtastic_NodeDetail_position_source_tag 12
-#define meshtastic_NodeDetail_snr_tag            13
-#define meshtastic_NodeDetail_last_heard_tag     14
-#define meshtastic_NodeDetail_channel_tag        15
-#define meshtastic_NodeDetail_hops_away_tag      16
-#define meshtastic_NodeDetail_next_hop_tag       17
-#define meshtastic_NodeDetail_battery_level_tag  18
-#define meshtastic_NodeDetail_uptime_seconds_tag 19
-#define meshtastic_NodeDetail_channel_utilization_permille_tag 20
-#define meshtastic_NodeDetail_air_util_tx_permille_tag 21
-#define meshtastic_NodeDetail_voltage_millivolts_tag 22
-#define meshtastic_NodeDetail_flags_tag          23
 #define meshtastic_DeviceState_my_node_tag       2
 #define meshtastic_DeviceState_owner_tag         3
 #define meshtastic_DeviceState_receive_queue_tag 5
@@ -360,33 +292,6 @@ X(a, STATIC,   SINGULAR, UINT32,   bitfield,         13)
 #define meshtastic_NodeInfoLite_position_MSGTYPE meshtastic_PositionLite
 #define meshtastic_NodeInfoLite_device_metrics_MSGTYPE meshtastic_DeviceMetrics
 
-#define meshtastic_NodeDetail_FIELDLIST(X, a) \
-X(a, STATIC,   SINGULAR, UINT32,   num,               1) \
-X(a, STATIC,   SINGULAR, FIXED_LENGTH_BYTES, macaddr,           2) \
-X(a, STATIC,   SINGULAR, STRING,   long_name,         3) \
-X(a, STATIC,   SINGULAR, STRING,   short_name,        4) \
-X(a, STATIC,   SINGULAR, UENUM,    hw_model,          5) \
-X(a, STATIC,   SINGULAR, UENUM,    role,              6) \
-X(a, STATIC,   SINGULAR, BYTES,    public_key,        7) \
-X(a, STATIC,   SINGULAR, SFIXED32, latitude_i,        8) \
-X(a, STATIC,   SINGULAR, SFIXED32, longitude_i,       9) \
-X(a, STATIC,   SINGULAR, INT32,    altitude,         10) \
-X(a, STATIC,   SINGULAR, FIXED32,  position_time,    11) \
-X(a, STATIC,   SINGULAR, UENUM,    position_source,  12) \
-X(a, STATIC,   SINGULAR, FLOAT,    snr,              13) \
-X(a, STATIC,   SINGULAR, FIXED32,  last_heard,       14) \
-X(a, STATIC,   SINGULAR, UINT32,   channel,          15) \
-X(a, STATIC,   SINGULAR, UINT32,   hops_away,        16) \
-X(a, STATIC,   SINGULAR, UINT32,   next_hop,         17) \
-X(a, STATIC,   SINGULAR, UINT32,   battery_level,    18) \
-X(a, STATIC,   SINGULAR, UINT32,   uptime_seconds,   19) \
-X(a, STATIC,   SINGULAR, UINT32,   channel_utilization_permille,  20) \
-X(a, STATIC,   SINGULAR, UINT32,   air_util_tx_permille,  21) \
-X(a, STATIC,   SINGULAR, UINT32,   voltage_millivolts,  22) \
-X(a, STATIC,   SINGULAR, UINT32,   flags,            23)
-#define meshtastic_NodeDetail_CALLBACK NULL
-#define meshtastic_NodeDetail_DEFAULT NULL
-
 #define meshtastic_DeviceState_FIELDLIST(X, a) \
 X(a, STATIC,   OPTIONAL, MESSAGE,  my_node,           2) \
 X(a, STATIC,   OPTIONAL, MESSAGE,  owner,             3) \
@@ -412,7 +317,7 @@ X(a, CALLBACK, REPEATED, MESSAGE,  nodes,             2)
 extern bool meshtastic_NodeDatabase_callback(pb_istream_t *istream, pb_ostream_t *ostream, const pb_field_t *field);
 #define meshtastic_NodeDatabase_CALLBACK meshtastic_NodeDatabase_callback
 #define meshtastic_NodeDatabase_DEFAULT NULL
-#define meshtastic_NodeDatabase_nodes_MSGTYPE meshtastic_NodeDetail
+#define meshtastic_NodeDatabase_nodes_MSGTYPE meshtastic_NodeInfoLite
 
 #define meshtastic_ChannelFile_FIELDLIST(X, a) \
 X(a, STATIC,   REPEATED, MESSAGE,  channels,          1) \
@@ -438,7 +343,6 @@ X(a, STATIC,   OPTIONAL, MESSAGE,  owner,             6)
 extern const pb_msgdesc_t meshtastic_PositionLite_msg;
 extern const pb_msgdesc_t meshtastic_UserLite_msg;
 extern const pb_msgdesc_t meshtastic_NodeInfoLite_msg;
-extern const pb_msgdesc_t meshtastic_NodeDetail_msg;
 extern const pb_msgdesc_t meshtastic_DeviceState_msg;
 extern const pb_msgdesc_t meshtastic_NodeDatabase_msg;
 extern const pb_msgdesc_t meshtastic_ChannelFile_msg;
@@ -448,7 +352,6 @@ extern const pb_msgdesc_t meshtastic_BackupPreferences_msg;
 #define meshtastic_PositionLite_fields &meshtastic_PositionLite_msg
 #define meshtastic_UserLite_fields &meshtastic_UserLite_msg
 #define meshtastic_NodeInfoLite_fields &meshtastic_NodeInfoLite_msg
-#define meshtastic_NodeDetail_fields &meshtastic_NodeDetail_msg
 #define meshtastic_DeviceState_fields &meshtastic_DeviceState_msg
 #define meshtastic_NodeDatabase_fields &meshtastic_NodeDatabase_msg
 #define meshtastic_ChannelFile_fields &meshtastic_ChannelFile_msg
@@ -459,8 +362,7 @@ extern const pb_msgdesc_t meshtastic_BackupPreferences_msg;
 #define MESHTASTIC_MESHTASTIC_DEVICEONLY_PB_H_MAX_SIZE meshtastic_BackupPreferences_size
 #define meshtastic_BackupPreferences_size        2277
 #define meshtastic_ChannelFile_size              718
-#define meshtastic_DeviceState_size              1737
-#define meshtastic_NodeDetail_size               182
+#define meshtastic_DeviceState_size              1944
 #define meshtastic_NodeInfoLite_size             196
 #define meshtastic_PositionLite_size             28
 #define meshtastic_UserLite_size                 98

src/mesh/generated/meshtastic/mesh.pb.h

@@ -734,6 +734,7 @@ typedef struct _meshtastic_Routing {
 } meshtastic_Routing;
 
 typedef PB_BYTES_ARRAY_T(233) meshtastic_Data_payload_t;
+typedef PB_BYTES_ARRAY_T(64) meshtastic_Data_xeddsa_signature_t;
 /* (Formerly called SubPacket)
  The payload portion fo a packet, this is the actual bytes that are sent
  inside a radio packet (because from/to are broken out by the comms library) */
@@ -767,6 +768,9 @@ typedef struct _meshtastic_Data {
     /* Bitfield for extra flags. First use is to indicate that user approves the packet being uploaded to MQTT. */
     bool has_bitfield;
     uint8_t bitfield;
+    /* XEdDSA signature for the payload */
+    bool has_xeddsa_signature;
+    meshtastic_Data_xeddsa_signature_t xeddsa_signature;
 } meshtastic_Data;
 
 typedef PB_BYTES_ARRAY_T(32) meshtastic_KeyVerification_hash1_t;
@@ -913,6 +917,8 @@ typedef struct _meshtastic_MeshPacket {
     uint32_t tx_after;
     /* Indicates which transport mechanism this packet arrived over */
     meshtastic_MeshPacket_TransportMechanism transport_mechanism;
+    /* Indicates whether the packet has a valid signature */
+    bool xeddsa_signed;
 } meshtastic_MeshPacket;
 
 /* The bluetooth to device link:
@@ -966,6 +972,10 @@ typedef struct _meshtastic_NodeInfo {
  Persists between NodeDB internal clean ups
  LSB 0 of the bitfield */
     bool is_key_manually_verified;
+    /* True if node is signing its packets via XEdDSA
+ Persists between NodeDB internal clean ups
+ LSB 1 of the bitfield */
+    bool has_xeddsa_signed;
 } meshtastic_NodeInfo;
 
 typedef PB_BYTES_ARRAY_T(16) meshtastic_MyNodeInfo_device_id_t;
@@ -1378,12 +1388,12 @@ extern "C" {
 #define meshtastic_User_init_default             {"", "", "", {0}, _meshtastic_HardwareModel_MIN, 0, _meshtastic_Config_DeviceConfig_Role_MIN, {0, {0}}, false, 0}
 #define meshtastic_RouteDiscovery_init_default   {0, {0, 0, 0, 0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0, 0, 0, 0}}
 #define meshtastic_Routing_init_default          {0, {meshtastic_RouteDiscovery_init_default}}
-#define meshtastic_Data_init_default             {_meshtastic_PortNum_MIN, {0, {0}}, 0, 0, 0, 0, 0, 0, false, 0}
+#define meshtastic_Data_init_default             {_meshtastic_PortNum_MIN, {0, {0}}, 0, 0, 0, 0, 0, 0, false, 0, false, {0, {0}}}
 #define meshtastic_KeyVerification_init_default  {0, {0, {0}}, {0, {0}}}
 #define meshtastic_Waypoint_init_default         {0, false, 0, false, 0, 0, 0, "", "", 0}
 #define meshtastic_MqttClientProxyMessage_init_default {"", 0, {{0, {0}}}, 0}
-#define meshtastic_MeshPacket_init_default       {0, 0, 0, 0, {meshtastic_Data_init_default}, 0, 0, 0, 0, 0, _meshtastic_MeshPacket_Priority_MIN, 0, _meshtastic_MeshPacket_Delayed_MIN, 0, 0, {0, {0}}, 0, 0, 0, 0, _meshtastic_MeshPacket_TransportMechanism_MIN}
-#define meshtastic_NodeInfo_init_default         {0, false, meshtastic_User_init_default, false, meshtastic_Position_init_default, 0, 0, false, meshtastic_DeviceMetrics_init_default, 0, 0, false, 0, 0, 0, 0}
+#define meshtastic_MeshPacket_init_default       {0, 0, 0, 0, {meshtastic_Data_init_default}, 0, 0, 0, 0, 0, _meshtastic_MeshPacket_Priority_MIN, 0, _meshtastic_MeshPacket_Delayed_MIN, 0, 0, {0, {0}}, 0, 0, 0, 0, _meshtastic_MeshPacket_TransportMechanism_MIN, 0}
+#define meshtastic_NodeInfo_init_default         {0, false, meshtastic_User_init_default, false, meshtastic_Position_init_default, 0, 0, false, meshtastic_DeviceMetrics_init_default, 0, 0, false, 0, 0, 0, 0, 0}
 #define meshtastic_MyNodeInfo_init_default       {0, 0, 0, {0, {0}}, "", _meshtastic_FirmwareEdition_MIN, 0}
 #define meshtastic_LogRecord_init_default        {"", 0, "", _meshtastic_LogRecord_Level_MIN}
 #define meshtastic_QueueStatus_init_default      {0, 0, 0, 0}
@@ -1409,12 +1419,12 @@ extern "C" {
 #define meshtastic_User_init_zero                {"", "", "", {0}, _meshtastic_HardwareModel_MIN, 0, _meshtastic_Config_DeviceConfig_Role_MIN, {0, {0}}, false, 0}
 #define meshtastic_RouteDiscovery_init_zero      {0, {0, 0, 0, 0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0, 0, 0, 0}}
 #define meshtastic_Routing_init_zero             {0, {meshtastic_RouteDiscovery_init_zero}}
-#define meshtastic_Data_init_zero                {_meshtastic_PortNum_MIN, {0, {0}}, 0, 0, 0, 0, 0, 0, false, 0}
+#define meshtastic_Data_init_zero                {_meshtastic_PortNum_MIN, {0, {0}}, 0, 0, 0, 0, 0, 0, false, 0, false, {0, {0}}}
 #define meshtastic_KeyVerification_init_zero     {0, {0, {0}}, {0, {0}}}
 #define meshtastic_Waypoint_init_zero            {0, false, 0, false, 0, 0, 0, "", "", 0}
 #define meshtastic_MqttClientProxyMessage_init_zero {"", 0, {{0, {0}}}, 0}
-#define meshtastic_MeshPacket_init_zero          {0, 0, 0, 0, {meshtastic_Data_init_zero}, 0, 0, 0, 0, 0, _meshtastic_MeshPacket_Priority_MIN, 0, _meshtastic_MeshPacket_Delayed_MIN, 0, 0, {0, {0}}, 0, 0, 0, 0, _meshtastic_MeshPacket_TransportMechanism_MIN}
-#define meshtastic_NodeInfo_init_zero            {0, false, meshtastic_User_init_zero, false, meshtastic_Position_init_zero, 0, 0, false, meshtastic_DeviceMetrics_init_zero, 0, 0, false, 0, 0, 0, 0}
+#define meshtastic_MeshPacket_init_zero          {0, 0, 0, 0, {meshtastic_Data_init_zero}, 0, 0, 0, 0, 0, _meshtastic_MeshPacket_Priority_MIN, 0, _meshtastic_MeshPacket_Delayed_MIN, 0, 0, {0, {0}}, 0, 0, 0, 0, _meshtastic_MeshPacket_TransportMechanism_MIN, 0}
+#define meshtastic_NodeInfo_init_zero            {0, false, meshtastic_User_init_zero, false, meshtastic_Position_init_zero, 0, 0, false, meshtastic_DeviceMetrics_init_zero, 0, 0, false, 0, 0, 0, 0, 0}
 #define meshtastic_MyNodeInfo_init_zero          {0, 0, 0, {0, {0}}, "", _meshtastic_FirmwareEdition_MIN, 0}
 #define meshtastic_LogRecord_init_zero           {"", 0, "", _meshtastic_LogRecord_Level_MIN}
 #define meshtastic_QueueStatus_init_zero         {0, 0, 0, 0}
@@ -1486,6 +1496,7 @@ extern "C" {
 #define meshtastic_Data_reply_id_tag             7
 #define meshtastic_Data_emoji_tag                8
 #define meshtastic_Data_bitfield_tag             9
+#define meshtastic_Data_xeddsa_signature_tag     10
 #define meshtastic_KeyVerification_nonce_tag     1
 #define meshtastic_KeyVerification_hash1_tag     2
 #define meshtastic_KeyVerification_hash2_tag     3
@@ -1522,6 +1533,7 @@ extern "C" {
 #define meshtastic_MeshPacket_relay_node_tag     19
 #define meshtastic_MeshPacket_tx_after_tag       20
 #define meshtastic_MeshPacket_transport_mechanism_tag 21
+#define meshtastic_MeshPacket_xeddsa_signed_tag  22
 #define meshtastic_NodeInfo_num_tag              1
 #define meshtastic_NodeInfo_user_tag             2
 #define meshtastic_NodeInfo_position_tag         3
@@ -1534,6 +1546,7 @@ extern "C" {
 #define meshtastic_NodeInfo_is_favorite_tag      10
 #define meshtastic_NodeInfo_is_ignored_tag       11
 #define meshtastic_NodeInfo_is_key_manually_verified_tag 12
+#define meshtastic_NodeInfo_has_xeddsa_signed_tag 13
 #define meshtastic_MyNodeInfo_my_node_num_tag    1
 #define meshtastic_MyNodeInfo_reboot_count_tag   8
 #define meshtastic_MyNodeInfo_min_app_version_tag 11
@@ -1694,7 +1707,8 @@ X(a, STATIC,   SINGULAR, FIXED32,  source,            5) \
 X(a, STATIC,   SINGULAR, FIXED32,  request_id,        6) \
 X(a, STATIC,   SINGULAR, FIXED32,  reply_id,          7) \
 X(a, STATIC,   SINGULAR, FIXED32,  emoji,             8) \
-X(a, STATIC,   OPTIONAL, UINT32,   bitfield,          9)
+X(a, STATIC,   OPTIONAL, UINT32,   bitfield,          9) \
+X(a, STATIC,   OPTIONAL, BYTES,    xeddsa_signature,  10)
 #define meshtastic_Data_CALLBACK NULL
 #define meshtastic_Data_DEFAULT NULL
 
@@ -1746,7 +1760,8 @@ X(a, STATIC,   SINGULAR, BOOL,     pki_encrypted,    17) \
 X(a, STATIC,   SINGULAR, UINT32,   next_hop,         18) \
 X(a, STATIC,   SINGULAR, UINT32,   relay_node,       19) \
 X(a, STATIC,   SINGULAR, UINT32,   tx_after,         20) \
-X(a, STATIC,   SINGULAR, UENUM,    transport_mechanism,  21)
+X(a, STATIC,   SINGULAR, UENUM,    transport_mechanism,  21) \
+X(a, STATIC,   SINGULAR, BOOL,     xeddsa_signed,    22)
 #define meshtastic_MeshPacket_CALLBACK NULL
 #define meshtastic_MeshPacket_DEFAULT NULL
 #define meshtastic_MeshPacket_payload_variant_decoded_MSGTYPE meshtastic_Data
@@ -1763,7 +1778,8 @@ X(a, STATIC,   SINGULAR, BOOL,     via_mqtt,          8) \
 X(a, STATIC,   OPTIONAL, UINT32,   hops_away,         9) \
 X(a, STATIC,   SINGULAR, BOOL,     is_favorite,      10) \
 X(a, STATIC,   SINGULAR, BOOL,     is_ignored,       11) \
-X(a, STATIC,   SINGULAR, BOOL,     is_key_manually_verified,  12)
+X(a, STATIC,   SINGULAR, BOOL,     is_key_manually_verified,  12) \
+X(a, STATIC,   SINGULAR, BOOL,     has_xeddsa_signed,  13)
 #define meshtastic_NodeInfo_CALLBACK NULL
 #define meshtastic_NodeInfo_DEFAULT NULL
 #define meshtastic_NodeInfo_user_MSGTYPE meshtastic_User
@@ -2046,7 +2062,7 @@ extern const pb_msgdesc_t meshtastic_ChunkedPayloadResponse_msg;
 #define meshtastic_ChunkedPayload_size           245
 #define meshtastic_ClientNotification_size       482
 #define meshtastic_Compressed_size               239
-#define meshtastic_Data_size                     269
+#define meshtastic_Data_size                     335
 #define meshtastic_DeviceMetadata_size           54
 #define meshtastic_DuplicatedPublicKey_size      0
 #define meshtastic_FileInfo_size                 236
@@ -2058,12 +2074,12 @@ extern const pb_msgdesc_t meshtastic_ChunkedPayloadResponse_msg;
 #define meshtastic_KeyVerification_size          79
 #define meshtastic_LogRecord_size                426
 #define meshtastic_LowEntropyKey_size            0
-#define meshtastic_MeshPacket_size               381
+#define meshtastic_MeshPacket_size               450
 #define meshtastic_MqttClientProxyMessage_size   501
 #define meshtastic_MyNodeInfo_size               83
 #define meshtastic_NeighborInfo_size             258
 #define meshtastic_Neighbor_size                 22
-#define meshtastic_NodeInfo_size                 323
+#define meshtastic_NodeInfo_size                 325
 #define meshtastic_NodeRemoteHardwarePin_size    29
 #define meshtastic_Position_size                 144
 #define meshtastic_QueueStatus_size              23

src/mesh/http/ContentHandler.cpp

@@ -738,9 +738,9 @@ void handleNodes(HTTPRequest *req, HTTPResponse *res)
     JSONArray nodesArray;
 
     uint32_t readIndex = 0;
-    const meshtastic_NodeDetail *tempNodeInfo = nodeDB->readNextMeshNode(readIndex);
+    const meshtastic_NodeInfoLite *tempNodeInfo = nodeDB->readNextMeshNode(readIndex);
     while (tempNodeInfo != NULL) {
-        if (detailHasFlag(*tempNodeInfo, NODEDETAIL_FLAG_HAS_USER)) {
+        if (tempNodeInfo->has_user) {
             JSONObject node;
 
             char id[16];
@@ -748,25 +748,26 @@ void handleNodes(HTTPRequest *req, HTTPResponse *res)
 
             node["id"] = new JSONValue(id);
             node["snr"] = new JSONValue(tempNodeInfo->snr);
-            node["via_mqtt"] = new JSONValue(BoolToString(detailViaMqtt(*tempNodeInfo)));
+            node["via_mqtt"] = new JSONValue(BoolToString(tempNodeInfo->via_mqtt));
             node["last_heard"] = new JSONValue((int)tempNodeInfo->last_heard);
             node["position"] = new JSONValue();
 
             if (nodeDB->hasValidPosition(tempNodeInfo)) {
                 JSONObject position;
-                position["latitude"] = new JSONValue(static_cast<float>(tempNodeInfo->latitude_i) * 1e-7f);
-                position["longitude"] = new JSONValue(static_cast<float>(tempNodeInfo->longitude_i) * 1e-7f);
-                position["altitude"] = new JSONValue(static_cast<int>(tempNodeInfo->altitude));
+                position["latitude"] = new JSONValue((float)tempNodeInfo->position.latitude_i * 1e-7);
+                position["longitude"] = new JSONValue((float)tempNodeInfo->position.longitude_i * 1e-7);
+                position["altitude"] = new JSONValue((int)tempNodeInfo->position.altitude);
                 node["position"] = new JSONValue(position);
             }
 
-            node["long_name"] = new JSONValue(tempNodeInfo->long_name);
-            node["short_name"] = new JSONValue(tempNodeInfo->short_name);
+            node["long_name"] = new JSONValue(tempNodeInfo->user.long_name);
+            node["short_name"] = new JSONValue(tempNodeInfo->user.short_name);
             char macStr[18];
-            snprintf(macStr, sizeof(macStr), "%02X:%02X:%02X:%02X:%02X:%02X", tempNodeInfo->macaddr[0], tempNodeInfo->macaddr[1],
-                     tempNodeInfo->macaddr[2], tempNodeInfo->macaddr[3], tempNodeInfo->macaddr[4], tempNodeInfo->macaddr[5]);
+            snprintf(macStr, sizeof(macStr), "%02X:%02X:%02X:%02X:%02X:%02X", tempNodeInfo->user.macaddr[0],
+                     tempNodeInfo->user.macaddr[1], tempNodeInfo->user.macaddr[2], tempNodeInfo->user.macaddr[3],
+                     tempNodeInfo->user.macaddr[4], tempNodeInfo->user.macaddr[5]);
             node["mac_address"] = new JSONValue(macStr);
-            node["hw_model"] = new JSONValue(tempNodeInfo->hw_model);
+            node["hw_model"] = new JSONValue(tempNodeInfo->user.hw_model);
 
             nodesArray.push_back(new JSONValue(node));
         }

src/mesh/mesh-pb-constants.h

@@ -39,7 +39,7 @@
 
 /// Verify baseline assumption of node size. If it increases, we need to reevaluate
 /// the impact of its memory footprint, notably on MAX_NUM_NODES.
-static_assert(sizeof(meshtastic_NodeDetail) <= 200, "NodeDetail size increased. Reconsider impact on MAX_NUM_NODES.");
+static_assert(sizeof(meshtastic_NodeInfoLite) <= 200, "NodeInfoLite size increased. Reconsider impact on MAX_NUM_NODES.");
 
 /// max number of nodes allowed in the nodeDB
 #ifndef MAX_NUM_NODES

src/modules/AdminModule.cpp

@@ -107,14 +107,14 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta
 
             // Automatically favorite the node that is using the admin key
             auto remoteNode = nodeDB->getMeshNode(mp.from);
-            if (remoteNode && !detailIsFavorite(*remoteNode)) {
+            if (remoteNode && !remoteNode->is_favorite) {
                 if (config.device.role == meshtastic_Config_DeviceConfig_Role_CLIENT_BASE) {
                     // Special case for CLIENT_BASE: is_favorite has special meaning, and we don't want to automatically set it
                     // without the user doing so deliberately.
                     LOG_INFO("PKC admin valid, but not auto-favoriting node %x because role==CLIENT_BASE", mp.from);
                 } else {
                     LOG_INFO("PKC admin valid. Auto-favoriting node %x", mp.from);
-                    nodeDB->set_favorite(true, mp.from);
+                    remoteNode->is_favorite = true;
                 }
             }
         } else {
@@ -341,9 +341,9 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta
     }
     case meshtastic_AdminMessage_set_favorite_node_tag: {
         LOG_INFO("Client received set_favorite_node command");
-        meshtastic_NodeDetail *node = nodeDB->getMeshNode(r->set_favorite_node);
+        meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(r->set_favorite_node);
         if (node != NULL) {
-            detailSetFlag(*node, NODEDETAIL_FLAG_IS_FAVORITE, true);
+            node->is_favorite = true;
             saveChanges(SEGMENT_NODEDATABASE, false);
             if (screen)
                 screen->setFrames(graphics::Screen::FOCUS_PRESERVE); // <-- Rebuild screens
@@ -352,9 +352,9 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta
     }
     case meshtastic_AdminMessage_remove_favorite_node_tag: {
         LOG_INFO("Client received remove_favorite_node command");
-        meshtastic_NodeDetail *node = nodeDB->getMeshNode(r->remove_favorite_node);
+        meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(r->remove_favorite_node);
         if (node != NULL) {
-            detailSetFlag(*node, NODEDETAIL_FLAG_IS_FAVORITE, false);
+            node->is_favorite = false;
             saveChanges(SEGMENT_NODEDATABASE, false);
             if (screen)
                 screen->setFrames(graphics::Screen::FOCUS_PRESERVE); // <-- Rebuild screens
@@ -363,32 +363,31 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta
     }
     case meshtastic_AdminMessage_set_ignored_node_tag: {
         LOG_INFO("Client received set_ignored_node command");
-        meshtastic_NodeDetail *node = nodeDB->getMeshNode(r->set_ignored_node);
+        meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(r->set_ignored_node);
         if (node != NULL) {
-            detailSetFlag(*node, NODEDETAIL_FLAG_IS_IGNORED, true);
-            clearMetricsFromDetail(*node);
-            clearPositionFromDetail(*node);
-            node->public_key.size = 0;
-            memset(node->public_key.bytes, 0, sizeof(node->public_key.bytes));
+            node->is_ignored = true;
+            node->has_device_metrics = false;
+            node->has_position = false;
+            node->user.public_key.size = 0;
+            node->user.public_key.bytes[0] = 0;
             saveChanges(SEGMENT_NODEDATABASE, false);
         }
         break;
     }
     case meshtastic_AdminMessage_remove_ignored_node_tag: {
         LOG_INFO("Client received remove_ignored_node command");
-        meshtastic_NodeDetail *node = nodeDB->getMeshNode(r->remove_ignored_node);
+        meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(r->remove_ignored_node);
         if (node != NULL) {
-            detailSetFlag(*node, NODEDETAIL_FLAG_IS_IGNORED, false);
+            node->is_ignored = false;
             saveChanges(SEGMENT_NODEDATABASE, false);
         }
         break;
     }
     case meshtastic_AdminMessage_set_fixed_position_tag: {
         LOG_INFO("Client received set_fixed_position command");
-        meshtastic_NodeDetail *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
-        if (node) {
-            applyPositionToDetail(*node, r->set_fixed_position);
-        }
+        meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
+        node->has_position = true;
+        node->position = TypeConversions::ConvertToPositionLite(r->set_fixed_position);
         nodeDB->setLocalPosition(r->set_fixed_position);
         config.position.fixed_position = true;
         saveChanges(SEGMENT_NODEDATABASE | SEGMENT_CONFIG, false);
@@ -774,26 +773,8 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c)
         config.lora = validatedLora;
         // If we're setting region for the first time, init the region and regenerate the keys
         if (isRegionUnset && config.lora.region > meshtastic_Config_LoRaConfig_RegionCode_UNSET) {
-#if !(MESHTASTIC_EXCLUDE_PKI_KEYGEN || MESHTASTIC_EXCLUDE_PKI)
-            if (!owner.is_licensed) {
-                bool keygenSuccess = false;
-                if (config.security.private_key.size == 32) {
-                    if (crypto->regeneratePublicKey(config.security.public_key.bytes, config.security.private_key.bytes)) {
-                        keygenSuccess = true;
-                    }
-                } else {
-                    LOG_INFO("Generate new PKI keys");
-                    crypto->generateKeyPair(config.security.public_key.bytes, config.security.private_key.bytes);
-                    keygenSuccess = true;
-                }
-                if (keygenSuccess) {
-                    config.security.public_key.size = 32;
-                    config.security.private_key.size = 32;
-                    owner.public_key.size = 32;
-                    memcpy(owner.public_key.bytes, config.security.public_key.bytes, 32);
-                }
-            }
-#endif
+            // Use consolidated key generation function
+            nodeDB->generateCryptoKeyPair();
             config.lora.tx_enabled = true;
             initRegion();
             if (myRegion->dutyCycle < 100) {
@@ -802,7 +783,7 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c)
             //  Compare the entire string, we are sure of the length as a topic has never been set
             if (strcmp(moduleConfig.mqtt.root, default_mqtt_root) == 0) {
                 sprintf(moduleConfig.mqtt.root, "%s/%s", default_mqtt_root, myRegion->name);
-                changes = SEGMENT_CONFIG | SEGMENT_MODULECONFIG;
+                changes = SEGMENT_CONFIG | SEGMENT_MODULECONFIG | SEGMENT_NODEDATABASE | SEGMENT_DEVICESTATE;
             }
         }
         if (config.lora.region != myRegion->code) {
@@ -828,22 +809,14 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c)
         LOG_INFO("Set config: Security");
         config.security = c.payload_variant.security;
 #if !(MESHTASTIC_EXCLUDE_PKI_KEYGEN) && !(MESHTASTIC_EXCLUDE_PKI)
-        // If the client set the key to blank, go ahead and regenerate so long as we're not in ham mode
-        if (!owner.is_licensed && config.lora.region != meshtastic_Config_LoRaConfig_RegionCode_UNSET) {
-            if (config.security.private_key.size != 32) {
-                crypto->generateKeyPair(config.security.public_key.bytes, config.security.private_key.bytes);
-
-            } else {
-                if (crypto->regeneratePublicKey(config.security.public_key.bytes, config.security.private_key.bytes)) {
-                    config.security.public_key.size = 32;
-                }
-            }
+        // Only regenerate keys if the private key is not 32 bytes
+        if (config.security.private_key.size != 32) {
+            nodeDB->generateCryptoKeyPair();
+        }
+        // If user provided a private key of correct size but no public key, generate the public key from private key
+        else if (config.security.private_key.size == 32 && config.security.public_key.size == 0) {
+            nodeDB->generateCryptoKeyPair(config.security.private_key.bytes);
         }
-#endif
-        owner.public_key.size = config.security.public_key.size;
-        memcpy(owner.public_key.bytes, config.security.public_key.bytes, config.security.public_key.size);
-#if !MESHTASTIC_EXCLUDE_PKI
-        crypto->setDHPrivateKey(config.security.private_key.bytes);
 #endif
         if (config.security.is_managed && !(config.security.admin_key[0].size == 32 || config.security.admin_key[1].size == 32 ||
                                             config.security.admin_key[2].size == 32)) {
@@ -853,9 +826,9 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c)
             sendWarning(warning);
         }
 
-        if (config.security.debug_log_api_enabled == c.payload_variant.security.debug_log_api_enabled &&
-            config.security.serial_enabled == c.payload_variant.security.serial_enabled)
-            requiresReboot = false;
+        changes = SEGMENT_CONFIG | SEGMENT_DEVICESTATE | SEGMENT_NODEDATABASE;
+
+        requiresReboot = true;
 
         break;
     case meshtastic_Config_device_ui_tag:

src/modules/CannedMessageModule.cpp

@@ -16,6 +16,7 @@
 #include "graphics/draw/NotificationRenderer.h"
 #include "graphics/emotes.h"
 #include "graphics/images.h"
+#include "input/SerialKeyboard.h"
 #include "main.h" // for cardkb_found
 #include "mesh/generated/meshtastic/cannedmessages.pb.h"
 #include "modules/AdminModule.h"
@@ -131,9 +132,9 @@ void CannedMessageModule::LaunchFreetextWithDestination(NodeNum newDest, uint8_t
 }
 
 static bool returnToCannedList = false;
-bool hasKeyForNode(const meshtastic_NodeDetail *node)
+bool hasKeyForNode(const meshtastic_NodeInfoLite *node)
 {
-    return node && detailHasFlag(*node, NODEDETAIL_FLAG_HAS_USER) && node->public_key.size > 0;
+    return node && node->has_user && node->user.public_key.size > 0;
 }
 /**
  * @brief Items in array this->messages will be set to be pointing on the right
@@ -254,11 +255,11 @@ void CannedMessageModule::updateDestinationSelectionList()
     this->filteredNodes.reserve(numMeshNodes);
 
     for (size_t i = 0; i < numMeshNodes; ++i) {
-        meshtastic_NodeDetail *node = nodeDB->getMeshNodeByIndex(i);
-        if (!node || node->num == myNodeNum || !detailHasFlag(*node, NODEDETAIL_FLAG_HAS_USER) || node->public_key.size != 32)
+        meshtastic_NodeInfoLite *node = nodeDB->getMeshNodeByIndex(i);
+        if (!node || node->num == myNodeNum || !node->has_user || node->user.public_key.size != 32)
             continue;
 
-        const String nodeName = node->long_name;
+        const String &nodeName = node->user.long_name;
 
         if (searchQuery.length() == 0) {
             this->filteredNodes.push_back({node, sinceLastSeen(node)});
@@ -525,7 +526,7 @@ int CannedMessageModule::handleDestinationSelectionInput(const InputEvent *event
         } else {
             int nodeIndex = destIndex - static_cast<int>(activeChannelIndices.size());
             if (nodeIndex >= 0 && nodeIndex < static_cast<int>(filteredNodes.size())) {
-                const meshtastic_NodeDetail *selectedNode = filteredNodes[nodeIndex].node;
+                const meshtastic_NodeInfoLite *selectedNode = filteredNodes[nodeIndex].node;
                 if (selectedNode) {
                     dest = selectedNode->num;
                     channel = selectedNode->channel;
@@ -836,6 +837,7 @@ bool CannedMessageModule::handleFreeTextInput(const InputEvent *event)
     if (event->inputEvent == INPUT_BROKER_BACK && this->freetext.length() > 0) {
         payload = 0x08;
         lastTouchMillis = millis();
+        requestFocus();
         runOnce();
         return true;
     }
@@ -844,6 +846,7 @@ bool CannedMessageModule::handleFreeTextInput(const InputEvent *event)
     if (event->inputEvent == INPUT_BROKER_LEFT) {
         payload = INPUT_BROKER_LEFT;
         lastTouchMillis = millis();
+        requestFocus();
         runOnce();
         return true;
     }
@@ -851,6 +854,7 @@ bool CannedMessageModule::handleFreeTextInput(const InputEvent *event)
     if (event->inputEvent == INPUT_BROKER_RIGHT) {
         payload = INPUT_BROKER_RIGHT;
         lastTouchMillis = millis();
+        requestFocus();
         runOnce();
         return true;
     }
@@ -1253,9 +1257,9 @@ const char *CannedMessageModule::getNodeName(NodeNum node)
     if (node == NODENUM_BROADCAST)
         return "Broadcast";
 
-    meshtastic_NodeDetail *info = nodeDB->getMeshNode(node);
-    if (info && detailHasFlag(*info, NODEDETAIL_FLAG_HAS_USER) && strlen(info->long_name) > 0) {
-        return info->long_name;
+    meshtastic_NodeInfoLite *info = nodeDB->getMeshNode(node);
+    if (info && info->has_user && strlen(info->user.long_name) > 0) {
+        return info->user.long_name;
     }
 
     static char fallback[12];
@@ -1565,18 +1569,18 @@ void CannedMessageModule::drawDestinationSelectionScreen(OLEDDisplay *display, O
         else {
             int nodeIndex = itemIndex - numActiveChannels;
             if (nodeIndex >= 0 && nodeIndex < static_cast<int>(this->filteredNodes.size())) {
-                meshtastic_NodeDetail *node = this->filteredNodes[nodeIndex].node;
+                meshtastic_NodeInfoLite *node = this->filteredNodes[nodeIndex].node;
                 if (node) {
-                    if (detailIsFavorite(*node)) {
+                    if (node->is_favorite) {
 #if defined(M5STACK_UNITC6L)
-                        snprintf(entryText, sizeof(entryText), "* %s", node->short_name);
+                        snprintf(entryText, sizeof(entryText), "* %s", node->user.short_name);
                     } else {
-                        snprintf(entryText, sizeof(entryText), "%s", node->short_name);
+                        snprintf(entryText, sizeof(entryText), "%s", node->user.short_name);
                     }
 #else
-                        snprintf(entryText, sizeof(entryText), "* %s", node->long_name);
+                        snprintf(entryText, sizeof(entryText), "* %s", node->user.long_name);
                     } else {
-                        snprintf(entryText, sizeof(entryText), "%s", node->long_name);
+                        snprintf(entryText, sizeof(entryText), "%s", node->user.long_name);
                     }
 #endif
                 }
@@ -1601,7 +1605,7 @@ void CannedMessageModule::drawDestinationSelectionScreen(OLEDDisplay *display, O
         if (itemIndex >= numActiveChannels) {
             int nodeIndex = itemIndex - numActiveChannels;
             if (nodeIndex >= 0 && nodeIndex < static_cast<int>(this->filteredNodes.size())) {
-                const meshtastic_NodeDetail *node = this->filteredNodes[nodeIndex].node;
+                const meshtastic_NodeInfoLite *node = this->filteredNodes[nodeIndex].node;
                 if (node && hasKeyForNode(node)) {
                     int iconX = display->getWidth() - key_symbol_width - 15;
                     int iconY = yOffset + (FONT_HEIGHT_SMALL - key_symbol_height) / 2;
@@ -1845,7 +1849,88 @@ void CannedMessageModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *st
             display->drawString(x + display->getWidth() - display->getStringWidth(buffer), y + 0, buffer);
         }
 
-        // --- Draw Free Text input with multi-emote support and proper line wrapping ---
+#if INPUTBROKER_SERIAL_TYPE == 1
+        // Chatter Modifier key mode label (right side)
+        {
+            uint8_t mode = globalSerialKeyboard ? globalSerialKeyboard->getShift() : 0;
+            const char *label = (mode == 0) ? "a" : (mode == 1) ? "A" : "#";
+
+            display->setFont(FONT_SMALL);
+            display->setTextAlignment(TEXT_ALIGN_LEFT);
+
+            const int16_t th = FONT_HEIGHT_SMALL;
+            const int16_t tw = display->getStringWidth(label);
+            const int16_t padX = 3;
+            const int16_t padY = 2;
+            const int16_t r = 3;
+
+            const int16_t bw = tw + padX * 2;
+            const int16_t bh = th + padY * 2;
+
+            const int16_t bx = x + display->getWidth() - bw - 2;
+            const int16_t by = y + display->getHeight() - bh - 2;
+
+            display->setColor(WHITE);
+            display->fillRect(bx + r, by, bw - r * 2, bh);
+            display->fillRect(bx, by + r, r, bh - r * 2);
+            display->fillRect(bx + bw - r, by + r, r, bh - r * 2);
+            display->fillCircle(bx + r, by + r, r);
+            display->fillCircle(bx + bw - r - 1, by + r, r);
+            display->fillCircle(bx + r, by + bh - r - 1, r);
+            display->fillCircle(bx + bw - r - 1, by + bh - r - 1, r);
+
+            display->setColor(BLACK);
+            display->drawString(bx + padX, by + padY, label);
+        }
+
+        // LEFT-SIDE DESTINATION-HINT BOX (“Dest: Shift + ◄”)
+        {
+            display->setFont(FONT_SMALL);
+            display->setTextAlignment(TEXT_ALIGN_LEFT);
+
+            const char *label = "Dest: Shift + ";
+            int16_t labelW = display->getStringWidth(label);
+
+            // triangle size visually matches glyph height, not full line height
+            const int triH = FONT_HEIGHT_SMALL - 3;
+            const int triW = triH * 0.7;
+
+            const int16_t padX = 3;
+            const int16_t padY = 2;
+            const int16_t r = 3;
+
+            const int16_t bw = labelW + triW + padX * 2 + 2;
+            const int16_t bh = FONT_HEIGHT_SMALL + padY * 2;
+
+            const int16_t bx = x + 2;
+            const int16_t by = y + display->getHeight() - bh - 2;
+
+            // Rounded white box
+            display->setColor(WHITE);
+            display->fillRect(bx + r, by, bw - (r * 2), bh);
+            display->fillRect(bx, by + r, r, bh - (r * 2));
+            display->fillRect(bx + bw - r, by + r, r, bh - (r * 2));
+            display->fillCircle(bx + r, by + r, r);
+            display->fillCircle(bx + bw - r - 1, by + r, r);
+            display->fillCircle(bx + r, by + bh - r - 1, r);
+            display->fillCircle(bx + bw - r - 1, by + bh - r - 1, r);
+
+            // Draw text
+            display->setColor(BLACK);
+            display->drawString(bx + padX, by + padY, label);
+
+            // Perfectly center triangle on text baseline
+            int16_t tx = bx + padX + labelW;
+            int16_t ty = by + padY + (FONT_HEIGHT_SMALL / 2) - (triH / 2) - 1; // -1 for optical centering
+
+            // ◄ Left-pointing triangle
+            display->fillTriangle(tx + triW, ty,       // top-right
+                                  tx, ty + triH / 2,   // left center
+                                  tx + triW, ty + triH // bottom-right
+            );
+        }
+#endif
+        // Draw Free Text input with multi-emote support and proper line wrapping
         display->setColor(WHITE);
         {
             int inputY = 0 + y + FONT_HEIGHT_SMALL;

src/modules/CannedMessageModule.h

@@ -45,7 +45,7 @@ struct Letter {
 };
 
 struct NodeEntry {
-    meshtastic_NodeDetail *node;
+    meshtastic_NodeInfoLite *node;
     uint32_t lastHeard;
 };
 

src/modules/ExternalNotificationModule.cpp

@@ -314,11 +314,10 @@ void ExternalNotificationModule::stopNow()
         audioThread->stop();
 #endif
     // Turn off all outputs
-    LOG_INFO("Turning off setExternalStates: ");
+    LOG_INFO("Turning off setExternalStates");
     for (int i = 0; i < 3; i++) {
         setExternalState(i, false);
         externalTurnedOn[i] = 0;
-        LOG_INFO("%d ", i);
     }
     setIntervalFromNow(0);
 #ifdef T_WATCH_S3

src/modules/KeyVerificationModule.cpp

@@ -1,7 +1,6 @@
 #if !MESHTASTIC_EXCLUDE_PKI
 #include "KeyVerificationModule.h"
 #include "MeshService.h"
-#include "NodeDB.h"
 #include "RTC.h"
 #include "graphics/draw/MenuHandler.h"
 #include "main.h"
@@ -37,9 +36,8 @@ AdminMessageHandleResult KeyVerificationModule::handleAdminMessageForModule(cons
 
         } else if (request->key_verification.message_type == meshtastic_KeyVerificationAdmin_MessageType_DO_VERIFY &&
                    request->key_verification.nonce == currentNonce) {
-            if (auto remoteNodePtr = nodeDB->getMeshNode(currentRemoteNode)) {
-                detailSetFlag(*remoteNodePtr, NODEDETAIL_FLAG_IS_KEY_MANUALLY_VERIFIED);
-            }
+            auto remoteNodePtr = nodeDB->getMeshNode(currentRemoteNode);
+            remoteNodePtr->bitfield |= NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_MASK;
             resetToIdle();
         } else if (request->key_verification.message_type == meshtastic_KeyVerificationAdmin_MessageType_DO_NOT_VERIFY) {
             resetToIdle();
@@ -74,9 +72,8 @@ bool KeyVerificationModule::handleReceivedProtobuf(const meshtastic_MeshPacket &
         sprintf(cn->message, "Enter Security Number for Key Verification");
         cn->which_payload_variant = meshtastic_ClientNotification_key_verification_number_request_tag;
         cn->payload_variant.key_verification_number_request.nonce = currentNonce;
-        const meshtastic_NodeDetail *remoteNode = nodeDB->getMeshNode(currentRemoteNode);
-        const char *remoteLongName = (remoteNode && remoteNode->long_name[0] != '\0') ? remoteNode->long_name : "";
-        strncpy(cn->payload_variant.key_verification_number_request.remote_longname, remoteLongName,
+        strncpy(cn->payload_variant.key_verification_number_request.remote_longname, // should really check for nulls, etc
+                nodeDB->getMeshNode(currentRemoteNode)->user.long_name,
                 sizeof(cn->payload_variant.key_verification_number_request.remote_longname));
         service->sendClientNotification(cn);
         LOG_INFO("Received hash2");
@@ -97,9 +94,8 @@ bool KeyVerificationModule::handleReceivedProtobuf(const meshtastic_MeshPacket &
                       options.bannerCallback =
                           [=](int selected) {
                               if (selected == 1) {
-                                  if (auto remoteNodePtr = nodeDB->getMeshNode(currentRemoteNode)) {
-                                      detailSetFlag(*remoteNodePtr, NODEDETAIL_FLAG_IS_KEY_MANUALLY_VERIFIED);
-                                  }
+                                  auto remoteNodePtr = nodeDB->getMeshNode(currentRemoteNode);
+                                  remoteNodePtr->bitfield |= NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_MASK;
                               }
                           };
                       screen->showOverlayBanner(options);)
@@ -108,10 +104,8 @@ bool KeyVerificationModule::handleReceivedProtobuf(const meshtastic_MeshPacket &
             sprintf(cn->message, "Final confirmation for incoming manual key verification %s", message);
             cn->which_payload_variant = meshtastic_ClientNotification_key_verification_final_tag;
             cn->payload_variant.key_verification_final.nonce = currentNonce;
-            const meshtastic_NodeDetail *remoteNodeFinal = nodeDB->getMeshNode(currentRemoteNode);
-            const char *remoteFinalLongName =
-                (remoteNodeFinal && remoteNodeFinal->long_name[0] != '\0') ? remoteNodeFinal->long_name : "";
-            strncpy(cn->payload_variant.key_verification_final.remote_longname, remoteFinalLongName,
+            strncpy(cn->payload_variant.key_verification_final.remote_longname, // should really check for nulls, etc
+                    nodeDB->getMeshNode(currentRemoteNode)->user.long_name,
                     sizeof(cn->payload_variant.key_verification_final.remote_longname));
             cn->payload_variant.key_verification_final.isSender = false;
             service->sendClientNotification(cn);
@@ -208,9 +202,8 @@ meshtastic_MeshPacket *KeyVerificationModule::allocReply()
             currentSecurityNumber % 1000);
     cn->which_payload_variant = meshtastic_ClientNotification_key_verification_number_inform_tag;
     cn->payload_variant.key_verification_number_inform.nonce = currentNonce;
-    meshtastic_NodeDetail *remoteNode = nodeDB->getMeshNode(currentRemoteNode);
-    const char *remoteName = (remoteNode && detailHasFlag(*remoteNode, NODEDETAIL_FLAG_HAS_USER)) ? remoteNode->long_name : "";
-    strncpy(cn->payload_variant.key_verification_number_inform.remote_longname, remoteName,
+    strncpy(cn->payload_variant.key_verification_number_inform.remote_longname, // should really check for nulls, etc
+            nodeDB->getMeshNode(currentRemoteNode)->user.long_name,
             sizeof(cn->payload_variant.key_verification_number_inform.remote_longname));
     cn->payload_variant.key_verification_number_inform.security_number = currentSecurityNumber;
     service->sendClientNotification(cn);
@@ -224,9 +217,9 @@ void KeyVerificationModule::processSecurityNumber(uint32_t incomingNumber)
     NodeNum ourNodeNum = nodeDB->getNodeNum();
     uint8_t scratch_hash[32] = {0};
     LOG_WARN("received security number: %u", incomingNumber);
-    meshtastic_NodeDetail *remoteNodePtr = nodeDB->getMeshNode(currentRemoteNode);
-    if (remoteNodePtr == nullptr || !detailHasFlag(*remoteNodePtr, NODEDETAIL_FLAG_HAS_USER) ||
-        remoteNodePtr->public_key.size != 32) {
+    meshtastic_NodeInfoLite *remoteNodePtr = nullptr;
+    remoteNodePtr = nodeDB->getMeshNode(currentRemoteNode);
+    if (remoteNodePtr == nullptr || !remoteNodePtr->has_user || remoteNodePtr->user.public_key.size != 32) {
         currentState = KEY_VERIFICATION_IDLE;
         return; // should we throw an error here?
     }
@@ -239,7 +232,7 @@ void KeyVerificationModule::processSecurityNumber(uint32_t incomingNumber)
     hash.update(&currentRemoteNode, sizeof(currentRemoteNode));
     hash.update(owner.public_key.bytes, owner.public_key.size);
 
-    hash.update(remoteNodePtr->public_key.bytes, remoteNodePtr->public_key.size);
+    hash.update(remoteNodePtr->user.public_key.bytes, remoteNodePtr->user.public_key.size);
     hash.finalize(hash1, 32);
 
     hash.reset();
@@ -272,10 +265,8 @@ void KeyVerificationModule::processSecurityNumber(uint32_t incomingNumber)
     sprintf(cn->message, "Final confirmation for outgoing manual key verification %s", message);
     cn->which_payload_variant = meshtastic_ClientNotification_key_verification_final_tag;
     cn->payload_variant.key_verification_final.nonce = currentNonce;
-    meshtastic_NodeDetail *remoteNodeFinal = nodeDB->getMeshNode(currentRemoteNode);
-    const char *finalRemoteName =
-        (remoteNodeFinal && detailHasFlag(*remoteNodeFinal, NODEDETAIL_FLAG_HAS_USER)) ? remoteNodeFinal->long_name : "";
-    strncpy(cn->payload_variant.key_verification_final.remote_longname, finalRemoteName,
+    strncpy(cn->payload_variant.key_verification_final.remote_longname, // should really check for nulls, etc
+            nodeDB->getMeshNode(currentRemoteNode)->user.long_name,
             sizeof(cn->payload_variant.key_verification_final.remote_longname));
     cn->payload_variant.key_verification_final.isSender = true;
     service->sendClientNotification(cn);

src/modules/Modules.cpp

@@ -13,6 +13,8 @@
 #include "input/TrackballInterruptImpl1.h"
 #endif
 
+#include "modules/StatusLEDModule.h"
+
 #if !MESHTASTIC_EXCLUDE_I2C
 #include "input/cardKbI2cImpl.h"
 #endif
@@ -119,6 +121,10 @@ void setupModules()
         buzzerFeedbackThread = new BuzzerFeedbackThread();
     }
 #endif
+#if defined(LED_CHARGE) || defined(LED_PAIRING)
+    statusLEDModule = new StatusLEDModule();
+#endif
+
 #if !MESHTASTIC_EXCLUDE_ADMIN
     adminModule = new AdminModule();
 #endif
@@ -175,12 +181,13 @@ void setupModules()
     // new ReplyModule();
 #if (HAS_BUTTON || ARCH_PORTDUINO) && !MESHTASTIC_EXCLUDE_INPUTBROKER
     if (config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_COLOR) {
+#ifndef T_LORA_PAGER
         rotaryEncoderInterruptImpl1 = new RotaryEncoderInterruptImpl1();
         if (!rotaryEncoderInterruptImpl1->init()) {
             delete rotaryEncoderInterruptImpl1;
             rotaryEncoderInterruptImpl1 = nullptr;
         }
-#ifdef T_LORA_PAGER
+#elif defined(T_LORA_PAGER)
         // use a special FSM based rotary encoder version for T-LoRa Pager
         rotaryEncoderImpl = new RotaryEncoderImpl();
         if (!rotaryEncoderImpl->init()) {

src/modules/NodeInfoModule.cpp

@@ -22,6 +22,12 @@ bool NodeInfoModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, mes
         LOG_WARN("Invalid nodeInfo detected, is_licensed mismatch!");
         return true;
     }
+    NodeNum sourceNum = getFrom(&mp);
+    auto node = nodeDB->getMeshNode(sourceNum);
+    if (node && (node->bitfield & NODEINFO_BITFIELD_HAS_XEDDSA_SIGNED_MASK) && !mp.xeddsa_signed) {
+        LOG_WARN("Dropping unsigned NodeInfo from node 0x%08x that previously signed", sourceNum);
+        return true;
+    }
 
     // Coerce user.id to be derived from the node number
     snprintf(p.id, sizeof(p.id), "!%08x", getFrom(&mp));

src/modules/PositionModule.cpp

@@ -169,9 +169,8 @@ meshtastic_MeshPacket *PositionModule::allocPositionPacket()
         return nullptr;
     }
 
-    meshtastic_NodeDetail *node = service->refreshLocalMeshNode(); // should guarantee there is now a position
-    assert(detailHasFlag(*node, NODEDETAIL_FLAG_HAS_POSITION));
-    meshtastic_PositionLite nodePosition = detailToPositionLite(*node);
+    meshtastic_NodeInfoLite *node = service->refreshLocalMeshNode(); // should guarantee there is now a position
+    assert(node->has_position);
 
     // configuration of POSITION packet
     //   consider making this a function argument?
@@ -181,7 +180,7 @@ meshtastic_MeshPacket *PositionModule::allocPositionPacket()
     meshtastic_Position p = meshtastic_Position_init_default; //   Start with an empty structure
     // if localPosition is totally empty, put our last saved position (lite) in there
     if (localPosition.latitude_i == 0 && localPosition.longitude_i == 0) {
-        nodeDB->setLocalPosition(TypeConversions::ConvertToPosition(nodePosition));
+        nodeDB->setLocalPosition(TypeConversions::ConvertToPosition(node->position));
     }
     localPosition.seq_number++;
 
@@ -402,7 +401,7 @@ int32_t PositionModule::runOnce()
         doDeepSleep(nightyNightMs, false, false);
     }
 
-    meshtastic_NodeDetail *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
+    meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
     if (node == nullptr)
         return RUNONCE_INTERVAL;
 
@@ -421,9 +420,8 @@ int32_t PositionModule::runOnce()
         if (nodeDB->hasValidPosition(node)) {
             lastGpsSend = now;
 
-            meshtastic_PositionLite nodePosition = detailToPositionLite(*node);
-            lastGpsLatitude = nodePosition.latitude_i;
-            lastGpsLongitude = nodePosition.longitude_i;
+            lastGpsLatitude = node->position.latitude_i;
+            lastGpsLongitude = node->position.longitude_i;
 
             sendOurPosition();
             if (config.device.role == meshtastic_Config_DeviceConfig_Role_LOST_AND_FOUND) {
@@ -431,11 +429,12 @@ int32_t PositionModule::runOnce()
             }
         }
     } else if (config.position.position_broadcast_smart_enabled) {
-        const meshtastic_NodeDetail *node2 = service->refreshLocalMeshNode(); // should guarantee there is now a position
+        const meshtastic_NodeInfoLite *node2 = service->refreshLocalMeshNode(); // should guarantee there is now a position
 
         if (nodeDB->hasValidPosition(node2)) {
             // The minimum time (in seconds) that would pass before we are able to send a new position packet.
-            auto smartPosition = getDistanceTraveledSinceLastSend(detailToPositionLite(*node));
+
+            auto smartPosition = getDistanceTraveledSinceLastSend(node->position);
             msSinceLastSend = now - lastGpsSend;
 
             if (smartPosition.hasTraveledOverThreshold &&
@@ -449,9 +448,8 @@ int32_t PositionModule::runOnce()
                           msSinceLastSend, minimumTimeThreshold);
 
                 // Set the current coords as our last ones, after we've compared distance with current and decided to send
-                meshtastic_PositionLite nodePosition = detailToPositionLite(*node);
-                lastGpsLatitude = nodePosition.latitude_i;
-                lastGpsLongitude = nodePosition.longitude_i;
+                lastGpsLatitude = node->position.latitude_i;
+                lastGpsLongitude = node->position.longitude_i;
             }
         }
     }
@@ -491,11 +489,11 @@ struct SmartPosition PositionModule::getDistanceTraveledSinceLastSend(meshtastic
 
 void PositionModule::handleNewPosition()
 {
-    meshtastic_NodeDetail *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
-    const meshtastic_NodeDetail *node2 = service->refreshLocalMeshNode(); // should guarantee there is now a position
+    meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
+    const meshtastic_NodeInfoLite *node2 = service->refreshLocalMeshNode(); // should guarantee there is now a position
     // We limit our GPS broadcasts to a max rate
     if (nodeDB->hasValidPosition(node2)) {
-        auto smartPosition = getDistanceTraveledSinceLastSend(detailToPositionLite(*node));
+        auto smartPosition = getDistanceTraveledSinceLastSend(node->position);
         uint32_t msSinceLastSend = millis() - lastGpsSend;
         if (smartPosition.hasTraveledOverThreshold &&
             Throttle::execute(
@@ -507,9 +505,8 @@ void PositionModule::handleNewPosition()
                       minimumTimeThreshold);
 
             // Set the current coords as our last ones, after we've compared distance with current and decided to send
-            meshtastic_PositionLite nodePosition = detailToPositionLite(*node);
-            lastGpsLatitude = nodePosition.latitude_i;
-            lastGpsLongitude = nodePosition.longitude_i;
+            lastGpsLatitude = node->position.latitude_i;
+            lastGpsLongitude = node->position.longitude_i;
         }
     }
 }

src/modules/RangeTestModule.cpp

@@ -151,7 +151,7 @@ ProcessMessage RangeTestModuleRadio::handleReceived(const meshtastic_MeshPacket
             }
 
             /*
-            meshtastic_NodeDetail *n = nodeDB->getMeshNode(getFrom(&mp));
+            NodeInfoLite *n = nodeDB->getMeshNode(getFrom(&mp));
 
             LOG_DEBUG("-----------------------------------------");
             LOG_DEBUG("p.payload.bytes  \"%s\"", p.payload.bytes);
@@ -189,7 +189,7 @@ bool RangeTestModuleRadio::appendFile(const meshtastic_MeshPacket &mp)
 #ifdef ARCH_ESP32
     auto &p = mp.decoded;
 
-    meshtastic_NodeDetail *n = nodeDB->getMeshNode(getFrom(&mp));
+    meshtastic_NodeInfoLite *n = nodeDB->getMeshNode(getFrom(&mp));
     /*
         LOG_DEBUG("-----------------------------------------");
         LOG_DEBUG("p.payload.bytes  \"%s\"", p.payload.bytes);
@@ -268,33 +268,27 @@ bool RangeTestModuleRadio::appendFile(const meshtastic_MeshPacket &mp)
         fileToAppend.printf("??:??:??,"); // Time
     }
 
-    fileToAppend.printf("%d,", getFrom(&mp)); // From
-    const char *senderName = (n && strlen(n->long_name) > 0) ? n->long_name : "?";
-    fileToAppend.printf("%s,", senderName); // Long Name
-    double senderLat = (n && detailHasFlag(*n, NODEDETAIL_FLAG_HAS_POSITION)) ? n->latitude_i * 1e-7 : 0.0;
-    double senderLon = (n && detailHasFlag(*n, NODEDETAIL_FLAG_HAS_POSITION)) ? n->longitude_i * 1e-7 : 0.0;
-    fileToAppend.printf("%f,", senderLat); // Sender Lat
-    fileToAppend.printf("%f,", senderLon); // Sender Long
+    fileToAppend.printf("%d,", getFrom(&mp));                   // From
+    fileToAppend.printf("%s,", n->user.long_name);              // Long Name
+    fileToAppend.printf("%f,", n->position.latitude_i * 1e-7);  // Sender Lat
+    fileToAppend.printf("%f,", n->position.longitude_i * 1e-7); // Sender Long
     if (gpsStatus->getIsConnected() || config.position.fixed_position) {
         fileToAppend.printf("%f,", gpsStatus->getLatitude() * 1e-7);  // RX Lat
         fileToAppend.printf("%f,", gpsStatus->getLongitude() * 1e-7); // RX Long
         fileToAppend.printf("%d,", gpsStatus->getAltitude());         // RX Altitude
     } else {
         // When the phone API is in use, the node info will be updated with position
-        meshtastic_NodeDetail *us = nodeDB->getMeshNode(nodeDB->getNodeNum());
-        double rxLat = (us && detailHasFlag(*us, NODEDETAIL_FLAG_HAS_POSITION)) ? us->latitude_i * 1e-7 : 0.0;
-        double rxLon = (us && detailHasFlag(*us, NODEDETAIL_FLAG_HAS_POSITION)) ? us->longitude_i * 1e-7 : 0.0;
-        int32_t rxAlt = (us && detailHasFlag(*us, NODEDETAIL_FLAG_HAS_POSITION)) ? us->altitude : 0;
-        fileToAppend.printf("%f,", rxLat); // RX Lat
-        fileToAppend.printf("%f,", rxLon); // RX Long
-        fileToAppend.printf("%d,", rxAlt); // RX Altitude
+        meshtastic_NodeInfoLite *us = nodeDB->getMeshNode(nodeDB->getNodeNum());
+        fileToAppend.printf("%f,", us->position.latitude_i * 1e-7);  // RX Lat
+        fileToAppend.printf("%f,", us->position.longitude_i * 1e-7); // RX Long
+        fileToAppend.printf("%d,", us->position.altitude);           // RX Altitude
     }
 
     fileToAppend.printf("%f,", mp.rx_snr); // RX SNR
 
-    if (n && detailHasFlag(*n, NODEDETAIL_FLAG_HAS_POSITION) && gpsStatus->getLatitude() && gpsStatus->getLongitude()) {
-        float distance = GeoCoord::latLongToMeter(n->latitude_i * 1e-7, n->longitude_i * 1e-7, gpsStatus->getLatitude() * 1e-7,
-                                                  gpsStatus->getLongitude() * 1e-7);
+    if (n->position.latitude_i && n->position.longitude_i && gpsStatus->getLatitude() && gpsStatus->getLongitude()) {
+        float distance = GeoCoord::latLongToMeter(n->position.latitude_i * 1e-7, n->position.longitude_i * 1e-7,
+                                                  gpsStatus->getLatitude() * 1e-7, gpsStatus->getLongitude() * 1e-7);
         fileToAppend.printf("%f,", distance); // Distance in meters
     } else {
         fileToAppend.printf("0,");

src/modules/RoutingModule.cpp

@@ -17,10 +17,8 @@ bool RoutingModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, mesh
          config.device.rebroadcast_mode == meshtastic_Config_DeviceConfig_RebroadcastMode_KNOWN_ONLY)) {
         if (!maybePKI)
             return false;
-        const meshtastic_NodeDetail *fromDetail = nodeDB->getMeshNode(mp.from);
-        const meshtastic_NodeDetail *toDetail = nodeDB->getMeshNode(mp.to);
-        if ((!fromDetail || !detailHasFlag(*fromDetail, NODEDETAIL_FLAG_HAS_USER)) &&
-            (!toDetail || !detailHasFlag(*toDetail, NODEDETAIL_FLAG_HAS_USER)))
+        if ((nodeDB->getMeshNode(mp.from) == NULL || !nodeDB->getMeshNode(mp.from)->has_user) &&
+            (nodeDB->getMeshNode(mp.to) == NULL || !nodeDB->getMeshNode(mp.to)->has_user))
             return false;
     } else if (owner.is_licensed && nodeDB->getLicenseStatus(mp.from) == UserLicenseStatus::NotLicensed) {
         // Don't let licensed users to rebroadcast packets from unlicensed users

src/modules/SerialModule.cpp

@@ -64,7 +64,8 @@ SerialModule *serialModule;
 SerialModuleRadio *serialModuleRadio;
 
 #if defined(TTGO_T_ECHO) || defined(CANARYONE) || defined(MESHLINK) || defined(ELECROW_ThinkNode_M1) ||                          \
-    defined(ELECROW_ThinkNode_M5) || defined(HELTEC_MESH_SOLAR) || defined(T_ECHO_LITE)
+    defined(ELECROW_ThinkNode_M5) || defined(HELTEC_MESH_SOLAR) || defined(T_ECHO_LITE) || defined(ELECROW_ThinkNode_M3) ||      \
+    defined(MUZI_BASE)
 SerialModule::SerialModule() : StreamAPI(&Serial), concurrency::OSThread("Serial")
 {
     api_type = TYPE_SERIAL;
@@ -84,42 +85,6 @@ SerialModule::SerialModule() : StreamAPI(&Serial2), concurrency::OSThread("Seria
 static Print *serialPrint = &Serial2;
 #endif
 
-namespace
-{
-const char *resolveNodeName(const meshtastic_NodeDetail *node, char *buffer, size_t bufferSize, bool preferLongName)
-{
-    if (!node) {
-        return "???";
-    }
-
-    if (detailHasFlag(*node, NODEDETAIL_FLAG_HAS_USER)) {
-        if (preferLongName) {
-            if (node->long_name[0]) {
-                return node->long_name;
-            }
-            if (node->short_name[0]) {
-                return node->short_name;
-            }
-        } else {
-            if (node->short_name[0]) {
-                return node->short_name;
-            }
-            if (node->long_name[0]) {
-                return node->long_name;
-            }
-        }
-    }
-
-    if (buffer && bufferSize > 0) {
-        snprintf(buffer, bufferSize, "(%04X)", static_cast<unsigned int>(node->num & 0xFFFF));
-        buffer[bufferSize - 1] = '\0';
-        return buffer;
-    }
-
-    return "???";
-}
-} // namespace
-
 char serialBytes[512];
 size_t serialPayloadSize;
 
@@ -240,7 +205,7 @@ int32_t SerialModule::runOnce()
                 Serial.setTimeout(moduleConfig.serial.timeout > 0 ? moduleConfig.serial.timeout : TIMEOUT);
             }
 #elif !defined(TTGO_T_ECHO) && !defined(T_ECHO_LITE) && !defined(CANARYONE) && !defined(MESHLINK) &&                             \
-    !defined(ELECROW_ThinkNode_M1) && !defined(ELECROW_ThinkNode_M5)
+    !defined(ELECROW_ThinkNode_M1) && !defined(ELECROW_ThinkNode_M3) && !defined(ELECROW_ThinkNode_M5) && !defined(MUZI_BASE)
             if (moduleConfig.serial.rxd && moduleConfig.serial.txd) {
 #ifdef ARCH_RP2040
                 Serial2.setFIFOSize(RX_BUFFER);
@@ -285,21 +250,19 @@ int32_t SerialModule::runOnce()
                 if (!Throttle::isWithinTimespanMs(lastNmeaTime, 10000)) {
                     lastNmeaTime = millis();
                     uint32_t readIndex = 0;
-                    const meshtastic_NodeDetail *tempNode = nodeDB->readNextMeshNode(readIndex);
-                    while (tempNode != NULL) {
-                        if (detailHasFlag(*tempNode, NODEDETAIL_FLAG_HAS_USER) && nodeDB->hasValidPosition(tempNode)) {
-                            char nameBuffer[12] = {0};
-                            const char *name = resolveNodeName(tempNode, nameBuffer, sizeof(nameBuffer), true);
-                            printWPL(outbuf, sizeof(outbuf), detailToPositionLite(*tempNode), name, true);
+                    const meshtastic_NodeInfoLite *tempNodeInfo = nodeDB->readNextMeshNode(readIndex);
+                    while (tempNodeInfo != NULL) {
+                        if (tempNodeInfo->has_user && nodeDB->hasValidPosition(tempNodeInfo)) {
+                            printWPL(outbuf, sizeof(outbuf), tempNodeInfo->position, tempNodeInfo->user.long_name, true);
                             serialPrint->printf("%s", outbuf);
                         }
-                        tempNode = nodeDB->readNextMeshNode(readIndex);
+                        tempNodeInfo = nodeDB->readNextMeshNode(readIndex);
                     }
                 }
             }
 
 #if !defined(TTGO_T_ECHO) && !defined(T_ECHO_LITE) && !defined(CANARYONE) && !defined(MESHLINK) &&                               \
-    !defined(ELECROW_ThinkNode_M1) && !defined(ELECROW_ThinkNode_M5)
+    !defined(ELECROW_ThinkNode_M1) && !defined(ELECROW_ThinkNode_M3) && !defined(ELECROW_ThinkNode_M5) && !defined(MUZI_BASE)
             else if ((moduleConfig.serial.mode == meshtastic_ModuleConfig_SerialConfig_Serial_Mode_WS85)) {
                 processWXSerial();
 
@@ -440,9 +403,8 @@ ProcessMessage SerialModuleRadio::handleReceived(const meshtastic_MeshPacket &mp
                 moduleConfig.serial.mode == meshtastic_ModuleConfig_SerialConfig_Serial_Mode_SIMPLE) {
                 serialPrint->write(p.payload.bytes, p.payload.size);
             } else if (moduleConfig.serial.mode == meshtastic_ModuleConfig_SerialConfig_Serial_Mode_TEXTMSG) {
-                meshtastic_NodeDetail *node = nodeDB->getMeshNode(getFrom(&mp));
-                char senderBuffer[12] = {0};
-                const char *sender = resolveNodeName(node, senderBuffer, sizeof(senderBuffer), false);
+                meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(getFrom(&mp));
+                const char *sender = (node && node->has_user) ? node->user.short_name : "???";
                 serialPrint->println();
                 serialPrint->printf("%s: %s", sender, p.payload.bytes);
                 serialPrint->println();
@@ -458,10 +420,7 @@ ProcessMessage SerialModuleRadio::handleReceived(const meshtastic_MeshPacket &mp
                         decoded = &scratch;
                     }
                     // send position packet as WPL to the serial port
-                    meshtastic_NodeDetail *node = nodeDB->getMeshNode(getFrom(&mp));
-                    char nameBuffer[12] = {0};
-                    const char *name = resolveNodeName(node, nameBuffer, sizeof(nameBuffer), true);
-                    printWPL(outbuf, sizeof(outbuf), *decoded, name,
+                    printWPL(outbuf, sizeof(outbuf), *decoded, nodeDB->getMeshNode(getFrom(&mp))->user.long_name,
                              moduleConfig.serial.mode == meshtastic_ModuleConfig_SerialConfig_Serial_Mode_CALTOPO);
                     serialPrint->printf("%s", outbuf);
                 }
@@ -578,7 +537,8 @@ ParsedLine parseLine(const char *line)
 void SerialModule::processWXSerial()
 {
 #if !defined(TTGO_T_ECHO) && !defined(T_ECHO_LITE) && !defined(CANARYONE) && !defined(CONFIG_IDF_TARGET_ESP32C6) &&              \
-    !defined(MESHLINK) && !defined(ELECROW_ThinkNode_M1) && !defined(ELECROW_ThinkNode_M5) && !defined(ARCH_STM32WL)
+    !defined(MESHLINK) && !defined(ELECROW_ThinkNode_M1) && !defined(ELECROW_ThinkNode_M3) && !defined(ELECROW_ThinkNode_M5) &&  \
+    !defined(ARCH_STM32WL) && !defined(MUZI_BASE)
     static unsigned int lastAveraged = 0;
     static unsigned int averageIntervalMillis = 300000; // 5 minutes hard coded.
     static double dir_sum_sin = 0;

src/modules/StatusLEDModule.cpp

@@ -0,0 +1,94 @@
+#include "StatusLEDModule.h"
+#include "MeshService.h"
+#include "configuration.h"
+#include <Arduino.h>
+
+/*
+StatusLEDModule manages the device's status LEDs, updating their states based on power and Bluetooth status.
+It reflects charging, charged, discharging, and Bluetooth connection states using the appropriate LEDs.
+*/
+StatusLEDModule *statusLEDModule;
+
+StatusLEDModule::StatusLEDModule() : concurrency::OSThread("StatusLEDModule")
+{
+    bluetoothStatusObserver.observe(&bluetoothStatus->onNewStatus);
+    powerStatusObserver.observe(&powerStatus->onNewStatus);
+}
+
+int StatusLEDModule::handleStatusUpdate(const meshtastic::Status *arg)
+{
+    switch (arg->getStatusType()) {
+    case STATUS_TYPE_POWER: {
+        meshtastic::PowerStatus *powerStatus = (meshtastic::PowerStatus *)arg;
+        if (powerStatus->getHasUSB()) {
+            power_state = charging;
+            if (powerStatus->getBatteryChargePercent() >= 100) {
+                power_state = charged;
+            }
+        } else {
+            power_state = discharging;
+        }
+        break;
+    }
+    case STATUS_TYPE_BLUETOOTH: {
+        meshtastic::BluetoothStatus *bluetoothStatus = (meshtastic::BluetoothStatus *)arg;
+        switch (bluetoothStatus->getConnectionState()) {
+        case meshtastic::BluetoothStatus::ConnectionState::DISCONNECTED: {
+            ble_state = unpaired;
+            PAIRING_LED_starttime = millis();
+            break;
+        }
+        case meshtastic::BluetoothStatus::ConnectionState::PAIRING: {
+            ble_state = pairing;
+            PAIRING_LED_starttime = millis();
+            break;
+        }
+        case meshtastic::BluetoothStatus::ConnectionState::CONNECTED: {
+            ble_state = connected;
+            PAIRING_LED_starttime = millis();
+            break;
+        }
+        }
+
+        break;
+    }
+    }
+    return 0;
+};
+
+int32_t StatusLEDModule::runOnce()
+{
+
+    if (power_state == charging) {
+        CHARGE_LED_state = !CHARGE_LED_state;
+    } else if (power_state == charged) {
+        CHARGE_LED_state = LED_STATE_ON;
+    } else {
+        CHARGE_LED_state = LED_STATE_OFF;
+    }
+
+    if (!config.bluetooth.enabled || PAIRING_LED_starttime + 30 * 1000 < millis()) {
+        PAIRING_LED_state = LED_STATE_OFF;
+    } else if (ble_state == unpaired) {
+        if (slowTrack) {
+            PAIRING_LED_state = !PAIRING_LED_state;
+            slowTrack = false;
+        } else {
+            slowTrack = true;
+        }
+    } else if (ble_state == pairing) {
+        PAIRING_LED_state = !PAIRING_LED_state;
+    } else {
+        PAIRING_LED_state = LED_STATE_ON;
+    }
+
+#ifdef LED_CHARGE
+    digitalWrite(LED_CHARGE, CHARGE_LED_state);
+#endif
+    // digitalWrite(green_LED_PIN, LED_STATE_OFF);
+#ifdef LED_PAIRING
+    digitalWrite(LED_PAIRING, PAIRING_LED_state);
+#endif
+
+    return (my_interval);
+}

src/modules/StatusLEDModule.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include "BluetoothStatus.h"
+#include "MeshModule.h"
+#include "PowerStatus.h"
+#include "concurrency/OSThread.h"
+#include "configuration.h"
+#include <Arduino.h>
+#include <functional>
+
+class StatusLEDModule : private concurrency::OSThread
+{
+    bool slowTrack = false;
+
+  public:
+    StatusLEDModule();
+
+    int handleStatusUpdate(const meshtastic::Status *);
+
+  protected:
+    unsigned int my_interval = 1000; // interval in millisconds
+    virtual int32_t runOnce() override;
+
+    CallbackObserver<StatusLEDModule, const meshtastic::Status *> bluetoothStatusObserver =
+        CallbackObserver<StatusLEDModule, const meshtastic::Status *>(this, &StatusLEDModule::handleStatusUpdate);
+    CallbackObserver<StatusLEDModule, const meshtastic::Status *> powerStatusObserver =
+        CallbackObserver<StatusLEDModule, const meshtastic::Status *>(this, &StatusLEDModule::handleStatusUpdate);
+
+  private:
+    bool CHARGE_LED_state = LED_STATE_OFF;
+    bool PAIRING_LED_state = LED_STATE_OFF;
+
+    uint32_t PAIRING_LED_starttime = 0;
+
+    enum PowerState { discharging, charging, charged };
+
+    PowerState power_state = discharging;
+
+    enum BLEState { unpaired, pairing, connected };
+
+    BLEState ble_state = unpaired;
+};
+
+extern StatusLEDModule *statusLEDModule;

src/modules/SystemCommandsModule.cpp

@@ -1,4 +1,5 @@
 #include "SystemCommandsModule.h"
+#include "input/InputBroker.h"
 #include "meshUtils.h"
 #if HAS_SCREEN
 #include "graphics/Screen.h"
@@ -22,7 +23,7 @@ SystemCommandsModule::SystemCommandsModule()
 
 int SystemCommandsModule::handleInputEvent(const InputEvent *event)
 {
-    LOG_INFO("Input event %u! kb %u", event->inputEvent, event->kbchar);
+    LOG_INPUT("SystemCommands Input event %u! kb %u", event->inputEvent, event->kbchar);
     // System commands (all others fall through)
     switch (event->kbchar) {
     // Fn key symbols

src/modules/Telemetry/Sensor/AHT10.cpp

@@ -35,7 +35,7 @@ bool AHT10Sensor::getMetrics(meshtastic_Telemetry *measurement)
     // prefer other sensors like bmp280, bmp3xx
     if (!measurement->variant.environment_metrics.has_temperature) {
         measurement->variant.environment_metrics.has_temperature = true;
-        measurement->variant.environment_metrics.temperature = temp.temperature;
+        measurement->variant.environment_metrics.temperature = temp.temperature + AHT10_TEMP_OFFSET;
     }
 
     if (!measurement->variant.environment_metrics.has_relative_humidity) {

src/modules/Telemetry/Sensor/AHT10.h

@@ -6,6 +6,10 @@
 
 #if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && __has_include(<Adafruit_AHTX0.h>)
 
+#ifndef AHT10_TEMP_OFFSET
+#define AHT10_TEMP_OFFSET 0
+#endif
+
 #include "../mesh/generated/meshtastic/telemetry.pb.h"
 #include "TelemetrySensor.h"
 #include <Adafruit_AHTX0.h>

src/modules/TraceRouteModule.cpp

@@ -317,7 +317,7 @@ void TraceRouteModule::maybeSetNextHop(NodeNum target, uint8_t nextHopByte)
     if (target == NODENUM_BROADCAST)
         return;
 
-    meshtastic_NodeDetail *node = nodeDB->getMeshNode(target);
+    meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(target);
     if (node && node->next_hop != nextHopByte) {
         LOG_INFO("Updating next-hop for 0x%08x to 0x%02x based on traceroute", target, nextHopByte);
         node->next_hop = nextHopByte;
@@ -490,13 +490,13 @@ TraceRouteModule::TraceRouteModule()
 
 const char *TraceRouteModule::getNodeName(NodeNum node)
 {
-    const meshtastic_NodeDetail *info = nodeDB->getMeshNode(node);
-    if (info && detailHasFlag(*info, NODEDETAIL_FLAG_HAS_USER)) {
-        if (strlen(info->short_name) > 0) {
-            return info->short_name;
+    meshtastic_NodeInfoLite *info = nodeDB->getMeshNode(node);
+    if (info && info->has_user) {
+        if (strlen(info->user.short_name) > 0) {
+            return info->user.short_name;
         }
-        if (strlen(info->long_name) > 0) {
-            return info->long_name;
+        if (strlen(info->user.long_name) > 0) {
+            return info->user.long_name;
         }
     }
 

src/modules/WaypointModule.cpp

@@ -115,7 +115,7 @@ void WaypointModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state,
     static char distStr[20];
 
     // Get our node, to use our own position
-    meshtastic_NodeDetail *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
+    meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
 
     // Text fields to draw (left of compass)
     // Last element must be NULL. This signals the end of the char*[] to drawColumns
@@ -135,11 +135,7 @@ void WaypointModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state,
 
     // If our node has a position:
     if (ourNode && (nodeDB->hasValidPosition(ourNode) || screen->hasHeading())) {
-        meshtastic_PositionLite op = meshtastic_PositionLite_init_default;
-        op.latitude_i = ourNode->latitude_i;
-        op.longitude_i = ourNode->longitude_i;
-        op.altitude = ourNode->altitude;
-        op.location_source = ourNode->position_source;
+        const meshtastic_PositionLite &op = ourNode->position;
         float myHeading;
         if (uiconfig.compass_mode == meshtastic_CompassMode_FREEZE_HEADING) {
             myHeading = 0;

src/motion/BMX160Sensor.cpp

@@ -115,8 +115,13 @@ int32_t BMX160Sensor::runOnce()
 void BMX160Sensor::calibrate(uint16_t forSeconds)
 {
 #if !defined(MESHTASTIC_EXCLUDE_SCREEN)
+    sBmx160SensorData_t magAccel;
+    sBmx160SensorData_t gAccel;
     LOG_DEBUG("BMX160 calibration started for %is", forSeconds);
-    highestX = 0, lowestX = 0, highestY = 0, lowestY = 0, highestZ = 0, lowestZ = 0;
+    sensor.getAllData(&magAccel, NULL, &gAccel);
+    highestX = magAccel.x, lowestX = magAccel.x;
+    highestY = magAccel.y, lowestY = magAccel.y;
+    highestZ = magAccel.z, lowestZ = magAccel.z;
 
     doCalibration = true;
     uint16_t calibrateFor = forSeconds * 1000; // calibrate for seconds provided

src/motion/ICM20948Sensor.cpp

@@ -47,6 +47,21 @@ int32_t ICM20948Sensor::runOnce()
 int32_t ICM20948Sensor::runOnce()
 {
 #if !defined(MESHTASTIC_EXCLUDE_SCREEN) && HAS_SCREEN
+#if defined(MUZI_BASE) // temporarily gated to single device due to feature freeze
+    if (screen && !screen->isScreenOn() && !config.display.wake_on_tap_or_motion && !config.device.double_tap_as_button_press) {
+        if (!isAsleep) {
+            LOG_DEBUG("sleeping IMU");
+            sensor->sleep(true);
+            isAsleep = true;
+        }
+        return MOTION_SENSOR_CHECK_INTERVAL_MS;
+    }
+    if (isAsleep) {
+        sensor->sleep(false);
+        isAsleep = false;
+    }
+#endif
+
     float magX = 0, magY = 0, magZ = 0;
     if (sensor->dataReady()) {
         sensor->getAGMT();
@@ -156,8 +171,20 @@ int32_t ICM20948Sensor::runOnce()
 void ICM20948Sensor::calibrate(uint16_t forSeconds)
 {
 #if !defined(MESHTASTIC_EXCLUDE_SCREEN) && HAS_SCREEN
+    LOG_DEBUG("Old calibration data: highestX = %f, lowestX = %f, highestY = %f, lowestY = %f, highestZ = %f, lowestZ = %f",
+              highestX, lowestX, highestY, lowestY, highestZ, lowestZ);
     LOG_DEBUG("BMX160 calibration started for %is", forSeconds);
-    highestX = 0, lowestX = 0, highestY = 0, lowestY = 0, highestZ = 0, lowestZ = 0;
+    if (sensor->dataReady()) {
+        sensor->getAGMT();
+        highestX = sensor->agmt.mag.axes.x;
+        lowestX = sensor->agmt.mag.axes.x;
+        highestY = sensor->agmt.mag.axes.y;
+        lowestY = sensor->agmt.mag.axes.y;
+        highestZ = sensor->agmt.mag.axes.z;
+        lowestZ = sensor->agmt.mag.axes.z;
+    } else {
+        highestX = 0, lowestX = 0, highestY = 0, lowestY = 0, highestZ = 0, lowestZ = 0;
+    }
 
     doCalibration = true;
     uint16_t calibrateFor = forSeconds * 1000; // calibrate for seconds provided

src/motion/ICM20948Sensor.h

@@ -82,7 +82,13 @@ class ICM20948Sensor : public MotionSensor
   private:
     ICM20948Singleton *sensor = nullptr;
     bool showingScreen = false;
+#ifdef MUZI_BASE
+    bool isAsleep = false;
+    float highestX = 449.000000, lowestX = -140.000000, highestY = 422.000000, lowestY = -232.000000, highestZ = 749.000000,
+          lowestZ = 98.000000;
+#else
     float highestX = 0, lowestX = 0, highestY = 0, lowestY = 0, highestZ = 0, lowestZ = 0;
+#endif
 
   public:
     explicit ICM20948Sensor(ScanI2C::FoundDevice foundDevice);

src/mqtt/MQTT.cpp

@@ -131,12 +131,11 @@ inline void onReceiveProto(char *topic, byte *payload, size_t length)
 
     // PKI messages get accepted even if we can't decrypt
     if (router && p->which_payload_variant == meshtastic_MeshPacket_encrypted_tag && strcmp(e.channel_id, "PKI") == 0) {
-        meshtastic_NodeDetail *tx = nodeDB->getMeshNode(getFrom(p.get()));
-        meshtastic_NodeDetail *rx = nodeDB->getMeshNode(p->to);
+        const meshtastic_NodeInfoLite *tx = nodeDB->getMeshNode(getFrom(p.get()));
+        const meshtastic_NodeInfoLite *rx = nodeDB->getMeshNode(p->to);
         // Only accept PKI messages to us, or if we have both the sender and receiver in our nodeDB, as then it's
         // likely they discovered each other via a channel we have downlink enabled for
-        if (isToUs(p.get()) ||
-            (tx && detailHasFlag(*tx, NODEDETAIL_FLAG_HAS_USER) && rx && detailHasFlag(*rx, NODEDETAIL_FLAG_HAS_USER)))
+        if (isToUs(p.get()) || (tx && tx->has_user && rx && rx->has_user))
             router->enqueueReceivedMessage(p.release());
     } else if (router &&
                perhapsDecode(p.get()) == DecodeState::DECODE_SUCCESS) // ignore messages if we don't have the channel key

src/platform/esp32/architecture.h

@@ -101,8 +101,6 @@
 #define HW_VENDOR meshtastic_HardwareModel_T_WATCH_S3
 #elif defined(GENIEBLOCKS)
 #define HW_VENDOR meshtastic_HardwareModel_GENIEBLOCKS
-#elif defined(PRIVATE_HW)
-#define HW_VENDOR meshtastic_HardwareModel_PRIVATE_HW
 #elif defined(NANO_G1)
 #define HW_VENDOR meshtastic_HardwareModel_NANO_G1
 #elif defined(M5STACK)
@@ -205,6 +203,8 @@
 #define HW_VENDOR meshtastic_HardwareModel_M5STACK_C6L
 #elif defined(HELTEC_WIRELESS_TRACKER_V2)
 #define HW_VENDOR meshtastic_HardwareModel_HELTEC_WIRELESS_TRACKER_V2
+#else
+#define HW_VENDOR meshtastic_HardwareModel_PRIVATE_HW
 #endif
 
 // -----------------------------------------------------------------------------

src/platform/extra_variants/tbeam_displayshield/variant.cpp

@@ -0,0 +1,43 @@
+#include "configuration.h"
+
+#ifdef HAS_CST226SE
+
+#include "TouchDrvCSTXXX.hpp"
+#include "input/TouchScreenImpl1.h"
+#include <Wire.h>
+
+TouchDrvCSTXXX tsPanel;
+static constexpr uint8_t PossibleAddresses[2] = {CST328_ADDR, CST226SE_ADDR_ALT};
+uint8_t i2cAddress = 0;
+
+bool readTouch(int16_t *x, int16_t *y)
+{
+    int16_t x_array[1], y_array[1];
+    uint8_t touched = tsPanel.getPoint(x_array, y_array, 1);
+    if (touched > 0) {
+        *y = x_array[0];
+        *x = (TFT_WIDTH - y_array[0]);
+        // Check bounds
+        if (*x < 0 || *x >= TFT_WIDTH || *y < 0 || *y >= TFT_HEIGHT) {
+            return false;
+        }
+        return true; // Valid touch detected
+    }
+    return false; // No valid touch data
+}
+
+void lateInitVariant()
+{
+    tsPanel.setTouchDrvModel(TouchDrv_CST226);
+    for (uint8_t addr : PossibleAddresses) {
+        if (tsPanel.begin(Wire, addr, I2C_SDA, I2C_SCL)) {
+            i2cAddress = addr;
+            LOG_DEBUG("CST226SE init OK at address 0x%02X", addr);
+            touchScreenImpl1 = new TouchScreenImpl1(TFT_WIDTH, TFT_HEIGHT, readTouch);
+            touchScreenImpl1->init();
+            return;
+        }
+    }
+    LOG_ERROR("CST226SE init failed at all known addresses");
+}
+#endif