v1.0.0

Qbit: Post-quantum peer to peer digital value

Mainnet is here.

Qbit v1.0.0 launches peer-to-peer digital value for the post-quantum era.
From block zero, Qbit is built around quantum-resistant spend authorization,
proof-of-work issuance, and long-horizon self-custody. Post-quantum protection
is a foundation of the network, not a future migration left for holders,
wallets, exchanges, and custodians to coordinate after the fact.

QBT begins with no premine and mining-only distribution under a fixed
210,000,000 QBT cap. Cadence combines open SHA-256 mining with AuxPoW merge
mining, allowing independent miners to participate while giving established
Bitcoin mining infrastructure a direct path to help secure Qbit. P2MR keeps
spend keys hidden until use and authorizes spending with hash-based,
quantum-resistant signatures.

This release carries Qbit from public testnet into its production network. It
is the starting point for a community-run chain designed to protect ownership
over a longer horizon while retaining the open participation, verifiability,
and self-custody expected of peer-to-peer digital value. Read more about the
design and long-term vision at qbit.org.

Launch commitments

The v1.0.0 source pins the mined mainnet genesis block, its genesis-bound ASERT
anchor, and production AuxPoW chain ID 47. The public testnet4 genesis block
and AuxPoW chain ID 31430 remain unchanged. Mainnet becomes official only
through the signed v1.0.0 release and qbit.org launch announcement.

How to Upgrade

Shut down the older qbit process and wait until it exits completely before
installing v1.0.0.

Any data created with a pre-launch mainnet genesis block is incompatible with
the launched chain. Remove or move aside pre-launch mainnet chainstate, block,
index, mempool, and peer-discovery data before starting the final v1.0.0
binary. Do not delete wallet files or wallet backups.

Testnet4 operators can continue using the existing testnet4 data directory
with -testnet4 or -chain=testnet4.

Mainnet network identity

Mainnet is the default chain for a standard v1.0.0 build. No chain-selection
flag is required.

Item	Value
Chain option	default, or -chain=main
Default P2P port	8355
Default RPC/REST port	8352
Address HRP	qb
DNS seed 1	flux-mainnet.qbit.org
DNS seed 2	phase-mainnet.qbit.org
Archive fallback 1	positron-mainnet.qbit.org:8355
Archive fallback 2	graviton-mainnet.qbit.org:8355
AuxPoW chain ID	47
Genesis block	0000000000004d60aa5d46013991d0a0e2995d89ee98e53068ae196d763e79f2
Genesis nBits	0x1a7f1ab5
ASERT permissionless / legacy anchor	0x18109c29
ASERT AuxPoW anchor	0x1801ca70

Mainnet-capable binaries are the build default. Operators who intentionally
need a binary that rejects mainnet must build with
-DQBIT_TESTNET_ONLY_RELEASE=ON. The distribution archive name does not
silently enable that restriction.

Changes since v0.1.2-testnet4

This release contains all changes after the signed v0.1.2-testnet4 tag,
together with the mainnet launch configuration completed for v1.0.0. The
principal changes in that range are listed below. The following
Overall v1.0.0 summary describes the resulting launch network as a whole.

P2MR consensus, conformance, and wallet safety

