Skip to content
Documentation · mainnet · release 1.0.37

Genoryn Krypton documentation

Everything you need to use, mine, trade, run, integrate and audit Genoryn Krypton: quantum-resistant, private-by-default money with a fair launch, a 21,000,000 GNR cap and atomic swaps with bitcoin. Start with the quick start, or jump to any topic from the contents.

Overview

Genoryn Krypton (ticker GNR) is a proof-of-work cryptocurrency built so that no elliptic curve protects your coins or your privacy. Spends are authorized by zk-STARK proofs over hash functions, every transfer is shielded, notes are encrypted with NIST's post-quantum ML-KEM, and light wallets verify the chain themselves without downloading it. GNR and bitcoin are traded peer to peer with atomic swaps: no exchange, no custody, no account.

PropertyValue
Ticker / unitGNR · 1 GNR = 100,000,000 gori
Block time60 seconds (difficulty retargets every block)
Block reward5 GNR, halving every 2,100,000 blocks (about 4 years)
Maximum supply21,000,000 GNR, enforced by every node
Premine / dev feeNone. The genesis issues nothing
PrivacyEvery transfer shielded (zk-STARK); no transparent mode
Proof of workKryptoHash v1, memory-bandwidth bound (GPU-first, CPU-capable)
Mining rewardsShared by every miner in proportion to its work, no pool needed
DifficultyLWMA-1, every block, 90-block window
TradingAtomic BTC ⇄ GNR swaps on an anonymous offer board; the seller's GNR is locked first
Light walletsFlyClient-style tip proofs, follow the most work, release checkpoint (block 14,800)
LicenseMIT or Apache-2.0

What makes it different, in one paragraph each:

  • Quantum-resistant end to end. Coin ownership is proven with hash-based STARKs, encryption is hybrid X25519 + ML-KEM, releases are signed with ML-DSA and SLH-DSA. A quantum computer that breaks elliptic curves breaks nothing here.
  • Private by default. Amounts, senders, recipients and memos are hidden for everyone, always. There is no "transparent" address type that would shrink the anonymity set.
  • Fair mining. Every block's reward is split among all miners by their share of the work, so a single GPU earns its exact share every block without joining a pool, and no operator stands between miners and their coins.
  • Trustless trading. The wallet swaps GNR and bitcoin with another wallet directly. Nobody can sell GNR they do not have: the seller's coins are locked on chain before the buyer pays.

Quick start

  1. Install. Download the Windows installer or the Linux package from Download (see Install & verify), or build from source.
  2. Create a wallet. Open the wallet, choose a password and write down the recovery phrase: 24 words, each with a two-digit number, on paper. Nobody, including the project, can restore a wallet without it.
  3. Get coins. Mine from the Mining tab, buy with bitcoin in the Swap tab, or share your short address (gnrs1…) to receive.
  4. Send privately. Enter an address and an amount; a zero-knowledge proof is built on your computer in about half a second and only then sent.

The same from the command line:

krypton-wallet-cli new                                 # create a wallet, shows the 24 words once
krypton-wallet-cli --node https://genoryn.io balance    # verified light sync, then the balance
krypton-wallet-cli --node https://genoryn.io send gnrs1... 2.5 --memo "invoice 42"

Install & verify

PlatformFileNotes
Windows 10 / 11 (x64)GenorynKrypton-<version>-Windows-x64-Setup.exeInstalls for the current user (no administrator rights) into %LOCALAPPDATA%\Programs\Genoryn Krypton. Wallets and chain data live in %APPDATA%\GenorynKrypton and are kept when the program is removed.
Windows, portablegenoryn-krypton-<version>-windows-x64-portable.zipThe same programs without an installer.
Ubuntu / Debian (x64)genoryn-krypton_<version>_amd64.debsudo apt install ./genoryn-krypton_<version>_amd64.deb; includes a desktop entry and systemd units.
Linux (any distribution)genoryn-krypton-<version>-linux-x64.tar.gzUnpack and run krypton-wallet.
From sourcegithub.com/genoryn/genorynRust stable: cargo build --release. The binaries land in target/release.

Every package contains four programs: krypton-wallet (desktop wallet), kryptond (full node), krypton-miner (GPU/CPU miner) and krypton-wallet-cli (command-line wallet).

Verify what you downloaded. Each release publishes SHA256SUMS and SHA256SUMS.sig, a hybrid post-quantum signature (ML-DSA-87 + SLH-DSA-SHAKE-256s) by the project's release key, fingerprint e4567fb116258bdd, published as docs/release-key.pub:

sha256sum -c SHA256SUMS --ignore-missing
cargo run --release -p krypton-release -- verify docs/release-key.pub SHA256SUMS SHA256SUMS.sig

The wallet's built-in updater performs exactly this check before it installs anything (Updates).

The wallet, tab by tab

The desktop wallet is a small local web server bound to 127.0.0.1 with a random session token, shown in its own window. Keys, scanning and proving never leave your computer.

Wallet

  • Balance: spendable, incoming (in the mempool, not mined yet) and maturing mining rewards, optionally with their market value in dollars.
  • Receive: your full address is about 2,600 characters, because it carries a post-quantum public key. Press Publish short form once: it goes to genoryn.io, your configured nodes and your own node, and the wallet shows where it resolves. Share the short form (gnrs1…); a sender's node resolves it and the sender's wallet checks that the answer hashes to it, so a node cannot substitute another recipient. A QR code is shown for both forms.
  • Send privately: address (full or short), amount and an optional memo that only the recipient can read. The fee follows the market (/v1/fee). Sending asks for the wallet's password.
  • Several wallets: any number, each with its own 24 words and password. The selector switches between them; Show all wallets lists them together with search, filters, sorting and their total. Removing a wallet moves its file to a removed folder; its 24 words bring it back.
  • Overview: live tiles and charts for network hashrate, estimated miners, block time, shares per block, difficulty and GNR issued, plus the latest blocks with the ones you found marked.

A transaction spends at most two notes. When a payment needs more, the wallet merges notes automatically in parallel rounds (one block per round) and then pays.

History

Paged (15 to 100 entries per page) with filters for received, sent, mining and pending, search by memo, txid, address or block, and totals. Each send has a Proof button for a payment proof.

Swap

