Signed Releases
An installed copy of your app updates only to a release you approved in your Vault.
An updater that trusts "whatever is at this address" can be made to install anything by whoever controls the address, the build machine or the signing key on it. A signed release adds one more check, and puts it in your hands: before your app installs an update, it checks that a person it trusts approved that exact set of files, for that channel, in their Flowsta Vault.
It works for any desktop app that updates itself, whether or not it runs Holochain. It needs no server of ours or yours: your app does the check on the device, from two public files.
The three pieces
| Piece | What it does | Where |
|---|---|---|
| The release manifest | Names one release: the app, the channel, the version, and every file with its size and SHA-256 | A JSON file you publish beside your release |
| Your signature | Your Vault shows you the manifest and signs it when you approve | POST /sign-release-manifest |
| The check | Your app refuses any manifest not signed by an identity compiled into it, for another app, for another channel, or older than what it has | flowsta-update-check (Rust) |
It sits beside your updater's own signature, and the two prove different things. The updater's key (Tauri's, for example) proves a file came out of your build. Your signature on the manifest proves a person meant to publish it. A stolen build key alone can no longer push an update to your users.
1. Choose who signs
Create a Flowsta identity for your project's releases in your Vault. Use one made for the project, not your personal one, so the role can be handed to someone else later.
Compile its DID into your app as a trusted signer:
const SIGNERS: &[&str] = &["did:flowsta:uhCAk..."];List a second identity, kept somewhere safe, before you need it. A change of signers reaches people only through an update signed by a signer their copy already trusts.
2. Write the manifest
After your release is built, write a manifest that names every file people will download:
{
"v": 1,
"app": "com.example.app",
"channel": "stable",
"sequence": 12,
"issued_at": "2026-11-20T03:00:00Z",
"version": "1.2.0",
"notes_url": "https://example.com/releases/1.2.0",
"rollout": { "percent": 100 },
"files": [
{
"platform": "windows-x86_64",
"kind": "nsis",
"name": "App_1.2.0_x64-setup.exe",
"url": "https://example.com/App_1.2.0_x64-setup.exe",
"size": 48211968,
"sha256": "<64 hex characters>"
}
]
}appis your app's identifier. A manifest for one app is never accepted by another.channelis a lowercase word of your choosing, such asstableorbeta. A copy follows one channel and refuses a manifest for any other, even one the same identity signed.sequencegoes up by one with every manifest on a channel. A copy remembers the last one it accepted and refuses anything at or below it, so an old manifest cannot be replayed.platformis one ofdarwin-aarch64,darwin-x86_64,windows-x86_64,linux-x86_64, andkindone ofapp-tarball,nsis,msi,deb,rpm,dmg.holochainis for an app that runs Holochain:"holochain": { "lines": ["holochain-0.7"] }names the version or versions the release runs on, and the Vault shows it when you sign. Leave it out otherwise.rollout.percentlets a release reach part of your users first. Each copy makes a number from 0 to 99 once and keeps it on the device; it is never sent anywhere.- Whole numbers only. A decimal prints differently from one language to the next and would change the hash, so a manifest with one is refused.
The library's README has every field, including the optional ones (a minimum version to update from, extra downloads a release needs).
3. Sign it in your Vault
Send the manifest to your Vault. It shows you the app, the version, the channel and every file with the start of its hash, and signs only when you approve:
const res = await fetch("http://127.0.0.1:27777/sign-release-manifest", {
method: "POST",
headers: { "Content-Type": "application/json", Origin: "http://localhost:7331" },
body: JSON.stringify({ manifest }),
});
const { signature, signer_did, statement } = await res.json();
manifest.signature = { signer: signer_did, sig: signature, statement };The caller must be an app your Vault is connected to, calling from one of your app's registered origins. A release script is a small app of its own for this purpose: give it an origin such as http://localhost:7331, register that origin for your app, and have it connect once.
Before you approve, compare what the Vault shows with what your script printed. The Vault's dialog is the one place where what gets signed is shown by something other than the script that built it.
Then publish the signed manifest at an address your app knows, one per channel.
4. Check it in your app
use flowsta_update_check::{check, check_file, Installed, Trust};
let release = check(
&manifest_bytes,
&Trust { app: "com.example.app", channel: "stable", signers: SIGNERS },
&Installed { version: env!("CARGO_PKG_VERSION"), last_sequence, rollout_ticket },
)?;
if let Some(file) = release.file("windows-x86_64", "nsis") {
// Download it (your updater checks its own signature), then:
check_file(file, &bytes)?;
// Install, and save release.sequence as the new last_sequence.
}check refuses, in this order: a manifest for another app, for another channel, not signed by one of your signers, at or below the last sequence, not newer than the installed version, or outside this copy's share of a partial rollout. check_file then compares the download's size and SHA-256 with the manifest. Every refusal says why in plain words. After one, install nothing and keep running.
An app in another language can do the same check: the signature is Ed25519 over the UTF-8 text
flowsta-release-manifest:v1:<app>:<channel>:<sequence>:<sha256>where the hash is of the manifest's JSON without signature, with object keys sorted and no whitespace. The signer's 32-byte public key is bytes 3 to 34 of the DID's key (uhCAk..., base64url without the leading u).
A working example
The Holochain Desktop Starter has all of it wired to Tauri's updater and GitHub releases: a script that builds the manifest from a published release, asks your Vault to sign it and publishes it per channel (scripts/release-manifest.mjs), the app's side (src-tauri/src/updater.rs), and a step-by-step release guide (RELEASING.md). The script and the guide can be taken into another Tauri app as they are.
What else your identity can sign
A release manifest is one use of the same idea: a statement about a set of files, signed by an identity people can check without asking a server.
- Anything you publish as files can carry a manifest of the same shape: a plugin, a model, a data pack. Your app checks who approved it before it loads it.
- Documents and creative work: Sign It signs a file's hash with your identity and lets anyone verify it.
- Your own data: a linked app can ask the Vault to sign bytes of its own, with the person's approval each time.
Next steps
- Vault IPC Endpoints - the signing call in full
- Register Your App - origins for your app and its release script
- Desktop apps - connecting an app to the Vault