Engineering roadmap / Multi-asset DEX

The road to
public swaps.

An exchange inside the Monzero GUI, with Litecoin settlement, light wallets for Litecoin, Bitcoin, Bitcoin Cash and Dogecoin, a growing BCH/XMZ engine and research for direct XMZ/XMR and other markets. Each market needs its own verified settlement and recovery path.

Engineering snapshot ·
Milestone-based delivery. No committed live launch date.

CURRENCY PROGRESS16 OCT 2026

XMZ pairs · Select a currency for test details.

Live trading is not available yet.

01 / Evidence, not promises

A foundation we can test.

Test evidence for all seven markets, with shared app suites shown separately. Recorded through 16 October 2026; incomplete and historical coverage are marked explicitly.

LTC / XMZ

First pair · live-chain runs passed
Tests and remaining work

New (15–16 Oct): LTC/XMZ is the first pair we aim to open. Success and refund trades passed between two running apps while both chains produced blocks on their own, and every safety check passed on its first attempt. A separate regression run still rejects reorganised chains and early actions. These runs found and fixed three problems the earlier tests could not see (details in the engineering update). Latest counts: 78 native Qt checks passed (21 skipped). New (16 Oct): the first swap on the public Litecoin testnet completed (0.2 tLTC for XMZ, 78 minutes). A testnet trade interrupted after its Litecoin lock was reopened and refunded in full, minus the agreed fees. New (17 Oct): the in-app light wallet paid the Litecoin side of a complete public-testnet swap, with no Litecoin node wallet involved (94 minutes; its change balance was exact). Light-wallet startup now uses a checkpoint: under a second instead of about 19 minutes on testnet. A light-funded testnet trade stopped after its Litecoin lock was also reopened after the 72-block window and refunded exactly 0.1998 tLTC to the light wallet. New (18 Oct): a testnet swap passed with the two traders in separate app processes connecting over a network address instead of the same machine's loopback, the step before trading between two machines. A new trade kit lets two people set up a swap with each other: each creates their own identity, both sign the same terms separately, and only public files are exchanged. Its first full test found that the Litecoin side's app depended on the test setup to create the view-only wallet it uses to check the XMZ lock; the app now creates that wallet itself, and swaps pass both ways. The kit now also writes each trader's complete app setup from their own node and wallet settings, and a swap passed with each trader started only from those files. A dropped connection between traders now reconnects by itself, including during settlement (six regtest cases passed). The light wallet now reads Litecoin MWEB payments, verified on testnet.

New (13 Oct): a light wallet inside the app funded a complete LTC/XMZ success path on isolated chains: approved Litecoin funding, redemption, recovered XMZ wallet and the final XMZ payout, with fees accounted for and reorganisation checks. 60 native Qt checks passed (21 external-fixture skips).

Continuous node-backed success and cancellation/refund pass with exact payments, fees and restart checks. A separate mature punishment path also passes. The light wallet now has 176 Rust unit checks (0 failed) and a local peer-recovery reopen check.

New (13 Oct, later): the light-wallet refund path also passes, returning the exact Litecoin balance to the local wallet and refunding XMZ. The helper now refuses a refund address the selected wallet did not issue. Recovery was accepted after four interruptions: an app restart after broadcast, a restart between signing and sending, a lost broadcast reply, and the send helper being killed mid-relay. In each case the same signed bytes are retried with fresh approval, and nothing is signed again. Latest counts: 202 wallet/engine unit checks (8 ignored), 60 native Qt checks (21 skipped) and 92 QML checks.

Still to verify: Power-loss (as opposed to process-kill) recovery, active-trade backup, settlement without node-backed test services, and public-network acceptance remain.

BCH / XMZ

Controller + Qt checks passed
Tests and remaining work

Complete isolated controller settlement passes, including final XMZ payout and reserve return. Real Qt/helper fixtures verify funding/recovery, proof retention, chain observation, preparation, saved status and public signing/release reviews.

The earlier controller snapshot records 50 passes and 8 optional skips; it is historical evidence, not a count of every newer BCH test.

New (13 Oct): a BCH light wallet (CashAddr, BCH signing rules) passes regtest receive/send tests against Bitcoin Cash Node through the helper and the app’s Qt worker.

New (14 Oct): BCH/XMZ swap funding from the local light wallet is being built. Already passing: P2SH32 CashAddr contract addresses (paid on an isolated Bitcoin Cash Node), funding terms derived from the agreed trade, verification of the exact signed funding, binding the refund address to the selected wallet, and helper preparation, review and signing for both raw-seed and BIP39 wallets. The node accepts the signed funding (testmempoolaccept), but the helper has not broadcast it yet. The latest BCH regression run passed 52 checks with none failed (17 ignored).

Still to verify: Helper broadcast, app (Qt) integration and a complete light-wallet BCH/XMZ swap. Protected desktop signing, peer transport and complete continuous app settlement remain under integration and acceptance. BCH light-wallet header checks for the public network (ASERT) are not implemented yet.

BTC / XMZ

Historical evidence
Tests and remaining work

The 19 September checkpoint records isolated funded settlement and lost-broadcast-reply handling without duplicate payment.

That checkpoint reports 89 engine library tests and three compile-fail checks; wallet approval checks passed with GCC and Clang.

New (13 Oct): the shared light wallet now supports Bitcoin (native SegWit). Regtest tests against Bitcoin Core 31.1 pass for receiving, sending and confirmation, both through the helper and through the app’s Qt worker.

Still to verify: BTC/XMZ swap regression against the current app, testnet4 support, release validation and activation remain. These older swap results are not a fresh full-suite pass.

DOGE / XMZ

Node-backed checks passed
Tests and remaining work

Timelock/refund primitives and chain observation pass isolated-node restart and reorganisation checks.

New (13 Oct): a Dogecoin light wallet passes regtest receive/send tests against Dogecoin Core 1.14.9 through the helper and the app’s Qt worker.

This verifies specific wallet, refund and observation behavior, not a complete DOGE/XMZ swap.

Still to verify: Funding transaction-ID malleability, complete settlement and broader recovery acceptance remain unresolved. Public-network light-wallet header checks (DigiShield, AuxPoW) are not implemented yet.

XMR / XMZ

Research / preview only
Tests and remaining work

Direct XMZ/XMR work is at preview and protocol/recovery research stage.

No completed direct-pair settlement or recovery acceptance is recorded. Shared preview checks do not establish a working swap.

Still to verify: A viable direct protocol, implementation and dedicated paired-chain tests are still required.

ETH / XMZ

Preview only
Tests and remaining work

Exact-precision amount previews are implemented.

No completed contract settlement or funded ETH/XMZ recovery acceptance is recorded. UI checks are not contract tests.

