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.
| Property | Value |
|---|---|
| Ticker / unit | GNR · 1 GNR = 100,000,000 gori |
| Block time | 60 seconds (difficulty retargets every block) |
| Block reward | 5 GNR, halving every 2,100,000 blocks (about 4 years) |
| Maximum supply | 21,000,000 GNR, enforced by every node |
| Premine / dev fee | None. The genesis issues nothing |
| Privacy | Every transfer shielded (zk-STARK); no transparent mode |
| Proof of work | KryptoHash v1, memory-bandwidth bound (GPU-first, CPU-capable) |
| Mining rewards | Shared by every miner in proportion to its work, no pool needed |
| Difficulty | LWMA-1, every block, 90-block window |
| Trading | Atomic BTC ⇄ GNR swaps on an anonymous offer board; the seller's GNR is locked first |
| Light wallets | FlyClient-style tip proofs, follow the most work, release checkpoint (block 14,800) |
| License | MIT 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
- Install. Download the Windows installer or the Linux package from Download (see Install & verify), or build from source.
- 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.
- Get coins. Mine from the Mining tab, buy with bitcoin in the Swap tab, or share your short address (
gnrs1…) to receive. - 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
| Platform | File | Notes |
|---|---|---|
| Windows 10 / 11 (x64) | GenorynKrypton-<version>-Windows-x64-Setup.exe | Installs 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, portable | genoryn-krypton-<version>-windows-x64-portable.zip | The same programs without an installer. |
| Ubuntu / Debian (x64) | genoryn-krypton_<version>_amd64.deb | sudo apt install ./genoryn-krypton_<version>_amd64.deb; includes a desktop entry and systemd units. |
| Linux (any distribution) | genoryn-krypton-<version>-linux-x64.tar.gz | Unpack and run krypton-wallet. |
| From source | github.com/genoryn/genoryn | Rust 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
removedfolder; 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.kryptonorwallets\*.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 chain | Hidden |
|---|---|
| Fees, transaction sizes, timing | Sender and recipient |
| Commitments and nullifiers | Amounts and memos |
| Mining shares and payouts per miner | How 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
| Purpose | Primitive | Standard |
|---|---|---|
| Spend authorization & privacy | zk-STARK (Winterfell), Rescue-Prime, SHA3-256 commitments | hash-based |
| Note encryption | X25519 + ML-KEM-1024, XChaCha20-Poly1305 | FIPS 203 (level 5) |
| Peer links | X25519 + ML-KEM-768, ChaCha20-Poly1305 | FIPS 203 |
| Offer board keys and messages | X25519 + ML-KEM-1024, XChaCha20-Poly1305 | FIPS 203 |
| Release signatures | ML-DSA-87 and SLH-DSA-SHAKE-256s | FIPS 204, FIPS 205 |
| Identifiers | SHA3-256, domain separated | FIPS 202 |
| Proof of work | KryptoHash v1 (BLAKE3) | hash-based |
| Wallet file | Argon2id 256 MiB, XChaCha20-Poly1305 | RFC 9106 |
| Swap hash locks (both chains) | SHA-256 | FIPS 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.
| Era | Blocks | Reward | Per day | Issued in era | Cumulative |
|---|---|---|---|---|---|
| 1 (~years 0–4) | 1 – 2,100,000 | 5 GNR | 7,200 | 10,500,000 | 50.0 % |
| 2 (~4–8) | 2,100,001 – 4,200,000 | 2.5 GNR | 3,600 | 5,250,000 | 75.0 % |
| 3 (~8–12) | 4,200,001 – 6,300,000 | 1.25 GNR | 1,800 | 2,625,000 | 87.5 % |
| 4 (~12–16) | 6,300,001 – 8,400,000 | 0.625 GNR | 900 | 1,312,500 | 93.75 % |
| 5 (~16–20) | 8,400,001 – 10,500,000 | 0.3125 GNR | 450 | 656,250 | 96.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.
| Year | GNR in existence | New GNR that year | Stock-to-flow |
|---|---|---|---|
| 2026 (launch) | under 0.5 million | 2.63 million | ≈ 0 |
| 2030 | 10.5 million | 1.31 million | 8 |
| 2034 | 15.8 million | 657,000 | 24 |
| 2038 | 18.4 million | 329,000 | 56 |
| 2042 | 19.7 million | 164,000 | 120 |
| 2046 | 20.3 million | 82,000 | 248 |
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.
- Announce a Bitcoin height H at least 72 hours ahead.
- Wait for block H; publish the release whose genesis contains its hash.
- Anyone rebuilds from source and compares the genesis hash.
- 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.
| Hardware | Measured hashrate | Notes |
|---|---|---|
| NVIDIA RTX 5090 | 74–83 MH/s | CUDA, dataset built in 0.11 s |
| NVIDIA RTX 4070 SUPER | ~18.5 MH/s | CUDA, reported by a community miner |
| Intel Core Ultra 9 285K (24 threads) | 1.37 MH/s | CPU, dataset built in 4.2 s |
| 16-thread desktop CPU | ~1.35 MH/s | CPU, reported by a community miner |
| AMD integrated GPU (gfx1036) | ~0.84 MH/s | OpenCL |
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
| Flag | Meaning |
|---|---|
--backend | auto (best GPU, else CPU), cuda, opencl or cpu |
--node | Node API to get work from (default http://127.0.0.1:30334) |
--address / --address-file | Where rewards go (the full address) |
--max-cpu | CPU threads as a percentage of the cores (CPU backend) |
--threads | Exact CPU thread count |
--devices | GPU indices as in --list-devices, e.g. 0,2 |
--batch | Nonces per GPU launch (auto-tuned by default) |
--json | Machine-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.
- Shares. A header whose proof of work meets
difficulty / 32is 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. - Pool. Each block adds
subsidy + feesto a consensus-held pool. Every credited share earnspool · weight / (8 · 32 · difficulty): the same slice for everyone, so 1 % of the shares earns 1 % of the rewards. - 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.
- 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 hashrate | Shares per hour | Expected 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:
- 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.
- A share of Bitcoin's value: that share of Bitcoin's total value divided by the GNR that exist in the chosen year.
- 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)
- 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.
- 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.
- 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.
- 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.
- 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 timing | Value |
|---|---|
| GNR confirmations the buyer waits for | 6 blocks up to 50 GNR, 15 up to 500 GNR, 30 above |
| Bitcoin confirmations the seller waits for | 1 up to 0.01 BTC, 2 above |
| Payment window | 2 hours after the GNR lock has confirmed |
| GNR timelock | 1,900 blocks (about 32 hours) from the lock |
| Bitcoin timelock | 36 Bitcoin blocks (about 6 hours) from the payment |
| Longest possible swap | One 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_pricessetting 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/infowill report it asassets_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:
- It extends its parent; its timestamp exceeds the median of the last 11 and is at most 300 s in the future.
- Its difficulty equals the LWMA value and its proof of work meets it.
- Its MMR, transaction and share roots, output and nullifier digests match.
- It is at most 4 MiB with at most 256 shares, each valid for its window and never credited before.
- Every proof verifies, nullifiers are unique, anchors are recent (≤ 2,880 blocks), and lock spends (swaps) follow the lock rules.
- Its payouts equal those computed by the reward rules.
- 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.
| Item | Size / time |
|---|---|
| Proof | ~92 KB |
| Transaction | ~97 KB (at most 160 KB) |
| Proving (desktop CPU) | ~0.5 s |
| Verification | ~2 ms |
| Fee | Market 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.
- The verifier's wallet (or
krypton-wallet-cli verify-payment, orPOST /v1/verify-payment) finds the transaction's block and checks it against the chain. - It decrypts exactly that output with the disclosed key and checks that it commits to the recipient's owner tag.
- It shows amount, memo, recipient, block and confirmations, and whether the payment went to the verifying wallet itself.
- 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:
- 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).
- 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.
- 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.
- 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.
- Blocks. Compact blocks since the wallet birthday are checked against their headers: outputs, nullifiers, payouts and the note-tree root.
- 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.
- 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
unsafecode. 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 %
| Flag | Default | Meaning |
|---|---|---|
--network | mainnet | mainnet, testnet or devnet |
--data-dir | %APPDATA%\GenorynKrypton or ~/.genoryn-krypton | Chain database location |
--listen | 0.0.0.0:30333 | P2P listen address |
--no-listen | off (on for the wallet's node) | Accept no incoming peers |
--rpc | 127.0.0.1:30334 | API listen address |
--peer | – | Extra peer (host:port), repeatable |
--no-seeds | off | Do not use the built-in seeds |
--max-inbound / --max-outbound | 64 / 8 | Peer limits |
| Network | P2P port | API port | Reward maturity |
|---|---|---|---|
| Mainnet | 30333 | 30334 | 100 blocks |
| Testnet | 31333 | 31334 | 20 blocks |
| Devnet (local) | 32333 | 32334 | 2 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.
| Command | What it does |
|---|---|
new | Create a wallet and show its 24-word recovery phrase once |
restore | Restore a wallet from a recovery phrase (asks for the words); --birthday skips history before that block |
address | Show the receiving address; --publish makes its short form resolve on the node |
sync | Verified light sync |
balance | Show 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 |
consolidate | Merge the two largest notes |
history / notes | Transactions / owned notes |
show-phrase | Show the recovery phrase (asks for the password) |
reset-pending | Forget unconfirmed spends after they expired |
status | Status 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
| Method | Path | Description |
|---|---|---|
| GET | /v1/info | Network, height, tip, difficulty, supply, hashrate, estimated miners, peers, next subsidy |
| GET | /v1/supply | Issued supply, subsidy, next halving |
| GET | /v1/stats?range=1h|24h|7d|30d|all | Time series for charts: hashrate, difficulty, block time, issuance |
| GET | /v1/blocks?count&from | Recent 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/peers | Connected peers: agent, height, direction, since (no IP addresses) |
Transactions and wallets
| Method | Path | Description |
|---|---|---|
| GET | /v1/tx/{txid} | Pending or confirmed, confirmations |
| POST | /v1/tx | Submit a transaction (binary body) |
| GET | /v1/mempool | Pool size and entries |
| GET | /v1/fee | Fee 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&count | Compact 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&at | MMR inclusion proof (also proves the chain's total work) |
| GET | /v1/flyclient?heights=a,b | Sampled headers with proofs, plus recent headers |
| POST | /v1/verify-payment | Check a gnrpay1… payment proof |
Addresses
| Method | Path | Description |
|---|---|---|
| GET | /v1/validate/{address} | Address check and short form |
| POST | /v1/address | Publish 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
| Method | Path | Description |
|---|---|---|
| POST | /v1/mining/template | Mining job for {"address": ...} |
| POST | /v1/mining/submit | Submit {"job_id", "nonce"} (shares and blocks) |
| GET | /v1/miner/{address} | Unpaid balance, next payout height, recent shares |
| GET | /v1/shares | Shares waiting to be credited |
Swap board
| Method | Path | Description |
|---|---|---|
| GET | /v1/swap/offers | Open offers (with online) and swaps in progress |
| POST | /v1/swap/offers | Publish an offer (with proof of work) |
| POST | /v1/swap/offers/cancel | Remove an offer with its cancel secret |
| POST | /v1/swap/offers/ping | The maker is online, for all its offers at once |
| POST | /v1/swap/progress | Mark a taken offer "in progress", or confirm it still runs (maker only) |
| POST | /v1/swap/inbox | Deliver a sealed message |
| GET | /v1/swap/inbox/{id} | Read a mailbox |
| POST | /v1/swap/trade | Report a completed swap (accepted once its claim is on chain) |
| GET | /v1/swap/market | Market price and completed swaps with their on-chain claims |
| GET | /v1/btc-price | BTC 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":[...]}.
| Method | Params | Returns |
|---|---|---|
getinfo / getblockchaininfo | – | same as /v1/info |
getblockcount | – | height |
getbestblockhash | – | hex hash |
getblockhash | height | hex hash |
getblock | height or hash | block summary |
getblockheader | height | header |
gettransaction | txid | status |
sendrawtransaction | hex | txid |
getmempoolinfo | – | pool |
getpeerinfo | – | peers |
getnetworkhashps | – | hashes per second |
getsupply | – | supply |
validateaddress | address | valid, network, short |
resolveaddress | short | full address |
getblocktemplate | payout address | mining job |
submitwork | job_id, nonce | accepted |
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
- Run your own
kryptond; never rely on third-party nodes for deposits. - Use a dedicated wallet; distinguish customers by memo or by account.
- Credit after 10 confirmations (more for large amounts).
- Withdraw with
krypton-wallet-cli send; consolidation is automatic. - Validate user-entered addresses with
/v1/validateorkrypton_address_network; accept short addresses only through resolution, which the wallet hash-checks. - 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.