This repository was archived by the owner on Nov 10, 2026. It is now read-only.
Repository navigation
ElastOS Weekly Shipping Report — Week of May 7 – May 15, 2026 #16
SashaMIT
announced in
Announcements
Replies: 0 comments
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Uh oh!
There was an error while loading. Please reload this page.
Elacity Labs — Weekly Team Update for the World Computer Initiative (WCI)
May 7 – May 15, 2026
Key Links This Week
v1.2.8.0on track for next release window once T-1 telemetry merges)feat/t-1-telemetry-and-supportdev/ipfs-connectivitydev/fix-dashhttps://europe-west1-elacity.cloudfunctions.net/chipotle-proxyscripts/deploy-supernode.shbash <(curl -fsSL https://raw.githubusercontent.com/Elacity/pc2.net/main/scripts/update.sh)curl -fsSL https://elastos.elacitylabs.com/install.sh | bashTable of Contents
dag/import+ Cluster Onboarding0.3.0Planning0.3.0, and BeyondThe Big Picture — A Consolidation Week Across Four Workstreams
The previous report closed with thirteen point releases in six days (v1.2.1 → v1.2.7.13) and a convergence release that finally made the desktop, the app store, dDRM, identity, payments, and runtime permissions feel usable together. This week deliberately stepped off that release cadence and into a consolidation phase across four workstreams running in parallel:
PC2 — branch work for the next two releases.
maindidn't move (last tagv1.2.7.14from May 6). Foundations went down on feature branches:feat/t-1-telemetry-and-support), 2 819 inserted lines, awaiting one more review pass before merge.Elacity/chipotle-functions); client-side switch still requires the consolidated Lit Actions that are pushing next.dev/ipfs-connectivityconsolidates upload paths and adds scoped CAR replication;dev/fix-dashbrings the internal MPEG-DASH manifest generator into strict standards-compliance.ipfs.ela.city(Google Cloud) joined the Elacity IPFS Cluster as third peer alongside the two supernodes. ~18 000 historical Elacity NFT-related pins are now replicating across three countries — the first time the historical Elacity content set is actively replicated rather than relying on a single node.Runtime — stricter authority-layer boundaries. The work this week pushed Runtime out of "convergence-release demo shell" territory and into "stronger authority layer" territory. Wallet was promoted to the main blockchain surface (accounts, approval methods, receive QR/address display, MetaMask linking, BTC groundwork, ESC/Base/BTC account direction). Browser was locked into a controlled capsule that exposes a constrained
window.ethereuminstead of raw wallet or chain access.ela.cityand Glide compatibility was fixed by routing account discovery, ESC default chain selection, typed signing, transaction approvals, and read-only chain calls through Runtime providers. Review-slice planning for the upcoming0.3.0branch is underway. The architectural principle: capsules can only reach the outside world through Runtime / Carrier / provider mediation, and all capsule-initiated external effects must be auditable.Supernode infrastructure — responsibly-disclosed RCE remediation. Friday May 15: a pre-authentication shell-injection vulnerability in one of the gateway registration endpoints was reported by an external researcher. The fix had been on
mainfor 23 days (commit16dccaf39, April 22) but had never been deployed — a "the patch exists, but only in source control" failure mode that we want to make impossible. Same-day response covered: stop-the-bleed kill-switches, full code-patch deploy to both supernodes, structural hardening (nginx fronting on both, ufw blocks on internal-only ports, TLS verification end-to-end, removal of orphanedNODE_TLS_REJECT_UNAUTHORIZED=0), and a new automated deploy script that smoke-tests every change and auto-rolls back on failure. The exploit endpoint that returneduid=0(root)in the morning returnsHTTP 400 "Invalid username"by end of day.map.ela.citycame back online after a 9-hour outage as a side effect of the structural hardening.Strategy — partnerships and the World Computer thesis. The CEO's continuous US travel cycle (Google Next, Bitcoin Las Vegas, Consensus Miami) closed this week with a published community update reframing the entire product as the "Elastos World Computer" — one user-owned execution layer, four converging environments (PC2 / Runtime / Carrier / Blockchain). In parallel, technical partnership conversations opened with a leading privacy-protocol team about adding a privacy layer to the Elastos main chain — a Mimblewimble + Lelantos hybrid, integrated in the extension-blocks pattern (proven by LTC/MWEB), not as a side-chain. And ENM (Elastos Node Manager) moved into final-shape territory: BPoS-aware, full-node operations console, ready to ship as a dApp-Centre installable app — the first operator-grade tool delivered through the dApp Centre.
Everything below is the detailed breakdown of these four workstreams.
T-1 Telemetry, Self-Diagnostic & User-Initiated Support Reports (v1.2.8.0)
This is the foundation that unblocks feedback-driven optimisation — the ability to say to any user "go to Settings → Health & Support, click the Report button, and we'll be able to see exactly what's going on" without asking for log paths, file uploads, or screen shares. Built as an extension of existing infrastructure (
pc2-node/src/utils/diagnose.tsandtelemetry.ts) rather than a greenfield rebuild — the existing telemetry primitives were already strong, they just needed user-facing surfaces and aggregation.T-1A — Self-Diagnostic
A live, in-app diagnostic panel that runs eleven categorised checks every time it opens:
package.jsonvia a newresolvePc2Version()helper that doesn't depend onnpm_package_versionenv at runtime), Node.js version, platform/arch/CPU/memory snapshot, uptime/api/supernodes), Boson DHT presence, IPFS swarm peer count/api/v0/version), Cluster peer-set, local datastore size, free diskEach check returns
{ ok | warning | error, message, durationMs, ...detail }so a future "post-mortem replay" can reconstruct the exact health state the system was in at any moment a user clicked "Report."A polyfill for ESM
__dirnamewas added todiagnose.ts(it was reading__dirnamedirectly, which is CommonJS-only; the new module is shipped as ESM). This was the cause of anHTTP 500from the diagnostic API during early integration testing — caught and closed before merge.T-1B — User-Initiated Support Reports
Phase 1: Local preview. Settings → Health & Support card now has a "Preview Report" button that opens a rendered preview of exactly what would be submitted: the eleven diagnostic checks, recent log tail (last 5 000 lines, redacted for paths under
~/.config/,~/.ssh/, and any string matching common secret patterns), and a wallet-address resolution. Users see exactly what's leaving their machine before they commit to sending it.Phase 2: Submission flow (wired in this commit, endpoint enabled at flip of a feature flag — held until T-1C aggregation is observable on the receiving end so we can measure submission rates from day one).
The Health & Support UI lives at
app/settings/health-and-support/and was modelled on a small standalone diagnostic test-app (elacity-health/index.html) that uses the same/whoamiand/api/diagnoseendpoints. That test-app surfaces a "Cannot resolve wallet address" error during early integration if the API path is wrong — caught by switching/api/whoami→/whoamiand broadening the wallet extractor.T-1C — Aggregated Telemetry (Local SQLite Metrics)
The local plumbing that makes the Self-Diagnostic + Support Report system useful at fleet scale. Counter and Histogram primitives backed by an in-process SQLite metrics store; hot-paths in the gateway are now instrumented:
/api/health,/api/supernodes,/api/diagnose, registration endpointsThe Health & Support card now surfaces these counters live (no flusher round-trip), with a
.metrics-carddirect style so the panel is visible by default (a transient bug where the panel was hidden by the inherited.card { display: none }was caught during local UI verification and fixed by lifting the metrics card out of the generic.cardcascade).Why this is the v1.2.8.0 headline
Feedback-driven optimisation requires that any user with an issue can hand us a perfect snapshot in one click. Today that requires log paths, file uploads, and back-and-forth. After v1.2.8.0 lands, it requires one button press. The infrastructure is also the foundation for automated self-healing (a future report can trigger a remediation directly), fleet-level performance dashboards, and regression detection across releases.
Companion: Runtime Heartbeat Helper
A small additional file landed alongside T-1:
pc2-node/src/utils/runtime-heartbeat.ts. This complements the launcher↔pc2-node heartbeat protocol (pc2.heartbeat.v1) introduced in v1.2.7.13, surfacing the heartbeat state to the Self-Diagnostic so the panel can tell whether the launcher believes pc2-node is healthy (separate from whether pc2-node believes itself healthy).IPFS Pinning Evolution — Scoped CAR Replication +
dag/import+ Cluster OnboardingThis branch is a structural cleanup of how PC2 pins content to IPFS, with the new
dag/importendpoint exposed by the cluster as the lever that makes recursive replication actually work.The "two upload paths" problem
Before this branch, PC2 had two parallel upload paths that had diverged over time:
/api/v0/addfollowed by an explicit/api/v0/pin/addNeither path was recursive in the way it needed to be —
pin/addon a directory CID would pin the root block but not automatically replicate the children across the cluster. Combined with two paths to maintain, this was friction.The fix: one path, CAR-based, scoped replication
pin/add, an attempt is made to upload a.carfile of the same content tree to/api/v0/dag/import(the cluster proxy endpoint, newly exposed at the cluster layer). This is how the cluster learns about the entire object graph at once, not just the root CID, so it can fan out replication correctly.carReplicate: true | false | undefined, can be set per-file or per-directory rather than globally. This gives creators and operators the right level of control over what's worth replicating versus what's local-only (saves cluster bandwidth and disk for genuinely ephemeral content).The cluster onboarding side
In parallel with the branch work,
ipfs.ela.city(a Google Cloud Engine node) was added as the third Elacity Cluster peer alongside the two supernodes. Sequence:/ip4/0.0.0.0/tcp/9096and/ip4/0.0.0.0/udp/9096/quic(was internal-IP only).peeridis now visible in the cluster peer-set on both supernodes./api/v0/pin/addendpoint onipfs.ela.city:5001was swapped to point at the cluster proxy service (under the hood, the same127.0.0.1:5001URL, but resolving to cluster-proxy instead of bare kubo). Net effect for any external client: identical API, but every new pin is automatically replicated across the cluster.dag/importendpoint was exposed at the cluster proxy layer too, so the PC2-side upload path described above lands directly into a replicated namespace.The 18 000-pin backfill
Once the new peer was in the cluster, all historical pins on
ipfs.ela.city(predominantly Elacity NFT-related content, accumulated over years) started replicating across the other two peers automatically. ~18 000 pins, ~340 GB, currently in flight. End state: the entire historical Elacity content set will be backed up across three independent geographies (US East / EU / GCE), which is a meaningful step on the durability + decentralisation axis. This is the first time the Elacity NFT historical asset set has been actively replicated rather than relying on a single node.Pssh v3 alignment
A small targeted fix in the same branch: the Protected System Specific Header (PSSH) input data that PC2's encryption flow writes into encrypted media files needed adjustment to match the V3 protection schema introduced in the convergence release. Four lines changed, but it's the kind of one-character bug class where a wrong byte order or wrong length-prefix means the entire CENC container fails to parse on the player side. Caught and fixed during cross-validation against the unified
cenc:lit-aes-gcm-v3protection type.MPEG-DASH Manifest Standardisation
PC2 ships its own internal DASH packager + MPD generator (instead of shelling out to the reference
mp4dashtool) for three reasons: it keeps the encryption flow in-process (the content encryption key never leaves the PC2 boundary), it's much faster, and it has no native-binary dependency. But the upside comes with a cost: the generator has to produce exactly the manifest XML structure that DASH players expect, byte-equivalent to what the reference tool would produce, or playback breaks in subtle ways (some players are lenient, others are strict).The drift that was found
A cross-comparison between the PC2-produced manifest and an
mp4dash-produced manifest for the same source media surfaced a structural divergence in the<AdaptationSet>block:<AdaptationSet>→<Representation>→<SegmentTemplate>(template nested inside each representation)<AdaptationSet>→<SegmentTemplate>(hoisted to the adaptation set, with$RepresentationID$placeholder) +<Representation>(sibling)The
SegmentTemplateis supposed to be a sibling of the representations under the adaptation set (so all bitrate variants share the same template, parameterised by$RepresentationID$), not a child of each representation. The previous structure happened to work for many players but produced different bytes than the reference, which mattered the moment any strict player or downstream tool was introduced into the path.What changed
pc2-node/src/services/media/mpdGenerator.ts— restructured to emit the standards-compliant tree shapepc2-node/src/services/media/dashPackager.ts— updated to support the new directory layout that pairs with the new manifest shapepc2-node/src/services/media/mpdParser.ts— the existing parser is already robust enough to read both the old and new shapes (it's regex-based extraction, so the structural reordering doesn't break it), confirmed by tests against both shapesCross-device impact
The fix is purely on the encoder/server side. No player-side change required. PC2's Rust/WASM player on Mac, Windows, and Jetson — and any standards-compliant external player a creator might use to verify their content — will all consume the new manifests cleanly. Existing already-encrypted content on the network continues to play (the parser handles both shapes).
Example output
A reference run that produced standards-compliant
stream.mpd(visible athttps://ipfs.ela.city/ipfs/bafybeicfkbtbwdlthsv7p5y7px7kecelbbl2saj3sgqac4atiapyybg3mq/) confirms the new structure is byte-equivalent tomp4dashoutput.Chipotle Migration Path — Serverless Proxy + Lit Actions Consolidation
This is the in-flight migration to remove the Lit Chipotle keystore API key from the wire entirely. Two parts:
Part 1: Serverless GCF Proxy (LIVE)
A new repository,
Elacity/chipotle-functions, hosts a minimal Google Cloud Functions proxy that the team stood up this week. Live at:The proxy is a drop-in replacement for the Lit Chipotle API endpoint: clients can switch the base URL from the official Chipotle API to the proxy and stop sending the
X-Api-Keyheader entirely. The proxy injects the key server-side. This eliminates the client-side wire leak of the keystore secret — the same secret that any browser or PC2 client could read out of the request payload.Architectural framing: this is a short-term decentralisation tradeoff (one new central service, replacing the previous client-side secret) but a major immediate security win (the secret is no longer on every client's filesystem). It's the bridge to the longer-term Chipotle Relayer (v1.2.9.0) where every PC2 supernode can act as a relayer itself, fully decentralising the path.
Cost is per-request, very small — billed on the GCF free tier or close to it for current volumes.
Part 2: Client switch (forthcoming, v1.2.9.0 trigger)
The PC2 client (
pc2-node/src/api/chipotle-client.ts) needs a 3-line change to point at the GCF proxy and drop theX-Api-Keyheader. Not made yet — it's gated behind the consolidated Lit Actions push (next), so the client switch and the action update land together in v1.2.9.0.Part 3: Consolidated Lit Actions (forthcoming)
Currently the dDRM path uses a handful of Lit Actions (separate scripts for media vs non-media, EOA vs Smart Account, encrypt vs decrypt). These are being consolidated to two:
Push to
mainis expected within the next two working days, along with the migration documentation. After that, the client switch in Part 2 lands cleanly and v1.2.9.0 can ship.PC2 ↔ Runtime Convergence Inventory Refresh
The
docs/handover/PC2_CONVERGENCE_INVENTORY_FOR_RUNTIME.mddoc — the feature-by-feature mapping of what PC2 v1 ships today versus what each piece becomes inside an Elastos Runtime capsule — was refreshed with post-launch reality:feature/lit-chipotle-migrationandfeature/metadata-alignmentwere the right pointers two weeks ago; today the canonical references are the merged code onmainplus the activefeat/t-1-telemetry-and-supportv1.2.0→v1.2.7.14shipping cadence and Runtimev0.2.0milestone, with explicit "what was added between snapshots" notationThe doc is the strategic reference for how PC2 features migrate into Runtime capsules over time — for example, how PC2's IPFS pinning becomes a Runtime "Storage capsule capability", or how PC2's dDRM gateway becomes a Runtime "Access capsule." The refresh keeps the doc honest as the underlying systems evolve.
Responsibly-Disclosed RCE Remediation — Same-Day Patch + Structural Hardening
A responsibly-disclosed pre-authentication shell-injection vulnerability in one of the gateway registration endpoints on the flagship supernode was reported by an external researcher early Friday May 15. Same-day full remediation:
The root cause
The fix for this exact class of bug had landed on PC2
mainon 2026-04-22 (commit16dccaf39, "SEC-2026-04 Wave 3" — switchingexecSyncshell calls toexecFileSyncwith array arguments + strict input validation). The supernodes were redeployed 2026-04-27 and 2026-04-28 — five days after the patch was in source control — but the redeploy used a stale local checkout that pre-dated the patch. The result: a 23-day window where the fix existed inmainbut had never reached production. The researcher's report ended that window.The same-day response
A structured five-phase remediation, all on Friday May 15:
503kill-switches at the very top of the four register endpoints — pure path-blocks, no state mutation, fully reversible. New registrations returned503 "registration temporarily unavailable for maintenance"for the next hour; existing peers (Wireguard, AmneziaWG, VLESS-Reality, plus all registered PC2 nodes) kept working uninterrupted.SEC-2026-04 Wave 3patch frommainwas deployed to both supernodes (atomic swap + smoke test + reload). After Phase 2 the exploit endpoint returnsHTTP 400 "Invalid username (must be 3–30 chars, lowercase alphanumeric with _ or -)"instead of the previous root-output. Inline Phase 1A 503-blocks were removed since the code-level fix supersedes them.pc2-nodesystemd unit in a restart loop (12 052 attempts/day from a port conflict with a PM2-managed process holding the same ports — preventable noise); an InterServernginxservice that had died at 06:55 UTC the same morning from a port-collision-on-manual-start; an orphanedNODE_TLS_REJECT_UNAUTHORIZED=0env on Contabo's slim gateway (a legacy workaround that disabled TLS certificate verification for all outbound HTTPS calls — small MITM gap).daemon-reloadissued. 12 052/day restart attempts → 0. PM2-managed instance unchanged, online.PRIMARY_GATEWAY_URLswitched from the supernode's IP to its domain (so the served Let's Encrypt cert SAN actually matches),NODE_TLS_REJECT_UNAUTHORIZED=0removed. Full TLS verification end-to-end on every upstream call. Pre-flight test confirmed Contabo can already reach the new domain with proper TLS verification before the change is applied, so the env-var bypass is genuinely orphaned. One-shot revert script (/root/revert-c2.sh) saved.*:80+*:443directly to binding127.0.0.1:3080+127.0.0.1:3443, with nginx terminating TLS on*:80+*:443and reverse-proxying to the localhost gateway. Same Let's Encrypt wildcard cert (*.ela.city) used by both layers. UFW deny rules added for tcp/3080 + tcp/3443 from the outside so the gateway can only be reached via nginx. Bonus side effect:map.ela.citycame back online after its 9-hour outage (its dead-nginx situation healed as part of bringing nginx up cleanly). Discovered during smoke-testing: the gateway's internal HTTP→HTTPS redirect didn't honorX-Forwarded-Proto: https, causing a redirect loop on first try — patched live by switching nginx'sproxy_passfromhttp://127.0.0.1:3080tohttps://127.0.0.1:3443(withproxy_ssl_verify offsince it's localhost), zero-downtime reload, loop resolved. Effective public HTTP downtime during the cutover: ~115 seconds.End-state architecture (both supernodes)
Both supernodes now sit behind nginx; no public-facing direct port bindings; TLS verification end-to-end. All eleven systemd services on the flagship are active (gateway, network-map, cloud-node, app-registry, vless-reality, ipfs-relay, cluster, kubo, boson, amneziawg, nginx). Contabo's PM2-managed slim gateway is active. Registry preserved exactly (117 entries before → 117 after; 35 WireGuard peers before → 35 after; 4 supernodes before → 4 after).
Researcher disclosure
The researcher is being credited and a bounty is being processed. The exact CVE-class details and exploit string stay private to protect any other deployments running pre-patch code; the responsible-disclosure window is closed on the Elacity supernodes as of Friday May 15 ~15:00 UK.
Supernode Deploy Automation — Root-Cause Fix for the RCE Incident
The RCE incident's root cause — the patch existed in
mainfor 23 days but never reached production — is the kind of failure mode that's permanently solvable with one tool: an automated, repeatable, smoke-tested deploy script with built-in rollback.scripts/deploy-supernode.shis that tool.What it does
Pipeline per host:
index.js+lib/to a timestamped path on the remotemainvs deployed).deploy-staging/directory on the host (atomic-swap target)node --checkevery file (catches syntax errors before they reach the live path; deliberately copies to a.js-extensioned temp path on the remote to bypass Node's ESM extension trap)mv staging/ live/is a single inode rename, no half-deployed state possiblesystemctl restartthe gateway/api/healthis 200,/api/supernodesreturns valid JSON, the exploit endpoint returns 400 (not 503, not root output)Security hardening of the script itself
SSHPASSenvironment variable (sshpass -e) rather thansshpass -p $PASSWORD.set +xguards wrap every section where the password is in scope. The password never appears inbash -xtraces orps auxf.set -e+trapensures any unexpected error aborts the script immediately with a clean state.--dry-run allbefore being committed — all six smoke checks green on both hosts in ~40 seconds.Why this is the deliberate "root-cause fix"
Today's RCE was patched in source control April 22 and never reached production until May 15. An automated deploy pipeline closes that window permanently. Future direction: wire this script as a GitHub Actions workflow on push to
main, so any patch reaches the supernodes within the time it takes for tests to run (currently a few minutes). For now it's manual but repeatable; the wiring to GitHub Actions only requires SSH deploy keys, which is a separate piece of operations housekeeping.ENM (Elastos Node Manager) — BPoS-Ready Operations Console
A new full-node operations console for the Elastos mainchain, built by the Elacity team to ship as an installable dApp-Centre app. The first version is BPoS-only (BPoS supernode operators are the most operationally-demanding audience); general full-node observer support is in the same codebase.
Installation and setup
On a fresh server, ENM's first-launch flow is a guided multi-step conversation:
elabinary from official releases and verifies it on disk.keystore.datsigning file and shows the public key to paste into Elastos Essentials when registering as a producer.After this, ENM writes the chain config and starts the node. From then on, the app is the operations surface.
The four tabs
Dashboard. A composite live view of the chain:
elarelease is detected upstreamLogs. Live tail of the chain's log file over Server-Sent Events:
× Ncounter so a flood of repeated entries during sync doesn't bury the rest of the feedSettings. Six task-oriented sections:
Saves that require a chain restart trigger a modal asking whether to restart now or later, so the change can be applied in one tap.
Why this matters
ENM is the first piece of dApp-Centre content that's a serious operations tool, not a viewer or a simple app. It validates the dApp-Centre as a delivery channel for power-user functionality — a BPoS operator can install ENM, register, and run a node, all from one installable app on ElastOS. Combined with the existing dApp-Centre catalogue (Elacity NFT, Glide Finance), this expands ElastOS from "user-facing personal cloud" into "user-facing personal cloud plus operator workbench" — same desktop, same install model, same identity, full operational coverage of the ecosystem participants.
Ready to ship. Final polish in flight.
Elastos Runtime — Stricter Authority-Layer Boundaries +
0.3.0PlanningWhat "stricter" means in practice
The Runtime convergence principle is that capsules should only reach the outside world through Runtime / Carrier / provider mediation — not through raw host networking, raw RPC, private keys, connector SDKs, or any other privileged API. This week's work pushed that principle from "stated direction" to "enforced in the code path":
Improved Home / System account model. Accounts are now treated more coherently as Runtime principals, with System focused on policy and runtime state instead of duplicating Wallet controls. Cleaner separation = fewer overlapping authorities = a simpler mental model for users and a smaller attack surface.
Wallet is now the main blockchain surface. Accounts, approval methods, receive QR / address display, MetaMask linking, BTC groundwork, ESC / Base / BTC account direction, and Wallet-owned approvals all routed through Wallet. The Wallet capsule is the only place that handles authority-bearing effects (signing, transactions); everything else either uses a typed chain-provider for read-only operations or asks Wallet for an approval.
Browser is a controlled capsule. Browser now opens through Runtime, uses Browser / Net / Exit provider contracts, and exposes a constrained
window.ethereuminstead of raw wallet or chain access. A capsule running inside Browser can request signatures via the constrained provider; it cannot directly touch a wallet, a private key, or a chain RPC. The dApp gets the API it expects (window.ethereum); the user gets the safety they need (a mediated, approve-able authority surface).Compatibility fixes for
ela.cityand Glide through Runtime providers. The first real cross-validation of the constrained-Browser model was runningela.cityand Glide inside it. What broke at first: account discovery, ESC default chain selection, typed signing requests, transaction approvals, and read-only chain calls. What was fixed: each of these now routes through a Runtime provider (chain-provider for reads, Wallet for signing) instead of trying to go directly. First proof point that real dApps can run inside the constrained-Browser capsule.Clearer separation between reads and authority-bearing effects. Chain reads go through a typed chain-provider; signing and transactions go through Wallet / Inbox approvals. This is the operational form of the "zero ambient authority" principle: a capsule doesn't get a wallet just by existing inside the runtime; it asks for a specific approval for a specific action, and the system records who asked, which policy allowed it, and which provider executed it. Some approvals may be granted once, permanently, or for a time window, with the audit trail attached.
Verification tooling added. Browser entropy checks, Home entropy checks, Browser route tests, hosted wallet smokes, provider decision reports, and review-slice planning artifacts. The Runtime work is now backed by an observability layer that can answer "which provider made which decision and why" after the fact.
Docs + planning updated around Browser, Carrier, Wallet, PC2 convergence, provider boundaries, and release readiness — including the
0.3.0review-slice plan.What
0.3.0is targetingThe remaining gaps before Browser is considered complete:
window.ethereumcall, every chain read, every exit-network request)Selkies (a hosted browser-streaming engine) is useful as the current hosted proof but not yet accepted as the final product Browser path — the Runtime team is treating it as an interim implementation while the final native-rendering / Carrier-mediated path is built.
Why the Browser-streaming insight matters
A side note from the week worth surfacing: with Browser rendering / streaming solved, the same primitive becomes a potential solution to run any app from any platform across nodes — via browsers (hosted-streaming) or local rendering (native). The implication: an ElastOS user could open a Linux-only app, or a Windows-only app, or an iOS-only app, inside their own Browser capsule, with the rendering happening on a remote node and the input/output streaming back. The compute and the data stay where they should; the user gets the experience they want. This is the "any app, anywhere, under user control" primitive that the World Computer thesis (see §12) needs as a foundation.
Tie-back to PC2
The PC2↔Runtime Convergence Inventory (§6) is the doc that tracks which PC2 feature becomes which Runtime capsule over time. The Wallet-as-authority-surface work is the Runtime side of what PC2 currently does ad-hoc through wallet-connect prompts. The constrained-Browser work is what enables PC2's dApp Centre apps to eventually run inside a Runtime capsule with proper capability scoping rather than as in-process Electron windows. Each piece of this week's Runtime work has a corresponding PC2 feature it's helping converge.
Partnership Conversations — Exploring a Privacy Layer for the Main Chain
This week opened a technical conversation with the Beam team — the privacy-protocol project behind one of the most rigorous Mimblewimble implementations in production — about whether and how a privacy layer could be integrated into the Elastos main chain.
What's actually being discussed
Three integration shapes are on the table; only one is being seriously pursued:
Side-chain integration. Off the table. Elastos has had a difficult history with side-chains (most are unused, several need active maintenance with no users). The strong preference is: whatever privacy layer lands, it lands on the main chain.
Full main-chain hard fork to a Mimblewimble base. Off the table. Too disruptive, breaks too many existing integrations, and conceptually misaligned — privacy as the default is the wrong choice for a chain that needs to support transparent rights / royalties / settlements alongside private transactions.
Extension-blocks pattern (the LTC / MWEB approach). Active conversation. Litecoin extended its block structure to support confidential transactions via Mimblewimble Extension Blocks (MWEB) without breaking existing nodes. The same pattern could allow Elastos to add an opt-in confidential-transaction path that lives alongside the existing transparent path on the main chain. Users choose per-transaction whether to use the confidential path. The transparent chain keeps working unchanged.
Why the Beam variant specifically
The Beam team didn't ship pure Mimblewimble. They built a hybrid called Lelantos Mimblewimble (LMW) that combines two protocols:
The hybrid is proven and battle-tested (Beam has run it in production for years), confidential assets are natively supported (new tokens automatically inherit the privacy properties of the chain), and the implementation includes quantum-resistant switch commitments — implemented and shipped in 2019, currently disabled by default, ready to be enabled by a hard fork when the post-quantum threat becomes critical.
Architectural fit with Runtime
The Beam conversation has a natural fit with the constrained-Browser / Wallet authority architecture being built in Runtime this week (§10). A potential first step:
Next steps in the conversation
Beam's team is reviewing the Elastos chain implementation to give specifics on what an extension-blocks integration would look like in practice — effort estimate, code touch-points, what stays untouched, what needs to migrate. Continued discussion is in a shared Telegram group. No commitments yet, just a serious technical conversation. The next data point will be Beam's review of the chain code.
Why it matters
If Elastos can add opt-in confidential transactions on the main chain via extension blocks, with battle-tested cryptography, with confidential assets native, with quantum-resistant primitives ready to enable, that's a significant differentiator — one that aligns with the World Computer thesis (a chain that anchors rights, identity, provenance, and settlement should be able to do so privately when the user chooses, not only publicly). It also gives Elastos a credible answer to the enterprise audience that came up repeatedly during the US trip (see §12): enterprises want control without surveillance.
Closing the US Travel Cycle — The Elastos World Computer Thesis Crystallises
The CEO's continuous US travel cycle — covering Google Next, Bitcoin Las Vegas, and Consensus Miami across April and May — closed this week with a published community update that consolidates what was learned across enterprise, Web3, AI, institutions, creators, and infrastructure teams. The headline shift: Elacity is not building separate tools — Elacity is helping converge PC2, ElastOS Runtime, Carrier, and the Elastos blockchain into one user-owned computing system: the Elastos World Computer.
What the trip clarified
Five patterns kept appearing across very different audiences: (1) AI agents are coming faster than governance (Gartner now expects very large enterprises to face massive AI-agent sprawl by 2028; IBM reports AI adoption is already outpacing AI security and governance); (2) Web3 still has a trust and usability gap; (3) creators and data owners still lack economic infrastructure for access, royalties, licensing, resale, and provenance; (4) enterprises want control without slowing down — safer execution, clearer ownership, better auditability; (5) the Elastos stack is converging — PC2, Runtime, Carrier, blockchain, wallets, dDRM, agents, marketplace logic stacking into one coherent system.
The simple thesis
The four environments of the World Computer
Why Runtime is the turning point
PC2 v1 currently behaves like a web server; ElastOS Runtime behaves like an operating system. In PC2 v1, a session token can become broad access. In the Runtime model, every action needs a scoped, signed capability and can be audited. This week's Runtime work (§10) is exactly that transition — from session-token authority to capability-mediated authority, from ambient access to explicit grants. That is the difference between a useful personal cloud and a trustworthy personal computer for AI agents, dApps, wallets, and digital property.
Closing line from the CEO's published update
(The CEO's full published update — including the per-audience opportunity surfaces, the "what must be proven next" list, and citations — is referenced in full in the canonical doc §12.)
Looking Ahead — v1.2.8.0, v1.2.9.0, Runtime
0.3.0, and BeyondNext release window:
v1.2.8.0 — T-1 Telemetry + Self-Diagnostic + Support Reports merges from
feat/t-1-telemetry-and-supportintomainand ships. Expected within the next working week. Headline: every user can submit a perfect snapshot of their system state in one click; aggregated telemetry surfaces fleet-level patterns; the foundation for feedback-driven optimisation is in.v1.2.9.0 — Chipotle Relayer / API-key wire-leak elimination. Two pieces both need to land:
X-Api-Keyheader — gated on the Lit Actions pushOutcome: no more keystore API key on the wire; centralised proxy as a stepping stone to per-supernode relayer in a later release.
Runtime trajectory:
0.3.0review-slice planning continues. Targets: Browser stability under sustained real-app use, independent multi-window sessions, stronger audit coverage for all capsule-initiated external effects, and final proof that Browser uses the Carrier / provider boundary consistently. Selkies remains the hosted-streaming proof; the final native-rendering / Carrier-mediated path is in design.Adjacent work:
dev/ipfs-connectivityanddev/fix-dashcarry small, focused, well-tested deltas. Likely merged in the v1.2.8.0 window if they don't go in standalone earlier.deploy-supernode.sh; closes the "patched in main but not in prod" failure mode permanently.--webrootswap now that nginx fronts port 80. 73 days of buffer.Partnership & strategy:
Future direction (no commitments yet, just the trajectory):
docs/core/DECENTRALIZATION_TRAJECTORY.md) — a forward-looking strategic doc for the network-level decentralisation roadmap, ready for sign-off and publication.Summary Statistics
By branch
feat/t-1-telemetry-and-support(T-1 telemetry + convergence inventory + deploy script)dev/ipfs-connectivity(upload consolidation + scoped CAR + dag/import + pssh)dev/fix-dash(MPEG-DASH manifest standardisation)By commit
e8ad84691feat/t-1-telemetry-and-support83d266df3dev/ipfs-connectivitydafc9cfe1dev/ipfs-connectivityee9e9b731dev/ipfs-connectivity0c1f4c72adev/ipfs-connectivity9fdf4f7efdev/fix-dashbd9110f48feat/t-1-telemetry-and-support8e11c4d61feat/t-1-telemetry-and-supportOperational milestones (not in commit log)
ipfs.ela.cityjoined the Elacity Cluster as third peer; UFW openings on both supernodes; symmetric handshakepin/addendpoint on the new peer swapped to cluster-proxy;dag/importexposed at cluster layermp4dashreference output; standards-compliance achievedeurope-west1(live since); short-term security win pending client switchmap.ela.cityback online after 9-hour outage (healed as part of nginx fronting)scripts/deploy-supernode.shcommitted as root-cause fixwindow.ethereum;ela.city+ Glide compatibility routed through Runtime providers;0.3.0review-slice planning underwayAdjacent repositories and workstreams
Elacity/chipotle-functionseurope-west1; client switch forthcoming.Elacity/elastos-runtime0.2.0is current stable onmain. Active stewardship work: Wallet promoted to main blockchain surface, Browser locked into controlled capsule,ela.city+ Glide compatibility fixed via providers,0.3.0review-slice planning underway.Generated 2026-05-15 by the Elacity Labs team. Format matches #15 (Week of Apr 26 – May 6, 2026).
All reactions