ballotlabMIDNIGHT VOTING RESEARCH

BEYOND THE LOCAL DEMO

Wallets. Proofs.
Network transactions.

Connect the application to a compatible wallet and development services. Read the tested setup, operational steps and limits before beginning.

Built from the maintained network integration guide.View document source ↗ (opens in a new tab)

Native browser network client

network.html is a separate real Midnight.js client, with public Preview selected by default. native.html runs generated Compact circuits locally and does not generate proofs or send network transactions. The network page becomes available only when its actual bundle and generated assets are built. Loading it does not connect a wallet or send a request to the public network.

Preview reset — 7 November 2026: the same Preview URLs now serve a new ledger-9 chain. The source uses Compact 0.36.0/runtime 0.21.0, Midnight.js 5.0.0 and zkir-v3 3.2.0. Local browser proving (opens in a new tab) passed eight standalone proofs and one bound SDK transaction proof without a wallet. A separate genuine Lace 2.5.1 connection (opens in a new tab) passed with its saved WASM setting, then stopped before funding at a generic wallet-indexer HTTP failure. Later read-only service probes (opens in a new tab) observed HTTP 500 from the wallet's published indexer and 200 from the canonical indexer, including the signed transport headers; they do not supply the original CI status. No new-chain DUST proof, signing or election transaction was reached. Complete CI/deployment and wallet/DUST acceptance remain unverified. Read current status (opens in a new tab) before funding; earlier elections and balances are historical.

The GitHub Pages network page (opens in a new tab) has commit-specific SDK/WASM loading evidence. A locally served copy also completed the real Lace browser-wallet election described below. Separately, the 0.6.1 hosted Node wallet acceptance workflow completed 17 confirmed transactions and 16 proof transactions, finalizing [2,1,2,0,0] at block 137 on its own fresh local development chain. GITHUB_EXECUTION.md (opens in a new tab) retains that Node run's precise address, transaction IDs, tested commit fa94c3a19b4791441208ceae54a121faff2c588b and run links. Wallet transactions from the hosted Pages origin remain untested.

Version 0.6.1 includes sealed 2–5 candidate-count handling, five fixed ciphertext lanes and an external scheduled local-devnet operator. Its successful network run waited for actual indexed time after the sealed closing deadline, then submitted closing, trustee contributions 1 + 3 and finalization. The preceding 0.6.0 failure at its fifth ballot remains separately retained; it is not relabeled as passing. The local browser's scheduled preview and public JSON verifier are separate features; neither submits a network transaction or authenticates a network record.

Public Preview setup

Preview uses shared public node and indexer services. You do not need an API key or a local node/indexer. The page fills in the official indexer URLs and keeps them read-only for Preview:

Lace uses its own published service configuration. Changing application settings would not repair an unavailable wallet indexer. The signed Lace 2.5.1 settings screen (opens in a new tab) has no normal node/indexer URL editor; its disabled service controls are informational, and Save changes only the prover setting. The later HTTP-500 probes above are service observations, not a reason to modify the extension or bypass its normal configuration.

ServiceAddress
Node RPC, also used by the service checkhttps://rpc.preview.midnight.network
Indexer HTTPhttps://indexer.preview.midnight.network/api/v4/graphql
Indexer WebSocketwss://indexer.preview.midnight.network/api/v4/graphql/ws

These are the current official Preview endpoints (opens in a new tab). The browser-only configuration generates contract proofs in an application Web Worker using official Midnight WASM. Lace separately balances, signs and proves its wallet/DUST work using Run in this app (WASM). Neither step requires Docker, Node.js or an HTTP proof service on the user’s computer. Public node/indexer access and downloads of public proving material are still required; on-device proving does not mean offline use.

Historical verification: on the previous chain, the Lace 2.5.1 Preview test (opens in a new tab) completed nine indexer-accepted application transactions and eight browser contract proofs, with a checked receipt and final record. Its overall result remains failed because the test did not observe Lace's internal prover-WASM resource. The saved on-device setting, application proofs and accepted transactions are distinct from that missing observation. The central status record (opens in a new tab) retains the exact limits and later fundless diagnostic. The application used a local CI origin, not the hosted Pages origin. Completed browser circuit proofs, Ledger transaction diagnostics and Node Wallet SDK acceptance retain their separate dated evidence below.

Select Preview in Lace

  1. Open the application in the same browser where Lace is installed, then open and unlock Lace. Enable its Midnight account; a Cardano-only connection does not work here.
  2. In Lace 2.5.0, open Settings → Network → Testnet → Midnight: Preview → Confirm. This is the route used by the retained successful connection test. Selecting Preview on the application page does not switch the wallet's network.
  3. Open Settings → Midnight, find On this device, select Run in this app (WASM) and choose Save configuration. Keep that mode selected for DUST generation and election transactions. This option and its offscreen worker route were checked in the signed Lace 2.5.0 and 2.5.1 packages. Do not choose Custom proof server or a delegated provider for this browser-only flow. The app cannot select or attest Lace’s private setting through DApp Connector API 4; see the wallet-mode limitation.
  4. Reload the application page after installing or enabling Lace, or click Refresh wallet list. Select Lace, enter a password for this application's local key storage, then click Connect selected wallet and approve Lace's permission request. Use at least 16 characters from three of these groups: uppercase, lowercase, numbers and symbols. Avoid sequences such as 1234 or abcd, and more than three identical characters in a row. The installed SDK checks these rules before requesting wallet access. This is not your wallet password or recovery phrase.

Connection progress and errors appear directly below Connect. If the panel says it is requesting a connection from Lace, open the extension to look for its permission request. This step does not request transaction approval.

If Midnight is missing from an existing Lace wallet, its account menu provides Accounts → Add account → Midnight → Name → Next, followed by authentication. Add the account to the existing wallet; do not recreate or re-import it just to change networks. This additional-account route was checked in the signed Lace 2.5.0 extension source, not exercised on the user's wallet.