Still to verify: Contract design, fees/nonces, settlement, recovery and dedicated review/testing remain.

RUNE / XMZ

Research / preview only
Tests and remaining work

Native RUNE previews and route research are present.

No completed native RUNE/XMZ settlement or recovery acceptance is recorded.

Still to verify: Native settlement design, implementation and dedicated network-backed acceptance remain.

Shared app checks

These counts describe separate recorded suites. They overlap in scope and must not be added into a single unique-test total or attributed to every currency.

92 / QML checks passed

Interface behavior

Wallet controls, amount display, separate approvals and stale-result clearing. Passing UI checks do not prove settlement on every network.

60 / DEX checks passed

Engine regression

The recorded DEX suite passed 60 checks. Another 21 cases require external fixtures and were skipped in that run; skips are not passes.

85 / protocol checks passed

BCH public reviews

Operation-specific review binding, response validation and malformed-request rejection. These checks support BCH review controls, not other coin engines.

29 / worker checks passed

BCH review worker

Public review process handling, invalid replies and stale-context rejection. Separate paired-chain fixtures provide real-helper evidence.

Private signing components — focused tests, incomplete app integration

The private BCH helper candidate passed 30 unit tests; its app request/response protocol passed 788 validation and buffer-wiping checks; the Linux private process channel passed 14 controlled-process checks. These are component results. Complete protected desktop signing, peer handoff and release acceptance are not established by these counts.

Build evidence

Wallet build + 92 QML checks passed Accepted engine patches reconstructed Rust snapshots have all-features/all-targets build checks

Verification boundary: evidence is specific to the named market, suite and checkpoint. Funded fixtures use isolated test chains; older BTC/BCH counts are labelled historical. No independent security audit, complete all-market recovery coverage or live-market readiness is implied. All markets remain disabled for real-money DEX trading.

Latest update / 15 October 2026

Recovery progress.

Completed checks and remaining work are reported separately. Earlier checkpoints below retain their original scope.

Verified in tests

BCH / XMZ: repair interrupted saves

The desktop recovery controls now pass an integration test through the actual Qt worker and Rust helper. Users review the retained trade record and explicitly approve completing its local save. This does not broadcast a payment or grant permission to release funds.

Desktop recovery interface, worker and controller checks also pass. The corrected node-backed publication recovery regression has now passed too. The integration uses a retained test trade and simulated chain observations; full live-network settlement remains unverified.

Validation underway

BCH / XMZ: fewer wallet dependencies

Payment preparation, separately approved broadcast and refund-key recovery can now use an owned BCH node connection without accessing its wallet. Compilation passes. The earlier read-only lock-check regression has passed. The corrected payment and refund-key recovery regression has now passed. This test predates the later wallet restoration, payout, cancellation and helper changes; their broader runtime acceptance remains pending.

The private helper now supports this node connection for payment preparation and separately approved broadcast. All 34 helper tests passed, including checks that reject an incompatible connection configuration. Desktop configuration and consent checks also pass for the new connection. Two isolated paired-chain tests have now passed: one through the production helper and one through the desktop workers and helper. They verify approved XMZ deposit preparation, broadcast, confirmation and restart recovery using the owned BCH node connection. These tests cover the payment stage; complete cross-chain settlement and the desktop recovery journey remain unfinished.

This still requires a trusted node. Public lightweight verification and the complete app flow remain unfinished. Refund-wallet restoration, reopening and checking have now passed their engine regression. Refund payout has also passed its engine regression. Cancellation now has helper routing and passing desktop component checks. The earlier native cancellation and punishment engine regression has also passed. That result predates the latest helper and desktop changes. The latest completed cancellation integration test failed at the review step. Its test setup now saves the required admission approval, and compilation passes; a new integration run is underway. Cancellation recovery through the app is not yet verified. The desktop punishment-review validator now passes 26 test cases, including rejection of changed fees, payout amounts, destination scripts and policy, plus checks at the minimum-payout and fee-limit boundaries. Punishment submission and user controls remain unfinished.

Next milestones

Complete the recovery journey

Resolve the cancellation review failure, complete punishment controls, connect the verified refund-wallet and payout paths to the app, and verify the complete recovery journey after interruptions. Wallet keys and recovery material remain on the user’s system.

Wallet communication checks passed: 78 checks passed for the native wallet connection, including authentication, cancellation and invalid-response handling. One separately funded test was skipped; this does not prove complete live trading.

No new completion claim is made here for LTC, BTC, DOGE, XMR or the research-stage currencies. Each market keeps its own verification requirements.

No new release or real-money market activation is announced. These component milestones do not change the delivery estimates below. Independent review and complete settlement and recovery acceptance remain required.

Engineering update / 17 October 2026

Working builds.
Verified progress.

The in-app Litecoin light wallet completed an LTC/XMZ swap on the public Litecoin testnet. A public Monzero mining pool is now online. LTC/XMZ is now the first pair, and its swaps and refunds pass on test chains that keep producing blocks. An in-app Litecoin light wallet completes LTC/XMZ test swaps and refunds, including recovery after interruptions. BCH/XMZ funding from the light wallet is under way, and the same light wallet now also supports Bitcoin, Bitcoin Cash and Dogecoin. BCH has private funding and recovery controls; every market still needs complete settlement and release acceptance.

New · 17 October

Light-wallet swap on the public Litecoin testnet

No Litecoin node needed: on 17 October the app's own Litecoin light wallet paid the Litecoin side of an LTC/XMZ swap on the public Litecoin testnet, with no Litecoin node wallet involved. The app reviewed the payment, signed it without sending, sent it only after a separate approval, re-sent the identical transaction, and then saw it confirmed in a block through the light wallet. The XMZ lock, Litecoin redemption and XMZ payout followed, and every app check passed on its first attempt. Afterwards the light wallet held exactly its change: 0.25 tLTC funded, minus the 0.2 tLTC traded, minus a 0.00001 tLTC fee. The whole swap took 94 minutes.

Problem found and fixed: the app only offered light-wallet funding when the wallet was on a local test chain, so on testnet the option never appeared. It now follows the network chosen at startup.

Dropped connections now recover by themselves: if the connection between the two traders drops in the middle of a trade, the apps now reconnect on their own instead of waiting for a restart. They rebuild the trade session from what is saved on disk, the same steps an app restart takes, and retry at growing intervals. They also re-exchange the already signed refund agreement, so the trade carries on. Messages that fail a check still stop the trade, and nothing is retried in that case. If the drop happens during the final settlement messages, the apps repeat only the steps already under way before the drop: the funding proof, and a release the user had already approved for that same payment. No new approval is ever created, and a settlement that had finished stays finished. In tests the connection was cut on each side after both coins were locked, after the funding proof, and after the release, and once more during a refund. The apps reconnected within 33–54 seconds, and all six trades finished with every check passing on its first try.

