v0.2.2

Quantus Node v0.2.2 (versionCode 28)

A diagnostic update: the shared log now explains the phone it came from. The node launch arguments, the database and the bundled node binary are unchanged (still the versionCode 10 build). One permission is added: ACCESS_NETWORK_STATE (a normal, read-only permission), used only for the network-change stamps below.

Highlights

• A summary block heads every shared log. App and device (app version, Android version and API level, device model and maker, chain, install and update times), the state at share time (status, session uptime, best / highest / peer counts, when the last RPC response arrived, telemetry on or off — the running session's launched value, or the saved setting, marked as such, when stopped), device resources (node data size, free storage, battery level and temperature, free memory, battery-optimization exemption, notification permission), session history (how the previous session ended and its exit code — kept across a restart, so it survives into the next session —, starts in the last 24 hours, the cumulative track record, when each setting last changed) and facts about the log itself (the shared excerpt's time range, whether it was truncated, WARN / ERROR line counts). Labels are fixed English; a value the app cannot know is printed as "n/a", never guessed — the finalized height, the bundled binary's own version and the genesis hash are the standing examples. The block sits outside the excerpt's existing 100,000-character cap.
• Network changes are stamped into the log. When the default network's type changes (wifi / cellular / none / other), the service writes an "[app] network: …" line, so a peer drop in a shared log can be read against the connection it rode on. This is what ACCESS_NETWORK_STATE is for; the stamps stay in the on-device log and nothing is transmitted.
• Sharing can mask identifying values, on by default. The share dialog gains a toggle (on unless the user turns it off): the display name — both the running session's launched name and the current setting's —, the IP addresses of this device's current network interfaces and the app-private paths are replaced in the shared log text, as whole tokens only (a peer's similar address, e.g. 10.0.0.10 next to this device's 10.0.0.1, is left untouched), so a log pasted into a public issue keeps its diagnostic structure without them. The summary block carries none of those values either way. If the device's addresses cannot be enumerated, masking stays on for that share.

Verification

The changes are verified on the JVM harness: 4,696 checks passed, 0 failed. On a real device (Pixel 9a / GrapheneOS), an in-place update over v0.2.1 was installed, and an actual share confirmed the summary block and the masking — the display name, this device's own IP address and the app-private paths masked, with the diagnostic structure intact.

Requirements

Android 12 or later, arm64 device.

APK

• File: quantus-node-v0.2.2.apk
• Size: 55,733,030 bytes
• SHA-256: e1b8fef1f4cde966b5bfe40fdc135c380fd6d555d82d96d06dc5d685ad72b701

v0.2.1

Quantus Node v0.2.1 (versionCode 27)

A maintenance release that fixes the two verified findings of an external audit of v0.2.0 — one medium, one low. No changes to the node launch arguments, the database, the permissions, the UI, or the bundled node binary (still the versionCode 10 build).

Fixes

• A node process can no longer be lost inside the app process (medium). When the on-disk pid record for a freshly spawned node could not be written, the spawn-intent marker was the only trace of the child; a service destroyed and recreated within the same app process then held neither the process object nor a usable record, and a restart could spawn a second node onto the same database and RPC port while the first was still exiting. Spawned children are now also tracked in a process-wide registry: the launch registers the child before the pid record is attempted, the worker unregisters it when it observes the exit, and the leftover wait consults the registry before the pid file and the marker — so the child is found by object, waited on as before, and never spawned over. A failed pid record still does not fail the launch, and the cross-process recovery (pid record, marker, orphan scan) is unchanged.
• The display name the user confirms is the name the node receives (low). The editor validated and previewed one normalization of the name while the launch applied another whose steps ran in a different order (the length cap before the leading-dash strip), so for inputs such as "--" followed by 64 letters, the confirmed name and the launched name differed. There is now a single normalization, in the editor's order; the editor stores the normalized value, the 64-code-point limit is checked against the normalized result (over the limit is still refused, never truncated), and the launch applies no second transformation of its own.

Verification

The fixes are verified on the JVM harness: 4,550 checks passed, 0 failed. On-device reproduction of the pid-record-failure sequence has not been performed; as with the earlier lifecycle fixes, that item is closed by construction and code review.