You do not need DUST to connect the wallet. The retained Preview connection test used an unfunded wallet and made no prover request. Before deploying, voting or submitting another transaction:

  1. Copy the Preview unshielded address (mn_addr_preview…) into the Preview faucet (opens in a new tab) and complete its CAPTCHA. The faucet supplies free test NIGHT and is rate limited.
  2. After the test NIGHT arrives, open the Midnight account in Lace and select Generate tDUST → Review transaction → Confirm. Lace fills in your tDUST address automatically; you do not need to copy another wallet address into that field. Wait for the DUST balance to become usable. Receiving test NIGHT alone does not start DUST generation. See the official funding guide (opens in a new tab).
  3. Keep the application tab and Lace open while proving. The first proof can download public proving material; complex proofs can use substantial memory and take time. A failed or interrupted proof is not an accepted transaction. The browser-only path has no HTTP-prover fallback.

Check public Preview services sends read-only RPC and HTTP indexer queries after you click it. The migrated guard pins the reset genesis, resolves the ledger protocol with the actual SDK and compares the indexer block hash to the RPC's block at that height. A matching name or URL alone is insufficient. It does not connect a wallet, inspect DUST, generate a proof or independently authenticate consensus. Preview wallet access and sensitive transaction steps repeat the guard; a changed session protocol or genesis fails closed. Wallet, network and service settings lock while connected so the form continues to describe the active session; disconnect before changing them.

If the faucet says “Captcha verification failed”

Use the official Preview faucet (opens in a new tab) with a Preview unshielded address (mn_addr_preview…), following the funding guide (opens in a new tab). Green Turnstile “Success” completes the browser challenge; the faucet must still validate its token. Captcha verification failed is a generic server-verification error and does not identify its cause.

Reload one faucet tab, complete a fresh challenge and click Request tokens once, promptly. Cloudflare tokens last five minutes and are single-use (opens in a new tab). The faucet resets the widget after failure, while the old error banner can remain beside a new green challenge. If the error immediately returns, stop repeated requests and give faucet support the exact message and time. Do not bypass the CAPTCHA or assume a browser extension caused it.

The read-only health/source check (opens in a new tab) retains timestamped public observations only; it neither submitted a request nor verified funding. Faucet recovery is separate from changes to this application.

If a button is disabled or a check fails

  • No wallet appears: check that Lace is enabled in this browser, has a Midnight account, and can access this site. Unlock it, reload the page and use Refresh wallet list. The application needs Midnight DApp Connector API 4; a Cardano-only wallet entry is insufficient.
  • Connect does not start: select a discovered wallet, complete the storage-password field and read the panel directly below Connect. The page brings this panel into view and names the current connection stage: wallet permission, account, network, wallet proving settings, browser proving worker or browser storage. Failures use fixed messages without exposing raw wallet errors or private data. Invalid passwords produce visible feedback before the public-service preflight or wallet request. Check that Lace itself is on Midnight Preview, not only the application's network selector.
  • Public services pass but Lace does not connect: the status below Connect identifies the current step: wallet permission, Midnight account access, matching network, wallet proving settings, browser-worker initialization or app storage. Failures use fixed guidance for that step without displaying wallet error payloads. A successful public-service check does not establish a wallet connection or a working proving worker. No transaction is submitted by Connect.
  • The app refuses a reported proof-server address: select Run in this app (WASM) in Lace, save the setting and reconnect. The browser-only path refuses a reported HTTP(S) prover address, including localhost. A missing address permits this check to continue but is not proof that Lace is using on-device proving; its API also omits the address for a delegated TEE mode.
  • A browser proof cannot finish: keep the tab open and check that the actual worker, WASM and public proving assets loaded. There is no server fallback. Do not resend a ballot after an uncertain wallet/submission result; resolve the existing attempt first.
  • The public-service check fails: this check does not require Lace, DUST or a running prover. The displayed message identifies the node or indexer and distinguishes an HTTP response, an unreadable response, a transport failure or a timeout. A transport failure cannot reliably distinguish CORS, DNS, TLS, an offline device or browser/network restrictions. The messages use fixed safe text and a validated HTTP status; they do not display upstream error bodies. A service-check failure does not diagnose the wallet. Share only the displayed error text when asking for help, never a recovery phrase, private key or storage password.
  • All controls stay disabled: read the page's loading/error message. The client keeps its controls disabled when its real SDK/WASM assets cannot load. Installing or funding a wallet does not fix an asset-loading failure.
  • Settings are locked after connection: disconnect before changing the wallet or network. This keeps the visible form consistent with the active session.

A fresh read-only recheck at 20:22 UTC on 4 November (opens in a new tab) returned HTTP 200 from RPC and indexer, Midnight Preview, node 1.0.400-87c0fbdb, and block 1600203. Both endpoints allowed the Pages origin through their CORS response and preflight headers. The WebSocket acknowledged a connection without a subscription. The deployment comparison (opens in a new tab) matched the latest successful Pages artifact to the local app files. These checks did not reproduce the reported button failure or exercise the user's browser, wallet or hosted application origin; they do not establish that the issue is fixed.

The revised feedback was then checked from local application origins: six browser scenarios (opens in a new tab), including deliberate node/indexer request failures, and six real public-service checks (opens in a new tab) passed. A fresh isolated Lace connection test (opens in a new tab) observed inline rejection of a weak password with no public request or wallet approval request, followed by a successful connection using a valid password and all five connection/five disconnect checks. It used a separate unfunded test wallet, not the user's wallet, and generated no proof or transaction. The evidence notes (opens in a new tab) bind these results to the tested bundle and preserve the preceding reports separately.

Recorded Preview checks

A separate read-only service probe on 4 November 2026 (opens in a new tab) returned Midnight Preview, node version 1.0.400-87c0fbdb, and indexer block 1599810. Its WebSocket check received a graphql-transport-ws connection acknowledgement without starting a subscription. This establishes service reachability at that time, not wallet synchronization, proof generation, accepted transactions or independent chain verification. The page's service-check button checks RPC/HTTP only.

A later real-browser service run (opens in a new tab) passed six checks from a locally served app: no automatic public request on load, actual cross-origin RPC/HTTP queries, an actual public-block WebSocket subscription, and layouts at 1440, 390 and 320 pixels. Both the HTTP query and WebSocket subscription returned block 1599911. This run did not connect a wallet or request a proof. Its subscription result is separate from the earlier command-line probe's acknowledgement-only result and from the page's RPC/HTTP check button.