Litecoin MWEB payments: Litecoin's private MWEB layer stores some transactions in an extended format that the light wallet could not read. So a payment out of an MWEB wallet into a light wallet, a common way to send Litecoin, would have stopped the light wallet from refreshing. The light wallet now reads these transactions while still checking every one against its block. On the public Litecoin testnet, 0.02 tLTC was sent from an MWEB-only wallet to a light wallet: the previous version failed to refresh, and the fixed version showed exactly 0.02 tLTC more.

Fast light-wallet startup: the light wallet used to check every Litecoin block header from the start of the chain each time it started, about 19 minutes on testnet. It now starts from a built-in checkpoint and, on restart, rechecks proof of work only for the most recent headers, while still checking that every saved header links to the one before it. A testnet sync now takes under a second and stores 230 KB instead of 394 MB. Mainnet still needs its own checkpoint.

New · 16 October

Monzero Pool is online

Mine XMZ together: the project now runs a public RandomX mining pool on the same server as the public node. Point XMRig at pool.monzero.org:3333 (CPUs and laptops) or :5555 (servers), with your own XMZ address as the username: xmrig -o pool.monzero.org:3333 -u YOUR_XMZ_ADDRESS -p rig1 -a rx/0. Live statistics are at pool.monzero.org.

How it pays: PPLNS with a 1% fee. Blocks are credited after 60 confirmations, and only if the chain still holds the exact block the pool found. Payouts are on: balances of 1 XMZ or more are paid every hour. The pool's first 14 blocks were credited to the atomic unit before payments were switched on.

Built for this chain: the pool was written for Monzero and checks every share with the node's own proof-of-work code. Tests on a private chain cover rejected shares, found blocks, orphaned blocks, exact reward splits and payments arriving in miners' wallets. A pool also lets Monzero be listed on mining statistics sites, and more independent miners make the network harder to attack.

New · 15–16 October

LTC/XMZ first, tested on moving chains

First market chosen: LTC/XMZ is the first pair we aim to open. Work on other pairs is paused until a small, capped test with invited testers is running.

Trades on chains that keep moving: a new test runs a whole trade between two running apps while both chains produce blocks on their own clock, as real networks do. Success and refund both passed, and every safety check passed on its first attempt. A separate regression run still rejects reorganised chains and actions taken too early.

Problems found and fixed: the connection between traders closed after five idle minutes, which would have ended every real trade before redemption; it is now kept alive. XMZ checks failed when the wallet briefly lagged its node or a block arrived mid-check; they now refresh and re-read a limited number of times, and every amount and depth rule is unchanged. A new Litecoin block during redemption release is now re-checked instead of failing.

Operator controls and recovery: a signed control document can pause new trades or cap their size, and trades already running keep their refund and recovery paths. The network is chosen at startup: local test chains by default, testnet on request, and mainnet cannot be selected. Each trade is kept in its own folder and reopens automatically. A step-by-step recovery guide covers every stage of a trade.

Testnet: the first LTC/XMZ swap on the public Litecoin testnet completed on 16 October, against a private XMZ test network, in 78 minutes. Both apps locked, redeemed and paid out on their own, with blocks arriving at the network's own pace, and every confirmation check passed on its first attempt. Two problems surfaced first and were fixed: the app accepted only local-test Litecoin addresses, and the test tool stopped on a momentary empty reply from the Litecoin node. That earlier attempt had already locked its Litecoin when the apps stopped, so it was recovered the way a user would: after the 72-block cancellation window, the saved trade was reopened and the Litecoin side approved the cancel and the refund. The refund returned exactly 0.1998 tLTC (the 0.2 tLTC lock minus the two agreed fees) to the agreed address.

New · 13–14 October

Light-wallet swaps and four light wallets

LTC/XMZ from a light wallet: the app’s Litecoin light wallet funded a full success path on isolated chains. The steps were approved funding, retry-safe submission, confirmation with reorganisation rejection, redemption, recovering and reopening the XMZ claim wallet, payout review and the final XMZ payout. Funding fees are accounted for on both chains. This uses node-backed test services.

Refunds and interruptions: the light-wallet refund path also passes, with the exact Litecoin balance returned to the local wallet and XMZ refunded. Recovery was accepted after an app restart after broadcast, a restart between signing and sending, a lost broadcast reply and the send helper being killed mid-relay. Each time the app retried the same signed bytes after fresh approval. Power-loss recovery is not yet tested.

BCH from the light wallet (14 October): the light wallet can now pay BCH P2SH32 contract addresses. The helper prepares, reviews and signs BCH/XMZ swap funding for both wallet formats, and Bitcoin Cash Node accepts the result. Broadcast, app integration and a complete BCH light-wallet swap are next.

One light wallet, four coins: the light-wallet core now supports Litecoin, Bitcoin, Bitcoin Cash and Dogecoin. 176 unit checks pass with none failed, and the original 153 Litecoin checks are unchanged. Each coin passes regtest receive/send tests against its real node software. In the app, each coin’s wallet can be created, reopened after restart, backed up and checked, and its recovery phrase revealed and hidden again. Mixing up coins is rejected. These are regtest results only. BCH and DOGE public-network header checks and Bitcoin testnet4 are not implemented, and no public light-wallet servers are running.

In development

Litecoin / XMZ

Shared trade setup now connects startup, pinned peer negotiation, reservation, funding, redemption and recovered-payment controls. Each payment requires its own review and approval. Success and refund paths pass through the Qt bridge on isolated nodes. The same running engines now complete success and cancellation/refund paths, including recovered XMZ payments and fresh-app checks after restart. A separate mature punishment fixture verifies early rejection, exact payout, retry, reorganisation rejection and restart. Broader interruption and recovery acceptance remain outstanding.

The light-wallet mode is intended to work without a personal Litecoin node. Its private app controls now create an encrypted wallet, verify the initial backup and separately open the reviewed configuration. Saved wallets reopen without recreating keys. Users can receive, review exact payment amounts and fees, approve signing, explicitly send retained bytes and request a dated chain observation. Backup and restore cover seed and address allocations; they do not recover active trade journals. Isolated Litecoin-node tests fund newly created wallets, restore their keys, accept payments, handle a lost send reply and reject stale proof after a reorganisation. Light-wallet DEX funding now completes isolated success and refund paths (see the update above); public setup, active-trade backup and settlement without node-backed test services remain unfinished. Server observations cannot prove complete wallet history or global freshness. A local Litecoin Core wallet remains the planned advanced option.

Private funding controls

Bitcoin Cash / XMZ

