Glossary

A

Account

Canonical state keyed by an address, containing a uint64 balance and the last confirmed outgoing uint32 nonce. Luracoin is account-based, not UTXO-based.

Address

A 34-character Base58Check string encoding version 0x30 plus HASH160 of a compressed secp256k1 public key. It identifies an account and transfer destination; it is not a public key or secret.

Alpha

The current pre-production development stage. Formats are implemented and tested but not frozen, independently audited, or safe for public economic value.

API version

The contract version of an HTTP interface. Private RPC and public Explorer API are both version 1 but are distinct APIs with different paths and trust boundaries.

B

Backfill

Sequential construction of the optional SQLite explorer projection from already accepted canonical blocks.

Balance

Confirmed spendable units recorded for an account, expressed internally as integer lurashis. Private RPC additionally reports a pending-aware spendable_balance.

Base58Check

Human-oriented encoding using the Base58 alphabet plus a four-byte double-SHA256 checksum. In Luracoin it encodes the 21-byte address payload.

before_height

An exclusive keyset-style anchor for newest-first Explorer API block pagination. Passing next_before_height avoids offset drift while the tip grows.

Bits

The four-byte compact encoding of a proof-of-work target: one exponent byte followed by a three-byte big-endian coefficient.

Block

A versioned header plus an ordered, nonempty list of complete transactions. The first transaction is the unique coinbase.

Block ID

Double-SHA256 of the canonical block preimage. The preimage omits the transmitted declared-ID field and includes a two-byte transaction count plus ordered transactions.

Block location

A local 17-byte blocks.db record identifying version, file number, byte offset, and expected serialized length for an exact canonical block read.

Branch

A sequence of blocks competing with another sequence after a shared ancestor. The alpha does not store or choose among branches.

C

Canonical

The one accepted byte representation or local history used by the implementation. Canonical encoding excludes alternate representations that might be semantically similar but hash differently.

Chain ID

A numeric network namespace embedded in transactions and P2P VERSION: mainnet 0, testnet 1, devnet 2.

Chain state

The local canonical tip and account state derived from accepted blocks. It does not include Redis pending transactions or the SQLite projection.

Chain work

A measure of accumulated proof of work used by mature PoW systems for fork choice. Luracoin does not yet calculate/use it across branches.

Checksum

Context-dependent corruption detection: Base58Check uses four bytes of double-SHA256 over an address payload; P2P headers use four bytes over the message payload.

Coinbase

The required first transaction in a block. It has the zero origin/unlocking sentinels, height nonce, zero fee, miner destination, and value equal to subsidy plus all normal fees (or genesis allocation at height zero).

Compact signature

A fixed 64-byte ECDSA signature encoded as 32-byte big-endian r followed by 32-byte big-endian s, without DER structure.

Confirmation

Explorer-reported local depth: tip_height - block_height + 1. In this alpha it is not robust finality because branch choice/reorganization is absent.

Consensus-critical

Any rule or byte that can cause honest nodes to disagree about a valid transaction, block, state transition, difficulty, subsidy, or history.

Core Explorer API

Read-only routes backed directly by canonical full-node stores, available without optional SQLite.

Cursor

An opaque private-RPC history pagination token. Clients pass it back unchanged and must not infer its internal encoding.

D

Data directory

The private network-specific filesystem root containing canonical databases, block files, RPC token, and optional SQLite index. Default: ~/.luracoin/<network>.

Declared ID

The 32-byte block-ID field carried in the transmitted 118-byte header. Deserialization must recalculate the canonical ID and require equality.

Deterministic signature

ECDSA whose ephemeral nonce is generated by RFC 6979 from key/message rather than fresh randomness, producing reproducible signatures for a fixed implementation and input.

Devnet

Chain ID 2, magic faceb00c, built-in educational genesis, and default Explorer/RPC ports 28000/28444. Intended for isolated development.

Difficulty

A human description of how hard it is to produce an ID under a target. Consensus carries compact target bytes, not a floating-point difficulty field.

Double-SHA256 (sha256d)

SHA256(SHA256(bytes)). Used for transaction IDs, block IDs, P2P checksums, and Base58Check checksums in their defined contexts.

E

Explorer

The combination of a public read-only chain API and the static website UI that presents blocks, transactions, addresses, and statistics.

Explorer index

Optional rebuildable SQLite projection enabling global transaction feed, address history/ranking, and aggregates. It is not consensus authority.