An actual Lace 2.5.0 / DApp Connector API 4.0.1 connection to Preview (opens in a new tab) also passed in isolated Chromium 156.0.8078.4, using a fresh, unfunded test wallet and a local application origin. The application completed its public-service preflight, the wallet displayed and accepted its permission request, and all five connected-state checks and five disconnect checks passed. The test verified that selectors and service settings locked while connected, then checked cleanup and disabled contract actions after disconnect. It did not fund the wallet, contact the prover, generate a proof, sign or submit a transaction.

In that connection, Lace reported its own Preview indexer at https://blockfrost.lw.iog.io/midnight-preview/, WebSocket at wss://blockfrost.lw.iog.io/midnight-preview/ws, node at https://blockfrost.lw.iog.io/midnight-preview-rpc/, and local prover configuration at http://localhost:6300/. These observed wallet settings differ from the application's official Midnight-domain indexer URLs; both configurations target Preview. A reported prover URL alone does not establish that a prover is running.

A separate Node Wallet SDK election completed on public Preview; see Public Preview SDK acceptance. It used an isolated test wallet and does not establish that another wallet is ready. The dated connection-only checks above did not test transactions. The later complete Lace Preview election and its failed prover-observation check are recorded in current verification status (opens in a new tab). Wallet connection and transactions from the hosted GitHub Pages origin remain untested. The completed nine-transaction Lace election below used a separate local development chain.

Local development remains an advanced option and requires a compatible ledger-9 node and indexer. This build rejects Preprod because that environment still uses ledger 8; it is not a fallback for Preview. Mainnet remains blocked. Keep any private service tokens out of published source and logs.

Browser-worker circuit proofs

On 7 November 2026, 09:24:57.219–09:29:51.025 UTC, the ledger-9 migration completed eight standalone browser proofs across seven circuits and one genuine bound SDK configureKeys transaction proof (opens in a new tab). It used Compact 0.36.0, compact-runtime 0.21.0, Midnight.js 5.0.0, ledger-v9 1.0.0 and ZKIR 3.2.0. Both invalid-input checks were rejected. The native browser election also completed voting, two-trustee tallying and public-record checks; the network client reached Ready and passed the pinned Preview service check at block 5040. These were local-origin checks of an uncommitted migration build, with no wallet, DUST proof, signing or network submission. They do not establish CI or deployment success, independent proof verification or a completed reset-chain wallet election.

The following runs retain their historical ledger-8 versions and results.

On 6 November 2026, 18:19:23.735–18:24:47.551 UTC, a real browser run from a local application origin generated eight nonempty proofs across all seven native circuit types using official ZKIR 2.1.1 in the dedicated worker. The public report (opens in a new tab) records a successful constraint check followed by a proof for key configuration, enrollment, opening, casting, closing, two trustee contributions and finalization. Compact 0.31.1, compact-runtime 0.16.0 and Midnight.js 4.1.1 were used. The complete run took about 5 minutes 24 seconds; key configuration took 83.698 seconds and the five-choice ballot proof 170.150 seconds on that device. These are observed timings, not performance guarantees.

The fixture created fresh synthetic witnesses in browser memory, used the actual generated contract, and ended at local phase 3 with one accepted synthetic ballot. Its controlled circuit-context timestamps test deadline constraints; they are not network block time or accepted network operations. An incorrect registered trustee share was rejected before a proof request. A cast-ballot preimage paired with the enrollment circuit location was rejected by the worker check. Only circuit names, proof lengths, proof digests, timings and bounded public status fields were retained; no choice, key, randomness or proof preimage was exported.

This run used no wallet or HTTP proof provider and submitted no transaction. The task-owned HTTP prover was stopped. The worker’s code permits only fixed same-origin public-asset GETs and verifies their sizes and SHA-256 digests against build pins. The page’s connect-src 'self' metadata is recorded separately; it does not itself constrain a normal same-origin worker. Independent verification of the returned proofs is not claimed. This is application-circuit proof generation, not a Lace wallet/DUST proof test or Preview acceptance.

The first attempt (opens in a new tab) remains a failed startup run: it timed out and produced zero proofs. Its erratum (opens in a new tab) corrects an overbroad CSP label without changing that result. The subsequent source fixes added an explicit worker boot handshake and preserved the official ledger WASM initializer before provider construction. The successful second attempt does not overwrite the failure.

The user has reported selecting Run in this app (WASM) in Lace. The signed-package source review (opens in a new tab) establishes that this normal option routes wallet proving through a dedicated worker; it is not a runtime observation of the user’s wallet. Later isolated Lace Preview testing is tracked in current verification status (opens in a new tab). Its selected WASM setting and accepted transactions must remain separate from observed prover-resource evidence, subject to the API-mode limitation. Hosted-origin wallet behavior remains untested.

Ledger transaction proof diagnostics

On 6 November 2026, two additional browser runs completed actual Ledger Transaction.prove calls with fresh synthetic fixtures and official SDK construction: openVoting at 19:00:08 UTC and configureKeys at 19:01:53–19:03:09 UTC. Each delegated a real constraint check and a bound proof to the same application worker. The transaction-proof calls took 371 ms and 75,716 ms respectively. The reports, screenshot and exact source/build hashes (opens in a new tab) retain their scope.

These calls used a fresh official proof-provider wrapper around the real worker callbacks. They did not exercise the application's outer transaction error/concurrency wrapper, connect Lace, generate wallet/DUST proofs or submit a transaction. The setup state and timing were synthetic; no independent proof verification is claimed. These timings do not establish that the user's pending key-registration operation was fixed.

A separate failure-only regression checks that the application preserves a safe terminal error code when Ledger wraps a worker callback rejection. That diagnostic fix distinguishes timeout, asset-integrity failure and cancellation without exposing private errors. It does not change proving performance or resolve an unknown stall.

Public Preview SDK acceptance

