feat: port Rust core runtime

[pgherveou]

What this PR ships

The shared-core SDK becomes real: one Rust core runs the TrUAPI protocol, and every host platform (web, Electron, iOS, Android) plus every product (the JS SPA inside the sandbox) consume the same auto-generated artifacts from that single source.

Concretely, after this PR a product engineer can:

import {
  AccountManagementClient,
  createMessagePortProvider,
  createTransport,
} from "@parity/truapi";

const transport = createTransport(createMessagePortProvider(port));
const accounts = new AccountManagementClient(transport);

const result = await accounts.accountGet({
  productAccountId: { dotNsIdentifier: "my-product.dot", derivationIndex: 0 },
});

…and the same call lands in the Rust core that's running inside the host, regardless of whether the host is dotli on web, Electron, an iOS app, or an Android app.

Runtime topology

   Product (iframe / WebView)              Host (web shell / Electron / iOS / Android)
 ┌───────────────────────┐               ┌────────────────────────────────────────┐
 │ @parity/truapi        │   wire bytes  │  ┌──────────────────────────────────┐  │
 │ generated TS client   │ ◄───────────► │  │   truapi-server (Rust core)      │  │
 │                       │  (transport)  │  └──────────────────────────────────┘  │
 └───────────────────────┘               │                  │                     │
                                         │           ┌──────┴──────┐              │
                                         │           │  bindings   │              │
                                         │           │  WASM       │ web/electron │
                                         │           │  UniFFI     │ ios/android  │
                                         │           └──────┬──────┘              │
                                         │                  │                     │
                                         │   ┌──────────────▼──────────────────┐  │
                                         │   │  HostCallbacks                  │  │
                                         │   │  implemented in JS / Swift /    │  │
                                         │   │  Kotlin by the host app         │  │
                                         │   └──────────────┬──────────────────┘  │
                                         │                  ▼                     │
                                         │             OS primitives              │
                                         └────────────────────────────────────────┘

Transports:

• Web + Electron: MessageChannel. The product opens a port; the host hands it to its core via createMessagePortProvider(port).
• iOS + Android: a localhost WebSocket bridge. The host calls core.startWsBridge() and forwards the resulting ws://127.0.0.1:<port>/?t=<token> URL to the product, which feeds it to @parity/truapi's createWebSocketProvider(url).

What gets generated, from one Rust source

The contract for every protocol domain (accounts, signing, chain access, chat, statements, payments, …) is a Rust trait in rust/crates/truapi/. Each method carries a stable #[wire(id = N)] annotation. From that single definition the codegen emits:

• @parity/truapi, the TypeScript product client. Typed methods, typed errors, typed subscription items.
• A Rust dispatcher (truapi-server/src/generated/) that the core uses to route incoming frames to host trait impls. Wire ids on the dispatcher and on the TS wire table are checked at build time to stay in lockstep.
• A typed HostCallbacks TypeScript interface mirroring truapi-platform's Rust traits, for web hosts.
• Kotlin and Swift HostCallbacks interfaces via UniFFI, for Android and iOS hosts.

The TS, Kotlin, and Swift surfaces are derived from Rust — they cannot drift.

        ┌─────────────────────────────────────┐
        │   Rust traits  (single source)      │
        │   truapi (protocol)                 │
        │   truapi-platform (host callbacks)  │
        └─┬───────────────┬────────────────┬──┘
          │               │                │
       codegen         used by          codegen + UniFFI
          │               │                │
          ▼               ▼                ▼
   ┌──────────────┐ ┌─────────────┐ ┌────────────────┐
   │ @parity/     │ │ Rust core   │ │ HostCallbacks  │
   │ truapi (TS)  │ │ runtime     │ │ TS / Kotlin /  │
   └──────────────┘ └─────────────┘ │ Swift          │
                                    └────────────────┘

A new RFC for a protocol method is a reviewable PR against the Rust traits. After it merges, codegen reruns, and every downstream artifact updates together.

The host surface (truapi-platform)

A host's only job is to fulfil the small set of capabilities the Rust core physically cannot do from its own process — open URLs, prompt the user, persist key/value pairs scoped to the origin, deliver push notifications, and open chain connections. That surface is:

• Storage — scoped key/value persistence
• Navigation — open URLs
• Notifications — push notifications
• Permissions — user permission prompts (device and remote-domain, kept as a two-call split per v0.1)
• Features — feature-support probing
• ChainProvider + JsonRpcConnection — chain RPC factory