Latest verified progress: Authenticated payment-proof retention, restoration of the saved funding context, fresh XMZ confirmation checks and public settlement review now pass through production Qt workers and the real Rust helper against isolated BCH/XMZ chains. The accepted proof, observation and review changes are integrated into the engine. Saved receipts remain separate from current chain evidence, and a settlement review does not release funds.

Private XMZ deposit preparation and separately approved broadcast also pass paired-chain Qt/helper tests. Amounts use XMZ’s 11-decimal denomination: the 200,000,000,000-atom fixture deposit displays as 2 XMZ. The wallet builds, 70 interface checks and 55 DEX checks pass; 21 additional DEX cases require external fixtures and were skipped in that suite.

Private settlement preparation and saved-preparation status now pass paired-chain tests through the actual Qt workers and Rust helper, and both changes are integrated into the engine. Checks cover exact consent, unchanged records after rejected approval, identical preparation after restart and refusal when the chain observer is unavailable. Saved status works without node credentials; it reports historical records, not fresh chain confirmation.

Encrypted Qt identity signing now also passes an isolated paired-chain interoperability test: the engine rejects an invalid signature without changing records, accepts the correct signature after fresh checks of both chains and restores the identical signed message. This verifies the signing components, not a complete protected desktop signing session.

Separate signing and signed-release review panels are implemented, with explicit requests, exact amounts and fees, and stale-result clearing. The wallet build and 70 interface checks pass, alongside 85 protocol checks and 29 review-worker checks. These panels only review public details; they do not sign or release funds. Operation-specific consent and the public signing/release review helper now pass paired acceptance and are integrated, including the actual Qt review worker. Private signing-helper, parser and local-process components have focused test evidence; their complete protected desktop integration remains unfinished. Protected signing and peer transport, complete desktop settlement, broader recovery and public-market activation remain unfinished.

Earlier BCH funding and recovery milestones

The corrected controller snapshot completed with 50 passes and 8 optional tests skipped, covering negotiated funding, BCH settlement/refund and recovered XMZ payouts using offline cryptography and loopback RPC services. Preparation does not broadcast.

Agreement review, explicit admission and read-only restart checks now pass complete retained-negotiation fixtures through the Qt launcher and Rust helper for both roles, including expiry and altered consent. The app also reviews exact retained BCH funding, fees, destination scripts and recovery transaction IDs; a complete Qt/helper fixture passes with the mock node stopped before review. The wallet build, 20 admission checks, 65 funding-launcher checks, 82 preparation/locking/signing/recovery-launcher checks and 61 QML checks pass. Admission does not fund a trade, and funding review neither broadcasts nor checks the chain. Private app controls now require a saved-status check, fresh review and explicit consent before sending retained funding. Four complete Qt/helper fixtures verify one broadcast request, saved acknowledgement, refusal to resend after a lost reply, and historical status after expiry. Acknowledgement is not confirmation; saved status does not check the chain.

A separate node check now reports confirmed unspent funding, mempool status or absent funding through the actual Qt job and helper. It works after quote expiry, rejects changed transaction data and chain tips, and clears stale display evidence on a failed check. Saved relay history remains visible beside the point-in-time node result. Observation never authorizes another send or settlement. The corrected controller snapshot now passes. This archived result does not substitute for separate validation of newer app controls. Wallet-selected unsigned preparation now passes 22 local-RPC scenarios, including exact fees, change, parent transactions and input confirmations, without locking, signing or broadcasting. A complete local fixture now verifies retained wallet preparation: restart reuses the original inputs, changed policy or damaged records block progress, and an interrupted publication resumes without selecting replacements. Private app preparation controls now pass initial wallet selection, restart without reselection and offline saved-status checks through the Qt launcher and Rust helper. The panel shows every saved input and output and the exact fee. Startup only reads saved status; preparing funding requires an explicit click and does not lock coins, sign or broadcast. Separate wallet-lock controls now require a fresh review and explicit consent. Complete Qt/helper fixtures cover a lost lock reply, historical intent without automatic retry, and approved reconciliation of the original inputs without reselection. The panel separates saved intent from the latest wallet check; locks are advisory and do not authorize signing or broadcast. Separate signing controls now show the exact transaction and require fresh, explicit consent. Complete Qt/helper fixtures cover a lost signing reply, saved intent without a result, and refusal to create another signature. Recovery controls review and import the exact recovered transaction through Qt and the production helper with the RPC descriptor removed. Changed candidate files, altered transaction details and wrong approval are refused; recovery remains available after expiry. Importing the reviewed bytes neither signs again nor broadcasts. Startup only reads saved admission, peer protection, peer funding receipts, preparation, lock, signing, private recovery, funding and cancellation status. The native-funder app now reviews the authenticated peer funding message, showing the exact BCH outpoint, principal, fee and contract script before explicit acceptance. A real Qt/helper fixture passes, including saved receipt status after removal of the peer message. Saving a receipt neither confirms the BCH lock nor approves an XMZ payment. Shared operation guards prevent overlapping BCH actions; the DEX regression run passes 52 checks with 21 external-fixture skips. New isolated BCHN tests verify covenant spends, recovery success/refund/punishment, exact recipient amounts, restart and reorganisation handling. Production chain observation passes 45 node-backed checks. A real-node funding fixture now uses the production controller for preparation, input locking, signing and relay. BCHN accepts and confirms the transaction with 100,000 atoms locked and a 235-atom fee. The controller restores the same saved transaction, and its confirmation survives a node restart. A second real-node fixture passes the authenticated funding handoff: it rejects the wrong peer signature, restores the same receipt after restart, refuses native funding while BCH is unconfirmed and accepts the confirmed lock. It then rejects funding as the cancellation boundary approaches. A paired-chain funding fixture now also passes production XMZ deposit preparation, approved relay, authenticated proof and incoming-payment confirmation in the negotiated shared wallet. Independent accounting records both funding fees, and the BCH confirmation survives a node restart. The next paired fixture also passes approved BCH redemption and recovery of the negotiated XMZ spend key from the confirmed transaction. It verifies a 99,000-atom BCH recipient output, a 1,000-atom redemption fee, refusal before confirmation and exact transaction recovery after node restart. The complete controller success path now passes on both isolated chains, including claim-wallet restore and reopen, separately approved XMZ payout and independent recipient balances. The recipient receives 100,000,000,000 XMZ atoms; 99,042,560,000 atoms return from the reserve and 957,440,000 atoms pay the payout fee. The recovered wallet is empty. The separate native funding fee is also accounted for. This is controller acceptance; complete app settlement, broader recovery and live-market readiness remain unfinished. The app now has separate peer refund-protection review and consent controls, with 22 worker checks and 61 QML checks passing. A complete retained-negotiation fixture now verifies acceptance through the Qt worker and real helper, then recovery of the identical receipt in a fresh process without the peer-message file. Saving protection neither funds the trade nor proves complete recovery readiness.