On 6 November 2026, from 2026-11-06T17:20:25.465Z to 2026-11-06T17:40:07.714Z, an isolated Node Wallet SDK wallet completed a full election on the shared public Preview network. The acceptance report (opens in a new tab) records nine application transactions reported SucceedEntirely by the configured public Preview indexer and eight completed contract-proof-provider calls. Deployment is included in the nine transactions; faucet funding and the separate accepted DUST registration are not. These counts are not a count of every prover HTTP request or wallet fee proof.

The final phase was 3, with one accepted test ballot, two active choices and five-lane totals [0,1,0,0,0]. The run checked the indexed receipt and public record (opens in a new tab) using the actual generated native helpers. Closing was requested at indexed time 1793986710, after the sealed deadline 1793986707. An external runner submitted closing, trustee contributions 1 + 3 and finalization; the chain did not execute them automatically.

  • Contract address: 85cac7e2cc83baaf7f26ec0fb6875f04088c631cd445d992175b0031834b361a.
  • Configuration fingerprint: a857d00ed53d82b8969fc586d60181434f88ef4e3558b3b38fecc3c7faa70ffc.
  • Tested source baseline: d22ce6171b5548f70b8360f12709562e9e8051fa (opens in a new tab); the source record (opens in a new tab) and report retain the exact staged-source hashes. The staged native client and generated contract bytes matched that source.
  • Tested SDK graph: compact-runtime 0.16.0, Midnight.js 4.1.1, Wallet SDK 1.2.0, ledger-v8 8.1.2, onchain-runtime-v3 3.0.0, zkir-v2 2.1.1; contract compiler pin 0.31.1. The separate graph passed 26 generated native-contract tests. Dependency-lock SHA-256: 1d8262cd228ed815ee7111d783a9b45639af99b770595824a1dc7ee0f15b1929.
  • Execution environment (opens in a new tab): Node 24.18.0, npm 11.16.0, local proof server 8.1.3. These are the SDK runner's versions, not a new browser/extension test or a replacement frontend lockfile.
Application operationTransaction IDIndexer block
deploy007a155f6d60c3b98018204a53bb16197a804f22d16b23e6684018fb78829bcc4a1627165
configure-keys00d5eb85f37fe374053447b22051c887aa183738516fac249f593cab620f1c28071627169
enroll-one-synthetic-voter00d77c34aabde9e10e412a986a88be3a4ec2bedf9668ff48a7e95e3b1f670c26611627172
open-voting005af2ad9de8779c0bda8b8832c21420e64f7463e2edf23f91b4473973261d13801627268
cast-one-synthetic-ballot00c4988fa7a4f4444852943f7bf5fb1266b81421533f5f1027b3211a3c987f29d51627273
close-voting006ec0ff327a65e3b0915343a5c0d8a71b7b0b7a98baba511695e83cdc6242e34f1627347
trustee-1009997be67a375ac9c12977f30ea9465b06b481ab71ab3e77719f8c9b1d28a7a261627351
trustee-300094deeef913eb72b696a3a3ed74631cc4709bb2c9232382ca83509097fccae3d1627354
finalize00d1f34ba80fa05c25230251b2b6283452e9b2a3d7e851bfb0a6eec9525ea0f4ef1627358

Scope: this is actual proof generation and configured-indexer acceptance on public Preview. It is not independent consensus or chain-inclusion verification, election certification, independent trustee custody or proof of fairness. The browser demo still runs locally without network proofs or submissions. This SDK run did not exercise Lace or the hosted frontend. The separate local Lace election is described below, and later Preview browser-wallet testing is recorded in current verification status (opens in a new tab). Wallet connection or transactions from the hosted GitHub Pages origin and Preprod transactions remain untested; mainnet is blocked.

Wallet compatibility

The recorded pre-reset Preview test used signed Lace 2.5.1 with DApp Connector API 4.1.0. Normal wallet creation, Preview selection, persisted Run in this app (WASM) selection, dApp connection, DUST registration and all nine application transactions completed in the isolated CI browser. Eight application proofs completed, and the final totals were [1,0,0,0,0]. The overall test failed only its required observation of Lace's internal prover-WASM resource; see current status and exact tested versions (opens in a new tab). It does not establish reset-chain or hosted-origin compatibility or independently attest the wallet’s proving mode.

Midnight-enabled Lace 2.5.0, exposing DApp Connector API 4.0.1, completed a full election through this application's real browser UI on the local `undeployed` network. The retained browser report (opens in a new tab) records wallet approval, proving, submission and configured-indexer acceptance. The official Midnight browser guide (opens in a new tab) describes Lace 2.4.3; the version tested here is Lace 2.5.0 (opens in a new tab), whose official announcement (opens in a new tab) describes its Midnight features. Package verification (opens in a new tab) retains the extension digest and verified developer/Web Store signatures.

The wallet picker discovers API-4 entries under window.midnight, including their name and rdns; it does not certify a wallet publisher. Other wallets are conditional candidates only if they implement the required API and satisfy these checks. A Cardano-only wallet or CIP-30 connection under window.cardano is not supported. Having ADA or Cardano NIGHT does not provide the Midnight connector used here.

  • The wallet must connect to preview or a compatible undeployed local chain and expose the required API-4 addresses, transaction balancing and submission methods. This ledger-9 build rejects Preprod while it remains ledger 8; mainnet is rejected.
  • Select Lace’s on-device WASM mode. The application’s contract proof provider runs in its own worker; this does not replace the wallet’s separate DUST/fee proving work. The application refuses any reported proverServerUri, including a loopback HTTP address, for its browser-only configuration.
  • A working indexer, usable test-network DUST and successful on-device proof generation are separate requirements. Connecting an unfunded wallet establishes none of them.

Wallet-mode limitation

DApp Connector API 4 exposes an optional, deprecated proverServerUri in getConfiguration() but no proving-mode field, attestation or app-supplied wallet prover callback. In the inspected signed Lace 2.5.0 and 2.5.1 packages, both `in-process` and `tee-delegated` omit that URI. Rechecking configuration before an operation can reject a reported external or loopback proof server; it cannot distinguish those two omitted-URI cases. A missing URI, user-selected option or successful proof must not be presented as cryptographic evidence of where the wallet processed its private data. Page CSP also does not constrain extension-origin network requests.