Account management, signing, statement-store, and preimage flows live in the Rust core itself, backed by Storage for key material and ChainProvider for chain access. They are not part of the host surface. Their in-core implementations are tracked separately; until they land, the corresponding methods on the typed product client resolve to CallError::Unsupported.

What lands in this PR

Rust crates (new):

• truapi-platform — the capability traits above.
• truapi-server — the runtime: dispatcher, SCALE codec, subscription lifecycle, chain-runtime (chainHead v1 state machine on top of any JsonRpcConnection, plus an embedded smoldot provider behind a feature flag), localhost WebSocket bridge for native hosts, UniFFI surface for iOS/Android, wasm-bindgen surface for web/Electron with setActiveSession / clearActiveSession for cross-tab session handoff.
• uniffi-bindgen-cli — workspace tooling to regenerate Kotlin and Swift bindings.

Host SDKs (new):

• @parity/truapi-host-shared, @parity/truapi-host-web, @parity/truapi-host-electron — the JS host runtime split by integration surface. Pre-built WASM bundles ship with @parity/truapi-host-shared.
• android/ — Kotlin host shell wrapping the UniFFI bindings (HostBridge, HostStorage, TrUAPIHostCore).
• ios/TrUAPIHost/ — Swift Package with the matching Swift shell.

Codegen extensions:

• Rust dispatcher emitter (TS wire-table parity verified by a workspace test).
• TypeScript HostCallbacks emitter derived from truapi-platform rustdoc — so web hosts get the same typed surface UniFFI gives iOS/Android.

Architecture documentation under docs/design/:

• dotli-rust-core-proposal.md — recommends running the Rust core inside dotli's stable-origin protocol iframe (host.dot.li), inside a SharedWorker so the core is one-per-browser and storage stays on a stable origin even when product CIDs change.
• dotli-architecture-change.md — diagrams the transition.

What this PR explicitly does not ship

Scoped out and tracked separately:

• Account / signing / statement-store / preimage in-core implementations. Their methods on the typed client resolve to Unsupported.
• npm publish workflow for @parity/truapi-host-*. The packages build and test in CI; the release pipeline is a follow-up.
• A SCALE-adapter layer that would let the typed generated HostCallbacks fully replace the byte-level WASM bridge glue in @parity/truapi-host-shared. Both surfaces are exported; the adapter is the next step.
• Native host repos. The android/ and ios/ SDKs are ready to be consumed by Android and iOS host repos as vendored sources or git submodules, the same model hosts/dotli/ uses today.

How to verify

• make check — full Rust + JS workspace verification.
• cargo test --workspace --features ws-bridge — 178 tests including the WS-bridge round-trip and the Rust↔TS wire-table parity check.
• cargo check -p truapi-server --target wasm32-unknown-unknown — the WASM bundle compiles.
• ./scripts/codegen.sh then git diff — the committed generated TS, dispatcher, and host-callbacks artifacts are byte-identical to what fresh codegen produces.

Closes #96, #97, #98, #99, #100, #101, #102, #103.

[socket-security]

Review the following changes in direct dependencies. Learn more about Socket for GitHub.

Diff	Package	Supply Chain Security	Vulnerability	Quality	Maintenance	License
	npm/​@​parity/​truapi-host-web@​0.1.0
	npm/​@​parity/​truapi-host-wasm@​0.1.0
	cargo/​web-sys@​0.3.98
	cargo/​tokio@​1.52.3
	cargo/​smoldot@​1.1.2
	cargo/​smoldot-light@​1.1.3
	cargo/​uniffi@​0.29.5
	cargo/​thiserror@​1.0.69
	cargo/​wasm-bindgen@​0.2.121
	cargo/​console_error_panic_hook@​0.1.7
	cargo/​send_wrapper@​0.6.0
	cargo/​async-trait@​0.1.89
	cargo/​futures-timer@​3.0.3
	cargo/​getrandom@​0.2.17
	cargo/​pin-project@​1.1.13
	cargo/​rand@​0.8.6
	cargo/​tempfile@​3.27.0
	cargo/​tokio-tungstenite@​0.21.0
	cargo/​wasm-bindgen-futures@​0.4.71
	cargo/​web-time@​1.1.0
	cargo/​js-sys@​0.3.98
	cargo/​url@​2.5.8
	cargo/​unicode-normalization@​0.1.25

View full report