The app now separately reviews and retains the private recovery bundle before funding. A complete Qt/real-helper fixture verifies approved retention and recovery of the same saved bundle in a fresh process. Direct helper tests also verify exact retry, recovery after an interrupted metadata-pin write and rejection of damaged snapshots. Only public transaction IDs and commitments enter the interface; private refund bytes stay private.

Cancellation controls now show the exact transaction and BCH fee, require separate submission consent and distinguish saved acknowledgement from a fresh chain check. The real helper passes acknowledged and lost-reply cancellation cases against an owned loopback RPC fixture, including maturity refusal, one relay request only and exact confirmation checks. The cancellation worker and protocol validators pass 29 checks, and the app passes 61 QML checks. The combined cancellation Qt/real-helper fixture now passes, including one relay request, lost-reply recovery, refusal to resend and exact confirmation checks. Cancellation does not release a refund or complete the XMZ payment. New refund controls show the exact amount, fee, destination and safety margin and require consent explaining the effect on the peer’s XMZ recovery. Offline review and saved status pass through the production Qt worker and real helper. Refund relay now passes through the production Qt worker and real helper against an owned loopback RPC fixture: spent-output refusal, exact approval, acknowledgement and lost-reply recovery, no automatic resubmission, changed-margin rejection and exact confirmation checks. Full two-chain recovery remains unfinished. Protected peer transport, complete recovery and settlement controls, broader interruption recovery and full authenticated BCH/XMZ execution remain unfinished; this market stays disabled.

Primitives + observation verified

Dogecoin

Two isolated Dogecoin node fixtures now verify timelock/refund transactions and production chain observation, including unspent-to-spent transitions, exact refunds, restart and reorganisation handling. One uses the engine signer and one independently constructs its refund. New checks show that another valid legacy funding signature can change the transaction ID and invalidate a previously signed refund. A complete DOGE/XMZ protocol must resolve this before trading can be enabled.

Settlement pending

Ethereum

Previews preserve 18-decimal precision and large wei amounts. Contract settlement, gas and nonce management, recovery and contract tests are still required.

Direct-pair research

XMZ / XMR

Twelve-decimal previews are available. Direct XMZ/XMR feasibility and recovery are under review; BTC-intermediary route work is paused pending route-design clarification. No direct pair or intermediary route is executable yet.

Route implementation pending

Native RUNE

Eight-decimal previews target native THORChain RUNE. Explicit routing is approved; route execution, chain integration and recovery remain unfinished.

Existing foundation

Bitcoin / XMZ

Existing settlement and recovery work remains the foundation. New market previews cannot reuse its signing authority. Complete GUI execution and release acceptance are still required.

Litecoin light wallet: verified controls and remaining work
  • Authenticated TLS and network checks precede wallet queries. Header validation checks Scrypt work, difficulty, timestamps and version rules; restart caches revalidate the selected branch.
  • The latest pinned helper passes 202 Rust/helper checks: 153 light-wallet checks, six TLS fixtures, eleven RPC tests, seven chain-helper groups, seven wallet-helper groups, nine signing/recovery/send/reconciliation groups and three groups each for backup, restore and creation. All-features/all-targets compilation and ordered patch reconstruction pass.
  • The app build, 41 Qt wallet test groups and 56 QML tests pass. Creation requires review and password confirmation; opening is a separate action. Saved-wallet review does not claim that backup contents were rechecked. Passwords and consent clear on submission or context changes.
  • Two actual isolated Litecoin-node scenarios create and reopen a disposable wallet through Qt, fund its address, restore keys and send an approved payment. Both verify confirmation and reorganisation handling; one drops the reply after node acceptance. These are ordinary wallet payments, not full light-wallet atomic swaps.
  • Light-wallet swap funding, settlement and refunds have since passed separate isolated-chain tests (13 October). Remaining work includes public profile setup, active-trade backup and settlement without node-backed test services. Inclusion evidence and reported balances alone do not establish complete or globally fresh spendability.