The normal Lace WASM setting routes both the wallet’s transaction proving service and its DApp circuit provider through an offscreen document and dedicated worker. The retained ledger-8 test used public proving-material directory 9; source review of the same signed wallet identifies directory 10 for ledger-9 material. These directory numbers are not ledger major versions, and source inspection is not execution evidence for the updated wallet/DUST path. getProvingProvider(KeyMaterialProvider) lets a DApp supply public contract keys for the wallet to prove; it does not expose wallet/DUST witnesses or install a DApp’s worker inside Lace. This application proves its own contract work in its worker and leaves wallet/DUST work inside Lace.

Record actual application-worker proofs, the selected Lace mode, wallet/DUST proof behavior and accepted Preview transactions separately. The current verification status (opens in a new tab) distinguishes the completed browser election from its failed wallet-prover observation. The preceding HTTP-prover tests remain historical evidence; they are not proof of the new browser path. Never extract wallet secrets, patch the extension or silently use a remote prover to manufacture this result. See the API specification (opens in a new tab) and the verified Lace package provenance (opens in a new tab).

The installed-provider boundary tests (opens in a new tab) passed three cases, and Chromium loading checks (opens in a new tab) passed four no-wallet cases. Those tests establish loading/rejection behavior only. The real Lace run below adds browser-wallet transaction evidence; the Node-wallet development-chain runs remain separate evidence. No other browser wallet has been tested.

Verified local Lace election

On 3 November 2026, from 21:16:54 to 21:28:56 UTC, the real application UI and Lace approval dialogs completed nine transactions: deployment, key configuration, enrollment, opening, one ballot, closing, contributions from trustees 1 and 3, and finalization. The eight contract calls used real proving. All nine were reported accepted by the configured local indexer; a separate Node SDK query to that same indexer (opens in a new tab) returned SucceedEntirely for each, at blocks 468–562. This is not independent consensus or chain-inclusion verification.

The final phase was 3 with two active choices and padded totals [0,1,0,0,0]. The receipt matched the indexed record, the rendered QR was independently decoded, and the public export passed its privacy check. The browser report (opens in a new tab) retains these checks and 33 successful HTTP responses from the local prover's /prove and /check endpoints. That count includes validation and fee-proof work; it is not a count of contract proofs. The report observed positive usable DUST after synthetic local funding (opens in a new tab). Funding transactions were sent by separate Node SDK wallets and are not included in the nine application transactions. No public-network or mainnet funds were used.

The environment used Lace 2.5.0, DApp Connector API 4.0.1, Node 24.18.0, Playwright 1.64.1, Chromium 156.0.8078.4, Midnight.js 4.1.1, compact-runtime 0.16.0, Compact 0.31.1, node 1.0.400, indexer 4.3.5 and proof-server 8.1.3. A byte comparison (opens in a new tab) matched all 27 checked application files and assets to Pages artifact 13268254934 from commit f510608ece6b34b3206b3a1b99f05806ed248d95. Matching code does not establish hosted-origin wallet permissions or service access. That local run did not test browser-wallet transactions from GitHub Pages, Preview or Preprod; the separate public Preview SDK acceptance above and later Lace Preview test (opens in a new tab) have their own evidence. Mainnet is blocked. The evidence directory (opens in a new tab) also preserves the first interrupted attempt separately.

Dependencies and APIs inspected

The current Preview target follows the compatibility matrix (opens in a new tab) checked on 7 November 2026: Compact 0.36.0, compact-runtime 0.21.0, onchain-runtime-v4 4.0.0 and Midnight.js 5.0.0. The installed browser prover is zkir-v3 3.2.0. Do not mix these with ledger-8 generated assets or the preserved local-devnet graph. Successful compilation/runtime tests are not browser-proof or accepted-transaction evidence.

contracts/native/browser-providers.mjs uses Midnight.js 5.0.0 providers, era-tagged transaction/state values and explicit network configuration. The browser contract proof provider uses official Midnight WASM in a dedicated worker; the wallet bridge uses DApp Connector API 4 for balancing, signing and submission. Earlier browser-guide examples use different wallet/runtime/prover versions and do not establish compatibility of this graph. The official migration guide (opens in a new tab) describes the ledger-9 API changes.

The browser build includes the real events, assert, buffer and process/browser packages where SDK dependencies require their browser implementations. An actual Chromium load exposed an unbound process reference in util; the network build now injects the installed browser process and Buffer implementations. These are platform compatibility dependencies, not replacements for the generated contract or Midnight WASM. The indexer provider receives the browser's native WebSocket constructor explicitly.

For plain-HTTP/WS local development indexers, use localhost or 127.0.0.1. Chromium rejected IPv6 literal CSP host sources in the earlier browser acceptance run, so those directives were removed and insecure IPv6 indexer URLs fail configuration validation. This concerns development indexer access, not permission to use an HTTP prover in the browser-only flow.

Run the flow

Use the published network page, or build the real native contract and network browser bundle and serve them over HTTPS or loopback. keys/ and zkir/ must be available under native-contract/ alongside network.html; the bootstrap preserves GitHub repository subdirectory paths.

During an action, the current step and elapsed time appear beside its button and in Election activity. Contract proving happens before Lace's transaction approval request. The elapsed timer measures time spent in the whole action, not proof completion or a network deadline. Do not retry a pending action just because its button is disabled; wait for its outcome and check the public record if submission is uncertain.

  1. Connect. Select Preview in Lace and your API-4 wallet in the app. Use Check public Preview services, enter a strong local storage password and connect. Funding is not required for connection. The app validates the password and public services before requesting wallet access; mainnet is rejected. Wallet account, network and reported prover configuration are rechecked before proving, balancing and submission. Connection settings stay locked until disconnect.
  2. Set up election. Before a transaction, obtain usable test DUST and confirm Lace is still set to Run in this app (WASM). Join with a trusted contract address and fingerprint, or create a test election with a future opening and closing schedule. Generate and register its trustee keys before enrollment, then save the election details and private trustee files. Registration is a separate proved configureKeys call; deployment does not prove private key setup.
  3. Vote. Register each voter before the scheduled opening time. Submit Open voting during the voting window and wait for confirmation, then use the same registered voter key to choose and submit a ballot. Ready to vote? explains any unmet requirement. The contract checks membership, uniqueness and one-hot encryption; the client compares the indexed receipt with the ballot it constructed from the private inputs. Save the voter’s receipt.
  4. Reveal results. Close voting after the real deadline, submit two registered trustee contributions and finalize with a supported pair. The contract uses the full frozen aggregate. Changing screens or reaching a countdown deadline does not advance the network clock or submit these transactions.
  5. Verify election. Refresh or download the connected election record, compare a receipt against that record, or upload a saved record for local consistency checks without a wallet. Keep the full JSON/QR receipt: its QR carries the network, contract, configuration, ballot index and receipt hash, without a choice, randomness or transaction ID. A matching record does not independently authenticate chain inclusion.

