lapsecoin 0.8.3__tar.gz

lapsecoin-0.8.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Victorio Nascimento
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lapsecoin-0.8.3/PKG-INFO

@@ -0,0 +1,203 @@
+Metadata-Version: 2.4
+Name: lapsecoin
+Version: 0.8.3
+Summary: LapseCoin full node: Falcon-512 post-quantum signatures, a VDF-based consensus clock, and a built-in wallet dashboard.
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Lapsecoin/core
+Project-URL: Repository, https://github.com/Lapsecoin/core
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: argcomplete>=3.2
+Requires-Dist: cachetools>=5.3
+Requires-Dist: chiavdf>=1.1.14
+Requires-Dist: flask>=3.0
+Requires-Dist: flask-limiter>=3.5
+Requires-Dist: liboqs-python>=0.14.0
+Requires-Dist: libtorrent>=2.0.0
+Requires-Dist: markdown>=3.5
+Requires-Dist: msgpack>=1.0
+Requires-Dist: orjson>=3.9
+Requires-Dist: peewee>=3.17
+Requires-Dist: Pillow>=10.0
+Requires-Dist: PyNaCl>=1.5
+Requires-Dist: pystray>=0.19
+Requires-Dist: requests>=2.31
+Requires-Dist: stellar-sdk>=13.0
+Requires-Dist: waitress>=3.0
+Dynamic: license-file
+
+<div align="center">
+  <img src="lapsecoin.svg" width="120" alt="LapseCoin logo" />
+
+  # LapseCoin
+
+  Peer-to-peer electronic cash, secured by a Verifiable Delay Function instead of proof-of-work mining, with quantum-resistant signatures.
+
+  [![Release](https://img.shields.io/github/v/release/Lapsecoin/core)](https://github.com/Lapsecoin/core/releases)
+  [![Live node](https://img.shields.io/badge/node-lapsenode.vicnas.me-2ea44f)](https://lapsenode.vicnas.me/)
+  [![Whitepaper](https://img.shields.io/badge/docs-whitepaper-blue)](docs/whitepaper.md)
+  [![Donate BTC](https://img.shields.io/badge/donate-BTC-f7931a)](#support)
+  [![Discord](https://img.shields.io/badge/discord-join-5865F2?logo=discord&logoColor=white)](https://discord.gg/FP2d8JmK6r)
+  [![Reddit](https://img.shields.io/badge/reddit-r%2FLapsecoin-FF4500?logo=reddit&logoColor=white)](https://reddit.com/r/Lapsecoin)
+</div>
+
+**Recommended: use a pre-built release.** Building from source requires native libraries (liboqs, chiavdf) that involve complex C/C++ compilation and can produce DLL or shared library errors depending on your platform. The release binaries on the [releases page](https://github.com/Lapsecoin/core/releases) are self-contained and require no dependencies.
+
+Join the [Discord](https://discord.gg/FP2d8JmK6r) for discussions, news, and trades with other coins.
+
+## Quick start
+
+Grab a binary from the [releases page](https://github.com/Lapsecoin/core/releases), self-contained with no dependencies.
+
+```
+# Linux                    # Windows
+chmod +x lapsecoin         lapsecoin.exe
+./lapsecoin
+```
+
+You'll be prompted for a signing passphrase, then the wallet is at `http://localhost:8335` and the block explorer at `http://localhost:8333`.
+
+For headless environments (Docker/systemd/CI, no GUI), set the passphrase non-interactively and pass `--no-gui`:
+
+```bash
+export LAPSECOIN_PASSPHRASE="your passphrase"
+./lapsecoin --no-gui
+```
+
+<details>
+<summary>How consensus works</summary>
+
+Most cumulative proven work wins, Bitcoin-style. Two blocks at the same height carry equal work, so that tie goes to the lower VDF output, not to whichever arrived first. A height stays open to a better sibling for a few seconds (`LAPSECOIN_DRAW_WINDOW_SECONDS`) so the comparison can happen; work on the next height never stops meanwhile.
+
+Block timing is enforced by a VDF anchored to real elapsed time, believed to have a much smaller hardware-advantage gap than proof-of-work. Transactions are ordinary and plaintext, with sender-bid fees, much like Bitcoin's own. Signatures are FALCON-512 (quantum-resistant). Full spec in [docs/whitepaper.md](docs/whitepaper.md).
+</details>
+
+<details>
+<summary>Running from source</summary>
+
+Requires Python 3.11+.
+
+**Linux/macOS:**
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/Lapsecoin/core/main/scripts/install.sh | bash
+```
+
+**Windows (PowerShell):**
+
+```powershell
+irm https://raw.githubusercontent.com/Lapsecoin/core/main/scripts/install.ps1 | iex
+```
+
+Then: `lapsecoin`. Installs build tools if missing, then the app; falls back to skipping `libtorrent` (with a starter peers list) only if that's what fails.
+</details>
+
+<details>
+<summary>Building the binary yourself</summary>
+
+```
+pip install pyinstaller cairosvg Pillow miniupnpc
+make linux    # on Linux
+make windows  # on Windows
+```
+
+Produces a self-contained binary in `dist/`. Requires cmake, ninja, and a C compiler (on Windows, also liboqs and MSVC redistributables).
+</details>
+
+<details>
+<summary>Updating, and when it isn't optional</summary>
+
+A node too old to speak the current wire format is refused at the handshake, so it sits alone mining a chain nobody sees. Old formats aren't carried forever, so some updates are mandatory. The version number says which:
+
+| Change | Example | What it means |
+|---|---|---|
+| Third number | `0.6.0` to `0.6.1` | Fixes. Update when convenient |
+| Second number | `0.5.1` to `0.6.0` | **Required.** Wire format changed, older nodes are dropped |
+| First number | `0.x` to `1.x` | Consensus break. Required, expect a resync |
+
+Alone with no peers after everyone else updated? Check your version first.
+</details>
+
+<details>
+<summary>Ports and passphrase</summary>
+
+| | Port | Interface | Purpose |
+|---|---|---|---|
+| Public | `8333` (`--port`) | `0.0.0.0` | Peer traffic (UDP) and the read-only node UI (TCP). Safe to expose. Send disabled. |
+| Private | `port+2` (`--private-port`) | `127.0.0.1` | Wallet UI. **Never expose.** Full access, including Send. |
+
+`port+3` is reserved for the DHT subsystem (libtorrent). Port `18334` is fixed and reserved across every node for same-network peer discovery (broadcast-based, finds other LapseCoin nodes on your LAN automatically regardless of their own port). Don't bind other services to either.
+
+The passphrase is required to start the node. By default you're prompted via `getpass` (nothing touches shell history or `ps`). For Docker/systemd/CI, set it non-interactively instead:
+
+```bash
+export LAPSECOIN_PASSPHRASE="your passphrase"
+python main.py
+```
+
+There is no `--passphrase` flag, since it was removed because it leaked into `ps aux` and shell history.
+
+The peer port can be set the same way, which is often easier than a flag in a container or unit file:
+
+```bash
+export LAPSECOIN_PORT=8444
+python main.py
+```
+
+`--port` still wins if you pass it, so the variable sets the default rather than overriding what you typed. The private port follows from it as usual unless you set `--private-port`.
+
+The log level can be set the same way:
+
+```bash
+export LAPSECOIN_LOG_LEVEL=DEBUG
+python main.py
+```
+
+`--log-level` still wins if you pass it.
+</details>
+
+<details>
+<summary>Settings and environment variables</summary>
+
+Node-local settings live on the private wallet UI under **Settings**, and each can also be set by environment variable. The environment wins, so a container or unit file can force a value for one launch without overwriting what's saved; a value set that way shows on the page as forced rather than editable.
+
+| Variable | Default | Meaning |
+|---|---|---|
+| `LAPSECOIN_SWAP_CONFIRM_DEPTH` | `2` | How many blocks must bury a LapseCoin payment before a swap treats it as settled |
+| `LAPSECOIN_SWAP_AUTO_ACCEPT_MIN_TRUST` | `0` | Minimum counterparty trust score for a fill request to auto-accept |
+
+**Upgrading from 0.6.2 or earlier with the privacy setting on?** That version created a second key file, `lapsecoin_key.json.privacy`, and advertised its address for peers to pay. Nodes no longer advertise an address at all, so nothing creates or uses that file any more, but yours still exists and may hold what peers already sent it. **Keep it, and back it up.** It is an ordinary key file with its own salt, so the same passphrase opens it on its own whenever you want those funds.
+</details>
+
+<details>
+<summary>All CLI options</summary>
+
+| Option | Default | Description |
+|---|---|---|
+| `--host` | `0.0.0.0` | Interface to bind for the public port |
+| `--port` | `8333` | Public port for HTTP API and peer connections |
+| `--private-port` | `port+2` | Private port for wallet UI, always bound to 127.0.0.1 |
+| `--keyfile` | `lapsecoin_key.json` | Path to encrypted keypair |
+| `--db` | `lapsecoin_chain.db` | Path to SQLite chain database |
+| `--peer host:port` | - | Bootstrap peer (repeatable) |
+| `--max-peers` | `125` | Hard cap on peer table size |
+| `--log-level` | `INFO` (or `LAPSECOIN_LOG_LEVEL`) | Verbosity: DEBUG, INFO, WARNING, ERROR. DEBUG adds the HTTP access log |
+| `--no-gui` | off | Headless. Implied when `LAPSECOIN_PASSPHRASE` is set |
+| `--no-update-check` | off | Don't check for new releases |
+| `--update-check-url` | *(project)* | Where to look for the current version |
+| `--releases-url` | *(project)* | Where the update notice points people |
+</details>
+
+## Exchanges
+
+No LAPSE exchange listings yet.
+
+In the meantime, [Discord](https://discord.gg/FP2d8JmK6r) allows direct trades with XLM, as well as the in-app Market (beta). Default rate is 1 XLM for 1000 LAPSE.
+---
+
+<div align="center" id="support">
+
+**Support the project:** BTC `bc1q8qxvr5zuws78650wz9rgzpqxfx7dqzl38rdtsw`
+
+</div>

lapsecoin-0.8.3/README.md

@@ -0,0 +1,174 @@
+<div align="center">
+  <img src="lapsecoin.svg" width="120" alt="LapseCoin logo" />
+
+  # LapseCoin
+
+  Peer-to-peer electronic cash, secured by a Verifiable Delay Function instead of proof-of-work mining, with quantum-resistant signatures.
+
+  [![Release](https://img.shields.io/github/v/release/Lapsecoin/core)](https://github.com/Lapsecoin/core/releases)
+  [![Live node](https://img.shields.io/badge/node-lapsenode.vicnas.me-2ea44f)](https://lapsenode.vicnas.me/)
+  [![Whitepaper](https://img.shields.io/badge/docs-whitepaper-blue)](docs/whitepaper.md)
+  [![Donate BTC](https://img.shields.io/badge/donate-BTC-f7931a)](#support)
+  [![Discord](https://img.shields.io/badge/discord-join-5865F2?logo=discord&logoColor=white)](https://discord.gg/FP2d8JmK6r)
+  [![Reddit](https://img.shields.io/badge/reddit-r%2FLapsecoin-FF4500?logo=reddit&logoColor=white)](https://reddit.com/r/Lapsecoin)
+</div>
+
+**Recommended: use a pre-built release.** Building from source requires native libraries (liboqs, chiavdf) that involve complex C/C++ compilation and can produce DLL or shared library errors depending on your platform. The release binaries on the [releases page](https://github.com/Lapsecoin/core/releases) are self-contained and require no dependencies.
+
+Join the [Discord](https://discord.gg/FP2d8JmK6r) for discussions, news, and trades with other coins.
+
+## Quick start
+
+Grab a binary from the [releases page](https://github.com/Lapsecoin/core/releases), self-contained with no dependencies.
+
+```
+# Linux                    # Windows
+chmod +x lapsecoin         lapsecoin.exe
+./lapsecoin
+```
+
+You'll be prompted for a signing passphrase, then the wallet is at `http://localhost:8335` and the block explorer at `http://localhost:8333`.
+
+For headless environments (Docker/systemd/CI, no GUI), set the passphrase non-interactively and pass `--no-gui`:
+
+```bash
+export LAPSECOIN_PASSPHRASE="your passphrase"
+./lapsecoin --no-gui
+```
+
+<details>
+<summary>How consensus works</summary>
+
+Most cumulative proven work wins, Bitcoin-style. Two blocks at the same height carry equal work, so that tie goes to the lower VDF output, not to whichever arrived first. A height stays open to a better sibling for a few seconds (`LAPSECOIN_DRAW_WINDOW_SECONDS`) so the comparison can happen; work on the next height never stops meanwhile.
+
+Block timing is enforced by a VDF anchored to real elapsed time, believed to have a much smaller hardware-advantage gap than proof-of-work. Transactions are ordinary and plaintext, with sender-bid fees, much like Bitcoin's own. Signatures are FALCON-512 (quantum-resistant). Full spec in [docs/whitepaper.md](docs/whitepaper.md).
+</details>
+
+<details>
+<summary>Running from source</summary>
+
+Requires Python 3.11+.
+
+**Linux/macOS:**
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/Lapsecoin/core/main/scripts/install.sh | bash
+```
+
+**Windows (PowerShell):**
+
+```powershell
+irm https://raw.githubusercontent.com/Lapsecoin/core/main/scripts/install.ps1 | iex
+```
+
+Then: `lapsecoin`. Installs build tools if missing, then the app; falls back to skipping `libtorrent` (with a starter peers list) only if that's what fails.
+</details>
+
+<details>
+<summary>Building the binary yourself</summary>
+
+```
+pip install pyinstaller cairosvg Pillow miniupnpc
+make linux    # on Linux
+make windows  # on Windows
+```
+
+Produces a self-contained binary in `dist/`. Requires cmake, ninja, and a C compiler (on Windows, also liboqs and MSVC redistributables).
+</details>
+
+<details>
+<summary>Updating, and when it isn't optional</summary>
+
+A node too old to speak the current wire format is refused at the handshake, so it sits alone mining a chain nobody sees. Old formats aren't carried forever, so some updates are mandatory. The version number says which:
+
+| Change | Example | What it means |
+|---|---|---|
+| Third number | `0.6.0` to `0.6.1` | Fixes. Update when convenient |
+| Second number | `0.5.1` to `0.6.0` | **Required.** Wire format changed, older nodes are dropped |
+| First number | `0.x` to `1.x` | Consensus break. Required, expect a resync |
+
+Alone with no peers after everyone else updated? Check your version first.
+</details>
+
+<details>
+<summary>Ports and passphrase</summary>
+
+| | Port | Interface | Purpose |
+|---|---|---|---|
+| Public | `8333` (`--port`) | `0.0.0.0` | Peer traffic (UDP) and the read-only node UI (TCP). Safe to expose. Send disabled. |
+| Private | `port+2` (`--private-port`) | `127.0.0.1` | Wallet UI. **Never expose.** Full access, including Send. |
+
+`port+3` is reserved for the DHT subsystem (libtorrent). Port `18334` is fixed and reserved across every node for same-network peer discovery (broadcast-based, finds other LapseCoin nodes on your LAN automatically regardless of their own port). Don't bind other services to either.
+
+The passphrase is required to start the node. By default you're prompted via `getpass` (nothing touches shell history or `ps`). For Docker/systemd/CI, set it non-interactively instead:
+
+```bash
+export LAPSECOIN_PASSPHRASE="your passphrase"
+python main.py
+```
+
+There is no `--passphrase` flag, since it was removed because it leaked into `ps aux` and shell history.
+
+The peer port can be set the same way, which is often easier than a flag in a container or unit file:
+
+```bash
+export LAPSECOIN_PORT=8444
+python main.py
+```
+
+`--port` still wins if you pass it, so the variable sets the default rather than overriding what you typed. The private port follows from it as usual unless you set `--private-port`.
+
+The log level can be set the same way:
+
+```bash
+export LAPSECOIN_LOG_LEVEL=DEBUG
+python main.py
+```
+
+`--log-level` still wins if you pass it.
+</details>
+
+<details>
+<summary>Settings and environment variables</summary>
+
+Node-local settings live on the private wallet UI under **Settings**, and each can also be set by environment variable. The environment wins, so a container or unit file can force a value for one launch without overwriting what's saved; a value set that way shows on the page as forced rather than editable.
+
+| Variable | Default | Meaning |
+|---|---|---|
+| `LAPSECOIN_SWAP_CONFIRM_DEPTH` | `2` | How many blocks must bury a LapseCoin payment before a swap treats it as settled |
+| `LAPSECOIN_SWAP_AUTO_ACCEPT_MIN_TRUST` | `0` | Minimum counterparty trust score for a fill request to auto-accept |
+
+**Upgrading from 0.6.2 or earlier with the privacy setting on?** That version created a second key file, `lapsecoin_key.json.privacy`, and advertised its address for peers to pay. Nodes no longer advertise an address at all, so nothing creates or uses that file any more, but yours still exists and may hold what peers already sent it. **Keep it, and back it up.** It is an ordinary key file with its own salt, so the same passphrase opens it on its own whenever you want those funds.
+</details>
+
+<details>
+<summary>All CLI options</summary>
+
+| Option | Default | Description |
+|---|---|---|
+| `--host` | `0.0.0.0` | Interface to bind for the public port |
+| `--port` | `8333` | Public port for HTTP API and peer connections |
+| `--private-port` | `port+2` | Private port for wallet UI, always bound to 127.0.0.1 |
+| `--keyfile` | `lapsecoin_key.json` | Path to encrypted keypair |
+| `--db` | `lapsecoin_chain.db` | Path to SQLite chain database |
+| `--peer host:port` | - | Bootstrap peer (repeatable) |
+| `--max-peers` | `125` | Hard cap on peer table size |
+| `--log-level` | `INFO` (or `LAPSECOIN_LOG_LEVEL`) | Verbosity: DEBUG, INFO, WARNING, ERROR. DEBUG adds the HTTP access log |
+| `--no-gui` | off | Headless. Implied when `LAPSECOIN_PASSPHRASE` is set |
+| `--no-update-check` | off | Don't check for new releases |
+| `--update-check-url` | *(project)* | Where to look for the current version |
+| `--releases-url` | *(project)* | Where the update notice points people |
+</details>
+
+## Exchanges
+
+No LAPSE exchange listings yet.
+
+In the meantime, [Discord](https://discord.gg/FP2d8JmK6r) allows direct trades with XLM, as well as the in-app Market (beta). Default rate is 1 XLM for 1000 LAPSE.
+---
+
+<div align="center" id="support">
+
+**Support the project:** BTC `bc1q8qxvr5zuws78650wz9rgzpqxfx7dqzl38rdtsw`
+
+</div>

lapsecoin-0.8.3/VERSION

@@ -0,0 +1 @@
+0.8.3

lapsecoin-0.8.3/conftest.py

@@ -0,0 +1,16 @@
+import os
+import sys
+from unittest.mock import patch
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "tests"))
+sys.path.insert(0, os.path.dirname(__file__))
+
+# block.validate rejects timestamps more than 30s in the future using
+# time.time(). On CI the system clock may be behind the genesis timestamp,
+# causing spurious failures. Patch block._time.time to a fixed value well
+# after genesis so tests are clock-independent.
+import block as _block_mod
+from params import GENESIS_TIMESTAMP
+
+_TEST_NOW = GENESIS_TIMESTAMP + 365 * 24 * 3600  # one year after genesis
+patch.object(_block_mod._time, "time", return_value=_TEST_NOW).start()

lapsecoin-0.8.3/docs/whitepaper.md

@@ -0,0 +1,97 @@
+# LapseCoin: A Peer-to-Peer Electronic Cash System
+
+*Victorio Nascimento*
+
+## Abstract
+
+LapseCoin keeps Bitcoin's consensus model: the chain with the most proven work wins. Proof-of-work is replaced with a Verifiable Delay Function (VDF), tying block production to real elapsed time rather than a race for a lucky hash. Transactions are ordinary and plaintext, with sender-bid fees, much like Bitcoin's own. The VDF is believed to have a much smaller hardware advantage gap than proof-of-work, so it does not push the network toward the same resource-consumption spiral.
+
+## 1. Consensus: Verifiable Delay Functions
+
+Each block requires a VDF proof computed over the hash of the previous block and the builder's address. The VDF takes about 120 seconds of strictly sequential computation, and no amount of parallel hardware speeds it up. Binding the builder's address into the challenge stops anyone from copying a broadcast proof and claiming it under their own address: each builder evaluates a different VDF, so a stolen proof verifies against nobody else's challenge.
+
+The transaction list is not part of the VDF challenge. A block rejected for a transaction problem can be fixed and rebroadcast without redoing the 120 seconds of work.
+
+When two chains compete, the one with more cumulative proven VDF iterations wins, not the one with more blocks. An iteration count only counts if the proof verifies for that many, so it can't be inflated by lying.
+
+Ties are routine rather than rare: two builders at the same height do the same protocol-set iteration count, so a plain fork ties exactly, and a tie can run many blocks deep if a competing chain matches the honest one's work all the way down. Ties break on VDF output, never on the block hash: the block hash covers the transaction list, which is not part of the VDF challenge, so a builder could swap transactions for free after the real work and grind hash variants at nearly zero cost, while VDF output can't be moved without redoing the 120 seconds, which keeps the tie-break's cost real. For a single contested height, that height stays open to a lower-output block for a short window after one is adopted, otherwise whatever arrived first wins as soon as anything is built on it and the tie-break decides nothing; work on the next height continues throughout. A tie spanning more than one height is settled the same way at every diverged height, not just the last one: whichever chain has the lower output at more of those heights wins. Deciding a multi-block tie from its final block alone, no matter how deep the tie ran, would have let matching a rival's work over many blocks be undone by out-grinding it at just the last one; requiring a majority of the diverged heights instead means undoing N blocks of tied work costs an advantage sustained over all N of them, the same assumption longest-chain systems already rest on.
+
+Rewriting old history means redoing every VDF since that point, sequentially, in as much real time as the honest chain took to produce them. The honest chain keeps advancing the whole time, so the gap only grows.
+
+## 2. Why a VDF instead of proof-of-work
+
+**Proof-of-work has no ceiling; a VDF has a floor instead.** Hash rate buys share without limit, which is what took Bitcoin from CPUs to ASICs and a growing energy bill. A VDF challenge is one sequential computation, about 120 seconds here, that no amount of hardware shrinks below. Building a block is not about running more attempts in parallel but about how fast a single chain of steps evaluates, and the arithmetic sets a hard floor on that.
+
+**The floor still leaves a hardware gap, just a bounded one.** Chia Network's 2019 competition on the same class-group VDF construction found specialized implementations beating commodity software by roughly 3 to 10 times. Unlike ASICs, which widened the lead every generation, that gap caps it. Below the top band a builder does not win a smaller proportional share the way lower hash rate does: it loses outright to any faster builder, having never finished in time to be compared.
+
+**Inside the top band it is a lottery, by design.** Builders that finish close together tie, and the tie goes to the lowest VDF output, a value fixed by the previous hash and the builder's address but indistinguishable from random across addresses. Each address completing a full evaluation gets exactly one draw.
+
+Nothing limits how many addresses an operator runs, and each needs its own real evaluation with no way to grind for a better one, so N addresses at the top tier win exactly N times the single-address share. Splitting one machine across several addresses does worse, since each fragment then runs too slow to compete. Both results were checked against a Monte Carlo model.
+
+**That draw is where Sybil resistance is priced, not a coin fee.** An extra draw costs a full VDF of real machine-time, so participation and its energy scale linearly with spending, as Bitcoin's hash rate does, but without the arms race: a capped hardware gap means spending more mostly buys more whole machines. A coin-denominated registration fee was rejected because the economics track hardware and machine count, not balance, and a fee payable only from a balance would lock out the empty-handed new node this design means to admit.
+
+**One Sybil surface sits outside this analysis: eclipse attacks on peer discovery**, where a node's view of the network is crowded out by attacker-controlled addresses. That is handled by capping how many peers from one address subnet a node admits, not by anything priced in coin.
+
+## 3. Transactions
+
+The base unit is the tick. One LAPSE equals 100,000,000 ticks.
+
+A transaction is a plain, visible dict: a sender address, a public key, a list of outputs (recipient and amount), a sequential per-sender nonce, a fee, and a signature, plus an optional short plaintext memo. Nothing about it is encrypted or hidden, the memo included: it is a public note, not a private message.
+
+Nonces are sequential per sender, starting from zero: a transaction's nonce must be exactly one more than the sender's last confirmed nonce. This is the standard replay-protection scheme, the same one Bitcoin-style account models use.
+
+Fees are chosen by the sender, not fixed by the protocol, with one exception noted in §4. A transaction is valid as long as the sender's balance covers every output plus the fee. Builders are free to prioritize whichever pending transactions pay the most per byte, the same market-based mechanism Bitcoin uses to clear its mempool under load.
+
+A block is capped at 2 MB. Bitcoin's own cap is sized for a ten-minute block; this chain's is a fifth of that, so the two carry the same bytes of chain growth per second, not a smaller one.
+
+Blocks apply their listed transactions in order, checking each one against the state as it stands after the transactions before it in the same block. There is no required canonical ordering across transactions; a block's builder can list them however it likes, as long as each one is individually valid at the point it is applied.
+
+## 4. Fees and block rewards
+
+The builder receives the full block reward for every block, unconditionally, plus every transaction fee in that block. There is no split, and no separate party to pay out to.
+
+One kind of transaction carries a protocol-enforced minimum on top of the usual sender-bid fee: a post to the public on-chain board, tagged by its memo, must clear a floor that rises in steps as more posts confirm, network-wide, over the board's lifetime, so it cannot be spammed indefinitely at a flat cost. The floor rises slowly enough, relative to how many posts a single block can carry, that it cannot invalidate a block's-worth of already-broadcast posts at once.
+
+## 5. Supply
+
+```
+reward(block) = floor((21,000,000 LAPSE - total minted) * (1 - 0.5^(1/5,000,000)))
+```
+
+The halflife is about 5,000,000 blocks, roughly 20 years at 2 minutes per block. This smooth curve avoids the instability a hard halving schedule can cause.
+
+## 6. Privacy and networking
+
+Transactions and blocks both propagate through Dandelion routing, so no observer can reliably tell which peer first broadcast a given item. A block's builder address is public by construction, since that is who gets paid, but which machine produced it need not be. The originator re-sends anything that never comes back, so handing an item to one peer is not a gamble.
+
+A node tells its peers nothing about which address it holds. It used to, so that peers could pay it, and that made every peer table a directory mapping an address to the machine that reported it. Where to pay a node now travels as a small note relayed on the same path as everything else, so the peer handing it over is almost never its author and no address is attributable to a machine.
+
+Signatures use FALCON-512, a lattice-based scheme designed to resist quantum computers. Addresses are twelve-word phrases derived from the public key.
+
+Peers find each other through the BitTorrent DHT. A node only connects to peers sharing its genesis block hash. The full chain is kept forever, so balances can always be recomputed from scratch.
+
+## 7. Security and censorship: what this design does and does not solve
+
+Consensus here is longest-chain, exactly like Bitcoin's, just measured in proven VDF iterations instead of hashes. That inherits Bitcoin's security model in full, including its limits.
+
+Ordinary transaction censorship, a single non-majority actor refusing to include some transaction, is defeated the same way it always has been: any other willing participant can include it instead, and ordinary confirmation-depth economics protect against a brief refusal turning into a permanent one.
+
+A sustained majority attacker is a different matter, and this design does not claim to beat Bitcoin there. Fork choice sees only cumulative proven work, and, on an exact tie, which side won more of the diverged heights; it never looks at what a chain contains, so a majority attacker can fork from before a transaction confirmed and build a history that never confirms it, at the cost of an ordinary reorg. No block-level or transaction-level rule stops that, because the attacker breaks no rule; it simply declines to extend the branch it dislikes. That is a property of longest-chain consensus generally, not a gap specific to this design.
+
+Other inherited limitations:
+
+- As with Bitcoin, a node syncing from scratch cannot cryptographically distinguish the honest chain from an attacker's alternative on its own; it has to trust the network it connects to at least once.
+- Whether VDF-solving hardware availability keeps pace with the network's needs is a market question the protocol cannot guarantee, the same as mining hardware availability is for Bitcoin.
+
+## 8. Conclusion
+
+LapseCoin keeps Bitcoin's core guarantee: no trust required, everything verifiable, no authority can reverse a transaction. It replaces proof-of-work with a Verifiable Delay Function, which is believed to narrow the hardware-advantage gap that drove proof-of-work's runaway energy use, without needing a separate rule bolted on to achieve that. Transactions stay ordinary and plaintext, with sender-bid fees. Supply is capped at 21 million LAPSE with smooth decay and no halvings. Censorship resistance beyond ordinary confirmation-depth security is not claimed, because no rule at the block or transaction level can give it against a genuine majority attacker in a longest-chain system.
+
+## References
+
+1. S. Nakamoto, "Bitcoin: A Peer-to-Peer Electronic Cash System," 2008.
+2. NIST, "FIPS 206 (Draft): FN-DSA (FALCON)," 2025.
+3. G. Fanti et al., "Dandelion: Redesigning the Bitcoin Network for Anonymity," 2018.
+4. A. Loewenstern et al., "BEP 44: Storing arbitrary data in the DHT," 2014.
+5. D. Boneh et al., "Verifiable Delay Functions," 2018.
+6. Chia Network, "Chia Network's Proof of Space and Time VDF Competition Results," 2019.

lapsecoin-0.8.3/hook_oqs.py

@@ -0,0 +1,31 @@
+"""
+PyInstaller runtime hook for oqs (liboqs-python).
+
+Pre-loads liboqs via ctypes before oqs imports so it gets the cached
+handle regardless of search path. Works on both Linux and Windows.
+"""
+import ctypes
+import glob
+import os
+import sys
+
+if hasattr(sys, "_MEIPASS"):
+    meipass = sys._MEIPASS
+
+    if sys.platform == "win32":
+        patterns = ["oqs.dll", "liboqs.dll"]
+    else:
+        patterns = ["liboqs.so*"]
+
+    candidates = []
+    for pat in patterns:
+        candidates += sorted(glob.glob(os.path.join(meipass, pat)))
+
+    for lib in candidates:
+        if os.path.isfile(lib):
+            try:
+                ctypes.CDLL(lib)
+                os.environ["OQS_INSTALL_PATH"] = meipass
+                break
+            except OSError:
+                pass