The GNR price, the offer board (sell offers, buy offers, swaps in progress, your own), the form to publish an offer, and your swaps with their progress. Taking an offer starts a swap at once; when it is time to pay, a window shows the amount, the address and a QR code. See Atomic swaps.

Mining

Choose Automatic, NVIDIA (CUDA), AMD / Intel (OpenCL) or CPU with a CPU-usage cap, then Start mining. The tab shows your hashrate, your share of the network, expected GNR per day, shares found, accruing rewards, payouts and the mining and price calculator. If the miner stops, the tab shows why (for example a GPU driver error); it is restarted automatically, and after three quick failures in a row the wallet stops retrying and says so. While the miner runs, closing the window keeps the wallet, node and miner running; Quit stops everything.

Network

Charts of hashrate, supply, active miners, difficulty, issuance, block time, shares and transactions per block over 1 hour to all time; block finders; peers; and the connection mode:

  • Light (recommended): remote nodes provide data; headers, outputs and tree updates are verified on your computer (Light clients). Several nodes can be configured; they are cross-checked.
  • Full node: one click starts kryptond, which downloads and validates the whole chain; the wallet then uses only your own node. By default it connects only out to other nodes; Let other nodes connect to my full node accepts incoming peers too (Peer-to-peer network).

Security and About

Change a wallet's password and lock wallets; see the version, check for updates and choose whether updates install automatically.

Backup & recovery

The recovery phrase is the wallet. It consists of 24 tokens of the form word-NN: an English BIP-39 word and a number from 00 to 63, 17 bits each. Together they carry 384 bits of entropy and a 24-bit SHA3 checksum, so a mistyped token is detected. Everything else (keys, addresses, notes, mining rewards) is derived from or found again with it.

  • Write it on paper (or metal), in order, with the numbers. Never type it into a website, a chat, an email or a photo. Anyone who has it owns the coins.
  • Restore: Wallet → Add a wallet → restore, or krypton-wallet-cli restore, then let it sync. Older 24-word phrases restore too.
  • The wallet file (%APPDATA%\GenorynKrypton\mainnet\wallet.krypton or wallets\*.krypton) is encrypted with Argon2id (256 MiB of memory) and XChaCha20-Poly1305 under your password. Copying it is a convenient backup of your history and swap records, but only the phrase guarantees access.
  • Swaps in progress live in the wallet file. If you restore from the phrase while a swap is running, finish or refund it from the old file if you still can. From 1.0.33 a restored wallet never reuses an earlier swap's secret, keys or outputs.
  • Lost the password but have the phrase? Restore from the phrase and choose a new password. Lost the phrase but have the file and password? Show the phrase (Security tab, or krypton-wallet-cli show-phrase) and write it down now.

Wallet security

  • Password for anything that moves coins. Sending, publishing or taking an offer and starting or accepting a swap ask for the wallet's password every time. The session token alone, which other programs of your user could read, cannot spend. After five wrong passwords the wallet refuses for five minutes.
  • Auto-lock. An unlocked wallet stays open for 24 hours, then locks itself and asks for its password again. The miner keeps running; swaps wait for the wallet to be unlocked (their timelocks leave hours of room).
  • Local only. The wallet's server listens on 127.0.0.1, checks a random token on every request and refuses requests addressed to any other host name, so a web page you visit cannot talk to it (DNS rebinding).
  • Nothing reaches your computer from the internet. The wallet's own full node only connects out unless you allow incoming peers, its API listens only on this computer, and it never runs commands or reads files for other nodes.
  • Signed updates only. The updater installs a release only if its post-quantum signature verifies against the key compiled into the wallet (Updates).
  • Your computer is your responsibility. Malware running as your user can read your screen and keystrokes; keep the system updated, the phrase offline, and use a strong, unique password.

Updates

The wallet checks GitHub for a newer release. It downloads SHA256SUMS, verifies its hybrid ML-DSA-87 + SLH-DSA-SHAKE-256s signature against the release key compiled into the program, downloads the installer and checks it against the signed hash. Only then does it install. A compromised download host, CDN or GitHub account cannot push code without the release key.

  • About → Check for updates, or the offer that appears when a release is out. Install updates automatically installs them as soon as they are found.
  • Your wallets, settings and chain data carry over; a running miner resumes by itself after the update.
  • Release notes list what changed and whether consensus changed. Security fixes are announced in general terms first and in detail once most wallets have updated.

Privacy model

Coins live as notes: (owner, value, randomness) hidden inside a commitment cm in a Merkle tree of depth 40. Spending a note reveals only its nullifier, a hash of a secret key and the note position, which prevents double spending without revealing which note was spent.

Visible on chainHidden
Fees, transaction sizes, timingSender and recipient
Commitments and nullifiersAmounts and memos
Mining shares and payouts per minerHow mined coins are spent later
Swap locks and claims (hash lock, revealed secret, refund height)Swap amounts and the parties' addresses

Mining income is public per miner (as coinbase rewards are on every chain); mine to a separate wallet if you want it unlinked from your receiving address. Spending mined coins is as private as any other spend. There is no transparent mode, so every user shares the same anonymity set.

On the network: peer connections are encrypted end to end; your own transactions are first relayed to a single random peer and announced to everyone only after 20 seconds, which hides their origin. The public node's API never lists peers' IP addresses.

On the offer board: every offer has its own one-time post-quantum key, never your address, so offers cannot be linked to you or to each other. Messages between the two wallets of a swap are sealed so that the board cannot read them. A swap's bitcoin side is an ordinary Bitcoin transaction and is as public as any other.

Cryptography

PurposePrimitiveStandard
Spend authorization & privacyzk-STARK (Winterfell), Rescue-Prime, SHA3-256 commitmentshash-based
Note encryptionX25519 + ML-KEM-1024, XChaCha20-Poly1305FIPS 203 (level 5)
Peer linksX25519 + ML-KEM-768, ChaCha20-Poly1305FIPS 203
Offer board keys and messagesX25519 + ML-KEM-1024, XChaCha20-Poly1305FIPS 203
Release signaturesML-DSA-87 and SLH-DSA-SHAKE-256sFIPS 204, FIPS 205
IdentifiersSHA3-256, domain separatedFIPS 202
Proof of workKryptoHash v1 (BLAKE3)hash-based
Wallet fileArgon2id 256 MiB, XChaCha20-Poly1305RFC 9106
Swap hash locks (both chains)SHA-256FIPS 180-4