In 02 / Set up election, choose Create a new election to enter its name, choices and schedule, or Join an election to enter an existing contract address and trusted fingerprint. Choosing a view does not send a transaction. The administrator key tools remain available in either view. Once this session has created or joined a contract, the choice is locked; disconnect before selecting another election.

The blue Your election, step by step row switches between five separate screens: 01 Connect, 02 Set up election, 03 Vote, 04 Reveal results and 05 Verify election. Only the selected screen is shown. Use its Back / Next controls or choose another blue stage button; Election activity remains available beside the current screen and stacks below it on narrow displays.

Switching screens preserves the current form values, private keys, receipt and uploaded-record result in this tab. It does not connect a wallet, join an election, refresh the indexer, send a transaction or advance the contract’s phase. You can open Verify election immediately to check a saved file without a wallet. Navigation is disabled while an action is running, keeping its progress visible. Refreshing or closing the browser remains different from changing screens and can discard the private session.

Existing links to headings and controls, such as network.html#vote-heading or network.html#check-heading, reveal the corresponding screen. A readiness or receipt link likewise opens its destination screen. These links do not bypass any action’s wallet, configuration, key or voting-window checks.

Election activity shows opening and closing dates from the last loaded contract record, with a countdown based on your device clock. It distinguishes scheduled voting, an opening transaction still needed, voting in progress, an elapsed voting window awaiting closing, a closed election awaiting the tally and finalized results. The time display does not send transactions or refresh the indexer automatically. Its last-updated time shows when the record was read; use Refresh election record to fetch the current phase. Reaching a deadline on your device is not evidence that a transaction has been accepted.

Earlier navigation and timing evidence (opens in a new tab) separates actual generated-ledger lifecycle checks from the browser’s navigation and unjoined-state checks. It records the preceding layout and is not a test of later screen-navigation changes.

The earlier five-stage navigation check (opens in a new tab) covers the Verify election shortcut on that build’s desktop, tablet and mobile layouts. The new screen-navigation evidence (opens in a new tab) records ten passing network-browser cases, including four viewport widths, preserved inputs/results, keyboard focus, direct links and browser history. It also retains the failing fragment-focus check and its successful correction, plus fresh native and provider checks. These checks generated no proof or transaction.

The Save this election for later card stays visible in 02 / Set up election, in both Create and Join modes. After Register trustee keys is confirmed, use Download election details to save the network, contract address and fingerprint in a public JSON file. The fingerprint is created during key registration, so this download is unavailable immediately after deployment. It is also available after joining a configured election. The download rechecks the pinned configuration against the configured indexer; it does not independently authenticate blockchain history.

To return, select the same network and choose Join an election → Load saved election details. Loading the file fills the address and fingerprint without connecting, joining or submitting anything. Connect your wallet and click Join election to run the contract checks. The importer requires a JSON file up to 4 KiB with exactly the supported public fields; wrong-network, duplicate-field, malformed and private-key files are rejected without replacing the existing details. Share this public file with participants through a trusted channel.

When voting is unavailable

Ready to vote? in stage 03 explains the current requirement and links to the relevant control. Connect the wallet, create or join the election, register trustee keys and register voters before the opening time. During the voting window, submit Open voting and wait for its confirmation. The contract does not execute an opening transaction merely because a countdown reaches zero. If another participant opened voting, use Refresh voting status to load that change.

The page checks the loaded voter key against the actual native election membership and spent-nullifier records before enabling choices. The checks run locally and disclose only readiness messages; they do not log the private key or derived identities. Load the key registered for this election rather than generating a replacement. Submission also requires an active choice, no unresolved vote attempt and a voting window that has not elapsed according to the device clock. The clock check is conservative UI guidance; the contract still validates the real transaction and its deadline. A stale record or incorrect device clock can require a refresh or clock correction.

A pending attempt remains locked until its outcome is resolved. It does not by itself prove that a transaction was submitted, and an absent receipt is not permission to submit again. None of these display checks advances the election, clears pending state or bypasses contract validation.

The 6 November readiness checks (opens in a new tab) include actual generated-contract lifecycle and eligibility tests, real Chromium controls and a fresh, unfunded Lace 2.5.0 connection to Preview from a local application origin. They do not establish a new accepted Preview vote or reproduce the user's wallet session. The preceding diagnostics build (opens in a new tab) is retained separately with its own source and bundle hashes.

Save and load trustee keys

After generating and registering the trustee shares, save Download trustee 1 key, Download trustee 2 key and Download trustee 3 key before leaving the setup session. Each private JSON file contains only one share, its trustee number and the public election identifiers. The filename includes the trustee number and an address prefix to help keep elections apart. Each download rechecks that the share matches the registered public key using the actual generated Midnight circuit helper; edited or regenerated shares that do not match are refused.

These files are private and unencrypted. Give each trustee only their own file, and keep them separate from public election details, receipts and election records. They are never included in public exports or logs. This file feature does not change the centralized demo key setup or its privacy limits.

A returning trustee joins the same election and chooses Or load your saved trustee key under Reveal results. The app validates the file’s network, address and fingerprint, refreshes the configured election, and uses the native public-key operation to check the share. Only then does it select the trustee and fill the hidden key field. Loading does not submit a contribution; the trustee still clicks Submit trustee contribution and approves any wallet request. A rejected file leaves the selected trustee and share unchanged. Imports accept only the exact supported JSON schema, valid UTF-8 and bounded nonzero scalar values, within 4 KiB.