BCH checkpoint: what passed and what is next
  • Verify both peer identities and proofs binding BCH contract keys to XMZ recovery keys.
  • Retain negotiation, approved funding and private recovery records across restarts.
  • Verify exact input signatures, outputs, fees and funding transaction identity.
  • Recover an explicitly approved signing result without asking the wallet to sign again.
  • Observe the retained funding transaction and require a separate broadcast approval.
  • Preserve an uncertain relay attempt and refuse automatic retransmission after lost or invalid replies.
  • Check that the authenticated BCH lock has enough confirmations and remains outside the cancellation margin before XMZ funding preparation; this check does not authorize a payment.
  • Prepare the agreed XMZ payment without broadcasting; retain its original result and restore it after restart. Mock checks reject altered records and automatic reconstruction after a lost reply.
  • Seventy-three native RPC tests pass in the latest verified adapter snapshot, including expiry checks, exact saved-byte relay, interrupted-dispatch handling and rejection of explicit incoming unlock delays. The real-wallet preparation fixture remains unrun.
  • Require separate approval for the exact saved XMZ payment, recheck the BCH lock and save a dispatch attempt before broadcasting. Mock tests cover acknowledgement, lost replies and restart without retransmission.
  • Bind the private XMZ payment proof to both peer identities, the agreed shared wallet and exact BCH funding. Verify current XMZ confirmations through the owned wallet; a saved proof is not cached confirmation or permission to release a success signature.
  • Verified controller snapshot: all 48 tests passed, including retained BCH redemption, separate approval/broadcast, recovered XMZ wallet and payout, mature BCH cancellation, recovery-output checks, BCH refund and recovered XMZ refund payment. These are loopback mock flows; real-node settlement remains unverified.
  • Focused checks pass for signed payout amounts and destinations, wallet restoration, and refusal to reuse an uncertain wallet session after cancellation or timeout. These checks do not establish complete BCH settlement.
  • Refund publication requires separate approval, confirmed cancellation and a currently unspent recovery output outside the punishment safety margin. A retained dispatch attempt prevents automatic retransmission after a lost reply. Read-only refund confirmation checks the exact saved transaction against current chain evidence; these assertions passed in the 48-test controller snapshot.
  • Focused recovery-output checks pass for spent outputs, changed amounts/scripts, stale evidence, tip changes and refund/punishment timing boundaries. These adapter tests do not prove the complete refund flow.
  • XMZ refund requests use the signed refund address and separate refund fee cap. Both request tests pass, including different claim/refund fee caps. The recipient is owed the original lock minus the actual bounded fee. Refund-wallet and payout controllers retain uncertain attempts and support read-only confirmation after lost replies; their assertions passed in the 48-test snapshot.
  • The separate punishment-review controller snapshot has now completed all 48 tests successfully. Later recovery controllers compile: fresh native/BCH maturity checks, approved punishment dispatch and exact confirmation. The XMZ funder can also derive cancellation without the BCH funder’s private recovery bundle. An earlier combined run exposed a fixture-context failure. After restoring the caller’s relay context in nested tests, the corrected archived snapshot completed with 50 passes and 8 optional tests skipped. Newer helper and app flows have separate acceptance results.
  • Complete cryptographic negotiation fixtures pass through the actual Qt admission launcher and Rust helper for both roles. They cover saved status after expiry, original approval retention, changed policy/pins, missing or corrupt consent and store leases. The app displays exact agreement terms and requires explicit approval; these checks save or inspect an agreement and do not fund a trade.
  • Retained funding review passes through the actual Qt job and Rust helper using a signed transaction and retained recovery records. The fixture shuts down its mock RPC server before review and checks unchanged records, deployment mismatch, missing consent and damaged recovery. This is offline review, not chain confirmation or broadcast approval.
  • Four complete Qt/helper funding process fixtures pass using local RPC mocks: retained review, one acknowledged relay, lost-reply handling without retransmission and status after quote expiry. Submission requires the original saved consent and exact funding commitment. Status works with the mock server and credentials removed; acknowledgement is not confirmation. The app now exposes exact funding consent and saved-status checks, resets consent when context changes, and refuses another send after an attempted or acknowledged relay. Separate read-only observation now passes through the actual Qt job and helper, including after expiry. Checks cover confirmation depth, mempool output states, changed-output/tip rejection and unchanged recovery records. An absent transaction never grants retransmission permission. Full recovery and settlement integration remain unfinished.
  • Private signing and recovered-transaction import now pass complete Qt/helper fixtures. Signing requires a distinct review and explicit consent, and an uncertain attempt cannot request another signature. Recovery binds approval to the exact candidate bytes and original signing intent; review/import work without an RPC descriptor and do not broadcast. The app distinguishes saved signed funding from chain confirmation. All 82 preparation/locking/signing/recovery Qt checks and 61 QML checks pass, including candidate-change refusal, post-expiry recovery and consent reset. The wallet build passes without launching mining. These local fixtures do not establish full settlement or real-node acceptance.
  • The refund-protection helper now passes private review, explicit submission and historical status checks using retained negotiation records. These offline/helper fixtures do not broadcast or observe a chain. Peer refund-protection and private recovery-retention controls now pass retained-state Qt/helper fixtures; complete settlement remains unfinished.
  • Authenticated peer handoff now passes against an isolated BCHN instance, including confirmation and cancellation-window checks. Production funding and native-payment proof confirmation now pass against both isolated chains. Approved BCH redemption and native claim-key recovery now also pass against the isolated chains. The final recovered XMZ payout now passes with exact recipient/reserve balances, bounded fees and an empty recovered wallet. Next: broader interruption recovery, protected peer transport and remaining app settlement controls.
Completed settlement and recovery checks
  • Retain authenticated keys and recovery transactions before funding operations.
  • Reject a spent or insufficiently confirmed Litecoin lock, including pending spends and unsafe cancellation windows.
  • Accept native confirmation after commercial quote expiry only against the original recovery agreement; new funding still requires valid terms.
  • Restore the exact saved XMZ preparation; reject changed sources, missing committed records and altered checkpoints.
  • Retry a failed non-broadcasting preparation under the same terms only when no prepared transaction was retained, with fresh quote and live-lock checks.
  • Retain the completed Litecoin redemption and recover the native claim keys in controller tests.
  • Verify confirmed Litecoin transaction bytes against an actual node, including restart, reorganisation rejection and reconsideration.
  • Restore and reopen the native claim wallet; prepare exact signed payout and reserve amounts without broadcasting.
  • Recover the exact payout checkpoint in a fresh process with both services stopped; reject altered terms and corrupted bytes.
  • Relay the saved native payout and verify exact recipient and reserve-return balances, including subaddresses.
  • Rebuild the disposable claim-wallet cache and verify both payments using retained private transaction proofs.
  • Verify shared payout and reserve addresses, a reserve equal to the signed fee ceiling, and zero reserve returns to separate subaddress recipients.
  • Complete a production-controller Litecoin–XMZ success path across both isolated chains, checking exact recipient balances, source-balance changes and funding fees.
  • Reject premature Litecoin cancellation, then confirm cancellation/refund and pay the recovered XMZ lock to the signed refund address; verify the recipient balance and an empty recovered wallet.
  • Reject a watch-only wallet substituted for the recovered spend wallet on both Linux hosts.
Shared setup verified

Saved-trade visibility

One upfront private configuration now covers startup, funding and recovered payments. Phase state and approvals stay separate. Both roles pass initial creation and fresh-engine resume checks; changed configuration blocks further operations.

Approval controls verified

Explicit refund review

Qt controls now review, approve, submit or explicitly retry the exact saved transaction. Separate checks verify confirmation and clear stale evidence after a reorganisation. Completed success and refund fixtures pass these controls.

Recovery evidence

Retain, check, then retry

Recovered wallets can be restored, reopened and checked. Tests reject unrelated and watch-only wallets, preserve exact transaction retries and recheck settlement after its Litecoin transaction moves into a different block. Complete recovery-path acceptance remains open.

Next integration gate

The continuous Litecoin app journey now passes success and cancellation/refund fixtures through recovered-wallet operations and final XMZ payment, and a light-wallet-funded success path now passes too. The light-wallet refund path and restart recovery also pass, and LTC/XMZ swaps now pass on chains that keep producing blocks. The first public-testnet swap has now passed. The interrupted-trade refund also passed on testnet. Next: light-wallet funding on testnet and a peer relay. Complete remaining recovery and interruption scenarios, then address public peer discovery, platform coverage and independent review. The Litecoin light wallet still needs public profile setup, active-trade recovery and refund acceptance; its swap funding and success settlement now pass on isolated chains. Creation, seed/address backup and restore, retained spend approval, signing, explicit send and chain reconciliation now have app/helper evidence. Backups exclude active trade journals; selected-chain proofs do not establish complete or globally fresh wallet observations. BCH needs protected signing and peer transport, continuous desktop settlement and broader recovery evidence; DOGE and the other added markets still need their own complete settlement flows.

Evidence spans 5–16 October 2026. BCH counts describe an archived controller snapshot; newer app and node-backed milestones have separate results. The complete BCH/XMZ controller success path passes against isolated chains, including final payout. Full desktop settlement, protected transport and broader recovery remain unfinished. After earlier incomplete runs, fresh Litecoin continuous success and refund fixtures passed with final reports. These results do not establish complete recovery coverage or live-market readiness. This update announces no new downloadable release, independent security audit or real-money market. Earlier BTC/XMZ evidence is retained below as a dated historical checkpoint.

