Malairte Bitcoin A fair-launched, CPU/GPU-mineable proof-of-work cryptocurrency built on double SHA-3-256.

§1

Abstract

Malairte Bitcoin (MLRT) is an independent layer-one proof-of-work cryptocurrency designed to keep mining accessible to ordinary participants. Its proof-of-work algorithm, MLRTHash v1, is double SHA-3-256 applied to a 96-byte block header. SHA-3 (Keccak) is the NIST-standardised primitive selected by FIPS 202 and reused by the FIPS 205 post-quantum signature scheme, giving the chain a coherent hash-based cryptographic foundation.

The chain launched fair on 2026-04-21 with no premine, no insider allocation, no token sale, and no venture round. Every MLRT in existence was mined under identical rules from block 0 onward. Block reward is 50 MLRT, halving every 210,000 blocks, with a target block time of 120 seconds and an asymptotic maximum supply of 21,000,000 MLRT — the same emission schedule as Bitcoin, compressed into a 2-minute block.

Malairte is implemented from scratch in Go. The node ships both CPU and CUDA GPU miners, intentionally targeting commodity hardware rather than ASICs. This document is the canonical technical brief and accompanies the open-source reference implementation under Apache 2.0.

§2

Design goals

• Fair launch. No premine, no ICO, no founders' allocation, no private round. The genesis coinbase pays an unspendable burn script. Every coin is the result of public proof-of-work performed under the consensus rules in the open-source reference client.
• Accessibility. Mining targets CPUs and GPUs. There is no ASIC fleet, no economy of scale that locks out home miners, no industrial threshold required to participate. A laptop, a desktop, or a small rig with a single consumer NVIDIA GPU is the intended baseline.
• Quantum security at the hashing layer. SHA-3 is structurally immune to length-extension attacks, shares no design DNA with SHA-2, and is the primitive family NIST chose for FIPS 205 (SLH-DSA). A 256-bit hash retains roughly 128 bits of post-quantum security against Grover's algorithm — comfortable headroom for proof-of-work.
• Transparent treasury. A small, disclosable protocol fee (see §8) funds ongoing development on-chain. The fee is a consensus rule visible in the source; it is not a hidden premine.
• Conservatism. Where possible, Malairte reuses Bitcoin's proven design choices: UTXO model, 21,000,000 cap, halving-based emission, Base58Check + Bech32 addresses, Bitcoin-compatible JSON-RPC. Novelty is reserved for the parts where it earns its keep — the hash function and the future signature scheme.

§3

Chain parameters

The following values are authoritative and pulled directly from internal/chain/params.go (MainNetParams) in the reference implementation.

§4

Proof-of-Work: MLRTHash v1

MLRTHash v1 is the deterministic double application of SHA-3-256 (NIST FIPS 202) over the 96-byte serialised block header. Both inner and outer hashes are the standard Keccak-f[1600] sponge with rate 1088 bits and capacity 512 bits.

MLRTHash(header) = SHA3-256(SHA3-256(serialize(header)))

A block header is valid iff:

MLRTHash(header) ≤ CompactToBig(header.Bits)

Block header (96 bytes)

The mining loop varies Nonce (offset 80, 8 bytes). Using a 64-bit nonce instead of Bitcoin's 32-bit nonce gives 2⁶⁴ attempts per timestamp/extraNonce combination without rolling extra fields. Height is included in the hash so reorganisations at different heights produce distinct work.

Test vectors

Any implementation that produces the following outputs is byte-for-byte correct against the canonical Go reference.

§5

UTXO model

Malairte uses an Unspent Transaction Output model identical in structure to Bitcoin. Every transaction consumes outputs from prior transactions (inputs) and creates new outputs. The UTXO set is the complete set of all outputs not yet spent. Coin ownership is determined by script locking conditions; the default script form is P2PKH (Pay-to-PubKey-Hash).

Addresses are derived from secp256k1 public keys via the standard sequence:

1. Generate a secp256k1 private key (32 random bytes).
2. Derive the compressed public key (33 bytes).
3. pubKeyHash = RIPEMD160(SHA256(compressedPubKey)).
4. payload = [versionByte] + pubKeyHash (versionByte = 50 for mainnet).
5. checksum = SHA256(SHA256(payload))[:4].
6. address = Base58Encode(payload + checksum).

Mainnet addresses therefore begin with the prefix M. Native SegWit Bech32 addresses use the human-readable prefix mlrt, producing mlrt1q… (v0) and mlrt1p… (taproot) forms.

§6

Difficulty retargeting

Difficulty is recalculated every 2,016 blocks using the same algorithm as Bitcoin:

new_target = old_target × (actual_time / expected_time)

Where expected_time = 2016 × 120 = 241,920 seconds (~67 hours). The adjustment is clamped to a factor of 4 in either direction per window to prevent extreme swings. A median-time-past rule over the last 11 blocks prevents trivial timestamp manipulation.

For short-window responsiveness the chain also applies an LWMA (Linearly Weighted Moving Average) component, which smooths out brief hashrate fluctuations without overreacting between full retarget windows.

§7

Tokenomics & emission

Initial block reward is 50 MLRT (5,000,000,000 atoms), halving every 210,000 blocks. The asymptotic maximum supply is 21,000,000 MLRT, approached but never reached: after 64 halvings the reward rounds down to zero atoms.