The file-backup checks (opens in a new tab) distinguish format tests, real generated-contract key matching and browser import/availability checks. They do not claim a newly executed wallet-connected backup/restore flow or accepted network transaction.

Transaction actions can request wallet approval and consume test-network DUST. Saving or loading a key file does not submit a transaction. Ending the local session clears its input fields and application references. It does not delete downloaded key files, revoke wallet permissions, erase encrypted SDK storage or guarantee erasure of JavaScript memory.

Save and load administrator or voter keys

The administrator field starts empty and read-only. Choose Generate administrator key for a new election, Use an existing key to paste a saved key, or load its file. This explicit entry step helps prevent browser login autofill from being mistaken for an election key. Generate administrator key or Generate voter key creates a new key and shows it in its field. Use Hide key to mask it and Show key to reveal it again. For an existing administrator or registered voter, load the existing key instead of generating a replacement. The same administrator key tools are available when joining an existing election.

Use Download key beside the appropriate field. Administrator files are named midnight-administrator-key.private.txt. Voter files are numbered, for example midnight-voter-key-000001.private.txt and midnight-voter-key-000002.private.txt. The first download or cast assigns a number to that key; repeated downloads in the same session reuse it. Loading an original numbered key file restores its number and reserves the numeric counter so a new key does not immediately reuse it. A renamed file or pasted key gets a new number when first used unless already known in this session. This browser persists only the counter; the key-to-label mapping exists only in memory and is cleared on disconnect. If the counter cannot be saved, allocation uses a timestamp and a session counter. These are file labels, not registered voter IDs.

The receipt matches that label, for example midnight-voter-000001-receipt.json. Its filename is captured for the key used at casting, so selecting or generating another key does not rename the last receipt. A pending receipt keeps its original label for recovery in this session; if no label is available, a neutral receipt-ID filename is used. The number is not added to receipt JSON, QR data, network records, logs or public exports. The browser demo uses its selected demo voter number with the same receipt filename format.

These are private, unencrypted text files. Keep them separate from public receipts and election records; they contain the key only, with no vote, receipt, contract address or network. Anyone who obtains the applicable key can attempt actions authorized by that key. The application does not include these keys in public exports or logs.

To restore a key, choose its file under Load a saved administrator key or Load a saved voter key. It is loaded hidden; use Show key if needed. Import accepts a .txt file of at most 256 bytes containing one nonzero 64-character hexadecimal key, with optional surrounding whitespace. It validates UTF-8 and the key format before replacing the field. A rejected file leaves the current key unchanged. Format validation does not establish that the key belongs to the selected election; the actual contract checks its authority or membership when used. Loading a voter key does not register a voter or allow another vote after that voter has already voted.

A key file is not a full election backup. Also save the public election-details file or retain its network, contract address and trusted fingerprint. To return to an already configured election, connect a wallet to the same network, join using those details, then load the original administrator or voter key. These application keys are separate from the wallet that pays transaction fees. A complete restore followed by an accepted transaction in another browser has not been tested. Administrator/voter files do not restore trustee shares; use the separate private trustee files described above. None of these files restores a wallet, the dealer’s setup secrets, a pending receipt check, encrypted SDK storage or the rest of a browser session. Reloading between deployment and key configuration still cannot be recovered through Join; keep that setup session open until configuration finishes. The pending-vote limitation below also remains unchanged.

The key-file and setup-control evidence (opens in a new tab) records eight passing browser scenarios, including actual private downloads and strict file rejection. A separate real Lace Preview connection checked mode selection and key clearing on disconnect. These controlled tests used disposable keys and an unfunded test wallet; they did not submit an election transaction or access the user's wallet.

If a ballot call has an uncertain result, the pending-ballot check retains only the locally expected public nullifier/receipt and checks the indexer without resubmitting. Further casts are blocked while it exists. This recovery state lasts only for the current client session, and a wallet rejection can also leave a pending record. Absence in an indexer is not evidence of non-submission. Check the transaction status through the wallet or a trusted network service before ending the session or making another attempt. Joining after reload currently requires an already configured election; resuming between deployment and key configuration needs additional deployment-state authentication and is not implemented. Keep the initial setup session open through key configuration.

After voting and checking a receipt ID

After a ballot is found in the configured indexer's accepted record, the page shows its receipt ID and a What happens next? explanation. The sealed closing time is the earliest time voting can close. Results require a closing transaction, valid contributions from two trustees and a finalization transaction. The deadline alone does not publish totals; this page does not run the external operator. Once final totals are available, voters can review the public observation and compare their receipts.

Paste receipt ID accepts the 64-character hexadecimal ID from the receipt. It searches only the currently joined, configuration-pinned election, requires a unique accepted match and checks that ballot's native receipt digest, ciphertext and receipt-set membership. This is a lookup in the configured indexer's record. It does not establish ownership, authenticate the indexer, verify a transaction reference or independently prove chain inclusion. Keep the full receipt: unlike a bare ID, it also supplies the network, contract and configuration details to compare. Existing full-receipt validation remains available.

Upload a downloaded network record

Open 05 / Verify election directly with its blue stage button. Upload a saved election record accepts the JSON produced by Download election record, including files from earlier sessions. No wallet or connected election is needed, and completing the preceding screens is not required. The file is checked locally using the generated contract helpers and actual Midnight WASM. The result displays its network, contract address, fingerprint, recorded stage, ballot count and finalized totals. Choice names appear only when the optional election manifest matches its committed digest. Switching to another screen and back preserves this result; choosing another file clears the earlier result before checking it.

The importer requires valid UTF-8 JSON up to 8 MiB, bounded nesting and the exact midnight-ballot-lab/native-indexed-observation/v1 schema. It rejects duplicate or extra fields, private data, invalid coordinates or subgroup points, inconsistent key/configuration relations, duplicate nullifiers, changed receipt commitments, incomplete aggregate sums and invalid finalized threshold equations. An unconfigured record cannot pass these checks; download it again after trustee-key registration. A failed upload clears any preceding upload result and preserves all connection/election settings.