Historical checkpoint / 19 September 2026

Exact payments. Safer recovery.

Earlier BTC/XMZ evidence, retained for context. Status statements in this section describe the 19 September checkpoint; the newer update above describes current multi-asset work.

Verified in isolated tests

Exact quoted XMZ reaches its destination, with network fees accounted for separately and unused reserve returned. A deliberately lost broadcast reply is reconciled without a second payment.

Wallet safeguard implemented

Saved transaction inputs are checked against the open wallet before submission. Wrong-wallet relay is rejected. Focused tests passed with GCC and Clang, and the wallet RPC was rebuilt successfully.

Restart research, not a finished vault

Encrypted transaction metadata can be restored in a fresh worker. Wrong keys and altered records fail before broadcast. Production key storage, backup and recovery after the whole application closes remain outstanding.

Public verification summary — no personal paths or raw logs
  • 89 engine library tests and three compile-fail checks passed in the latest acceptance run.
  • Both funded scenarios passed, including lost replies, metadata tampering and wrong-wallet rejection.
  • Four focused wallet-validation tests passed with each of GCC and Clang.
  • AI-assisted source review informed the work; independent security review is still required.

Only an aggregate summary is published here. Raw development logs, local usernames, home-directory paths and private wallet data are not included.

Agreed payout policy

A quote for 100 XMZ means exactly 100 XMZ received. The XMZ buyer funds a separate network-fee reserve and receives its unused balance. The new signed terms, isolated-wallet payout tests and first paired-chain success test are implemented; complete recovery and GUI execution remain unfinished. Initial application trading fees remain zero, separate from network fees.

At that checkpoint, next steps were: implement signed reserve terms and durable recovery storage; prove complete two-party settlement and refunds; connect GUI approval to execution; validate public peers, pricing rules and release gates. Cancellation-fee responsibility, recovery unlocking and reserve funding for buyers without XMZ still need resolution.

02 / The delivery path

Six milestones.
One complete journey.

Estimates last revised on 11 October 2026 for an initial LTC/XMZ and BCH/XMZ release path; progress updated 16 October. Ranges below are remaining engineering effort; each milestone still needs its observable exit condition.

Verified foundation In development / next Planned Release-gated
Next focus8–16 engineer-weeks · LTC + BCH

SETTLEMENT ENGINE

Every atom accounted for.

Complete isolated Litecoin–XMZ success and refund paths now pass with exact balances and fees. Finish the remaining BCH private signing, protected peer handoff and continuous desktop path (4–8 engineer-weeks), then Litecoin light-wallet atomic-swap settlement (4–8 engineer-weeks; light-wallet success and refund paths and process-interruption cases now pass, while power loss and settlement without node-backed services remain). These estimates cover the initial two-market scope; other currencies have separate gates below.

Deliverables & completion gate
  • Implement the agreed exact XMZ payout with a buyer-funded reserve and unused reserve returned to the buyer.
  • Account for funding fees, recovery fees, change and remaining balances.
  • Verify complete payout and refund paths with exact on-chain accounting.
Exit condition

Full proceeds or the defined refund reach the correct wallet; every fee and remaining output has an explicit treatment.

Still needed: broader paired-chain failure coverage and each market’s settlement and recovery gate

Integration in progress4–6 engineer-weeks · shared

DURABLE RECOVERY

Close the app. Keep the trade safe.

Litecoin shared setup, saved approvals and recovered wallets pass focused restart checks. Light-wallet trades now also recover from a killed app or helper, and from a lost broadcast reply, without duplicate funding. Each trade now has its own folder that the app reopens by itself, and a user recovery guide covers each stage. Power-loss and full interruption coverage at every settlement boundary remain required.

Deliverables & completion gate
  • Persist signed terms, peer identities, policy and protocol progress.
  • Connect single-use execution ownership to a restart-safe journal.
  • Test crashes, interrupted writes, missing replies and uncertain broadcasts.
  • Reconcile an existing payment instead of blindly sending it again.
Exit condition

A fresh application process resumes or safely reconciles interrupted swaps without duplicate funding or loss of recovery information.

Builds on: authenticated Litecoin state, prepared XMZ transactions and isolated recovery tests

Integration in progress2–4 engineer-weeks · shared

MONZERO GUI

One clear trading experience.

Coin selectors, exact-precision previews, Litecoin payment/recovery controls and BCH agreement, funding approval, saved-status, node-observation and separate settlement signing/release review controls are implemented. BCH admission, saved-approval recovery, exact funding relay, lost-reply handling and read-only chain observation pass actual Qt/helper fixtures; funded Litecoin paths pass isolated integration runs. Complete the continuous app journey and a tester-ready workflow.

QuoteApproveFundSettle / refund
Deliverables & completion gate
  • Separate saving commercial terms from explicit permission to start a trade.
  • Display exact amounts, destinations, fees, confirmations and deadlines.
  • Connect journal loading to read-only payment checks and recovery controls.
  • Test the complete interface against the native settlement engine.
Exit condition

A tester can complete a full test-network swap in the GUI, including an interrupted-and-restarted scenario, without developer intervention.

Requires: full settlement + durable recovery

Planned4–6 engineer-weeks · first pilot

PUBLIC TRADING INFRASTRUCTURE

Find a peer. Verify the offer.

Move beyond controlled local counterparts to authenticated peers and discoverable offers on a public test network.

Deliverables & completion gate
  • Implement public peer authentication and offer discovery.
  • Handle unavailable peers, expired offers and conflicting trade attempts.
  • Introduce operational monitoring and a controlled tester workflow.
  • Recruit willing counterparties; adapters do not create liquidity.
Exit condition

Separate testers can discover, agree and complete supported test-network trades, with failures and offline peers handled explicitly.

Requires: authenticated protocol + working execution workflow

Design + foundations2–4 engineer-weeks · after decisions

PRICE POLICY & XMZ UTILITY

Transparent rules. Explicit fees.

Apply agreed price limits and clear fee rules to trades through the Monzero protocol. The initial BTC/XMZ scope permits zero mandatory app trading fee; network fees remain explicit.

Deliverables & completion gate
  • Select the initial reference price, trusted pricing source and permitted deviation.
  • Reject stale references and out-of-band new trades; keep existing recovery paths available.
  • Define reference updates and manipulation protections for a thinly traded market.
  • Keep the initial zero-app-fee scope explicit; separately agree any later fee recipient and failure/refund behaviour.
Exit condition

Actual trade admission enforces the approved price policy and fee rules; users can distinguish application fees from native network fees.