Requirements

Android 12 or later, arm64 device.

APK

• File: quantus-node-v0.2.1.apk
• Size: 55,733,030 bytes
• SHA-256: 9f1ce2da422a11d2355572ffa113e18bf02bb18a6b8f743d1c28bea96e6db46c

v0.2.0

A full UI redesign release.

Highlights

• Reorganized into four screens: Home / Node details / Track record / Settings (no more cards)
• Node state is now shown distinctly as Stopped / Starting / Syncing / Synced / Failed. When startup fails, the reason and a retry action are shown
• Redesigned the pulse: a ripple appears when a new block is observed while synced
• Colors now follow the official Quantus palette (background #0E0E0E, accent #FF6B35, synced #4ADE80)
• Display name is edited in a dialog, validated to at most 64 characters after sanitization
• Language changes apply immediately on selection, and quantity expressions follow each language's plural rules
• Removed the Quantum Watch
• Fixed translations rendering as "?" in some languages

Verification

• Fully audited before release, with no findings of medium severity or above (all 7 low findings were addressed)
• Verified on a real device (Pixel 9a + GrapheneOS)

APK

• File: quantus-node-v0.2.0.apk
• Size: 55,733,030 bytes
• SHA-256: ec13212cf4e4a6e9597b7779591966e094eff30fc12454030a08535442e218ee

v0.1.5

v0.1.5 — hardening release

A maintenance release focused on reliability and safety. Eleven verified issues found in external review of v0.1.4 — five medium and six low severity — are fixed, with nothing deferred. A follow-up review of this tree raised eight further low-severity points, which were also fixed and verified before publication.

Highlights:

• Cleartext loopback RPC is now permitted by an explicit, narrow network security configuration (127.0.0.1 and localhost only; cleartext denied everywhere else). The earlier working assumption — that the platform permits loopback cleartext by default — is not supported by primary sources for API levels below 37; see SECURITY.md for the correction.
• Orphan node recovery is licensed by provenance (incarnation-stamped pid records) instead of a consumable first-session flag, and an interrupted spawn leaves a marker so a later process can find and recover the orphan.
• Stop now escalates for the session's own child: destroy, bounded wait, then destroyForcibly.
• "Sync complete" requires evidence: a valid system_syncState response in the same session.
• Node log reading is chunk-bounded (no unbounded line accumulation), RPC calls have an overall deadline and are disconnected on stop, and build outputs are isolated per run.

No changes to the node launch arguments, the database, the permissions (still four), or the bundled node binary (still the versionCode 10 build).

APK: quantus-node-v0.1.5.apk, 55,700,262 bytes
SHA-256: 22ab1fe1faa9e07598a3b13f24dd7a299c8bef403af655239a7fe25029e9ec2e
Signed with the release certificate used since v0.1.0. An in-place update over v0.1.4 was confirmed on the reference device, with existing node data preserved.

Pre-release verification: 1,107 JVM harness checks passing, API-surface scan clean for minSdk 31, string keys consistent across all 9 languages, entry-level reproducible build comparison, and a full-repository consistency check with no corrections required.

v0.1.4

v0.1.4 — maintenance update

A maintenance release for the Android full node. It fixes all five findings of the full-section audit of v0.1.3 (three new lows and two carried-over items; no critical, high or medium issues, and nothing deferred this time). No changes to the node's launch arguments, the database format, or the app's permissions: it installs over v0.1.3 and keeps your settings and synced data — verified on the reference device, where the node resumed at the chain tip after the update without re-syncing and a stop → immediate start worked cleanly.

What's fixed

• The orphan recovery can no longer misfire across sessions — the v0.1.3 orphan-termination gate judged by a captured flag and the current pid record, without re-checking that the deciding worker still belonged to the current session. A stale worker from a destroyed service instance, resuming late, could have mistaken a newer session's healthy node for an orphan and terminated it. The kill decision now re-validates, immediately before acting, that the worker's generation is still the current one; any doubt falls back to the previous wait-and-refuse behaviour. (One part of the new check — re-reading the pid record — is deliberately redundant: pid-file changes are serialized by the pid lock, so it restates an invariant as defence in depth. The generation check is the one that closes the audited sequence. Both are documented in the code and the changelog.)
• RPC judgement is now uniform for missing fields — a missing isSyncing was decided as false outright, and a non-numeric peers value collapsed to a real 0 over the retained count. Both now follow the same rule as every other field since v0.1.2: an absent or unusable value means "not said", and the judgement uses the retained values.
• The translation table is verified, not just written — docs/I18N.md's generated table still carried v0.1.1 in its footer row while the app itself already showed the newer version. The table has been regenerated from the compiled string table (the only stale cells were that row) and the project's release checklist now verifies the current version in the footers and a zero-diff regeneration of the whole table, so staleness of any age is caught mechanically. This release's own version bump was run through that strengthened check.
• Repository hygiene — the Gradle staging directory for the native libraries (src/main/jniLibs/) is now git-ignored, closing the chance of a stray 53 MB binary being committed by accident (this item had been carried over without being counted in earlier deferral lists; the accounting is now explicit).
• Documentation accuracy — the app README's settings section described "two user settings"; it now documents all four (telemetry, display name, language, and the settings lock).

Verification

• JVM checks: 951 assertions, zero failures — string-table completeness and placeholders (49 keys × 9 languages, all footers at v0.1.4), the regenerated I18N table compared cell-by-cell (490 comparisons, zero mismatches), the sanitizing regression suite, the orphan-gate predicate truth table, and the RPC judgement expressions over the audit's scenarios (including reproductions of the old behaviour).
• API-surface re-check against the official API database: no reference beyond API 31; sensitivity controls confirmed (a deliberate readAllBytes use is flagged, Process.pid() surfaces as unresolved).
• Desk check: the audit's cross-instance sequence (stale worker resuming late) traced through the new code — the gate now stands down — and the genuine orphan case still recovers as before.
• Byte-level comparison with the v0.1.3 APK: only classes.dex, the version in AndroidManifest.xml, and the signature files differ — the node binary, the CA bundle and all resources are byte-identical.
• On device (Pixel 9a, GrapheneOS): updated in place over v0.1.3, resumed at the tip, steady state; stop → immediate start confirmed working.
• Honest notes: the cross-instance race is verified by code tracing and predicate exercises, not reproduced on a device; a full Gradle build remains not runnable in the maintainer's build environment, so Gradle compilation itself is still unverified.

Requirements

• Android 12 or newer, arm64 device
• Verified on: Pixel 9a + GrapheneOS. Other devices are expected to work, but vendor power management may stop the background service
• About 3 GB of free storage (measured after a full sync: 1.30 GB total)
• Wi-Fi recommended for the first sync (about 2–3 hours; battery went from 71% to 27% in our first-sync test, including time on mobile data)

Install

1. Download quantus-node-v0.1.4.apk from the assets below.
2. Install it (you may need to allow installs from your browser/file manager). If v0.1.3 is installed, install over it — do not uninstall first, or your synced data will be lost.
3. Open the app, tap Start, and keep it charging on Wi-Fi for the first sync.
4. Optional: set a node name and turn telemetry on in Settings if you want to appear on the public telemetry list.

See the repository's Usage Guide for details and troubleshooting.

Checksum (SHA-256)

f662112bc213b0ae5f9be724b5421badf39730652381ca0ae3dc22e8b1ec74b2 — quantus-node-v0.1.4.apk (55,700,181 bytes)

v0.1.3

v0.1.3 — maintenance update

A maintenance release for the Android full node. It fixes the findings of a full-section audit of v0.1.2 (thirteen sections; no critical- or high-severity issues — three medium and seventeen low, of which the three mediums and the consequential lows are fixed here, and two lows are deferred and named below). No changes to the node's launch arguments, the database format, or the app's permissions: it installs over v0.1.2 and keeps your settings and synced data — verified on the reference device, where the node resumed at the chain tip after the update without re-syncing, a stop → immediate start worked cleanly, and the in-app footer now shows the real version.

What's fixed

• The cancelled-start fix from v0.1.2 is now complete — the bounded wait for a destroyed child reported an outcome the teardown never checked, so the pid record was cleared even when the child had outlived the 5-second bound, reopening exactly the double-start the wait was meant to close. The record is now cleared only when the exit is confirmed; otherwise it stays, and a later launch waits on the process through the usual leftover path. (Verified on the JVM with real processes, including a child that ignores SIGTERM.)
• An orphaned node can no longer block starting forever — if the app process died while its node child survived, every later start refused for as long as the orphan lived. When the launching session is provably the first one of this process (so the leftover has no living owner) and the recorded pid still strictly names this app's own node executable, the orphan is terminated and startup proceeds. Any doubt falls back to the previous wait-and-refuse behaviour.
• A new session starts from unknown values — best/highest/peers were retained across sessions, so a new session's first judgement could call it synced on the old session's numbers, and its starting screen and first notification showed stale values. They are now reset at session establishment.
• Missing RPC fields no longer overwrite known values — a health response without "peers" wrote a real 0 over the retained count, and a sync response without "currentBlock" flipped a synced node back to syncing. An absent field now means "not said", following the same principle as the highestBlock fix in v0.1.2.
• Display-name sanitizing covers the directional marks — U+200E, U+200F and U+061C joined the stripped set, along with the word joiner, the deprecated invisible operators and the soft hyphen. The zero-width non-joiner and joiner are still kept: they carry meaning in Arabic-script and Indic names.
• Sharing the log is bounded and coordinated — the share read used to load the whole file outside the writers' lock, so a rotation mid-read could hand over a partial log that looked complete, and the tail cut could split a character. It now reads a bounded tail under the writers' own lock, starts at a line boundary, and never splits a pair. What is shared is unchanged: the last 100,000 characters.
• Log rotation is atomic — the retained tail is written to a temp file and renamed over the log, instead of truncate-and-rewrite in place, which lost the whole retained half if the process died mid-rotation.
• Settings reads survive a damaged preferences file — a stored value of the wrong type crashed the UI with a ClassCastException (only reachable if the preferences file is damaged outside the app). Reads now fall back to defaults, and a failed synchronous uptime save is retried asynchronously.
• The in-app footer shows the real version again — v0.1.2 shipped with "v0.1.1" in the footer of all nine languages, the same staleness class an earlier release had already fixed once. All nine footers now read v0.1.3, and the project's release checklist names the footer as a version-bump item with a mechanical check.
• The usage guides describe the present again — all nine USAGE files still described the v0.1.0 state (how to obtain the APK, telemetry listing as unverified). They now state the current release, point at GitHub Releases, and record the verified telemetry listing. Their measured figures were audited and are unchanged. SECURITY.md's status and audit record and the app README's figures were likewise brought current.
• Build hygiene — the manual build now verifies the signed APK before placing it at the release path (a failed verification fails the build), and the stale-APK set-aside now happens before every preflight exit, closing the last gap of the v0.1.2 fix.
• Deferred, deliberately — two lows were left for later and are recorded in the CHANGELOG: a cosmetic log-line confusion when a leftover refusal also triggers the linker retry, and an unoptimized per-second text refresh in the UI (its visible harm was already suppressed by the scroll fix).

Verification

• The audit was run in three parallel passes over all thirteen sections; its two most consequential claims were independently re-read in the code before this release was cut.
• JVM checks (55 + 13 cases): the name-sanitizing suite with the new invisible characters (and the kept ZWNJ/ZWJ regression cases), the bounded exit wait's both branches against real processes, log rotation including the atomic rewrite, the bounded share read (line boundaries, surrogate safety), the status-judgement expressions over the audit's scenarios, translation tables (49 keys × 9 languages, all footers at v0.1.3), and an API-surface re-check (no reference beyond API 31).
• Negative tests: an invalid build-mode setting now still sets the previous APK aside before failing; the post-signing verification step passes on real builds.
• Byte-level comparison with the v0.1.2 APK: only classes.dex, the version in AndroidManifest.xml (exactly two bytes), and the signature files differ — the node binary, the CA bundle and all resources are byte-identical.
• On device (Pixel 9a, GrapheneOS): updated in place over v0.1.2, resumed at the tip, steady state; footer shows v0.1.3; stop → immediate start confirmed working.
• Honest notes: the orphan-recovery kill path and the race sequences are verified by code tracing and JVM exercises, not reproduced on a device; a full Gradle build remains not runnable in the maintainer's build environment, so Gradle compilation itself is still unverified.

Requirements

• Android 12 or newer, arm64 device
• Verified on: Pixel 9a + GrapheneOS. Other devices are expected to work, but vendor power management may stop the background service
• About 3 GB of free storage (measured after a full sync: 1.30 GB total)
• Wi-Fi recommended for the first sync (about 2–3 hours; battery went from 71% to 27% in our first-sync test, including time on mobile data)

Install

1. Download quantus-node-v0.1.3.apk from the assets below.
2. Install it (you may need to allow installs from your browser/file manager). If v0.1.2 is installed, install over it — do not uninstall first, or your synced data will be lost.
3. Open the app, tap Start, and keep it charging on Wi-Fi for the first sync.
4. Optional: set a node name and turn telemetry on in Settings if you want to appear on the public telemetry list.

See the repository's Usage Guide for details and troubleshooting.

Checksum (SHA-256)

dff1df99e5fa75f253477dcae1e46c04a2cf2672c4411c88b8207cdf639680e0 — quantus-node-v0.1.3.apk (55,700,181 bytes)

v0.1.2

v0.1.2 — maintenance update

A maintenance release for the Android full node. It fixes all eleven findings of an external audit of v0.1.1 (conducted with ChatGPT, delivered in two rounds, each finding verified against the code before fixing; no critical- or high-severity issues). No changes to the node's launch arguments, the database format, or the app's permissions: it installs over v0.1.1 and keeps your settings and synced data — verified on the reference device, where the node resumed at the chain tip after the update without re-syncing, and a stop → immediate start right after launch worked cleanly.

What's fixed

• A cancelled start can no longer collide with the next start — if a stop arrived while the node was still starting, the cancelled child was destroyed but its pid record was cleared before it had actually exited, so a quick stop → start could overlap the still-closing old node and the new node died on the old one's database lock. The teardown now waits for the child to exit (up to 5 s) before clearing the record. (The audit reproduced the lock failure with a real child process.)
• Android 12/12L compatibility restored — four places used InputStream.readAllBytes(), which only exists from API 33; on API 31–32 devices the call escapes as a NoSuchMethodError — including in the pid-file read that runs at every node start. All four now use a plain read loop. Not verified on a real API 31–32 device (none available to us); behaviour on newer versions is unchanged.
• A hostile RPC response can no longer kill the status poller — the recursive JSON parser overflows the stack on a deeply nested response body, and that Error escaped every catch, silently killing the polling thread while the node kept running. A failed parse is now treated like any failed call. (Reproduced against the AOSP JSON implementation, not on a device.)
• "Synced" is no longer shown when it isn't — if system_syncState answered without a highest block, the status flipped to SYNCED mid-sync by definition. It is now judged against the last known highest block.
• The status notification unsticks itself — the de-duplication key survived across sessions, so a new session could stay showing "starting" in the notification shade. The key is now reset when a session is established.
• Log rotation accounts for the existing log — the rotation counter restarted at zero for every service instance, so a log written by many short sessions could grow past its 512 KB cap unchecked. It is now seeded with the existing file's length.
• Start-failure capture caps line length — captured lines are truncated at 8192 characters (the file log already capped lines separately).
• Display-name edge case — a name like - --help could survive sanitizing and again start with - after trimming; values hiding dashes behind whitespace now fall back to the default name.
• Build hygiene — Gradle builds now include the bundled CA list (cacert.pem); the manual build now sets the previous APK aside before every preflight check, so a failed build can never leave a stale file at the release path; and Process.pid() is now probed reflectively (see Verification for the honest detail).

Verification

• Every audit finding was re-checked against the actual code before fixing; two details of the audit report itself were corrected along the way (readAllBytes is API 33, not 34; and the reported Gradle compile block on Process.pid() could not be reproduced — the SDK stub does contain it. What stands: pid() appears in no level of the official API database and the target runtime throws NoSuchMethodError for it, so the call is now reflective, with identical behaviour).
• API-surface check: all 345 external references of the compiled classes were resolved against the official API database — nothing outside the API ≤ 31 surface; the same check run on v0.1.1 flags exactly the two items above.
• JVM checks: translation tables (49 keys × 9 languages), the name-sanitizing suite including the new edge cases, the log-rotation fix against a pre-grown 614,400-byte log, the bounded child-exit wait against real processes, and the lifecycle desk check including the new stop → start interplay.
• Byte-level comparison with the v0.1.1 APK: only classes.dex, the version in AndroidManifest.xml, and the signature files differ — the node binary, the CA bundle and all resources are byte-identical.
• On device (Pixel 9a, GrapheneOS): updated in place over v0.1.1, resumed at the tip, steady state; stop → immediate start after launch confirmed working.
• Honest notes: a full Gradle build is still not runnable in the maintainer's build environment (the Gradle daemon does not start there), so Gradle compilation itself remains unverified; the lifecycle races are verified by code tracing and JVM exercises, not reproduced on a device.

Requirements

• Android 12 or newer, arm64 device
• Verified on: Pixel 9a + GrapheneOS. Other devices are expected to work, but vendor power management may stop the background service
• About 3 GB of free storage (measured after a full sync: 1.30 GB total)
• Wi-Fi recommended for the first sync (about 2–3 hours; battery went from 71% to 27% in our first-sync test, including time on mobile data)

Install

1. Download quantus-node-v0.1.2.apk from the assets below.
2. Install it (you may need to allow installs from your browser/file manager). If v0.1.1 is installed, install over it — do not uninstall first, or your synced data will be lost.
3. Open the app, tap Start, and keep it charging on Wi-Fi for the first sync.
4. Optional: set a node name and turn telemetry on in Settings if you want to appear on the public telemetry list.

See the repository's Usage Guide for details and troubleshooting.

Checksum (SHA-256)

7c196901d0160a6035bf931eb8bc69fbbf13e4ea17c9510e2891be7ac0548b7f — quantus-node-v0.1.2.apk (55,700,181 bytes)

v0.1.1 — maintenance update

v0.1.1 — maintenance update

A small maintenance release for the Android full node. It fixes the low-severity findings of a full source audit of v0.1.0 (no high- or medium-severity issues were found). No changes to the node's launch arguments, the database format, or the app's permissions: it installs over v0.1.0 and keeps your settings and synced data — verified on the reference device, where the node resumed at the chain tip after the update without re-syncing.

What's fixed

• Leftover-process check tightened — the "is an old node still running?" check now uses the same strict match as the process scan (libquantus_node.so), removing a rare false-positive that could block starting (PID reuse combined with an unrelated process name).
• Interrupted workers now shut down cleanly — if the node-waiting thread is ever interrupted, the session now goes through the same generation-checked stop path as a normal exit instead of returning early.
• Display-name hardening — bidirectional text controls, U+FEFF and zero-width spaces are stripped from node names (ZWNJ/ZWJ are kept: legitimate in Arabic-script and Indic names), and the 64-character limit now counts Unicode code points, so emoji can no longer be split into broken characters. The stored raw name is also capped at 256 characters.
• CA bundle freshness by content — the bundled Mozilla CA list is now re-copied when its contents differ, not only when its length changes.
• Start-failure evidence is more complete — the per-attempt output capture now waits up to 3 s, so the node's final lines (often the failure reason) are not cut off.
• Two unused translation keys removed (49 keys × 9 languages, machine-verified again), a stale code comment corrected, and the in-app footer now shows the real version (v0.1.1) instead of the old "v0.1-mvp" label.

Verification

• Full source audit of v0.1.0 before fixing: findings were low-severity only; the race fixes of earlier builds were re-read and confirmed closed.
• JVM checks: translation tables (49 keys × 9 languages, all format strings executed), name-sanitizing suite 21/21 cases.
• Lifecycle desk check: 9 sequences traced through the code (the previous 8 plus the new interrupt case).
• Byte-level comparison with the v0.1.0 APK: only classes.dex, the version in AndroidManifest.xml, and the signature files differ — the node binary, the CA bundle and all resources are byte-identical.
• On device (Pixel 9a, GrapheneOS): updated in place over v0.1.0, settings carried over, node resumed at the tip and ran in steady state.
• Honest note: the race and interrupt sequences are verified by code tracing, not reproduced on a device.

Requirements

• Android 12 or newer, arm64 device
• Verified on: Pixel 9a + GrapheneOS. Other devices are expected to work, but vendor power management may stop the background service
• About 3 GB of free storage (measured after a full sync: 1.30 GB total)
• Wi-Fi recommended for the first sync (about 2–3 hours; battery went from 71% to 27% in our first-sync test, including time on mobile data)

Install

Download quantus-node-v0.1.1.apk below and open it on the phone. If you already run v0.1.0, just install it over the existing app — do not uninstall first, or your synced database and node identity are deleted. Android may ask you to allow installs from your browser or file manager.

Files

• quantus-node-v0.1.1.apk — 55,683,797 bytes
  SHA-256: b1f91fca62e6944dfcb47ca029c72c9c8d7a41c341c4be0a4e7c6379a5cad6b0

Signing

Release signing certificate SHA-256 (unchanged from v0.1.0):
65bb1a5fef27d70be1dd12fc12ce3484b4c848fceca92f8898cd96cb2784f6ff

Verify with: apksigner verify --print-certs quantus-node-v0.1.1.apk

v0.1.0 — first public release

Quantus Node for Android — v0.1.0

First public release.

An Android app that runs a regular (non-mining) Quantus Network full
node on your phone. It starts the bundled quantus-node binary as a
child process under a foreground service, syncs the mainnet chain
with pruning enabled, and shows status — peer count, best block,
sync progress — on a quiet dashboard. There is no wallet and no
mining; the app holds no keys to any funds. This build adds the
launcher icon: a bright core with concentric pulse rings on a dark
background, echoing the node's pulse.

Requirements

• Android 12 (API 31) or later, arm64 device
• Enough free storage for a pruned node database, and a Wi-Fi
  connection for the initial sync (it takes on the order of a
  couple of hours and downloads a few GB)

Verified device

• Confirmed working: Pixel 9a with GrapheneOS
• Other Android 12+ / arm64 devices are expected to work but are
  not yet verified. A manufacturer battery manager that kills
  foreground services may stop the node. Working reports via
  GitHub Issues are very welcome — they grow the verified list.

Install

1. Download quantus-node-v0.1.0.apk from this release.
2. Install it directly (you will need to allow installs from your
   browser / file manager for this source).
3. Open the app and press Start.

Updates install over the existing app: your node database,
display name and settings carry over. Do not uninstall first —
uninstalling erases the node data and the next start syncs from
genesis again.

Verify your download

• APK SHA-256:
  ef1ef477d6102333f7a5c2deaee9e512eee7a98b6282cd0c167dbd4d1d003583
• Signing certificate SHA-256 fingerprint:
  65:BB:1A:5F:EF:27:D7:0B:E1:DD:12:FC:12:CE:34:84:B4:C8:48:FC:EC:A9:2F:88:98:CD:96:CB:27:84:F6:FF

This is the first release signed with the project's release key;
all future updates will carry the same signature.

Known limitations

• Two known vulnerabilities in transitive dependencies of the
  bundled node binary (zstd-safe 6.0.6 and crypto-bigint 0.5.5)
  have no fix available within their compatible version ranges
  yet and are waiting on upstream releases. See SECURITY.md.
• The concurrency fixes from the external audits (findings 2–7)
  were verified by code review and desk-checked interleavings;
  a deterministic on-device race-reproduction test has not been
  run, as noted in SECURITY.md.
• UI translations (9 languages) were produced by the maintainer
  with AI assistance and have not been reviewed by native
  speakers.
• State and block pruning are fixed at 256; very old history
  cannot be queried from this node.

License: Apache-2.0.