The uploaded result is separate from Election activity and the live receipt lookups. Uploading never joins an election, changes the selected network, advances its phase, enables voting or sends a transaction. It validates consistency of the supplied public data, not the authenticity, freshness or completeness of the record. No ballot eligibility, ciphertext well-formedness, trustee contribution or chain-inclusion proof package is present. An internally consistent replacement record can still pass. The browser-demo snapshot schema remains separate and belongs in the browser demo's upload control.

Evidence stages and privacy

The UI emits fixed stage labels only. It never logs raw SDK return objects, errors, transactions, private contexts or proof data. Confirmed operation records retain only a transaction ID, block height and explicit configured-indexer confirmation source. Receipt exports are an allowlist. Public observations reuse the public-ledger field projection with a distinct native-indexed-observation/v1 schema and explicitly state that no proof package or independent chain verification is included.

The application’s proving worker receives private contract witnesses and uses official Midnight WASM locally. It has no HTTP proof fallback. Lace separately handles its wallet secrets and DUST witnesses; select its on-device mode. The application refuses a reported proof-server URI but cannot attest the omitted-URI mode through API 4. This distinction is described in Wallet-mode limitation; do not label the whole wallet flow as independently verified on-device merely because the application worker returned a proof.

A prover return is not a submitted transaction. A wallet submission return is not confirmation. callTx/deployContract resolve after the configured indexer reports the outcome. That does not independently validate a canonical chain, honest deployment state or maintenance history. Verifier-key and configuration comparisons remain necessary but insufficient for an authenticated public election record.

The synthetic dealer knows the master secret and every share; this is not distributed key generation. Two colluding trustees can decrypt individual ciphertexts outside this contract. Eligibility administration, device trust, coercion resistance and cast-as-intended assurance remain outside this prototype.

External scheduled development operator

contracts/devnet/scheduled-operator.mjs is invoked by the isolated acceptance runner. It reads the sealed closing deadline, waits for both actual wall-clock and indexed block time, then closes, supplies two externally provided synthetic trustee shares and finalizes through the real SDK providers. Each step requires configured-indexer acceptance. It does not bypass deadline/share constraints, change node time or make the chain execute itself. A running operator, wallet, prover and indexer are required. Hosting the frontend on Pages does not run this service. See the operator instructions (opens in a new tab).

Fresh checks and remaining requirements

During this continuation, the actual installed browser-provider module and SDK client with real generated bindings imported successfully in Node. Nine configuration/privacy boundary tests, four receipt-encoding tests and three tests of fail-before-wallet-access behavior using the installed official SDK passed. These are adapter/API checks; they do not constitute generated-contract execution, a real wallet connection, proof generation or a network transaction. Full browser and release evidence belongs in the continuation verification report.

The historical isolated local-development run used node 1.0.400, indexer 4.3.5 and proof-server 8.1.3, preserved under contracts/devnet/. Its runner used the actual then-matching application/generated bindings and official local genesis fixture in memory, against real wall/chain deadlines. It accepted no external seed, used no faucet and connected to no public network. The manual workflow now rejects current ledger-9 source before starting these incompatible ledger-8 services; its historical acceptance reports are unchanged.

The Node wallet acceptance graph is isolated in contracts/devnet/package-lock.json: Midnight.js/testkit 4.1.1, wallet SDK 1.2.0, compact-runtime 0.16.0, ledger 8.1.2, onchain runtime 3.1.1 and ZKIR 2.1.1, matching the maintained official example overrides (opens in a new tab). That recorded run used a separate application/browser dependency graph. Its staging copied byte-identical application sources and generated bindings into the Node graph, recorded their SHA-256 hashes and reran the actual generated-contract tests there. It does not recreate the contract with different logic. Both testkit and supplied wallet loggers are silenced before fixture credentials are read; the runner emits only allowlisted public records. Encrypted transient SDK storage uses a random in-memory password and a dedicated temporary directory removed after the run.

The recorded local network run passed on 3 November 2026, from 17:04:48 to 17:14:25 UTC. The retained public report (opens in a new tab) records 17 transactions reported SucceedEntirely at blocks 8 through 100: deployment, key configuration, five enrollments, opening, five ballots, closing, two trustee contributions and finalization. The run completed 16 contract proof transactions after deployment, checked five indexed receipts, and finalized phase 3 with totals [2, 1, 2]. Invalid choice, duplicate credential, wrong trustee share and changed totals were rejected by adapter/generated-runtime checks without a completed proof or submission. The replay attempt was rejected by the submission pipeline; its exact private diagnostic was withheld, and independent network rejection is explicitly unverified.

A readiness result or a locally generated proof is not an accepted transaction. The runner requires SucceedEntirely from the configured indexer for every counted transaction and compares native receipts and final totals. This establishes accepted local development transactions under that confirmation source, without authenticating the indexer or independently verifying canonical chain inclusion. The evidence contains the contract address, configuration digest, public transaction identifiers, source hashes and exact dependency versions.

The separate local Lace election above establishes actual browser-wallet application transactions on that local chain. The Node runner alone does not establish browser-wallet behavior. Public Preview service queries, a public-block subscription and a real Lace connection have now been checked separately from a local application origin. The separate Node Wallet SDK run above now establishes proving and configured-indexer acceptance on public Preview. That SDK run does not establish browser-wallet behavior. The completed Lace Preview election and failed wallet-prover observation are tracked in current verification status (opens in a new tab); hosted-origin wallet connection/transactions and Preprod service/wallet use remain untested. Public Preprod service access requires a matching Blockfrost project token or your own services; do not invent one or publish a private credential. No wallet seed belongs in this repository, a frontend bundle or CI.

The application deliberately does not offer a public authenticated-proof-verification claim. A future independent verifier must authenticate deployment/initial state, circuit and verifier-key provenance, key configuration, accepted chain state and maintenance policy. The current public export alone cannot establish these facts or certify an election.

GitHub Pages supplies static frontend, worker, WASM and public contract assets. It does not deploy the Midnight contract or operate a prover, wallet or indexer service. In the browser-only configuration, application and wallet proof computation must execute on the user’s device.