Emission

Creation of new lurashis through genesis allocation and block subsidy. Current policy halves periodically but retains a permanent one-LURA tail reward.

F

Fee

A uint32 number of lurashis debited from a transaction sender and included in the block’s coinbase payment. Zero is valid.

Finality

Assurance that accepted history will not change. The alpha provides no production finality model; local depth must not be mislabeled as finality.

Fork

See branch. A state where nodes have accepted different children/descendants of a shared block. Current nodes cannot resolve this automatically.

Fork choice

The deterministic rule selecting one branch as canonical. Not implemented in v0.1.0.

Full node

A process that initializes genesis, validates complete transactions and blocks, stores canonical history/state, speaks P2P, and optionally serves RPC/explorer/mining.

G

Gateway

The Python wallet-web service that serves a dedicated browser build and proxies four allowlisted operations to private RPC while retaining the bearer token server-side.

Genesis

Height-zero block that defines initial chain identity and allocation. Testnet/devnet manifests are built in; mainnet genesis is undefined.

H

Handshake

P2P activation sequence exchanging v2 VERSION and VERACK, validating protocol version, chain ID, listening port, and advertised height.

HASH160

RIPEMD160(SHA256(bytes)). Applied to the compressed public key to form the 20-byte address hash.

Height

Zero-based position of a block in local canonical history. Genesis is height 0; next valid block is local tip + 1.

High-S / low-S

ECDSA signatures have a symmetric s counterpart. Luracoin accepts only 1 <= s <= curve_order / 2 (low-S) to remove that malleability form.

I

Indexed route

Explorer API route requiring index.ready == true. Disabled/building/error states return explicit HTTP 503 errors rather than empty results.

Inventory (inv)

A P2P announcement containing an object type and raw 32-byte block/transaction hash. A peer may request it with getdata.

K

Key derivation

The wallet’s deterministic route from 24-word BIP39 mnemonic and passphrase LURA to the BIP32 master/root secp256k1 key. No child path is currently used.

L

Linear chain

The implemented model in which only a block extending the current local tip can be accepted. It lacks side branches and reorganization.

Loopback

Local-only networking addresses such as 127.0.0.1 and ::1. Private RPC enforces this bind boundary.

LURA

The display coin unit. One LURA equals 100,000,000 lurashis. It is also the fixed BIP39 passphrase string; these meanings are context-dependent.

Lurashi

Smallest protocol monetary unit. All consensus arithmetic uses integer lurashis.

M

Magic bytes

Four-byte P2P network discriminator at the start of every message header.

Mainnet

Reserved chain ID 0 and magic ba77d89f. It has no defined genesis and cannot initialize in the alpha.

Malleability

Ability to alter an encoding/identifier without changing intended authorization. Canonical fixed widths and low-S reduce known transaction signature malleability; broader system behavior still requires analysis.

Mempool

Redis-backed local set of admitted, unconfirmed normal transactions plus sender/nonce reservations. It is policy/relay state, not canonical history.

Miner

Node component that builds a valid candidate from the tip and mempool, creates coinbase, derives expected difficulty, searches nonce, rejects stale solutions, and relays accepted work.

Mnemonic

The 24-word English BIP39 recovery phrase that can recreate the official wallet root key. It is secret recovery material.

N

Network

A Luracoin namespace defined by chain ID, magic, genesis, data/Redis isolation, and operational ports. “Network” can also refer generally to peers; use context carefully.

Node readiness

Local condition: initialized, not syncing, and not below any connected peer’s advertised height. It is not proof of global synchronization.

Nonce (block)

uint32 field miners vary to search proof of work.

Nonce (transaction)

Per-sender uint32 sequence. A confirmed normal transaction requires current account nonce + 1; pending sequences must be contiguous.

O

Origin

In browser security, scheme + host + port used to validate same-origin gateway requests. In transactions, “origin” may informally mean from_address; avoid confusing the two.

Orphan append

A complete block record written immediately after the known tip but not yet indexed due to a crash. The node has narrow adjacent recovery for this case.

Opaque cursor

See cursor. The client contract is pass-through, not interpretation.

P

P2P

Peer-to-peer TCP protocol version 2 used for network communication. It is unrelated to HTTP RPC despite sharing node data.

Payload

Command-specific bytes following a P2P 24-byte header, or more generally an API/message body. Always use the surrounding protocol to determine encoding.