Unit of account: 1 MLRT = 100,000,000 atoms (8 decimal places, equivalent to Bitcoin's satoshis).

Cumulative supply figures are upper bounds assuming every block is mined and accepted into the canonical chain. They do not include the protocol fee component (§8).

§8

Protocol fee disclosure

Malairte enforces a small protocol fee at the consensus layer. Each block coinbase and each non-coinbase transaction must pay 10 atoms (0.0000001 MLRT) to a publicly-known address:

MRxSEiJJ4FgHrUMMEMfTMeT6EmMDARE1AD

The fee is a consensus rule, visible in the open-source internal/chain/params.go as AdminFeeAtoms = 10. Every node rejects any block that does not include the fee. The genesis block coinbase also pays this address under the same rule.

There was no premine: every MLRT in existence was mined under identical rules from block 0 onward. The protocol fee accrues on-chain block by block, auditable in the block explorer, and funds ongoing development transparently. It is not vested, locked, or distributed off-chain.

The honest framing: a 10-atom fee per block and per transaction is on the order of 10^-8 of a single MLRT — economically negligible to users, materially significant only at multi-year aggregate scale. Exchanges and analytics tools will see it in on-chain data; this section is the canonical place to point them.

§9

Network protocol

The P2P layer is a binary TCP protocol inspired by Bitcoin's. All communication is full-duplex and message-based. Every message is wrapped in a fixed 24-byte header followed by a variable-length payload:

[4]  magic           Network identifier (0x4d4c5254 "MLRT" on mainnet)
[12] command         ASCII command string, null-padded to 12 bytes
[4]  length          Payload length, little-endian uint32
[4]  checksum        SHA3-256(payload)[0:4]
[N]  payload         Variable-length message body

Handshake

On TCP connection, both peers immediately send a version message and respond with verack upon receiving a valid one. After both sides have exchanged verack, the connection is fully established. Periodic ping / pong messages keep it alive.

Block and transaction propagation

New blocks and transactions are announced via inv messages (type + 32-byte hash). Receiving peers request the full payload with getdata, and the sender responds with the corresponding block or tx message. After validation, receivers relay the inv to their own peers.

Initial sync

A newly-connected peer uses getblocks(locator, stop) where the locator is built exponentially — the most recent 10 hashes, then every 2nd, every 4th, etc., back to genesis. The sync peer responds with up to 500 block hashes starting after the highest locator hash it recognises, and the new peer requests each block with getdata.

RPC surface

The node exposes a Bitcoin-compatible JSON-RPC 1.0 HTTP server on port 9332, including getblockchaininfo, getblock, getblockhash, getblocktemplate, submitblock, sendrawtransaction, getrawmempool, validateaddress, and getmininginfo. Most existing Bitcoin tooling that talks JSON-RPC works against a Malairte node with only a port change.

§10

Post-quantum roadmap (MLIP-1)

Most projects marketing themselves as "quantum-resistant" conflate hash-function strength with signature-scheme strength. Malairte does not.

What MLRTHash hardens today. Double SHA-3-256 over a 96-byte header. SHA-3 / Keccak is structurally immune to length-extension attacks, shares no design DNA with SHA-2, and is the same primitive family NIST chose for FIPS 205. A 256-bit hash retains roughly 128 bits of post-quantum security against Grover's algorithm.

What MLRTHash does not solve today. Signatures still use ECDSA over secp256k1 — the same scheme Bitcoin uses, and the same scheme Shor's algorithm breaks on a sufficiently large quantum computer.

The roadmap to fix it. Malairte Improvement Proposal MLIP-1 introduces a new address type backed by SLH-DSA-128f-SHAKE-256 (FIPS 205) — stateless hash-based signatures whose security reduces to the same Keccak primitive as MLRTHash. Existing ECDSA addresses continue working; users opt in to SLH-DSA addresses for new keys. Activation horizon is approximately 12 months from mainnet launch, with at least one halving cycle of public testnet exposure before mainnet activation.

§11

Project roadmap

§12

References

1. Reference implementation — Malairte node, CLI wallet, CPU + CUDA miner, all in Go. Source: github.com/computervirtualservices/malairte.
2. Architecture overview — chain design, UTXO model, PoW, difficulty: docs/architecture.md.
3. Wire protocol specification — full P2P protocol, message types, framing: docs/protocol.md.
4. MLRTHash v1 canonical specification: malairtebitcoin.com/technology.
5. Quantum security overview & MLIP-1 rationale: malairtebitcoin.com/quantum-security.
6. Fair-launch verification: malairtebitcoin.com/fair-launch.
7. NIST FIPS 202 — SHA-3 Standard: Permutation-Based Hash and Extendable-Output Functions. National Institute of Standards and Technology, 2015.
8. NIST FIPS 205 — Stateless Hash-Based Digital Signature Standard (SLH-DSA). National Institute of Standards and Technology, 2024.
9. Nakamoto, S. Bitcoin: A Peer-to-Peer Electronic Cash System. 2008. The UTXO model, halving emission schedule, and JSON-RPC surface in Malairte are deliberate continuations of this work.
10. Live network status: malairtebitcoin.com/network · Block explorer: explorer.malairtebitcoin.com.