• Published the normative qbit P2MR v1 consensus profile and added a
  reproducible corpus, an independent Rust oracle, exact-release evidence, and
  a fail-closed conformance gate (#118).
• Activated corrected P2MR validation-weight accounting on testnet4 at block
  60,000; v1.0.0 applies the corrected accounting on mainnet from genesis
  (#109).
• Rejected malformed future P2MR leaf versions in qbit-qt, bound imported
  proofs to the expected signer, bounded proof parsing, and reduced portable
  proof exports to verifier-required data (#82, #85, #95, #96).
• Preserved wallet-local PQC usage and budget reporting when a Qt signing
  attempt consumes a reservation and later fails (#128).
• Expanded restricted-output fundrawtransaction coverage so disallowed
  prebuilt outputs fail before wallet funding (#86).

Consensus, mining, and peer-to-peer hardening

• Rejected AuxPoW substitutions whose parent proof is valid for the wrong qbit
  block height (#106).
• Cached Cadence lane predecessors to avoid repeated chain walks during
  lane-local difficulty processing (#108).
• Based assume-valid burial estimates on aggregate Cadence work and based
  peer-to-peer anti-DoS thresholds on recent chainwork (#88, #89).
• Added regression coverage that reliably reaps nodes after expected startup
  failures (#111).

Wallet and qbit-qt reliability

• Fixed wallet shutdown lifetime and model-adoption ordering issues that could
  deadlock qbit-qt (#87, #90).
• Prevented wallet progress dialogs from being closed while their operation is
  still active (#97).
• Prohibited test-only PQC runtime controls from production qbit builds (#107).

Release engineering, CI, and public documentation

• Bound builder attestations to the reconstructed archive from the signed-tag
  source, made resumed draft notes deterministic, and replaced automated
  publication with a validation-first local publisher (#84, #116, #117).
• Required published releases to become immutable and rechecked their final
  asset names and digests after publication (#117).
• Split release-tag creation from immutability policy, recorded public trust
  data for v0.1.2-testnet4, and enabled the protected v1.0.0 validation line
  (#66, #68, #73).
• Split the MSan dependency build, resolved high- and medium-severity scanner
  findings, and added stronger release and source-policy test coverage
  (#67, #72, #74).
• Updated the generated RPC documentation to display the qbit version and full
  project logo (#119).

Mainnet launch configuration completed for v1.0.0

• Changed the release version to v1.0.0 and made mainnet the default chain in
  ordinary source and Guix builds. Testnet-only binaries remain an explicit
  opt-in build mode.
• Added production mainnet DNS seeds, compiled fixed seeds, and documented
  archive-node fallbacks while preserving the existing testnet4 identity.
• Set the launch blockchain and chainstate size estimates to zero so initial
  storage guidance does not imply pre-existing mainnet history.
• Added a fail-closed mainnet posture validator and a phase-aware Core Checks
  job. The checked-in final policy and the publisher require complete success
  and reject altered genesis/ASERT commitments, incomplete bootstrap wiring,
  or missing default-mainnet assertions.
• Added mainnet operator, mining-pool, exchange, bootstrap, compatibility, and
  release-verification guidance.

Overall v1.0.0 summary

Consensus and authorization

• qbit launches with the versioned qbit P2MR v1 consensus profile.
• P2MR spend authorization uses the bounded SLH-DSA-SHA2-128s profile and
  qbit-specific commitment and signature domains.
• The independently reproducible P2MR v1 conformance corpus, Rust oracle, and
  commit-bound release evidence gate the release.
• Corrected P2MR validation-weight accounting is active on mainnet from
  genesis.
• Restricted-output mode is active from genesis for public launch-chain
  spendable outputs.

Mining

• Mainnet uses a 60-second aggregate Cadence target split between a 75-second
  permissionless lane and a 300-second AuxPoW lane.
• Mainnet AuxPoW uses production chain ID 47, distinct from public
  testnet4 chain ID 31430.
• Both lanes use independent ASERT difficulty tracking with a two-hour
  half-life.
• Launch difficulty is fixed from the July 13, 2026 Hashrate Index snapshot:
  the permissionless lane uses the seven-day average USD hashprice, while the
  AuxPoW lane assumes 1% of the seven-day Bitcoin hashrate SMA. The selected
  genesis target matches public testnet4 nBits. The mined mainnet block and
  all three ASERT lane-anchor targets are pinned in source and checked by the
  publication gate.
• Permissionless mining uses getblocktemplate and submitblock.
• Merged mining uses createauxblock and submitauxblock; pool software must
  follow the commitment order and chain ID returned by the node.

Bootstrap and archive operation

• Mainnet ships two DNS seed hostnames and two compiled fixed seed addresses.
• Project-operated archive nodes are published as explicit
  -connectarchive fallbacks for degraded automatic discovery.
• Full block and witness history remains the default operating mode.
• Archive nodes advertise NODE_ARCHIVE; witness pruning is explicit opt-in
  behavior and advertises NODE_WITNESS_PRUNED.

Release security

• Mainnet publication fails closed unless the signed tag target retains
  production AuxPoW chain ID 47, final sourced genesis/ASERT data, exact
  bootstrap seed generation, and tested default-mainnet build behavior.
• Release source is bound to a verified signed annotated tag and a distinct
  trusted validation ref.
• Builder attestations bind each counted artifact set to the reconstructed
  source archive.
• Release publication is performed by the validation-first local publisher.
• Publication requires an immutable GitHub Release and revalidates the final
  asset names and digests after immutability is observed.

Compatibility

qbit is not wire-, consensus-, address-, wallet-, or data-directory-compatible
with Bitcoin Core. Bitcoin addresses and Bitcoin payment URIs are not valid
qbit payment destinations.

Public testnet4 remains available with:

qbitd -testnet4
qbit-cli -testnet4 getblockch...

v0.1.2-testnet4

Qbit version v0.1.2-testnet4 is available from the release page for that
version.

This is a public testnet4 maintenance release based on the changes since
v0.1.1-testnet4. It preserves the reset testnet4 lineage from v0.1.0 and
focuses on AuxPoW mining compatibility, P2MR wallet and Qt signing behavior,
witness-pruned startup safety, P2MR/PQC script and data-signature coverage,
release/CI hardening, and public testnet operator documentation.

Testnet-era release artifacts are for public testnet use only unless the
release page explicitly says otherwise. Qbit mainnet is not launched. Do not
treat any in-tree mainnet genesis block, hash, seed placeholder, or endpoint
placeholder as an official mainnet launch commitment.

Testnet coins have no economic value, and the public testnet may be reset or
replaced during rehearsal.

Please report bugs using the Qbit issue tracker.

How to Upgrade

Shut down the older qbit process first and wait until it exits completely.
Then install the new binaries from the GitHub Release page.

This release does not require a testnet4 chain reset for nodes upgrading from
v0.1.1-testnet4.

On Linux, replace the existing qbitd, qbit-cli, qbit-tx, qbit-util,
and qbit-wallet binaries with the new versions.

On macOS, replace the installed Qbit application bundle or unpack the updated
archive into the desired location.

On Windows, run the installer if one is provided for the release, or replace
the unpacked binaries with the new release artifacts.

Compatibility

The public Qbit testnet4 chain is selected with:

qbitd -testnet4
qbit-cli -testnet4 getblockchaininfo

Official testnet release binaries are expected to reject no-flag mainnet
startup and explicit -chain=main startup. Use -testnet4 or
-chain=testnet4 for the public testnet.

Supported and tested platforms for this release are the artifacts attached to
the GitHub Release page. The release page is the source of truth for available
platform builds, checksums, signatures, and attestations.

Public testnet4 network identity remains the v0.1.0-testnet4 reset testnet4
identity unless the release page explicitly says otherwise.

There are no scheduled consensus activation changes in v0.1.2-testnet4.
Mining pools, exchanges, explorers, wallets, and other testnet4 operators can
upgrade without a chain reset.

Item	Value
Chain flag	-testnet4 or -chain=testnet4
Default P2P port	48355
Default RPC/REST port	48352
Address HRP	tq
AuxPoW chain ID	31430

Notable changes

Consensus, mining, and node operation

• submitauxblock now accepts legacy Dogecoin-style AuxPoW payloads that
  include the extra parent-block hash field, normalizes them into qbit's
  canonical AuxPoW layout, and validates/stores the canonical form.
• Permissionless getblocktemplate responses now sanitize regtest
  -blockversion overrides that accidentally set the AuxPoW signalling flag.
  Permissionless templates remain canonical with chain_id=0, auxpow=false,
  and preserved low versionbits.
• The mining pool quickstart now documents the commitmentorder and
  commitmentactivationheight fields returned by createauxblock, and tells
  pool software to follow the node-returned commitment order instead of
  Namecoin, Dogecoin, or serializer assumptions.
• Witness-pruned -reindex-chainstate startup now validates the supplied
  -assumevalid hash before any local chainstate or snapshot chainstate wipe
  can run. Null, unknown, off-best-header-chain, insufficient-work, and too-low
  hashes fail before destructive startup paths.

Wallet, RPC, and PQC signing

• Qt Sign/Verify is enabled again on P2MR-only chains, with P2MR data-proof
  labels instead of legacy message-signing labels.
• Qt Sign/Verify can sign UTF-8 text after hashing it, or sign raw 32-byte
  hashes directly, with wallet-owned P2MR/PQC keys. It emits proof JSON
  compatible with signdatapqchash.
• Qt Sign/Verify can verify pasted P2MR/PQC proof JSON compatible with
  verifydatapqchash.
• Qt signing locally verifies generated proofs before displaying them and shows
  PQC signature-budget state after signing.
• P2MR data-proof verification is shared between the Qt verifier and the
  verifydatapqchash RPC path.
• Wallet-backed PQC data-hash signing now treats persisted counter
  reservations as consumed once the reservation succeeds, even if the later raw
  signing operation fails.
• signdatapqchash reports and logs consumed PQC counter ranges for
  data-hash signing attempts that fail after a reservation has already been
  persisted.
• P2MR data-hash signing now distinguishes exhausted PQC signature budgets from
  missing private keys when a selected leaf cannot be signed.
• Provider, wallet unit, and functional RPC coverage now exercise successful
  and failing PQC data-hash signing counter paths.
• New qbit-qt wallets now default to encrypted creation for ordinary private-key
  wallets. The Create Wallet dialog labels encryption as recommended and
  explains that encryption protects private keys while enabling authenticated
  wallet loads that avoid repeated plaintext PQC key validation.
• P2MR getnewaddress and MarkUnusedAddresses flows avoid full synchronous
  keypool top-ups when ranged P2MR descriptors remain above the low watermark.
  They schedule bounded low-watermark refills while preserving exhaustion,
  locked-wallet, recovery, and rescan behavior.
• Explicit wallet output types must now be both chain-allowed and backed by a
  matching wallet manager on P2MR-only chains.
• fundrawtransaction now rejects prebuilt raw outputs that are not allowed in
  restricted-output mode before wallet funding. P2MR, OP_RETURN, and
  PayToAnchor outputs remain accepted where policy permits them.
• deriveaddresses RPC help now labels rawmr(<merkle root>) as an
  expert-only arbitrary-root descriptor form whose roots cannot be proved or
  signed by the wallet.

P2MR descriptors and future leaves

• Added an end-to-end feature_p2mr.py regression for rawmr(<future-leaf-root>)
  outputs.
• Covered public descriptor derivation, wallet funding, signer refusal for a
  non-0xc0 future leaf, standard mempool rejection, and mandatory block
  acceptance for the same reveal spend.
• Added focused unit and functional coverage around reserved P2MR leaf-version
  policy, masked future leaf control bytes, and PSBT signing/finalization
  refusal for reserved leaf versions.
• Added independent JSON vectors for P2MR leaf hashing, branch hashing, control
  blocks, Merkle roots, scriptPubKeys, and mainnet/regtest addresses.
• P2MR commitment-vector tests now cover malformed control blocks, wrong leaf
  versions, wrong CompactSize or script-length commitments, mutated siblings,
  unsorted branch roots, and wrong root commitments.
• Descriptor, RPC, script, and PSBT tests now reuse the independent P2MR
  commitment vectors.

P2MR script, sighash, and data-signature coverage

• Added fixed byte-vector P2MR script-path tests for a single-leaf spend and a
  two-leaf branch spend.
• Added a fixed byte-vector CTV spend test that avoids deriving the accepted
  spend from production commitment helpers.
• Added independent P2MR/PQC witness-vector coverage for the default
  OP_CHECKSIGPQC spend path, including mutated signatures, wrong sighash
  domains, bad hashtype suffixes, and wrong script/pubkey commitments.
• Added an independent annex-present P2MR OP_CHECKSIGPQC witness vector with
  annex spend-type encoding, annex hash commitment, no-annex contrast data, and
  annex-specific near-miss failures.
• Added independent fixed P2MR OP_CHECKSIGPQC witness vectors for non-default
  sighash modes, including SIGHASH_NONE, SIGHASH_SINGLE, and
  ANYONECANPAY combinations.
• The fixed P2MR PQC witness fixture now pins serialized spend transactions,
  spent outputs, P2MR leaf/control data, public keys, signatures, raw
  p2mrSigMsg data, and final p2mrSighash values.
• Added reproducible generator coverage for the P2MR PQC witness vectors so
  the checked-in fixtures can be regenerated independently.
• Added codeseparator-specific P2MR OP_CHECKSIGPQC vectors for default and
  non-default OP_CODESEPARATOR positions, including same-leaf branches with
  different codeseparator positions.
• Added negative coverage for wrong codeseparator positions, domains, public
  keys, scripts, and signatures.
• Added explicit SIGHASH_SINGLE P2MR cases covering both matched-output
  acceptance and missing-output rejection.
• P2MR SIGHASH_SINGLE tests now assert failure for missing outputs instead
  of allowing the legacy uint256::ONE behavior.
• Added independent OP_CHECKDATASIGPQC P2MR witness-vector coverage for
  accepted data-signature spends and near misses involving corrupted
  signatures, wrong domains, mutated witness message hashes, mutated leaves,
  and wrong public keys.
• Added independent OP_CHECKDATASIGADDPQC P2MR witness-vector coverage for
  threshold data signatures, including n-of-n success, m-of-n success with
  empty-signature skips, threshold failure, invalid non-empty signatures, wrong
  message hashes, wrong committed keys, wrong domains, and mutated leaves.
• Added pinned P2MR data-hash proof fixtures for the QbitDataSigPQC domain,
  including C++ fixture validation, wallet signing reproduction, and
  verifydatapqchash functional coverage for malformed or mutated proof data.

Release and CI

• Release publication validation now requires the signed release tag target to
  be an ancestor of the configured trusted_release_ref.
• Public release-trust documentation records the v0.1.1-testnet4 signed tag
  object and target from public git state.
• Public branch rulesets now use a path-aware Required Merge Gate profile so
  source, release-policy, RPC docs, public docs, and GitHub metadata changes
  receive appropriate validation...

v0.1.1-testnet4

Qbit version v0.1.1-testnet4 is available from the release page for that
version.

This is a public testnet4 maintenance release based on the changes since
v0.1.0-testnet4. It preserves the reset testnet4 lineage from v0.1.0 and
focuses on AuxPoW mining compatibility and upgrade behavior, wallet and PQC
signing reliability, Qt send responsiveness and status visibility, and public
release/CI hardening.

Testnet-era release artifacts are for public testnet use only unless the
release page explicitly says otherwise. Qbit mainnet is not launched. Do not
treat any in-tree mainnet genesis block, hash, seed placeholder, or endpoint
placeholder as an official mainnet launch commitment.

Testnet coins have no economic value, and the public testnet may be reset or
replaced during rehearsal.

Please report bugs using the Qbit issue tracker.

How to Upgrade

Shut down the older qbit process first and wait until it exits completely.
Then install the new binaries from the GitHub Release page.

This release does not require a testnet4 chain reset for nodes upgrading from
v0.1.0-testnet4.

On Linux, replace the existing qbitd, qbit-cli, qbit-tx, qbit-util,
and qbit-wallet binaries with the new versions.

On macOS, replace the installed Qbit application bundle or unpack the updated
archive into the desired location.

On Windows, run the installer if one is provided for the release, or replace
the unpacked binaries with the new release artifacts.

Important

Operators who run v0.1.0-testnet4 past height 20500 may need to run
reconsiderblock on the first rejected post-activation block after upgrading;
-reindex is the fallback if that block is unknown.

Compatibility

The public Qbit testnet4 chain is selected with:

qbitd -testnet4
qbit-cli -testnet4 getblockchaininfo

Official testnet release binaries are expected to reject no-flag mainnet
startup and explicit -chain=main startup. Use -testnet4 or
-chain=testnet4 for the public testnet.

Supported and tested platforms for this release are the artifacts attached to
the GitHub Release page. The release page is the source of truth for available
platform builds, checksums, signatures, and attestations.

Public testnet4 network identity remains the v0.1.0-testnet4 reset testnet4
identity unless the release page explicitly says otherwise.

Mining pools and AuxPoW adapters should upgrade before the testnet4 AuxPoW
display-commitment activation height. createauxblock now reports the active
commitment byte order and the activation height so pool software can follow the
node result instead of inferring the encoding.

The AuxPoW display-commitment change is a scheduled testnet4 consensus rule
transition at height 20500. Nodes and mining software that remain on older
rules after that height may be unable to follow corrected AuxPoW blocks.

Item	Value
Chain flag	-testnet4 or -chain=testnet4
Default P2P port	48355
Default RPC/REST port	48352
Address HRP	tq
AuxPoW chain ID	31430
AuxPoW display-commitment activation height	20500

Notable changes

Consensus and mining

• Corrected the AuxPoW parent-coinbase commitment byte order used by merged
  mining templates and validation.
• Preserved existing testnet4 AuxPoW history by validating the original
  internal byte order before height 20500 and the corrected display byte
  order at and after height 20500.
• Added commitmentorder and commitmentactivationheight fields to
  createauxblock results. Before activation the commitment order is
  internal; at activation and later it is display.
• Added regtest control for the AuxPoW commitment transition through
  -testactivationheight=auxpowcommitment@<height> and covered the
  n-1/n boundary with functional and unit tests.

Node operation and upgrade behavior

• Archive nodes with legacy AuxPoW block-index entries can recover missing
  persisted AuxPoW payloads from retained block files during startup.
• Legacy pruned datadirs that are missing both persisted AuxPoW payloads and
  historical block data now trigger a one-time automatic full reindex/resync so
  the node can redownload and revalidate the missing AuxPoW history.
• -reindex-chainstate is rejected for that legacy pruned AuxPoW recovery
  path because it cannot restore missing historical block data. Use a full
  reindex/resync when the node reports this condition.

Wallet, RPC, and PQC signing

• Added wallet RPC signdatapqchash for signing a caller-supplied 32-byte
  hash with a PQC key committed by a wallet-owned P2MR address.
• Added utility RPC verifydatapqchash for verifying those P2MR/PQC data-hash
  signature proofs without requiring wallet access.
• Hardened P2MR data-hash signing so scriptPubKey manager lookup failures do
  not fall through to the wrong signing context.
• For multi-leaf P2MR data-hash signing, the wallet now continues to later
  matching single-key leaves after a runtime PQC signing failure on an earlier
  matching leaf. Explicitly selecting a failing leaf still returns a signing
  failure.
• Authenticated encrypted PQC key records and improved fast restore/loading of
  persisted PQC keys.
• Added phase-aware signing progress for transaction preparation, PQC counter
  reservation, input signing, and finalization.
• Added default-on parallel P2MR/PQC wallet signing, controlled by
  -walletpqcparallel and -walletpqcsignthreads, with serial fallback for
  ineligible transactions.
• Batch-reserved PQC signature counters for parallel signing, assigned
  deterministic counters to worker jobs, and finalized witnesses after raw PQC
  signatures complete.
• Reduced signing-provider collection overhead for transactions with many P2MR
  inputs.
• Plaintext descriptor PQC records now load into a pending validation state and
  are fully validated after wallet load before private signing use.
• PQC signing, send/sign RPCs, and wallet encryption are blocked while
  plaintext PQC key validation is pending or failed.
• getwalletinfo reports pqc_key_validation status and progress fields so
  operators can see whether plaintext PQC key validation is pending, complete,
  or failed.
• Added PQC and Qt send-preparation timing logs to make slow-signing diagnosis
  easier.
• Aligned the public RPC atomic unit naming with the GUI's bits terminology.

Qt

• Moved Qt send preparation off the GUI thread so large P2MR/PQC transactions
  no longer block the interface while signing work is prepared.
• Made send cancellation stop in-flight asynchronous preparation.
• Shows phase-aware send-preparation labels and progress for PQC counter
  reservation, input signing, and transaction finalization.
• During Qt send preparation, Cancel remains available until PQC counters are
  reserved. After reservation, the preparation dialog removes Cancel and
  finishes preparing the transaction; users can still decline the final send
  confirmation before broadcast.
• Hid the receive-address type selector when P2MR is the only available receive
  type.
• Prevented stale sync-progress displays from reaching a visible 100% before
  the node has actually completed synchronization.
• Shows plaintext PQC key-validation status and encryption guidance for
  unencrypted wallets.
• Uses a theme-aware overview background logo so the GUI remains legible in
  light and dark themes.
• Shows the Qt client version in the status bar next to the display unit
  selector.

Release and CI

• Bumped release metadata to v0.1.1-testnet4.
• Added and hardened public contribution templates, public contribution
  guidance, and release-tag signature/ruleset documentation.
• Added public Core Checks and trusted-runner gating, including release
  validator coverage for retained public release tests.
• Improved local release publication linkage fallback handling and release tag
  signature enforcement documentation.

Known issues

No new release-specific known issues are added by v0.1.1-testnet4. Testnet4
remains a public rehearsal network and may still be reset or replaced during
the testnet era.

Credits

Thanks to everyone who contributed code, testing, review, infrastructure, and
release coordination for this release.

v0.1.0-testnet4

Qbit: Post-quantum peer to peer digital value

Crypto is vulnerable to quantum theft, but it doesn't have to be. For the first
time, digital value can be secured natively with quantum-resistant signatures
from block zero.

Qbit version v0.1.0-testnet4 is available from the release page for that
version.

This release provides the public Qbit testnet4 node, wallet, GUI, mining, relay,
RPC, documentation, and release-verification surface. It includes Qbit-specific
network identity, consensus rules, wallet signing, mining flows, address
behavior, relay tooling, and operator workflows for public testnet
participation.

Testnet-era release artifacts are for public testnet use only unless the
release page explicitly says otherwise. Qbit mainnet is not launched. Do not
treat any in-tree mainnet genesis block, hash, seed placeholder, or endpoint
placeholder as an official mainnet launch commitment.

Testnet coins have no economic value, and the public testnet may be reset or
replaced during rehearsal.

This release starts a reset testnet4 lineage. It is not compatible with earlier
testnet4 rc chain data; operators who ran an earlier rc should remove or
archive their old testnet4 network directory before starting this release.

Please report bugs using the Qbit issue tracker.

Compatibility

The public Qbit testnet4 chain is selected with:

qbitd -testnet4
qbit-cli -testnet4 getblockchaininfo

Official testnet release binaries are expected to reject no-flag mainnet
startup and explicit -chain=main startup. Use -testnet4 or
-chain=testnet4 for the public testnet.

Supported and tested platforms for this release are the artifacts attached to
the GitHub Release page. The release page is the source of truth for available
platform builds, checksums, signatures, and attestations.

Public testnet4 identity in this release:

Item	Value
Chain flag	-testnet4 or -chain=testnet4
Default P2P port	48355
Default RPC/REST port	48352
Default onion bind port	48356
Address HRP	tq
Message start / network magic	0xc7c41640
Genesis hash	000000000000796fe86bbc0bf1b66a07e4b4c0676f74b54cf7e5ce8b3f1a0090
Genesis bits	0x1a7f1ab5
Initial Cadence lane bits	0x1a7f1ab5
Spendable address model	P2MR
DNS seeds	coherence-testnet4.qbit.org, triplet-testnet4.qbit.org
Fixed seeds	57.129.86.61:48355, 40.160.66.196:48355
Archive endpoints	fermion-testnet4.qbit.org:48355, boson-testnet4.qbit.org:48355
Minimum chain work	0000000000000000000000000000000000000000000000000000000000000000
Default assume-valid block	0000000000000000000000000000000000000000000000000000000000000000

No public faucet or explorer is assumed by this release note. Use only
resources explicitly published for this release.

Notable changes

Network identity and operator defaults

• Qbit ships Qbit-native executable names: qbitd, qbit-cli, qbit-qt,
  qbit-tx, qbit-util, and qbit-wallet.
• The default config filename is qbit.conf. Default data directories are
  ~/.qbit/ on Linux, ~/Library/Application Support/Qbit/ on macOS, and
  %LOCALAPPDATA%\Qbit\ on Windows.
• Default RPC/REST ports are Qbit-specific: 8352 for mainnet, 18352 for
  testnet3, 48352 for testnet4, 38352 for signet, and 18452 for regtest.
• Qbit init, service, manpage, CMake, package, Qt, NSIS, and product metadata
  have been aligned around Qbit names and assets.
• Payment URIs use qbit:. The wallet and GUI reject incompatible payment URI
  variants for Qbit payments.

Consensus and policy

• Qbit defines its own public-chain genesis blocks, address prefixes,
  message-start bytes, ports, seeds, and chain parameters.
• Blocks target a 60 second aggregate cadence with ASERT difficulty adjustment
  and a 2 hour half-life.
• Cadence mining is active from genesis on public Qbit chains. Permissionless
  mining targets a 75 second lane, and AuxPoW merged mining targets a 300
  second lane.
• Public Qbit chains use P2MR as the spendable output model. P2MR is a witness
  v2, 32-byte Merkle-root output with script-path spending only.
• OP_CHECKSIGPQC is active inside P2MR execution and verifies bounded
  SLH-DSA-SHA2-128s signatures. Current PQC keys are 32-byte public keys,
  64-byte secret keys, and 3,680-byte signatures.
• P2MR-only script validation rejects OP_CHECKSIGPQC outside P2MR and rejects
  executed legacy signature opcodes inside P2MR. P2MR authorization uses
  canonical PQC checksig, verify, and threshold forms.
• P2MR-only data-signature opcodes OP_CHECKDATASIGPQC (0xbc) and
  OP_CHECKDATASIGADDPQC (0xbd) support 32-byte message-hash attestations.
• P2MR-only OP_CHECKTEMPLATEVERIFY is available at opcode byte 0xbb, with
  node-canonical default CTV hash support.
• Qbit has no witness discount. WITNESS_SCALE_FACTOR is 1, and max block
  weight is 2,000,000.
• Coinbase maturity is 1,000 blocks.
• The block subsidy starts at 210 QBT, steps every 43,200 blocks, and uses
  a compound floor stepdown of 598 / 625 until the 210,000,000 QBT money cap
  is reached.
• Public-chain restricted-output mode accepts ordinary spendable P2MR outputs,
  reserved future witness forms, OP_RETURN, and PayToAnchor outputs. Legacy,
  P2SH-SegWit, native SegWit v0, and Taproot receive/change outputs are not the
  public Qbit payment path.
• Public testnet4 starts this reset release without a post-genesis
  minimum-chainwork floor or assume-valid checkpoint. Those values should only
  be raised after a validated reset-chain checkpoint exists.
• Regtest defaults follow Qbit's P2MR-only restricted-output behavior unless a
  test explicitly opts out.

Wallet, address, PSBT, and RPC behavior

• Descriptor wallets are the supported wallet type. Legacy wallet creation is
  not supported.

• Wallet receive and change flows use P2MR on launch and rehearsal chains:

  qbit-cli -testnet4 -rpcwallet=<wallet> getnewaddress "" "p2mr"
  qbit-cli -testnet4 -rpcwallet=<wallet> getrawchangeaddress "p2mr"

• Qbit adds P2MR descriptors and script support, including mr(...),
  rawmr(...), pk(...), multi_a(...), sortedmulti_a(...), and pqc(...)
  where appropriate.

• P2MR signing uses stateful PQC signature counters. Wallet and signing RPCs
  can report pqc_signature_count, pqc_signature_limit,
  pqc_signatures_remaining, pqc_limit_state, and related warning fields.

• Do not run two active copies of the same signing wallet. Restore and backup
  procedures must preserve wallet state, including PQC signature counters.

• Plain xpub-only watch-only flows are not enough for Qbit P2MR. Use
  exportpubkeydb, importpubkeydb, getnextpubkeydbaddress, and
  listpubkeydbstatus for watch-only P2MR address allocation.

• Qbit supports P2MR PSBT signing and finalization, including dedicated P2MR
  data and Qbit-proprietary fields. Non-Qbit PSBT tooling should not be assumed
  to preserve or understand those fields.

• Wallet transaction construction, PSBT, input, spend, coin-control, and fee
  estimate paths account for Qbit P2MR signature sizes.

• Wallet-created payment outputs to reserved future witness versions are
  rejected before send, funding, PSBT, or bumpfee RPCs can report ordinary
  success.

• Imported PQC secret material is validated before it reaches wallet storage,
  and deterministic PQC key derivation uses the trusted key-generation public
  key output.

• Parallel PQC wallet signing is supported while preserving per-wallet lock
  ordering and failure handling.

• Qbit adds or changes public RPCs for Qbit-specific operation, including
  createauxblock, submitauxblock, getarchivepeers, getorphanmetrics,
  getconfirmationtarget, exportpubkeydb, importpubkeydb,
  getnextpubkeydbaddress, listpubkeydbstatus, and getdefaultctvhash.

• Existing RPCs such as getblocktemplate, getnetworkinfo, getblock,
  getnewaddress, getrawchangeaddress, validateaddress, getaddressinfo,
  walletprocesspsbt, decodepsbt, and signrawtransactionwithkey have
  Qbit-specific behavior where P2MR, PQC signing, archive service bits, witness
  pruning, Cadence, or AuxPoW apply.

Mining and confirmation policy

• Permissionless mining continues to use getblocktemplate and submitblock,
  but templates use Qbit Cadence, ASERT, restricted-output, and full-witness
  weight rules.
• AuxPoW merged mining is exposed through createauxblock and
  submitauxblock. Public testnet's AuxPoW chain ID is 31430.
• ASICBoost-compatible version-mask handling is available for Qbit mining
  templates. Custom and AuxPoW templates suppress inappropriate rolling masks
  where miners must not mutate Qbit chain-id, reserved, or AuxPoW layout bits.
• getnetworkhashps can report estimates for all, permissionless, or
  auxpow lanes.
• getconfirmationtarget estimates Qbit confirmation targets from transaction
  value, requested security level, observed stale rate, and observed or modeled
  hashrate. Exchanges and custodians should use it as an input to local deposit
  policy.
• Fresh coinbase rewards mature after 1,000 Qbit blocks. Pool and custody
  accounting must not treat newly mined rewards as immediately spendable.
• PayToAnchor mining payouts are rejected, and mining/RPC policy is tightened
  around Qbit output-script expectations.

Node operation and archive bootstrap

• Qbit defaults to archive/full-history witness retention. Witness pruning is
  an explicit opt-in mode with -prunewitnesses=1.
• Archive-capable nodes advertise NODE_ARCHIVE. Witness-pruned nodes
  advertise NODE_WITNESS_PRUNED.
• -connectarchive=<host:port> provides a stricter arc...