Initial BTC/XMZ scope permits zero mandatory app trading fee. Pricing policy and later fee-bearing scope remain separate work.

Release gate closed8–16 engineer-weeks + external waits

REVIEW & STAGED RELEASE

Earn the right to go live.

A passing test suite is evidence, not a launch switch. Real-money activation follows review, platform validation and explicit release approval.

Deliverables & completion gate
  • Complete adversarial testing and obtain an independent security review.
  • Validate native platform behaviour, including Windows; some new primitives are Linux-only.
  • Reproduce and sign release artifacts, verify downloads and document limitations.
  • Move from a public test-network pilot to a separately approved, controlled real-money rollout.
Exit condition

Settlement, recovery, security and release requirements have supporting evidence. Warnings and public testing do not replace those requirements.

Requires: prior milestones + review findings addressed

03 / Revised plan · 11 October 2026

More work than
the original estimate.

The previous 4–8-week GUI and 8–16-week public-pilot ranges belonged to the earlier BTC/XMZ scope. They were not a credible estimate for the expanded multi-coin project and are superseded here.

Are we behind schedule?

The project is behind the readiness implied by the old roadmap. Verified controller and component progress has not yet produced a tester-ready multi-coin desktop exchange. The original scope grew without a matching schedule revision. No agreed start date, staffing baseline or measured delivery velocity is available to calculate an exact number of weeks late.

Estimate basis: provisional engineering judgement, not a measured forecast. One engineer-week means roughly 30–40 focused engineering hours. Calendar windows assume one continuous full-time workstream, the current tooling, LTC/BCH first, prompt policy decisions and no additional features. They include routine integration/retest effort, but exclude reviewer booking delays and major protocol redesign. Automated run time is not a substitute for engineering capacity. At half that capacity, elapsed time could roughly double. Confidence is low until complete app workflows pass.

LTC + BCH settlement8–16 weeks
Recovery and active-trade backup4–6 weeks
Desktop setup and trade workflow2–4 weeks
Public peers and offers4–6 weeks
Price and fee policy2–4 weeks
Platform hardening and release8–16 weeks

Solid bars show the lower estimate; hatching extends to the upper estimate. These are remaining effort allowances, not percentages complete. The single-workstream baseline totals the first three stages for a private pilot, adds peers and policy for a public pilot, then adds release work. Parallel work would require additional capacity; it is not assumed.

From this revision14–26 weeks

Tester-ready LTC/BCH desktop flow

Indicative window: January–April 2027. Complete isolated-chain GUI journeys, Litecoin light-wallet swap funding, BCH protected signing/handoff, active-trade backup and interruption recovery. This is a private test milestone, not real-money activation.

Cumulative from this revision20–36 weeks

Public test-network pilot

Indicative window: late February–June 2027. Adds public counterparties, offer discovery, agreed market rules and tester operations. Requires suitable test-network services and willing counterparties.

First controlled real-money release: conditional planning allowance only

Allow another 8–16 engineer-weeks after public-pilot readiness for adversarial findings, platform validation, wallet/mining regression checks, packaging and review remediation. That gives a provisional 28–52 weeks from this revision (late April–October 2027), plus external review waits. There is no committed launch date. Independent review, Windows/platform readiness and unresolved findings can move or invalidate this window.

Remaining work by currency

BCH / XMZ · 4–8 engineer-weeks

Finish private signing, protected peer transport and the complete desktop settlement path. Controller success and public review are verified; light-wallet funding now signs through the helper, and broadcast and app integration are next. Recovery, public-network and release gates are shared stages above, not included in this coin-specific allowance.

LTC / XMZ · 4–8 engineer-weeks

LTC/XMZ is the first pair; swaps and refunds also pass on chains that keep producing blocks, and the first public-testnet swaps have passed, one paid from the in-app light wallet. Light-wallet success and refund paths now pass, including recovery after process interruptions; power-loss recovery and settlement without node-backed test services remain. Node-backed continuous success/refund already pass. Public setup and active-trade backup belong to the shared GUI/recovery stages. Together LTC and BCH account for the 8–16-week settlement allowance above.

BTC / XMZ · 2–4 engineer-weeks

Revalidate the historical settlement path against the current app, recovery and packaging changes. This is an additional regression/integration allowance after the initial LTC/BCH scope stabilizes; it is not included in the first-pilot dates.

DOGE / XMZ · decision first

Allow 2–4 engineer-weeks to resolve the legacy funding transaction-ID malleability design. If a viable design is demonstrated, budget a further 8–16 engineer-weeks for implementation and isolated settlement/recovery acceptance. Confidence is very low; the design gate may require a different approach. Shared release gates still apply.

ETH / XMZ · 16–26 engineer-weeks

Provisional allowance after work starts: 4–6 weeks for protocol/contract design, then 12–20 for settlement, fee/nonce handling and recovery testing. This is a separate project beyond current previews, excluded from first-pilot dates and subject to dedicated contract review. Confidence is very low.

Direct XMZ / XMR · research gate

Allow 4–8 engineer-weeks for a feasibility and recovery design decision after prioritization. There is no defensible implementation finish date until that gate passes. Intermediary work remains paused; a preview is not a settlement engine.

Native RUNE / XMZ · research gate

Allow 4–8 engineer-weeks to establish a viable native settlement and recovery design. Implementation and release cannot yet be estimated responsibly. This work is excluded from the initial LTC/BCH delivery windows.

Wallet, mining and website

Existing app features need regression checks as the DEX changes. Release validation is included in the shared hardening allowance. Roadmap/build-status upkeep continues alongside engineering; neither has a one-time completion date. New mining or website features would require their own scoped estimate.

Whole-project completion: no credible fixed date for every listed currency. Research outcomes, additional coin effort and external review are not covered by the first-release window. Focus the initial delivery on LTC/BCH, then schedule each added market after its design gate. Re-estimate when the complete BCH desktop flow and Litecoin light-wallet swap pass, and whenever scope or staffing changes. Test counts alone do not demonstrate schedule completion.

04 / Clear expectations

What this roadmap means.

Readiness is per market

BTC/XMZ provides historical foundations, while Litecoin and BCH/XMZ development progresses. Direct XMZ/XMR, DOGE, ETH and native RUNE each require their own verified settlement and recovery before activation.

Price bands are not value guarantees

Limits apply to new trades through our protocol. They do not set prices on other exchanges, guarantee a buyer or establish a guaranteed XMZ value.

Community testing complements review

Public test-network participation can uncover failures. It does not replace independent review, and no paid bug-bounty programme is announced by this roadmap.

Open development. Honest milestones.

Follow the evidence.
Help shape what comes next.

Explore the project, review the security guidance and follow future tester instructions. No deposit is required to read or follow this roadmap.