Keys derive deterministically from the recovery phrase. SHAKE256 turns its 384 bits into a spend secret, a hybrid KEM key pair and an ML-DSA key. The spend secret yields an authorization key ak, a nullifier key nk and an owner tag H(ak, nk); view-only wallets can hold nk without being able to spend. A separate swap seed derives the one-time board keys and the per-swap secrets and keys.

Quantum security

Shor's algorithm breaks RSA and elliptic curves (ECDSA, Ed25519, Pallas, BLS). None of them protect Genoryn Krypton coins: spends are proofs of knowledge of a hash preimage, verified with hash-based STARKs. Encryption is hybrid, so recorded traffic stays secret as long as either X25519 or ML-KEM holds ("harvest now, decrypt later" is defeated by ML-KEM).

Grover's algorithm square-roots brute force: 256-bit hashes and keys keep a 128-bit margin; the 384-bit recovery phrase keeps 192 bits; STARK soundness parameters target about 160 conjectured bits.

The bitcoin side of a swap uses Bitcoin's own secp256k1 keys, as every Bitcoin transaction does. They protect the bitcoin only for the few hours a swap runs.

Every primitive has a versioned identifier, so a weakened algorithm can be replaced by a soft fork without stopping the network.

Emission & supply

The schedule follows Bitcoin's shape on 60-second blocks. Block h ≥ 1 issues 5 GNR >> floor((h − 1) / 2,100,000) into the reward pool; the genesis issues nothing. Fees join the pool too, and the pool pays miners in proportion to their shares (Mining rewards). That is 7,200 GNR a day in the first era.

EraBlocksRewardPer dayIssued in eraCumulative
1 (~years 0–4)1 – 2,100,0005 GNR7,20010,500,00050.0 %
2 (~4–8)2,100,001 – 4,200,0002.5 GNR3,6005,250,00075.0 %
3 (~8–12)4,200,001 – 6,300,0001.25 GNR1,8002,625,00087.5 %
4 (~12–16)6,300,001 – 8,400,0000.625 GNR9001,312,50093.75 %
5 (~16–20)8,400,001 – 10,500,0000.3125 GNR450656,25096.88 %

After 29 halvings the reward reaches zero; total issuance stays below 21,000,000 GNR by less than one coin of integer rounding. Every node rejects a block that would exceed the cap. Live figures: GET /v1/supply and the explorer.

Scarcity over time

A common way to express how rare a coin is, is stock-to-flow: the coins that exist divided by the coins mined in the following year, i.e. how many years of mining are already stored. Gold is about 60. Every halving doubles it. The figures below follow from the schedule alone.

YearGNR in existenceNew GNR that yearStock-to-flow
2026 (launch)under 0.5 million2.63 million≈ 0
203010.5 million1.31 million8
203415.8 million657,00024
203818.4 million329,00056
204219.7 million164,000120
204620.3 million82,000248

GNR reaches gold's scarcity around 2041 and that of Bitcoin in 2026 (about 122) around 2045. Bitcoin, which started 17 years earlier, keeps getting scarcer too. Scarcity is a property of the schedule; it does not set a price by itself.

Fair launch

The mainnet genesis commits to the hash of a Bitcoin block mined after the launch was announced. That hash is unpredictable, so no Genoryn Krypton block can exist before the announced moment, and everyone, the author included, starts together. Mainnet commits to Bitcoin block 974,438 (00000000000000000001075275c9ea6c90ce99dd94214d855d2b726fb173bed9), the newest Bitcoin block when the network launched; genesis hash 3c10136cd72a74d673257249752522e0102b6268f5b8c348ba34ae36740ca3b3.

  1. Announce a Bitcoin height H at least 72 hours ahead.
  2. Wait for block H; publish the release whose genesis contains its hash.
  3. Anyone rebuilds from source and compares the genesis hash.
  4. Mining opens for everyone at the same time under the same rules.

Genoryn Krypton is a new chain. Balances of the earlier Genoryn Mainnet 1.0, which used different cryptography, are not migrated; see the published policy.

Mining

Every miner earns in proportion to its hashrate (Mining rewards). No pool, permission or account is needed: point the miner at any node and your address, and keep it online so its shares reach the network. The easiest way is the wallet's Mining tab; the command-line miner does the same.

