Please do not open a public issue for security vulnerabilities. Use GitHub's private vulnerability reporting ("Security" tab → "Report a vulnerability") for this repository.
We will acknowledge reports as soon as we reasonably can and will credit reporters who wish to be named.
- This app holds no wallet secrets by design. Its secrets are identity keys only: the node P2P identity key, and — only when DePIN activity recording is enabled — the DePIN participation identity seed (stored encrypted in app-private storage). Neither controls any assets.
- Public releases began on 2026-11-04 (v0.1.0); the current release is v4.2.5. Signed release APKs and their SHA-256 checksums are published on the Releases page. Builds from other sources should not be trusted.
The node binary's dependency tree is inherited from upstream (Quantus-Network/chain, built on polkadot-sdk); this project adds no dependencies of its own to that tree.
Re-checked on 2026-11-04 against the then-current RustSec advisory database, scoped to the dependency closure of the shipped quantus-node binary. (A whole-workspace audit reports more; the difference is tooling and test-only graphs that never enter the binary.)
Of the 22 advisories inside the binary's closure, 20 are resolved by semver-compatible lockfile updates, applied and shipped in the versionCode 10 node binary (verified with cargo check for aarch64-linux-android before the rebuild):
wasmtime36.0.13 -> 36.0.20 (six advisories, including two critical Cranelift miscompilations; three of the six concern the component model and WASI, which this build does not enable),quinn-proto0.11.15 -> 0.11.19 (five advisories; the QUIC stack is exercised by the node's external-miner server, which the app enables only while mining is on — since v4.0.0 — with the auth token and TLS pinning as the boundary; see the accepted items below),rustls0.23.32 -> 0.23.46 andrustls-webpki0.103.13 -> 0.103.16 (TLS client paths: opt-in telemetry, offchain HTTP, litep2p),zstd0.13.3 -> 0.13.4,zstd-safe7.2.4 -> 7.4.0,zstd-sys-> 2.1.2 (wasmtime's on-device module cache).
Two advisories remain in the closure because no fixed release exists inside the version ranges the pinned framework allows; both are inherited from upstream unchanged:
zstd-safe6.0.6 (RUSTSEC-2026-0403) — uninitialized memory when streaming decompression of a legacy-format frame fails. The only call site in this build decompresses the chain's own runtime blobs, which are produced in the current format.crypto-bigint0.5.5 (RUSTSEC-2026-0387) — timing variability in operations intended to be constant-time. The fix requires a newer elliptic-curve stack than the pinned framework provides.
Four items from earlier reviews are not applicable to the current lockfile, and this section corrects earlier wording that said otherwise: h2 is locked at the fixed 0.4.20; ring 0.17.14 is inside the patched range of RUSTSEC-2025-0009 (>= 0.17.12); curve25519-dalek is locked at 4.1.3, the fixed release for RUSTSEC-2024-0344 (>= 4.1.3) — no 3.x copy exists in the lockfile; anyhow is locked at 1.0.104, not the yanked 1.0.99.
Re-checked again on 2026-11-16, this time for both bundled binaries. For the node, 19 advisories sit in the shipped closure. Two batches are new since 2026-11-04 and are both handled at the next node rebuild: 16 advisories in hickory-proto / hickory-net 0.26.1 (fixed in 0.26.2; they arrive through litep2p's vendored DNS resolver, and most need DNSSEC validation or zone-file parsing that this build never performs) and RUSTSEC-2026-0538 in quinn-udp 0.5.14 (fixed in 0.5.16; a receive-loop spin reachable before authentication on the miner endpoint while mining is on — a LAN-reachable availability issue only, with no effect on keys or consensus). The two items below (zstd-safe 6.0.6, crypto-bigint 0.5.5) are unchanged. The miner binary (quantus-miner, bundled since v4.0.0) was audited for the first time: 12 advisories in its shipped closure, all with semver-compatible fixes at the versions the node's lockfile already runs (rustls 0.23.46, rustls-webpki 0.103.16, quinn-proto 0.11.19, quinn-udp 0.5.16); in the app the miner is only a TLS/QUIC client to the user's own node on loopback, and its lockfile is updated before its next build.
Re-checked again on 2026-11-17, after the node rebuild the 2026-11-16 check was gating. The node lockfile now runs quinn-udp 0.5.16 and hickory-net / hickory-proto 0.26.2 (the vendored hickory-resolver 0.26.1 is unchanged and resolves against 0.26.2), and the miner lockfile runs the update set the node's lockfile already had — rustls 0.23.46, rustls-webpki 0.103.16, quinn-proto 0.11.19, quinn-udp 0.5.16 — plus anyhow 1.0.104 and crossbeam-epoch 0.9.20. In the shipped closures the node is down to the two standing items above (zstd-safe 6.0.6, crypto-bigint 0.5.5) and the miner to none; what remains at workspace level in either tree sits in tooling and test graphs that never enter the binaries. The same rebuild binds the node's miner endpoint to loopback (see the accepted items below).
Advisories of the "unsound" class (informational — a safe API that can be misused into undefined behaviour) are present in both shipped closures as well, as of the 2026-11-17 check (RustSec database 02e2517f). For each, no call path in the shipped configuration was found that triggers it:
- Node —
lru0.7.8 (RUSTSEC-2026-0253, use-after-free on a panic inLruCache::pop()): reached only throughtracing-log's interest cache, which never callspop(). - Node —
memmap20.5.10 (RUSTSEC-2026-0186, unchecked offsets in theadvise_range/flush_rangefamily): used byparity-db, whose only range call flushes an in-bounds range of its own map. - Node —
tokio1.47.1 (RUSTSEC-2026-0386,AsyncFdconstructors violate I/O safety): no crate in the node's tree constructs anAsyncFd. - Node —
zstd-safe6.0.6 (RUSTSEC-2026-0395, -0397, -0399, -0400, -0401, -0402, -0404, -0406: dictionary, context-cloning, multithreading, training and buffer-position APIs): the only call site is a plain streaming decode of the chain's runtime blobs (sp-maybe-compressed-blob), which uses none of those APIs. - Miner —
rand0.8.5 and 0.9.2 (RUSTSEC-2026-0097, unsound with a custom logger that draws fromrand::rng()): the miner logs throughenv_logger, which draws no random numbers. - Miner —
tokio1.50.0 (RUSTSEC-2026-0386, as above): no crate in the miner's tree constructs anAsyncFd.
Exposure assessment: the app holds no asset secrets — there is no wallet and no seed phrase to steal; the secrets are identity keys — the node's P2P identity key and, when DePIN activity recording is enabled, the participation identity seed — kept in app-private storage (the seed encrypted at rest), plus, when mining is enabled, the rewards inner hash, a preimage that cannot spend (see the mining note in the boundaries below). Policy: track upstream — apply semver-compatible lockfile security updates as they become available, follow upstream releases for the rest, and re-run this audit on every node binary rebuild.
- No wallet and no seed phrases: there is no asset secret inside the app. The mining inner hash (v4.0.0) is a preimage, not a key — it cannot spend rewards.
- The node's JSON-RPC listens on loopback only and is never exposed to the network; the app polls it locally (v4.2.4: M-1, I-4).
- Besides
127.0.0.1, the node also opens an[::1]endpoint. - When port 9944 is already taken, the node does not fail: it silently rebinds its RPC to a random port. A fixed
127.0.0.1:9944could therefore be another app's. - The app adopts the RPC address and the peer identity from the node's own startup output ("Running JSON-RPC server: addr=…", "Local node identity is: …"), polls only that address, and on every poll round requires
system_localPeerIdto equal that identity before it uses any value. - The DePIN observer and the transfer protocols use the same verified address, from an app-private record; without it they fail closed (no observation is signed, no permit height is read).
- The record is kept only while the node runs, and the reading side enforces this itself (v4.2.4, V4-1). The record names the node process it came from (its pid and its start time), and the DePIN side trusts it only while that process is alive, runs this app's node executable, and was started in the current boot. A record left behind by a node that ended without the app seeing it (a force-stop, a reboot, the app process being killed) therefore fails closed too, even though the peer ID in it is still correct. The app also deletes such a record the next time it starts.
- The peer ID is public, so this is a consistency check rather than authentication: it rules out an app that merely holds the port the app used to poll.
- Besides
- The node starts with mDNS disabled (
--no-mdns, v4.2.4, L-5) and without its Prometheus endpoint (--no-prometheus, v4.2.4, I-8): no UDP 5353 socket announces the node to the local network, and no metrics endpoint listens on127.0.0.1:9615. - Running the node discloses the device's interface addresses to connected peers (L-3, accepted with documentation). The node's identify messages carry every local interface address — the Wi-Fi LAN address, cellular addresses (including a routable IPv6 address) and the address underneath a VPN. A VPN does not mask these from the node's peers.
- The only exported Android component is the launcher activity; the node service is not exported.
- Telemetry is opt-in and off by default: the node starts with
--no-telemetryunless the user explicitly turns telemetry on (v4.2.4: L-4, I-4).- Turning it on makes the node name and status publicly visible; telemetry also discloses the node's peer ID and its authority (mining) flag.
- The display name is passed to the node only while telemetry is on. When it is, connected peers can also see it, in the node's identify string.
- With telemetry off, the node runs under the generic default name (
quantus-android-node), which is all its peers see.
- DePIN activity recording is likewise opt-in and off by default. Checkpoints are signed on the device and stay on the device; a proof bundle leaves the phone only when the user exports and shares the file. The app transmits nothing anywhere for DePIN.
- Price fetch (v4.2.0) is on by default: about once an hour the app fetches the QTC price from CoinGecko (
api.coingecko.com) over HTTPS, to show on the home screen. It can be switched off in the price sheet or in Settings → External information; off means no connection is ever made. A fetch sends no identifiers and nothing about the node; its User-Agent names the app and its version (QuantusNode/<version>), and nothing else identifies the device. As with any HTTPS request, CoinGecko sees the device's IP address. (Corrected in v4.2.4, I-4: this item used to say a fetch sends no app data.) - Mining (v4.0.0) is likewise opt-in and off by default, and needs a user-entered rewards inner hash before it can be switched on. The inner hash is a preimage, not a key: it cannot spend rewards, and by protocol design it becomes public in block headers once blocks are produced. It is kept in app-private settings, is never shown again after saving, and is scrubbed — together with the node's miner auth token — from every log line, screen text and shared diagnostic text. The bundled miner process receives the token and the node's TLS certificate fingerprint as file paths in app-private storage, never on its command line in clear form beyond those paths, and its metrics exporter is disabled in the shipped build.
- The wormhole address the app shows for comparison is the first such report in the node's own output, and none is accepted after the node's miner endpoint has been announced: a later line carrying the marker can be text a peer sent to that endpoint, not the node's own report. The address that actually receives rewards is decided by the node alone, from the launch argument.
- The node identity key is generated on first start and stays in app-private storage; cloud backup is disabled (
allowBackup=false) and data-extraction rules exclude all five data domains (root, files, databases, shared preferences and external storage) from both cloud backup and device-to-device transfer, so a phone migration cannot clone the identity. No user input is involved. It is unrelated to any wallet. - Distribution: signed APKs with SHA-256 checksums published alongside on the Releases page (see Scope notes). Public releases began 2026-11-04.
- The node's miner endpoint listens on loopback only (127.0.0.1, port 9833) in the bundled node build: a small patch (
patches/miner-loopback-patch.diff, docs/BUILD-android.md §3.4) changes the upstream all-interfaces bind, because the only miner this build ever serves is the one bundled in the same app.- A client authenticates to the node with the 256-bit auth token alone; the token is held only in app-private storage and given only to the bundled miner (as a file path).
- The pinned TLS certificate fingerprint works the other way round: it lets the miner authenticate the node before the miner sends its token. It is not a layer a connecting client has to pass. (Corrected in v4.2.4, I-4, here and in the patch's own comment, which said otherwise; the comment change does not change the binary's behaviour.)
- The rewards destination is set by the node's launch arguments and cannot be changed over this endpoint.
- The app starts the miner only after the node's own "Miner server listening" line, and starts none for a node that reports "Failed to start miner server" (v4.2.4, L-7).
- In releases up to v4.2.2 the endpoint listened on all interfaces, with the token and pinning as the boundary, and the mining confirmation in Settings said so.
- Identity-signed transfer messages do not prove which device sent them (design note, I-6). After a handover both devices hold the identity seed, so either one can produce a permit, acknowledgement, abandonment or cancel token, and the notice and receipt MACs are keyed with a confirm secret both sides hold. The transfer protocols' anti-duplication guarantees therefore assume cooperating devices; what protects a handover against third parties is the confidentiality of the package and its transfer code in transit.
- A forged node log line can still pass the log anchoring (v4.2.4, V4-11; the residual of L-2 / I-12): the node writes some peer-supplied text verbatim and does not indent what follows a line break in it, so a peer — or, while mining is on, a local app through the miner port — that reproduces a complete line header can still add to the "Blocks accepted" / "Seals rejected" estimates and move the shared WARN/ERROR counts; the cheap forms (fragments, markers inside other messages) are refused, and the miner's start gate takes only the node's first endpoint report (V4-2). The miner's own log is effectively closed: its logger indents every continuation line. The complete fix, the node escaping what it logs, is kept for the next node rebuild.
- Four small patches on upstream code (all in
patches/): one makes explicit pruning values take effect, one adds a DNS fallback so the node can run as a plain process, one makes the Wasm runtime create instances on demand instead of reserving its whole memory pool up front, and one binds the miner endpoint to loopback. They are a standing maintenance commitment: on every upstream version bump they are re-applied and re-verified before a build ships. - Log-writing granularity: the node's log sink opens/closes the file per line and re-reads to rotate it. It completed a full on-device sync (about 2 hours 21 minutes) with no observed ill effect; this is accepted as a performance item, not a correctness issue.
- Synchronous save on the stop path: uptime is saved with a synchronous commit when the node stops. This is deliberate — preserving the contribution record takes priority over a few milliseconds of latency.
An external source audit of the versionCode 12 tree raised seven findings; six were confirmed and addressed in versionCode 13. A re-audit of the versionCode 13 tree then confirmed the fixes for findings 2, 6 and 7, withdrew the cleartext finding's priority (see the last paragraph), and showed that the versionCode 13 fixes for findings 3, 4 and 5 left residual races. Those are addressed in versionCode 14, and the status below is the versionCode 14 state. On-device race-reproduction tests have not been performed: the race items are closed by construction and code review, not by reproduction, and this section does not claim otherwise. An internal desk check of the versionCode 14 tree afterwards found one further race of the same family — a START delivered during a finish could be consumed as a duplicate and leave a node-less foreground service (sequence B) — which is fixed in versionCode 15 by re-validating the start under the lifecycle lock; the on-device race-reproduction status stated above is unchanged.
- Finding 2 (node key could travel to a new device):
allowBackup=falsedoes not govern device-to-device transfer on Android 12+. Data-extraction rules exclude all five data domains — root, file, database, shared preferences and external — from both cloud backup and device transfer. - Finding 3 (stop could tear down a newer session): versionCode 13 ended the service with
stopSelfResult()on a startId recorded per session, but the value was re-read from a shared field outside the lifecycle lock at stop time, a duplicate START never refreshed it (so a natural exit could leave a node-less service lingering), and the stop sequence was not atomic with the generation check. In versionCode 14 the stop startId is bound to its session and managed under the lifecycle lock — set when the session is created, refreshed by duplicate STARTs while it is live and by a STOP command — and a finish performs the generation re-check, the startId read,stopSelfResult(), and (on acceptance)stopForeground()plus the notification cancel as one locked unit, so a START cannot interleave between the check and the act. - Finding 4 (database lock race across service instances): the previous F-2 wait only covered a process the same service instance still referenced. Each spawned child's pid is recorded in filesDir; a later instance waits up to 5 s for a verified leftover (checked via
/proc/<pid>/cmdline, never killed) and otherwise fails the launch with the reason recorded, instead of racing it for ParityDB's exclusive lock. In versionCode 14 the pid-file operations are indivisible under a process-wide lock that launch() holds across the whole wait → spawn → record sequence, and the record's check-and-clear runs under the same lock, so a late cleanup cannot erase a newer process's pid. If the pid record itself cannot be written, the launch still proceeds — the process remains tracked in-process through itsProcesshandle — and the failure is recorded in the app log and in the launch attempt's evidence; in that case cross-instance tracking degrades rather than being guaranteed. On runtimes whereProcess.pid()itself throws (observed on the target device class, where versionCode 17 confirmed the pid could not be obtained that way), versionCode 18 recovers the child pid by scanning /proc for this process's children whose cmdline names the node binary, and records that pid instead; if the scan also fails, the launch proceeds with cross-instance tracking degraded, as before. - Finding 5 (stale notification after stop): in versionCode 14 the poller's notification update performs its generation/state check and the
notify()call itself under the same lifecycle lock the stop paths hold while cancelling the notification, so a passed check can no longer be followed by a stop settling in between and the post landing afterwards. The stop paths also cancel the status notification when they end the service. - Finding 6 (unbounded local RPC reads): RPC responses are capped at 64 KiB and redirects are no longer followed away from the loopback endpoint. (Confirmed fixed by the re-audit.)
- Finding 7 (quick-exit window could be masked): the failed-start lifetime is measured from the actual process spawn, excluding the wait for a previous process, so a quick failed start reliably triggers the one linker64 retry. The spawn timestamp is a per-attempt value handed back by the launch, not a shared field. (Main fix confirmed by the re-audit.)
- Process-reference ownership (third audit, of the versionCode 15 tree): the third audit confirmed the versionCode 14 fixes for findings 3 and 5 and the versionCode 15 sequence-B fix. One residual race of the same family remained, in the ownership of the shared node-process reference: the worker stored its process there unconditionally after launch() returned (and unconditionally nulled it after a staleness re-check), and the exit path cleared it with an identity check that was not atomic with the assignment — so a stale worker could overwrite a newer session's reference, or pass the identity check, watch a newer process register, and then null the newer reference, leaving a live node unpollable and unstoppable. In versionCode 16 registration is a lifecycle-lock decision: the process is stored only if, inside the lock, its session is still the live one (started, current generation); a process that is not accepted never joins the session — it is destroyed and its pid record removed. The exit-path check-and-clear runs indivisibly under the same lock, and the pid-file clear stays under the pid lock, in a separate, never-nested scope. The on-device race-reproduction status stated above is unchanged for this item as well.
One finding was reviewed and deliberately not acted on at the time: the suggestion to add a network security configuration for the loopback RPC's cleartext HTTP. The reasoning recorded then — that the platform's default network security policy permits cleartext traffic to loopback destinations — was wrong, as a later re-examination against primary sources established (see the 2026-11-06 audit record below): for targetSdk 28 and above the default policy denies cleartext with no loopback exception, and an implicit localhost permission only exists from Android 17 (API 37). What remains true is the observation: the app's RPC polling over http://127.0.0.1:9944/ has been observed working on the target device class (GrapheneOS, API 36) in every build since versionCode 1 — an execution-layer behaviour the policy layer does not guarantee, not verified for the stock implementations of API 31–35 within the supported range. Corrected in versionCode 25: the app now ships a network security configuration that denies cleartext in its base configuration and permits it for exactly two loopback destinations (127.0.0.1 and localhost), so the polling the UI depends on is permitted by policy on every supported version, and nothing else is.
- 2026-11-03: a security audit (supply chain, dependency advisories, secret handling) confirmed that no secret value appears in the repository, its history, or the shipped APK.
- 2026-11-04: a full-source bug audit of the app, plus an extended audit covering the Rust patches, the provenance of the shipped node binary, the build pipeline and documentation consistency. None of the audits produced a finding of high severity. The confirmed findings were fixed in versionCode 8 and versionCode 9.
- 2026-11-04: a third-party-style double-check of the public repository, followed by a dependency re-audit against the current RustSec database (see "Dependency advisories" above). The double-check found no high-severity issue; the dependency re-audit's fixes shipped in versionCode 10, and its corrections to this file's earlier dependency wording are included above.
- 2026-11-04: an external audit (ChatGPT) of the versionCode 12 source tree. Of its seven findings, six were confirmed and fixed in versionCode 13; one (cleartext configuration for the loopback RPC) was reviewed and deliberately not acted on. See "External audit — 2026-11-04 (ChatGPT)" above.
- 2026-11-04: a re-audit (ChatGPT) of the versionCode 13 source tree. It confirmed the fixes for findings 2, 6 and 7 and withdrew the cleartext finding's priority for the verified device class; it found residual races in the versionCode 13 fixes for findings 3, 4 and 5, addressed in versionCode 14. On-device race-reproduction tests have not been performed.
- 2026-11-04: a third external audit (ChatGPT) of the versionCode 15 source tree. It confirmed the versionCode 14 fixes for findings 3 and 5 and the versionCode 15 sequence-B fix; it found one residual race in the ownership of the node process reference, addressed in versionCode 16. On-device race-reproduction tests have not been performed.
- 2026-11-05: a full-source audit of the versionCode 20 tree (the shipped v0.1.0). No finding above low severity; of the ten low findings, eight were fixed in versionCode 21 (v0.1.1) and two were left as documented design (per-second UI text updates; the synchronous track-record save).
- 2026-11-05: an external audit (ChatGPT) of the v0.1.1 tree, delivered in two rounds — eleven findings in total (four medium, seven low), each re-verified against the code before fixing; all eleven were fixed in versionCode 22 (v0.1.2). Two details of the audit were corrected during verification:
InputStream.readAllBytes()was added in API 33 (not 34), so its reach was Android 12/12L only; and the reported Gradle compile block onProcess.pid()did not reproduce (the SDK stub declares it) — the call was still made reflective, becausepid()appears in no level of the official API database and the target runtime throwsNoSuchMethodErrorfor it. - 2026-11-05: a full-section audit of the versionCode 22 tree (thirteen sections, including build, documentation and repository hygiene). No critical or high findings; three medium (a residual hole in the versionCode 22 cancelled-start fix, and two version-staleness items in the shipped UI text and the usage guides) and seventeen low. The mediums and the consequential lows were fixed in versionCode 23 (v0.1.3); two lows were deferred and are named in the changelog. On-device reproduction tests have not been performed for the race items in this entry either.
- 2026-11-05: a full-section audit of the versionCode 23 tree (the shipped v0.1.3), comparable in scope to the thirteen sections of the versionCode 22 audit and including a rebuild comparison. No critical, high or medium findings; three new low findings and two carried-over items, all of them addressed in versionCode 24 (v0.1.4) with nothing deferred. The rebuild reproduced the published v0.1.3 APK byte-for-byte across all 33 entries. On-device reproduction tests have not been performed for the race item in this entry either.
- 2026-11-06: three external audits of the v0.1.4 tree (the first audit, a re-audit and an additional audit round), each finding re-verified against the code and, for the cleartext item, against primary platform sources. No critical or high findings. Five mediums and six lows stood after verification, and all eleven are addressed in versionCode 25 (v0.1.5) with nothing deferred. Two earlier judgements were corrected in the process: the cleartext finding of 2026-11-04 (dismissed then on a premise about the platform default that primary sources do not support — see the corrected paragraph above) is now fixed by an explicit loopback-only network security configuration; and the "sync complete" misjudgement (first raised as a low) was re-rated medium after verification showed it persists for as long as a partial RPC failure does. The additional round reproduced two items by executing the real code on a JVM harness (the consumed orphan-recovery right, and an out-of-memory in the log drain on a 64 MiB newline-free line); the fixes are verified the same way. On-device reproduction tests have not been performed for the race items in this entry either.
- 2026-11-06: a further re-audit of the versionCode 25 tree, run against the repository at the versionCode 25 commit. It confirmed seven of the eleven fixes closed and returned eight low-severity residuals — four partial closures (the sync-evidence adoption coerced malformed JSON heights; the RPC deadline did not cover the header wait; a stop landing during the spawn-marker write could still spawn; parallel manual builds could pair one run's APK with another's .idsig) and four new observations (the in-flight RPC reference was neither atomic nor generation-checked; the orphan kill was not re-verified after the gate's last file I/O; the log drain's truncation flag no longer reached the sinks; a multi-orphan recovery settled its evidence after the first orphan). Each residual was re-verified against the code — all eight stood, all low — and all eight are fixed in versionCode 25 before its release, with nothing deferred. The fixes are verified on the JVM harness (1107 checks, including the shipped height validation and log encoding executed directly) and, for the build-script item, by a lock-contention test and parallel builds. On-device reproduction tests have not been performed for the race items in this entry either.
- 2026-11-06: a full-section audit of the versionCode 26 tree (v0.2.0, the UI redesign build). No critical, high or medium findings; seven low findings, all addressed in versionCode 26 before release. A diff against the versionCode 25 tree confirmed that the service-side additions are display-only (the stop classification and the observation record) and that the previously audited lifecycle code is unchanged.
- 2026-11-06: an external audit of the v0.2.0 tree (versionCode 26). No critical or high findings. Two findings stood after re-verification against the code: one medium — a spawned node whose pid record could not be written could be lost to a service destroyed and recreated within the same app process, because the surviving spawn-intent marker is only acted on when it names a foreign incarnation, so a restart could spawn a second node onto the same database and RPC port — and one low: the display-name editor and the launch applied different normalizations (their steps ran in a different order), so the confirmed name and the launched name could differ. Both are fixed in versionCode 27 (v0.2.1): spawned children are additionally tracked in a process-wide registry that the leftover wait consults before the pid file and the marker, and a single normalization is shared by the editor, the stored value and the launch, with the 64-code-point limit checked against the normalized result. The fixes are verified on the JVM harness (4,550 checks passed, 0 failed). On-device reproduction tests have not been performed for the race item in this entry either.
- 2026-11-10 – 2026-11-11: a three-round final check of the DePIN integration tree (versionCodes 53–57 during the rounds). Round 1: no critical findings; two high, seven medium and sixteen low. Round 2: no critical; one high — a journal-cache defect that could truncate participation history after an identity migration — three medium and nine low. Round 3: no critical or high; two medium and eleven low, plus a staging path, found on a final read, that wrote a transferred identity seed to disk in plaintext. Every finding of every round was re-verified against the code before fixing (no finding was dismissed), and all are fixed in versionCode 58 (v3.0), together with the remaining migration-recovery items and the companion app's share of the journal fix. The plaintext staging path was removed outright (imports now decrypt in memory only). The fixes are covered by the project's JVM suites (312 base checks, 368 migration checks, 197 vision-logic checks, 329 strings × 9 languages — all passing) and by an on-device run of versionCode 58 (in-place update over versionCode 57; the participation chain verified end to end at 364 checkpoints).
- 2026-11-11 – 2026-11-12: a fourth external audit round of the shipped v3.0 tree (versionCode 58), run together with an internal review of the same code. The round also read areas the earlier rounds had not covered, including the transfer receiver and sender internals. No critical findings in the node app. Every finding was re-verified against the code before fixing (no finding was dismissed), and all verified findings are fixed in versionCode 62 (v3.0.1) — among them: a pending recording-off intent could be missed while the recording process was connecting, leaving recording running while the display showed it off; a journal filled to exactly the checkpoint maximum could no longer be exported; exporting a proof bundle after the home identity had been sent out and erased could create a fresh home seed as a side effect; temporary vault files could retain a copy of an erased seed; and a keystore-caused decryption failure was misclassified as a corrupted transfer code. One display item that needs new UI strings in all nine languages was deliberately left for a later release. The fixes are covered by the project's JVM suites (330 base checks, 393 migration checks, 206 vision-logic checks, 329 strings × 9 languages — all passing) and by an on-device run of versionCode 62 (the participation chain verified end to end at 389 checkpoints).