Peer

One activated remote P2P connection that completed the compatible handshake. Peers are not authenticated identities.

Pending

Locally admitted to the mempool but not included in canonical block history. Pending is not confirmed or final.

Proof of work (PoW)

Search for a block ID numerically less than or equal to the target encoded by bits.

Projection

Derived database optimized for queries, especially the Explorer SQLite index. It can be rebuilt and cannot decide canonical validity.

Protocol v2

Current P2P protocol version. It added chain ID to the 18-byte handshake and is deliberately incompatible with the prototype v1 handshake.

R

Ready index

SQLite projection whose indexed height has reached its observed canonical target and whose state is ready.

Reorganization (reorg)

Replacing part of canonical history with a different branch, including reversing/reapplying state and indexes. Not implemented.

Relay backlog

Bounded process-local map retaining pending transactions for replay when peers become available or finish synchronization.

Retarget

Difficulty-target recalculation every 480 blocks using elapsed timestamps, an expected 86,400-second span, and a 4× clamp.

RocksDB

Embedded key-value storage (through rocksdict) for accounts, block/transaction/address indexes, and chain metadata.

RPC

Authenticated loopback HTTP API under /v1 for the official wallet and local operators. It is private and includes transaction submission.

S

Seed

Initial peer endpoint supplied to discovery. No public seeds are bundled in the alpha.

Sentinel

Reserved all-zero fixed-width value with special meaning, such as the 34-zero coinbase origin or 128-zero coinbase unlocking field.

Serialization

Deterministic conversion of protocol objects into exact bytes. Field order, width, endianness, and absence of trailing data are consensus/wire-critical.

Side branch

A valid-looking branch not extending the selected tip. The current node does not store it.

Spendable balance

Private RPC’s confirmed balance after simulating the valid contiguous pending outgoing sequence. It excludes unconfirmed incoming value.

State transition

Ordered validation and mutation from one account-state snapshot to the next using a complete block.

Subsidy

New value created for a non-genesis block: initially 50 LURA, halved every 259,200 heights, floored permanently at 1 LURA.

Synchronization

Downloading consecutive complete blocks from one selected peer until local height reaches its advertisement. It is not branch-aware.

T

Tail emission

Permanent minimum subsidy of one LURA per block after ordinary halvings would go lower. Therefore supply is not capped.

Target

Positive 256-bit threshold expanded from bits. A valid block ID interpreted as a big-endian integer is <= target.

Testnet

Safe default network: chain ID 1, magic fbc0b6db, educational known-key genesis, default Explorer port 18000 and RPC port 18444.

Tip

Highest block in one node’s local canonical linear chain, identified by both height and block ID.

Transaction ID (txid)

Double-SHA256 of the complete canonical 213-byte transaction, including public key and signature, displayed as 64 lowercase hex characters.

U

Unlocking field

Final 128 transaction bytes: raw 64-byte public key plus compact 64-byte signature. Coinbase uses 128 zero bytes.

Unsigned transaction

The first 85 canonical transaction bytes. Their single SHA-256 digest is signed; they are not valid for mempool/P2P submission alone.

UTXO

Unspent-transaction-output model used by some chains. Luracoin does not use it; references to “inputs” and “outputs” are usually incorrect here.

V

Vault

Official wallet’s versioned local encrypted record containing wallet secret state. It uses PBKDF2-SHA256 and AES-256-GCM; public address/key metadata remains outside ciphertext for locked display.

Vector

Public deterministic fixture specifying exact intermediate and final bytes for interoperability tests.

VERACK

Empty P2P message acknowledging compatible VERSION exchange and completing the handshake state machine.

W

Wallet

Client that derives/retains keys, displays account/history state, constructs and signs transactions, and submits them to a local node. It does not validate or store the whole chain.

WAL

Write-ahead log. SQLite explorer indexing uses WAL files for transactional durability; backup/rebuild operations must account for -wal and -shm companions.

Wire format

Exact bytes exchanged across a protocol boundary. Luracoin defines separate transaction, block, and P2P wire formats.

Z

Zero origin

The 34-character ASCII-zero coinbase from_address. It is a reserved sentinel and is not a valid spendable address.

Zero-conf

Informal description of a pending, unconfirmed transaction. Luracoin offers no special zero-confirmation security guarantee; the official UI should present it as pending only.