HardwareMeasured hashrateNotes
NVIDIA RTX 509074–83 MH/sCUDA, dataset built in 0.11 s
NVIDIA RTX 4070 SUPER~18.5 MH/sCUDA, reported by a community miner
Intel Core Ultra 9 285K (24 threads)1.37 MH/sCPU, dataset built in 4.2 s
16-thread desktop CPU~1.35 MH/sCPU, reported by a community miner
AMD integrated GPU (gfx1036)~0.84 MH/sOpenCL
krypton-miner --list-devices                         # tests every GPU: "usable" or "NOT usable: <reason>"
krypton-miner --node http://127.0.0.1:30334 --address-file my-address.txt --backend auto
krypton-miner --node https://genoryn.io --address-file my-address.txt --backend cuda --devices 0,1
krypton-miner --node http://127.0.0.1:30334 --address-file my-address.txt --backend cpu --max-cpu 50
FlagMeaning
--backendauto (best GPU, else CPU), cuda, opencl or cpu
--nodeNode API to get work from (default http://127.0.0.1:30334)
--address / --address-fileWhere rewards go (the full address)
--max-cpuCPU threads as a percentage of the cores (CPU backend)
--threadsExact CPU thread count
--devicesGPU indices as in --list-devices, e.g. 0,2
--batchNonces per GPU launch (auto-tuned by default)
--jsonMachine-readable status lines; with --list-devices, a JSON device list with usable and error

The status line shows the device and its index, hashrate, share of the network, expected GNR per day, shares, blocks and rejects. Reward notes mature after 100 blocks on mainnet (20 on testnet). GPU solutions are re-verified on the CPU before submission. Each hash reads 64 random 128-byte pairs from a 2 GiB dataset, so speed follows memory bandwidth: a desktop GPU has hundreds of GB/s, a CPU tens.

Mining rewards

Genoryn Krypton splits every block's reward among all miners by the work they did, without pools and without luck deciding who takes a whole block.

  1. Shares. A header whose proof of work meets difficulty / 32 is a share. The network finds about 32 per block; the block itself is one of its miner's shares. Shares are relayed peer to peer and credited by any block within the next 32.
  2. Pool. Each block adds subsidy + fees to a consensus-held pool. Every credited share earns pool · weight / (8 · 32 · difficulty): the same slice for everyone, so 1 % of the shares earns 1 % of the rewards.
  3. No incentive to censor. A share's credit never depends on which other shares a block includes, so leaving out other miners' shares gains a block finder nothing, and those shares are credited by the next block.
  4. Payouts. Credits accrue per miner and are paid as one note every 360 blocks (~6 hours), at most 64 payouts per block, spendable after 100 blocks.
Your share of the hashrateShares per hourExpected GNR per day
10 %≈ 192≈ 720
1 %≈ 19≈ 72
0.1 %≈ 2≈ 7.2

Payout notes are built by consensus from public data (owner, value, height, index) and verified by light wallets against the block header. Specification: docs/spec/rewards.md.

Mining & price calculator

The wallet's Mining tab and genoryn.io/mining carry the same calculator, fed by live data from the chain:

  • Join now: from the network's live hashrate, what 1, 10, 100, 1,000 or more GPUs (each like one RTX 5090) would mine: share, GNR a day, month and year, time per GNR, and the value at the market price. The more GPUs join, the smaller each one's share.
  • The future: choose a year (up to 40 ahead) and how many computers mine; the reward follows the halvings by block height.
  • Scarcity: stock-to-flow by year, next to Bitcoin's and gold's.
  • Price models, all "what if", none a forecast:
    1. The work behind one GNR: today's price × how many times more work one GNR takes then (more computers sharing the reward, halvings passed). If 1,000 GNR cost $3 today and 100,000 computers mine later, the same work yields thousands of times fewer GNR.
    2. A share of Bitcoin's value: that share of Bitcoin's total value divided by the GNR that exist in the chosen year.
    3. People and dollars: a number of people each holding some dollars of GNR, divided by the GNR that exist then.

Electricity and hardware costs are not counted. The real price is only what people pay each other (Market price).

KryptoHash algorithm

Memory-hard and GPU-first: each hash reads 64 random 128-byte pairs from a dataset, so throughput follows memory bandwidth, the resource that specialised chips gain least on.

  • Epoch: 16,384 blocks (~11.4 days); seed from the genesis hash and the epoch number.
  • Cache: 16 MiB, BLAKE3 chain plus three RandMemoHash passes.
  • Dataset: 2 GiB at launch, +4 MiB per epoch, capped at 12 GiB; each 64-byte item mixes 64 cache items.
  • Hash: 128-byte mix, 64 dataset accesses with FNV and rotations, final BLAKE3.
  • Target: hash · difficulty < 2^256; difficulty is a 128-bit integer.
  • Verification: needs only the cache: about 1 ms per block, so light clients can check proofs of work.
  • GPU kernels: CUDA and OpenCL, compiled by the GPU driver on first use; a driver whose compiler is broken is reported with a hint to reinstall it.

Atomic swaps

An atomic swap exchanges GNR for bitcoin between two wallets so that either both payments happen or neither does. Both sides lock their coins under the same hash lock (the SHA-256 of a secret) with a timelock: whoever reveals the secret to take one side's coins also lets the other side take theirs, and if nobody does, both refund after their timelocks. No third party ever holds the coins.

How a swap runs (GNR locked first)

  1. Agree. A buyer takes a sell offer, or a seller takes a buy offer, on the offer board. The wallets exchange the swap codes through sealed mailboxes, by themselves, within seconds.
  2. The seller locks the GNR. The seller's wallet holds the secret and locks exactly the agreed GNR on chain, payable only to the buyer with that secret, or back to the seller after the GNR timelock. Before locking, the seller checks the buyer's terms.
  3. The buyer checks and pays. The buyer's wallet watches the lock until it has confirmed (see the table) and checks that it is exactly the agreed amount and only the buyer can claim it. Only then does it show where to pay, in a window with the amount, the address and a QR code. The buyer pays within 2 hours into a bitcoin contract with the same hash lock, refundable to the buyer after its own timelock.
  4. The seller takes the bitcoin. Once the payment has confirmed, the seller's wallet claims the bitcoin with the secret, well before the bitcoin timelock. That claim reveals the secret on the Bitcoin chain.
  5. The buyer takes the GNR. The buyer's wallet reads the secret from the seller's bitcoin claim and claims the GNR with it.

A seller who does not have the GNR cannot lock it, so a buyer never pays someone who cannot deliver. The seller cannot take the bitcoin without revealing the secret that releases the GNR to the buyer.

Mainnet timingValue
GNR confirmations the buyer waits for6 blocks up to 50 GNR, 15 up to 500 GNR, 30 above
Bitcoin confirmations the seller waits for1 up to 0.01 BTC, 2 above
Payment window2 hours after the GNR lock has confirmed
GNR timelock1,900 blocks (about 32 hours) from the lock
Bitcoin timelock36 Bitcoin blocks (about 6 hours) from the payment
Longest possible swapOne week; terms that would run longer are refused

When something stops

  • The buyer never pays: the swap ends after the payment window; the seller's GNR returns automatically after its timelock (keep or reopen the wallet then).
  • The buyer pays, the seller never claims: the bitcoin returns to the buyer after its timelock. A payment smaller than agreed, or too late to claim safely, is not taken.
  • Either side cancels before anything of theirs is locked: the other side is told through the board and its swap ends too.
  • A wallet is closed or locked: the swap waits. Only your wallet holds the keys that lock, claim and refund your coins, so keep it running (the window may be closed) and unlocked until your swaps are done; the timelocks give hours of room.

Every swap gets a random number from which its secret, keys and outputs derive, so secrets never repeat, even in a wallet restored from its recovery phrase. Specification: docs/spec/atomic-swaps.md.

The offer board

The board, run by nodes (/v1/swap/...), lists offers and passes sealed messages between the two wallets of a swap. It never sees keys, codes or coins. The wallet's Swap tab and genoryn.io/market show it.

  • Publish: side (sell or buy GNR), amounts, your Bitcoin address (to receive the bitcoin, or for a refund) and how long the offer stays: 1 hour, 6 hours, 24 hours, 3 days, 1 week, 1 month or 1 year. Any price may be offered. The wallet only warns when a price is more than 3× from the market, in case of a typo.
  • Proof of work: every offer, message and trade report carries a small proof of work (18 bits, about a second). Longer offers need one more bit for every doubling beyond a day: 21 bits for a week, 23 for a month, 27 for a year, a few seconds on a modern CPU. Keeping junk on the board for long costs as much more as it lasts.
  • Reserved GNR: an open sell offer reserves its amount plus the fee in your wallet, so a buyer always finds the coins. Sends and other offers cannot use them; cancelling the offer frees them.
  • Online and offline: your wallet tells the board every 45 seconds that it is online, for all its offers at once (each proven with its cancel secret). An offer whose maker was seen in the last 2 minutes shows a green dot and can be taken; taking it starts the swap within seconds with no approval. While the maker's wallet is offline the offer stays listed, greyed out, and cannot be taken; after a week offline it is removed and the wallet frees its GNR.
  • Taking: the taker's wallet sends a sealed take message; the maker's wallet answers by itself. An offer is taken once.
  • In progress: a taken offer moves to "in progress" (only its maker can do that, proven against the offer the board stores). The maker's wallet confirms every 10 minutes that the swap still runs and removes the entry as soon as the swap can no longer complete; entries not confirmed for 30 minutes, or older than 12 hours, are dropped.
  • Limits: up to 5,000 offers, offers of 10,000 sat to 1,000 BTC, mailboxes of 100 messages kept for a day, per-client rate limits.

Offers are anonymous: each has its own one-time X25519 + ML-KEM-1024 key derived from the wallet's swap seed and used for nothing else, never your address.

Market price

The GNR price shown by the wallet and genoryn.io is the board's market price and nothing else: the plain average of the swaps people completed.

  • After a swap completes, both wallets may report its amounts and hash lock (the share_prices setting turns this off). The board accepts a report only if a claim with that hash lock is on its own chain, and counts each hash once.
  • The price is the arithmetic mean of the swaps completed in the last 72 hours, each counting the same whatever its size; with none that recent, of all recorded swaps.
  • With three or more swaps, a swap more than 4× away from their median is left out: amounts are private on chain and reported by the wallets, so a typo or a fake report must not move the average.
  • Open offers and swaps in progress are listed with their totals in bitcoin and dollars, but never move the price: anyone can post an offer at any price.
  • Dollar values use the BTC price, which genoryn.io fetches from mempool.space so visitors' browsers and wallets contact no third party.

GET /v1/swap/market returns the price (sat per GNR), how many swaps it averages (priced), a confidence v / (v + 25) for the GNR v behind it, the best offers, volumes, and every completed swap with what the GNR chain shows of it: the claim transaction, its block and time, the hash lock, the revealed secret and the refund height.

Quantum coins (coming soon)

Coming in a future release. Quantum coins will be coins anyone can issue on Genoryn Krypton, or bring from another network. They will live in the same shielded note tree as GNR and move the same way: every transfer a zk-STARK proof, so the coin, the amount, the sender and the recipient stay hidden, and nothing that guards them depends on elliptic curves.

  • No smart contracts. A coin is a short public declaration of everything its issuer may ever do (supply, burning, pausing). It is hashed into the coin's id, can never change, and every wallet shows it to holders in plain words.
  • GNR at the core. Fees are paid in GNR, creating a coin carries a fee paid to the miners, and coins trade against GNR in one atomic transaction between two wallets.
  • Supply anyone can audit. Transfers stay private; creating and destroying coins is public.
  • Status. The design is implemented and tested, but not active on mainnet: coin transactions are a consensus upgrade whose activation height will be announced with a future release. /v1/info will report it as assets_height.

The wallet's Coins tab explains them and turns on by itself once they are active. Overview: genoryn.io/coins. Design: docs/spec/assets.md.

Consensus rules

A 332-byte header commits to the previous block, a Merkle Mountain Range of all earlier blocks, the transactions, the shares, the note-tree root, the nullifiers, the outputs, the payouts and its miner. A block is valid when:

  1. It extends its parent; its timestamp exceeds the median of the last 11 and is at most 300 s in the future.
  2. Its difficulty equals the LWMA value and its proof of work meets it.
  3. Its MMR, transaction and share roots, output and nullifier digests match.
  4. It is at most 4 MiB with at most 256 shares, each valid for its window and never credited before.
  5. Every proof verifies, nullifiers are unique, anchors are recent (≤ 2,880 blocks), and lock spends (swaps) follow the lock rules.
  6. Its payouts equal those computed by the reward rules.
  7. The note tree after appending matured payout notes and transfer outputs has the committed root.

Fork choice: the valid chain with the most cumulative work. Side branches are checked for proof of work before storage and fully validated when they become heavier; a branch far behind the main chain is not stored at all. Full specification: docs/spec/consensus.md.

Transactions

Every transfer spends two notes (one may be a zero-value dummy) and creates two outputs (payment and change). The STARK proof shows that the inputs exist under a recent tree root, that their nullifiers are correct, that the outputs commit to the stated owners and values, that all values are below 2^60 and that inputs equal outputs plus fee.

ItemSize / time
Proof~92 KB
Transaction~97 KB (at most 160 KB)
Proving (desktop CPU)~0.5 s
Verification~2 ms
FeeMarket rate (/v1/fee); relay floor 10 gori/KB ≈ 0.00001 GNR

The proof is bound to the exact transaction through its sighash, which replaces a signature. Transactions expire after 120 blocks if not mined; the wallet then frees the notes they would have spent. Lock transactions (swaps) create a note spendable either by a claim with the secret or by a refund after the timelock.

Payment proofs

Transfers are private, yet the sender can prove a payment. When you send, the wallet keeps the one-time key of the payment output. Proof in the History tab (or krypton-wallet-cli prove-payment <txid>) turns it into a short gnrpay1… text.

  1. The verifier's wallet (or krypton-wallet-cli verify-payment, or POST /v1/verify-payment) finds the transaction's block and checks it against the chain.
  2. It decrypts exactly that output with the disclosed key and checks that it commits to the recipient's owner tag.
  3. It shows amount, memo, recipient, block and confirmations, and whether the payment went to the verifying wallet itself.
  4. Before the next block the proof already works and verifies as pending. The recipient's wallet likewise lists the payment as incoming, pending until it is mined.

The proof reveals nothing else: not the sender's balance, other notes, change or keys. Only the sender (who made the key) and the recipient can produce one. A 128-bit checksum rejects incomplete or altered proofs.

Light clients

A light wallet trusts nodes for availability only, never for validity:

  1. Tip. The wallet samples headers (dense near the tip, sparse across history) and checks each one's proof of work and its inclusion in the tip's Merkle Mountain Range; the most recent 91 headers are checked fully, including the difficulty rule. Cost grows with log(chain length).
  2. Checkpoint. Every release carries a checkpoint (mainnet: block 14,800). The chain must contain it; every header above it needs at least 1/16 of its difficulty, and the blocks since it must carry that much work on average.
  3. No future blocks. A header dated more than two hours (plus the 5-minute consensus drift) ahead of your computer's clock is refused, so a fork cannot lower its own difficulty quickly.
  4. The most work wins. Every MMR node hashes the work beneath it, so the tip proves the total work of the chain. The wallet remembers the most work it has verified and refuses a chain with less. A cheap fork cannot replace the chain it follows, and faking confirmations costs as much work as the honest network spends on them. If a node proves a different block at the wallet's height inside an at least as heavy chain, the wallet goes back to the fork point by itself; a node that only sends bad proofs proves nothing and changes nothing.
  5. Blocks. Compact blocks since the wallet birthday are checked against their headers: outputs, nullifiers, payouts and the note-tree root.
  6. Witnesses. The wallet downloads a whole 4,096-leaf chunk and computes its own Merkle path, so a node does not learn which note you spend.
  7. Cross-checks. Several configured nodes must agree; transactions are sent through all of them.

A wallet that has never synced trusts the first chain shown to it above the checkpoint; for large amounts run your own node or configure several independent ones. Specification: docs/spec/light-client.md.

Peer-to-peer network

Nodes talk to each other over encrypted links. A node is built so that other nodes can never use it against the computer it runs on:

  • Encryption: every link starts with an X25519 + ML-KEM-768 handshake and runs ChaCha20-Poly1305 frames.
  • Nothing to break into: the networking code is memory-safe Rust with no unsafe code. Peers can only send protocol messages; a node never runs commands, opens files or reaches its own API for them.
  • Strict limits: frames of at most 8 MiB (the length is checked before memory is allocated), a cap on every list in a message, 10 seconds for a handshake, at most 64 handshakes at once, 30 seconds for a new peer to introduce itself, at most 4 connections per IP (IPv6: per /64), 64 inbound and 8 outbound peers, a cap on data queued for slow peers.
  • Bans: a peer that sends a malformed message, an invalid block or transaction, or shares without work is disconnected and its IP refused for 24 hours; a flood of useless shares disconnects it.
  • Address book: peers can only point a node at public internet addresses on unprivileged ports, never at this computer, its local network or special ranges; one network group (IPv4 /16, IPv6 /32) fills at most 16 places, one peer's list is accepted at most once every 10 minutes, and the seeds are always tried first when a node has few peers.
  • Outbound-only by default in the wallet: the full node the wallet starts does not accept incoming connections unless you enable it (Network → Let other nodes connect to my full node), so nothing on the internet can open a connection to your computer.

Messages: Hello (network, genesis, height, listening port), Inv, GetHashes/Hashes, GetBlocks/Block, GetTxs/Tx, Shares, GetAddr/Addr, Ping/Pong.

Running a node

kryptond                                      # mainnet: P2P 0.0.0.0:30333, API 127.0.0.1:30334
kryptond --no-listen                          # connect out only: no incoming peers
kryptond --listen 0.0.0.0:30333 --rpc 127.0.0.1:30334 --peer 2.24.162.163:29710
sudo deploy/setup-server.sh mainnet --miner address.txt   # Linux server: systemd, CPU miner capped at 50 %
FlagDefaultMeaning
--networkmainnetmainnet, testnet or devnet
--data-dir%APPDATA%\GenorynKrypton or ~/.genoryn-kryptonChain database location
--listen0.0.0.0:30333P2P listen address
--no-listenoff (on for the wallet's node)Accept no incoming peers
--rpc127.0.0.1:30334API listen address
--peer–Extra peer (host:port), repeatable
--no-seedsoffDo not use the built-in seeds
--max-inbound / --max-outbound64 / 8Peer limits
NetworkP2P portAPI portReward maturity
Mainnet3033330334100 blocks
Testnet313333133420 blocks
Devnet (local)32333323342 blocks

Storage grows by at most ~4 MiB per block when blocks are full; empty blocks are a few kilobytes. The API has no administrative or wallet functions, but expose it to the internet only behind a reverse proxy with limits (see deploy/caddy); the node budgets requests per client. Opening port 30333 helps the network but is not needed to use it.

Command-line wallet

krypton-wallet-cli [--node URL[,URL…]] [--wallet FILE] [--network mainnet|testnet|devnet] <command>. The same settings can come from KRYPTON_NODE, KRYPTON_WALLET and KRYPTON_NETWORK. With several nodes it syncs from the first, cross-checks the others and sends through all of them.

CommandWhat it does
newCreate a wallet and show its 24-word recovery phrase once
restoreRestore a wallet from a recovery phrase (asks for the words); --birthday skips history before that block
addressShow the receiving address; --publish makes its short form resolve on the node
syncVerified light sync
balanceShow the balance
send <address> <amount> [--memo …] [--fee …]Send GNR to a full or short address; the fee defaults to the node's estimate for the current backlog
consolidateMerge the two largest notes
history / notesTransactions / owned notes
show-phraseShow the recovery phrase (asks for the password)
reset-pendingForget unconfirmed spends after they expired
statusStatus of every configured node
prove-payment <txid>Create a payment proof for one of your sends
verify-payment <proof>Check a payment proof against the chain

API reference (REST)

Base URL: your node (http://127.0.0.1:30334) or the public node https://genoryn.io. JSON unless marked binary. Amounts are in gori (1 GNR = 10^8), prices in sat per GNR.

Chain

MethodPathDescription
GET/v1/infoNetwork, height, tip, difficulty, supply, hashrate, estimated miners, peers, next subsidy
GET/v1/supplyIssued supply, subsidy, next halving
GET/v1/stats?range=1h|24h|7d|30d|allTime series for charts: hashrate, difficulty, block time, issuance
GET/v1/blocks?count&fromRecent block summaries
GET/v1/block/{height|hash}Block with transactions, credited shares and payouts
GET/v1/header/{height}Header fields
GET/v1/rawblock/{height}Canonical block bytes (binary)
GET/v1/peersConnected peers: agent, height, direction, since (no IP addresses)

Transactions and wallets

MethodPathDescription
GET/v1/tx/{txid}Pending or confirmed, confirmations
POST/v1/txSubmit a transaction (binary body)
GET/v1/mempoolPool size and entries
GET/v1/feeFee estimates per KB (economy, normal, fast) from the backlog
GET/v1/rawtx/{txid}A pending transaction (binary)
GET/v1/nullifier/{hex}Spent height or null
GET/v1/compact?from&countCompact blocks for wallets (binary)
GET/v1/frontier/{height}Note-tree frontier (every 64 blocks, binary)
GET/v1/subtree/{chunk}4,096 leaves + upper path (private witness)
GET/v1/witness/{pos}Merkle path for one position
GET/v1/mmrproof?leaf&atMMR inclusion proof (also proves the chain's total work)
GET/v1/flyclient?heights=a,bSampled headers with proofs, plus recent headers
POST/v1/verify-paymentCheck a gnrpay1… payment proof

Addresses

MethodPathDescription
GET/v1/validate/{address}Address check and short form
POST/v1/addressPublish a full address for short resolution
GET/v1/address/{short}Resolve a short address (the client checks the hash)
GET/v1/address-info/{address}Explorer view: published, owner tag, mining activity and payouts

Mining

MethodPathDescription
POST/v1/mining/templateMining job for {"address": ...}
POST/v1/mining/submitSubmit {"job_id", "nonce"} (shares and blocks)
GET/v1/miner/{address}Unpaid balance, next payout height, recent shares
GET/v1/sharesShares waiting to be credited

Swap board

MethodPathDescription
GET/v1/swap/offersOpen offers (with online) and swaps in progress
POST/v1/swap/offersPublish an offer (with proof of work)
POST/v1/swap/offers/cancelRemove an offer with its cancel secret
POST/v1/swap/offers/pingThe maker is online, for all its offers at once
POST/v1/swap/progressMark a taken offer "in progress", or confirm it still runs (maker only)
POST/v1/swap/inboxDeliver a sealed message
GET/v1/swap/inbox/{id}Read a mailbox
POST/v1/swap/tradeReport a completed swap (accepted once its claim is on chain)
GET/v1/swap/marketMarket price and completed swaps with their on-chain claims
GET/v1/btc-priceBTC price in USD, EUR and more (genoryn.io only, from mempool.space)
curl -s https://genoryn.io/v1/info
curl -s "https://genoryn.io/v1/blocks?count=5"
curl -s https://genoryn.io/v1/swap/market

JSON-RPC 2.0

POST /rpc with {"jsonrpc":"2.0","id":1,"method":"...","params":[...]}.

MethodParamsReturns
getinfo / getblockchaininfo–same as /v1/info
getblockcount–height
getbestblockhash–hex hash
getblockhashheighthex hash
getblockheight or hashblock summary
getblockheaderheightheader
gettransactiontxidstatus
sendrawtransactionhextxid
getmempoolinfo–pool
getpeerinfo–peers
getnetworkhashps–hashes per second
getsupply–supply
validateaddressaddressvalid, network, short
resolveaddressshortfull address
getblocktemplatepayout addressmining job
submitworkjob_id, nonceaccepted
curl -s https://genoryn.io/rpc -d '{"jsonrpc":"2.0","id":1,"method":"getblock","params":[1]}'

WebSocket

wss://genoryn.io/v1/ws sends the node info once, then an event for every new block and transaction:

{"type":"block","height":1234,"hash":"…","txs":3,"reorg_depth":0,"timestamp":1793670000}
{"type":"tx","txid":"…"}

SDKs

TypeScript / JavaScript

import { KryptonClient, formatAmount } from "@genoryn/krypton";
const k = new KryptonClient("https://genoryn.io");
const info = await k.info();
console.log(info.height, formatAmount(BigInt(info.supply)));
k.subscribe(e => e.type === "block" && console.log("new block", e.height));

Rust

use krypton::{NodeClient, Wallet, Address};
let node = NodeClient::new("https://genoryn.io")?;
let mut wallet = Wallet::open("wallet.krypton".as_ref(), &password)?;
wallet.sync(&node, |_, _| {})?;
let to = Address::decode(&recipient)?;
wallet.send_auto(&node, &to, 150_000_000, 200_000, "memo", |s| println!("{s}"))?;

C (libkrypton)

#include "krypton.h"
uint64_t v;
if (krypton_parse_amount("12.5", &v)) { /* v == 1250000000 */ }
int net = krypton_address_network(addr);   /* 1 mainnet, 2 testnet, 0 invalid */

Exchange integration

  1. Run your own kryptond; never rely on third-party nodes for deposits.
  2. Use a dedicated wallet; distinguish customers by memo or by account.
  3. Credit after 10 confirmations (more for large amounts).
  4. Withdraw with krypton-wallet-cli send; consolidation is automatic.
  5. Validate user-entered addresses with /v1/validate or krypton_address_network; accept short addresses only through resolution, which the wallet hash-checks.
  6. Give customers payment proofs (prove-payment) when a withdrawal is disputed; they verify without revealing anything else.

Security model & audits

  • Testing: over a hundred automated tests (consensus, proofs, reorganizations, forged light-client data, fake chains, swap flows, board abuse, parser property tests) and end-to-end swaps against Bitcoin Core on regtest before releases.
  • Audits: internal audit of 5 November 2026 covering node, consensus, wallets, light client, website and server (report). In November 2026 an independent researcher reported issues privately through GitHub security advisories; all were confirmed and fixed in 1.0.33. No external audit of the whole system yet.
  • Chain observer: sees fees, sizes and timing; not amounts, senders or recipients.
  • Malicious node: may withhold data; cannot forge it undetected, cannot replace the chain a light wallet follows with a lighter one, cannot steal swaps or remove other people's offers.
  • Malicious peer: can only send protocol messages, within strict limits, and is banned for invalid data (Peer-to-peer network).
  • Swap counterparty: cannot take your coins: a buyer pays only after the seller's GNR is locked, and the seller's claim releases the GNR to the buyer.
  • Quantum adversary: no elliptic-curve dependency for GNR funds or privacy.
  • Your computer: a compromised machine is out of scope; keep the recovery phrase offline.

Reporting a vulnerability: privately through GitHub security advisories, never in a public issue. Coordinated disclosure: 90 days from acknowledgement, extended while fixes are in progress. See SECURITY.md.

Troubleshooting

My GPU is not used, or the miner says "no usable … GPU found"

Run krypton-miner --list-devices: it tests every GPU and prints usable or NOT usable: <reason>. If the reason says the driver could not compile the mining kernel, reinstall the GPU driver cleanly (on NVIDIA, a clean install, for example after DDU) and try again. The Mining tab shows the same reason when the miner stops.

The wallet does not sync, or says a node "shows a chain with less proof of work"

In light mode the wallet refuses a node that is behind or shows a lighter chain than one it has already verified. Wait a few minutes (a node may still be catching up), add another node in Network → Connection mode, or start your own full node. "The node's chain ends before this release's checkpoint" means the node is far behind or on another network.

A payment I received shows as "incoming, pending"

It is in the mempool and becomes spendable once mined (about a minute). Mining rewards become spendable 100 blocks after their payout.

My swap seems stuck

Keep the wallet running and unlocked: only it can lock, claim and refund your coins. The swap card says what it waits for (confirmations, the payment, the other side). If the buyer never pays, the seller's GNR returns after its timelock (about 32 hours); if the seller never claims, the buyer's bitcoin returns after about 6 hours.

"Too many wrong passwords"

After five wrong passwords the wallet refuses for five minutes. If you forgot the password, restore the wallet from its recovery phrase with a new one.

My offer shows as offline

Offers can be taken only while the maker's wallet runs. It stays listed while your wallet is offline and is removed after a week offline, freeing its GNR. Open the wallet again to bring it back online.

The update does not install

The updater installs only releases whose signature verifies; a failed download or signature is retried at the next check. You can always download the release yourself and verify it (Install & verify).

Upgrades & 100-year design

  • Crypto-agility: every primitive has a versioned ID; replacements activate by soft fork.
  • Room to grow: a depth-40 note tree holds about one trillion outputs.
  • Log-time verification: the header MMR keeps light clients fast at any chain length.
  • Bounded resources: fixed headers, 4 MiB blocks, bounded decoders, mempool and board.
  • Done: proportional mining rewards, atomic swaps with bitcoin, the anonymous offer board, payment proofs, signed in-app updates.
  • Roadmap: recursive proof aggregation per block, prebuilt GPU kernels per architecture, more independent public nodes, external audits.

Governance

Genoryn Krypton was created by the pseudonymous Zarazi Sokani, whose identity is unknown and will never be revealed. Anyone may develop, market or extend the project in any direction. No person, company or foundation controls the protocol or holds keys over it; rules change only when node operators choose to run new software. The release key signs the project's binaries; it cannot move anyone's coins or change consensus.

FAQ

Do I need a GPU?

No. A GPU is about 50 times faster, but CPUs mine too, and the wallet works without mining at all.

Do I need to join a pool?

No. Every block pays all miners in proportion to their shares, so a single computer earns its share every block, as in a pool, but without an operator.

Why are addresses so long?

They carry a post-quantum public key (ML-KEM-1024). Publish the short form once and share it; the sender's wallet verifies it.

Can anyone see my balance?

No. Balances are computed only by wallets that hold the keys.

How do I buy GNR?

In the wallet's Swap tab: take a sell offer, or publish a buy offer. You pay bitcoin only after the seller's GNR is locked for you.

Where does the GNR price come from?

Only from completed swaps: their plain average over the last 72 hours. Offers never move it.

Can a swap cheat me?

No. The buyer pays only after the seller's GNR is locked on chain for exactly the agreed amount, and the seller's bitcoin claim reveals the secret that releases the GNR to the buyer. If anyone stops, timeouts refund both.

Why must the wallet stay open during a swap?

Only your wallet holds the keys that lock, claim and refund your coins; no server can do it for you, which is also why nobody can take them. Closing the window is fine: the wallet keeps working in the background.

Can someone break into my computer through the node?

No. The wallet's node only connects out unless you allow incoming peers, its API listens only on your computer, the networking code has no unsafe code, and peers can only send protocol messages that are checked and limited.

What happens if a node lies to my light wallet?

Its data fails verification against headers, proof of work and total work, and the wallet refuses it.

Is there a premine?

No. The genesis issues nothing and the launch was bound to a then-future Bitcoin block hash.

What about coins from Genoryn Mainnet 1.0?

Krypton is a new chain with different cryptography; old balances are not migrated (policy).

I lost my recovery phrase

If you still have the wallet file and its password, show the phrase (Security tab or show-phrase) and write it down. Without the phrase, file or password, nobody can recover the coins.

Glossary

Note
A private coin: owner, value and randomness hidden in a commitment.
Commitment
A hash that binds a note's contents without revealing them.
Nullifier
A unique tag published when a note is spent; prevents double spends without revealing which note.
Anchor
A recent note-tree root that a spend proves membership against.
zk-STARK
A hash-based zero-knowledge proof; no trusted setup, quantum-resistant.
ML-KEM
NIST's post-quantum key encapsulation (FIPS 203).
ML-DSA / SLH-DSA
NIST's post-quantum signatures (FIPS 204 / 205), used for release signatures.
MMR
Merkle Mountain Range: an append-only commitment to all block hashes and their total work.
FlyClient
Light-client verification by sampling headers with proofs against the tip.
Checkpoint
A recent block shipped with each release that light wallets require.
LWMA
Linearly weighted moving average difficulty algorithm.
Share
A proof of work at 1/32 of the block difficulty; earns a slice of the reward pool.
Payout
The note paying a miner's accrued rewards, every 360 blocks.
Hash lock
The SHA-256 of a swap's secret; locks both sides of a swap.
Timelock
The height after which locked coins can be refunded to their owner.
Offer board
The node service listing swap offers and passing sealed messages.
Stock-to-flow
Coins in existence divided by coins mined in the next year.
gori
The smallest unit: 1 GNR = 100,000,000 gori.