electricalgrade
EG

home miner

Public Key

npub12z774rgz3g4nerpaf9ju0pq5znw6z75d4wmqnkxd90r6uqfg935sddvdkj

Profile Code

nprofile1qqs9p00235pg52eu3s75jew8ss2pfhdp02x6hdsfmrxjh3awqy5zc6gpzpmhxue69uhkummnw3ezuamfdejsz9rhwden5te0wfjkccte9ejxzmt4wvhxjmckl8825

Publishing to

nostr.wine

relay.damus.io

nos.lol

Author Public Key

npub12z774rgz3g4nerpaf9ju0pq5znw6z75d4wmqnkxd90r6uqfg935sddvdkj

Show more details

Last Notes

2025-09-17 01:04:36 UTC

- reply

hmm.. FPPS doesn’t really make sense for a DATUM pool. The pool operator doesn’t control the block template (miners do), so fee attribution is fuzzy and the variance/treasury risk sits on the pool. FPPS works today mostly because legacy pools own the template (and often a private mempool). With DATUM, per-block PPLNS fits better: pay on confirmed coinbase using a last-B-blocks (or N-difficulty) window.
Building such a pool is more grunt work, totally doable. Turning this PoC into a realistic PPLNS/(or similar) DATUM pool is mostly plumbing and ops — not research. This was the whole point about my post. If pool owners are motivated for decentralized mining where miners control template then DATUM is just ready to go.
DB-wise: keep it boring. Postgres for users/rounds/credits/payouts. If you want raw share lineage, add Timescale for a shares hypertable; otherwise store per-height aggregates only.

2025-09-16 02:51:12 UTC

Got a minimal DATUM “pool” talking to datum_gateway (interop demo)
TL;DR: datum_gateway being open source is enough to build your own pool. EGPOOL is a minimal proof — not production.
Datum_gateway is open source and the protocol is right there in the code. My take: if you can read the protocol, you can build your own pool.
Before arguing, I wanted to try it. So I hacked together a tiny Python prototype called EGPOOL. It speaks the DATUM protocol and can handshake, push CONFIG, and round-trip shares with the gateway — no Ocean pool code involved.
What I proved (all from the public datum gateway code):
• Framing: 4-byte XOR’d header + payload
• Handshake:
- proto=1 HELLO: sealed to pool LT X25519, signed by client LT Ed25519
- proto=2 RESP: sealed to client SESSION X25519, signed by pool LT Ed25519
• Channel (cmd=5):
- Box(serverSessSK, clientSessPK) w/ 24-byte nonce from nk + client session pk
- Nonces increment per message (LE 6×u32)
• CONFIG 0x99: signed by pool SESSION key, applied by gateway
• Share submit 0x27 ↔ response 0x8F: round-trip works
My test setup
EGPOOL pool server <-> DATUM GATEWAY -> Bitcoin node
I connected a bitaxe miner to DATUM Gateway.
I saw gateway handshake with pool server and accepting shares from miner.
Datum Gateway logs from my run:
Handshake response received.
DATUM Server MOTD: Welcome to Python DATUM Prime (prototype)
client configuration cmd received from DATUM server
DATUM Pool Coinbase Tag: "EGPOOL"
DATUM Pool Prime ID: a1b2c3d4
DATUM Pool Min Diff: 65536
Starting Stratum v1 server
---
quick disclaimer — this is a test rig, not a real pool
This is just an interop demo to show the protocol surface is enough.
A production pool still needs all the boring-but-critical stuff: reliable networking & reconnects, user/worker auth, proper vardiff and duplicate detection, real accept/reject plumbing, accounting backed by a DB, coinbaser v2 with real splits, the 0x50 validation path (stxids → by-id → full set), signature discipline (LT vs session), rate limiting/DoS guards, key management/rotation, metrics/alerts, etc
Want to understand more about the protocol?
check my GitHub
https://github.com/electricalgrade/sv2/blob/main/doc/Datum_Protocol_Spec.md
#Bitcoin #Mining #DATUM

2025-09-12 02:25:10 UTC

- reply

🧱 Selfish Mining Revisited — Deep Dive into Two Key Papers
Reclaiming Miner Sovereignty: Why Decentralized Block Construction is Crucial for Bitcoin's Future
#bitcoin #mining
👇
https://primal.net/e/naddr1qvzqqqr4gupzq59aa2xs9z3t8jxr6jt9c7zpg9xa59agm2akp8vv62784cqjstrfqquj6um9d3nxjumg94kkjmnfdenj6un9we5hx6t5v4jz6ttyv4jhqttyd9mx2ttfde6x7tt5wahj66m90ykhqctsv4e8xtgdvppt0

2025-09-12 02:16:19 UTC

- reply

Mechanic you should do a video on this.
Many people think prunable means they can remove from their node. The pruning is only for utxo validation but once in block it stays there forever. This means if you run full node you will have it.
Already everyday so much junk is put in the OP_RETURN (even with <80bytes).
I run a spam check (I have a simple ML classification model )
It detects
| 🧬 Malware indicators : `MZ`, binary blobs, shellcode, etc.
| 🧱 Overly large payloads : Likely trying to store malware
| 🧾 Structured address spam: Recognizable crypto address formats
| 🧟 Botnet / C2 : Random hex data, possible signal packets
| 🧨 Garbage entropy :Nonsense strings, high entropy content
https://blossom.primal.net/ce49a218915aec65a70e04ac8d7a5ea9253a92ba55a838b59db4ce86fd8ab6b4.png

2025-09-11 04:03:43 UTC

🚨 Bitcoin blocks are silently accumulating embedded data — not all of it benign.
I built a model that scans OP_RETURNs for suspicious payloads like malware, phishing links, and binary blobs. It works — and that’s the scary part.
📌 Here's why it matters:
- Today, AV/EDR systems don’t scan `.bitcoin/blocks`
- Tomorrow, they will — and when they do, infected chains could get flagged
- Nodes on cloud infrastructure (AWS, GCP) may face bans or throttling
- Centralized miners can bypass mempool policy, embedding malicious data
🧠 This is about more than spam. It's about Bitcoin's long-term health and legitimacy.
We need:
- Sensible datacarrier/mempool policies
- Transparency in block contents
- Decentralized, policy-respecting mining
Bitcoin is permissionless. Let’s not let it become indefensible.
#Bitcoin #OP_RETURN #Malware #AVDetection #Mempool #Mining #ChainSecurity #Nostr

2025-09-11 03:50:41 UTC

- reply

There are more nuances.. basically FPPS is not very transparent.
many pools may not even share transaction fees.
I like Ocean mainly because that is what PoW is ..
1) You get reward only if you pool mines a block
2) You can create your own block templates and if you are big miner you directly get paid by coinbase transaction and for a small miner like me I get a BOLT12 lightning payout

2025-09-08 02:45:04 UTC

- reply

https://blossom.primal.net/2dfcbd7227f6e6d71fe1ccce3725181faa53680bff7d2766a2a4aa6dafe660e9.png

2025-09-08 02:41:00 UTC

🧪 Homomorphic Encryption over Nostr — Proof of Concept
Simulated a lightweight Nostr relay using WebSockets + a custom event kind 555 to send/aggregate homomorphically encrypted integers.
Paillier scheme, local clients, fully async, dumb relay.
Built it to explore encrypted coordination on top of Nostr.
+------------------+
| Initiator |
|------------------|
| Gen Paillier Key |
| Encrypt Value X |
| Send via Kind 555|
+--------+---------+
|
v
[ Local Relay ]
|
+-------------------+-------------------+
| | |
v v v
+--------------+ +--------------+ +--------------+
| Responder 1 | | Responder 2 | | Responder 3 |
|--------------| |--------------| |--------------|
| Receive X | | Receive X | | Receive X |
| Add secret a | | Add secret b | | Add secret c |
| Send X+a | | Send X+b | | Send X+c |
+------+--------+ +------+--------+ +------+--------+
| | |
+--------+---------+------------------+
|
v
+------------------+
| Initiator |
|------------------|
| Decrypt X+a |
| Decrypt X+b |
| Decrypt X+c |
+------------------+

2025-09-08 02:25:19 UTC

🛠️ Spin up Bitcoin Knots + DATUM Gateway in Docker Compose.
No more juggling configs — just docker-compose up and you're live with a proper Bitcoin node + Datum Gateway.
🔗 https://github.com/electricalgrade/btc_datum
Built this for myself, but figured someone else might want it.
Run infra, not drama.
#Bitcoin #Nostr #Docker

2025-09-04 03:40:12 UTC

📢 Bitcoin Knots v29.1.knots20250903 Released
Bitcoin Knots v29.1.knots20250903 is now available!
Built on top of Bitcoin Core v29.1, this release includes:
🧱 Improved NAT-PMP & IPv6 support
⚡ Ephemeral anchors support (Lightning-friendly)
🧠 Smart mempool + mining policy updates
👀 GUI now supports Qt6 & new OCR-Bitcoin font
🧪 Enhanced RPCs, REST API, and logging
🛠️ Switched to CMake build system
⛏️ Wallet + mining stability and safety upgrades
🔐 Custom policy options like -acceptunknownwitness, -permitbareanchor, -minrelaycoinblocks
Get it here:
👉 https://bitcoinknots.org/files/29.x/29.1.knots20250903/
Release notes:
📄 https://github.com/bitcoinknots/bitcoin/releases
How to upgrade
If you are running an older version, shut it down. Wait until it has completely shut down (which might take a few minutes in some cases), then run the installer (on Windows) or just copy over /Applications/Bitcoin-Qt (on macOS) or bitcoind/bitcoin-qt (on Linux).
If you want to build from source then build system has moved to cmake.
cmake -B build
cmake --build build --target bitcoind
cmake --install build --component bitcoind
Refer to the release notes for more details.
#Bitcoin #BitcoinKnots #FOSS #node #privacy #selfsovereign

2025-08-30 02:14:39 UTC

- reply

🧪 Part 2: Minimal Stratum V2 Handshake (Noise XX/NX + SetupConnection)
Following up on the Noise Protocol intro — here's a small, self-contained C implementation that performs a Noise handshake (XX or NX) and exchanges Stratum V2 SetupConnection messages immediately after.
It’s built to test client/server handshake logic without needing full SV2 support or encryption on the transport layer (yet).
Just Noise + SetupConnection, using raw TCP with framed messages.
🔧 What’s included:
Minimal “pool server” (sv2_pool_server.c) that:
Accepts TCP connections
Completes a Noise handshake (XX by default, NX optional via --nx)
Decodes a SetupConnection message and responds with SetupConnection.Success
Matching client (noise_client.c) that:
Connects to the pool
Runs Noise handshake
Sends a valid SetupConnection payload
Handshake and transport logic is handled using noise-c — clean, constant-time, and easy to audit.
🔐 Handshake Patterns:
XX: Both parties are anonymous; ephemeral key exchange on both sides.
NX: Server has a static key; client is ephemeral (more realistic for mining pools).
These map directly to Noise patterns (Noise_XX_25519_ChaChaPoly_BLAKE2s) and can be swapped via --xx / --nx.
🧰 Framing and Messages:
Transport uses simple framing: uint16_be length prefix + payload.
After handshake, we send:
SetupConnection (client → server)
SetupConnection.Success (server → client)
These are built using SV2 helpers (sv2_common.[ch], sv2_wire.[ch]) to encode/decode the frames.
🔄 Example Usage:
Start the pool server:
./sv2_pool_server -l 0.0.0.0:3334 --prologue STRATUM/2 --sk <hex-secret>
Start the client:
./noise_client -l 127.0.0.1:3334 --prologue STRATUM/2
Both ends should print confirmation of the handshake and the SetupConnection exchange.
🚫 What's intentionally missing (for now):
No full SV2 session yet (no channel open, no job distribution)
No post-handshake encryption of transport messages
No persistent session keys or reconnection logic
This is by design — the goal is to test handshakes + basic SV2 flows before introducing more complexity. Once the handshake layer is stable, you can drop in encrypted transport using sv2_noise_send_transport() and sv2_noise_recv_transport() provided in the demo.
💡 I’m using this for testing SV2 client implementations and validating message formats over raw TCP before wiring into a full miner or pool stack.
This is all part of adding SV2 mining protocol support to Datum gateway.
I already have a SV1 to SV2 translator. Now adding SV2 server features.
#noiseprotocol #stratumv2 #miningprotocol #bitcoinmining #handshake #cryptography #protocoltesting #cprogramming #securecommunications #nostrdev #decentralization #packetengineering #DLT
#nevent1q…frff

2025-08-28 14:43:52 UTC

- reply

Here is the git hub to quickly get knots+datum running.
Tested this on Mac, arm64 and x86
#bitcoin
https://github.com/electricalgrade/btc_datum.git
#nevent1q…c7vl

2025-08-27 14:48:14 UTC

Running Bitcoin Knots + Datum is as simple as
docker compose up

2025-08-26 15:23:06 UTC

Built Bitcoin Knots (v28.1.knots20250305) from source in a clean Docker container 🚀
- Ubuntu 22.04 base
- Wallet disabled (--disable-wallet)
- Auto builds from official Knots repo
- Clean & reproducible setup
- bitcoind ready out-of-the-box
💡 Useful for devs, testers, node runners
#Bitcoin #BitcoinKnots #Docker #Nostr
Source & Dockerfile:
https://github.com/electricalgrade/bitcoin/tree/28.x-knots/docker

2025-08-26 00:08:51 UTC

Noise Protocol: A Minimal and Modular Cryptographic Tool
Been working with the Noise protocol recently — here’s a quick breakdown of what it does and how it works under the hood.
Noise is a small framework for building secure handshakes. It’s not a full protocol like TLS, more like a toolkit to define your own. It handles the initial key exchange, identity/auth, and gives you encrypted transport keys after the handshake. That’s it. No certificates, no extensions, no middleboxes.
Each handshake in Noise is built using a "pattern" — I’ve been using XX and NX. These define how the keys are exchanged:
* XX: both sides are anonymous, and exchange keys during handshake.
* NX: responder has a static pubkey, initiator is ephemeral (closer to client-server flows like SV2).
Behind the scenes, these patterns are just sequences of Diffie-Hellman operations between the parties' keys (ephemeral and static), and the handshake hash is updated after each message. Once complete, both sides split the final hash into two symmetric cipherstates, and that’s what’s used to encrypt transport messages.
All operations are constant-time. I’m using the `noise-c` library, which supports `Noise_XX_25519_ChaChaPoly_BLAKE2s` (or SHA256 if you tweak the suite string). Noise defines the handshake state machine, but the crypto primitives are pluggable.
The nice part is that everything’s deterministic and testable. Given the same inputs, the handshake always produces the same shared keys. It’s all pure key material — no ASN.1, no PEMs, no handshake extensions to worry about.
In the next post, I’ll show a tiny C implementation that wraps a Noise handshake (XX or NX), and exchanges Stratum V2 `SetupConnection` messages post-handshake. Useful for testing your own SV2 client/server implementations.
#noiseprotocol #cryptography #infosec #keyexchange #stratumv2 #miningprotocol #cprogramming #protocolengineering #decentralization #bitcoin #nostrdev #datumgateway #DLT #securecommunication #networkprotocols

2025-08-24 23:32:26 UTC

- reply

Just a quick reminder — I created Nostr Bot to share a few useful and curated updates on the Nostr network, and I’m excited for you to follow it!
It’s built using Python and uses Nostr to post updates directly to my self-hosted relay. This means it won’t spam anyone, and once you follow the bot, you’ll get periodic updates without the clutter.
I also use n8n for all automation.
Here’s what the bot will share:
1) Machine Learning News: Regular updates from the MachineLearning subreddit, keeping you up to date with the latest trends and discussions in the field.
2) Daily AI-Powered Research Summaries: Every morning, I post a summary of the latest arXiv Deep Learning papers. I use my local AI model to condense the key points, making it easier for you to stay informed.
3) USD to SAT Exchange Rate: Every 12 hours, I share the latest conversion of 1 USD to SATs. This helps you keep track of the market movements, especially if you're into crypto.
4) Ocean Pool Block Updates: Every time the Ocean pool finds a new block 🧱, I’ll notify you with the update. This is useful for miners and crypto enthusiasts alike.
The bot is efficient and non-intrusive—it posts only to my relay, so once you follow it, you won’t be bombarded with constant messages.
If you're interested, follow my Nostr Bot and get these updates directly from my relay! It’s a simple, clean way to stay updated on these topics without any noise.
#nostr #bot #machinelearning #arxiv #bitcoin #mining #oceanpool #DL #NostrRelay
EGBot: npub13ktz9vxqyvmvnsmr7url6zy2sxaxl7ugkw3xdswp8w5ztsuapayqp9xv6t
#nevent1q…0r8p

2025-08-24 15:14:38 UTC

Continuing on my journey of adding Stratum V2 (SV2) support to Datum Gateway (focused on the mining protocol), the first step is getting the connection setup between the SV2 server and the miner (client) working.
It uses noise protocol.
This weekend, I got this connection setup working (see below).
I’ll be writing two posts on the current progress.
In the first post, I’ll explain how the Noise handshake works, the cryptographic primitives behind it, and why it's a great fit for securing communication. I'll also dive into key concepts like Diffie-Hellman and ephemeral keys.
In the second post, I’ll walk through a simple C implementation where we use the Noise handshake to exchange SV2 SetupConnection messages. This will show how Noise can be integrated into a real-world Stratum V2 mining pool setup.
This will be useful for anyone working with mining infrastructure or interested in the cryptographic side of things. Stay tuned for the full details!
Here is current progress!
[pool] listening on 0.0.0.0:3334 (pattern=NX, prologue="STRATUM/2")
[pool] static pubkey: 39c0a192403e698f375524d21594068c5ac693137898582d054b052cddb7da47
[pool] handshake complete
[pool] SetupConnection: protocol=2 min=2 max=2 vendor="c-noise-client"
[pool] sent SetupConnection.Success (version=2 flags=0x00000000)
[client] handshake complete
[client] SetupConnection.Success used_version=2 flags=0x00000000
#cryptography #mining #stratumv2 #NoiseProtocol #DatumGateway #SV2 #Nostr #miningprotocol #blockchain

2025-08-20 06:02:16 UTC

working on adding support of sv2 to Datum (only mining protocol)
a small, self-contained C library for SV2 wire handling, with a minimal evented adapter integrated into DATUM. This brings upstream/downstream SV2 compatibility while preserving the SV1 path.
✅ Core library in C (wire framing, message helpers)
✅ Thin evented server: accept SV2 clients, handle Setup/Open/Submit
✅ Python SV1↔SV2 bridge for testing (no miner firmware changes) for my standalone testing.
and some initial results here
SV2 server (dummy)
[sv2-dummy] client ('127.0.0.1', 52379) connected
[sv2-dummy] <- ext=0x0000 msg=0x00 pay=17 bytes hex=0000001100000c646174756d2d62726964676500000000...
[sv2-dummy] -> SetupConnection.Success used_version=2 flags=0
[sv2-dummy] <- ext=0x0001 msg=0x20 pay=8 bytes hex=010020080000010000000000c842...
[sv2-dummy] (noop) ext=0x0001 msg=0x20
SV2-SV1 bridge for my testing
[bridge] SV1 client connected: ('0.0.0.0', 54730)
[sv1] <- ('', 54730) {"id": 1, "method": "mining.subscribe", "params": ["cpuminer/2.5.1", "b10cf00c1"]}
[sv1] -> ('', 54730) {"id":1,"result":[[["mining.notify","b10cf00c1"],["mining.set_difficulty","b10cf00c2"]],"b10cf00c",8],"error":null}
[sv1] -> ('1', 54730) {"id":null,"method":"mining.set_difficulty","params":[1024]}
[sv1] (seed) dummy job_id=e1ad9163 ntime=68a549f7
[sv1] -> ('1', 54730) {"id":null,"method":"mining.notify","params":["e1ad9163","0000000000000000000000000000000000000000000000000000000000000000","01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff1042524447","ffffffff010000000000000000015100000000",[],"20000000","1d00ffff","68a549f7",true]}
and the miner (SV1)..
* Trying .0.0.167:13333...
* Connected to 0.0.167 (0.0.167) port 13333 (#0)
* Connection #0 to host 0.0.167 left intact
[2025-08-20 05:07:19] > {"id": 1, "method": "mining.subscribe", "params": ["cpuminer/2.5.1", "b10cf00c1"]}
[2025-08-20 05:07:19] < {"id":1,"result":[[["mining.notify","b10cf00c1"],["mining.set_difficulty","b10cf00c2"]],"b10cf00c",8],"error":null}
[2025-08-20 05:07:19] Stratum session id: b10cf00c1
[2025-08-20 05:07:19] > {"id": 2, "method": "mining.authorize", "params": ["", ""]}
[2025-08-20 05:07:19] < {"id":null,"method":"mining.set_difficulty","params":[1024]}
[2025-08-20 05:07:19] Stratum difficulty set to 1024
[2025-08-20 05:07:19] < {"id":null,"method":"mining.notify","params":["e1ad9163","0000000000000000000000000000000000000000000000000000000000000000","01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff1042524447","ffffffff010000000000000000015100000000",[],"20000000","1d00ffff","68a549f7",true]}
[2025-08-20 05:07:19] < {"id":2,"result":true,"error":null}
[2025-08-20 05:07:19] DEBUG: job_id='e1ad9163' extranonce2=0000000000000000 ntime=68a549f7
#bitcoin #Datum

2025-08-18 03:18:52 UTC

- reply

until now all contributions were first sent to core and Luke would merge them to knots. But recent core attitude of rejecting patches that would make forking easier means in future, things may change and devs will be encouraged to directly push patches to knots.
I am personally working on creating a consensus only lib which will be same code base as core but this will allow easier integration of polyglot clients. This way we only "agree" on consensus code and can have our own mempool/wallet etc implementation. people can then choose any non-consensus related implementations and all use the same consensus implementation. I have started looking at the libbitcoinkernel project
This will make maintaining much easier..

2025-08-17 17:51:14 UTC

🧠 Just built a lightweight Heartbeat Dashboard for monitoring Stratum miners!
⛏️ Designed to auto-check active clients from journal logs and optionally restart the gateway.
🖥️ Web dashboard + auto backoff + warning when no miners connected.
🛠️ Written in Python. .
https://github.com/electricalgrade/datum_dash
📝 Check it out: #opensource #bitcoin #stratum #mining #nostr #datum

2025-08-14 03:20:31 UTC

- reply

Bitcoin is rules without rulers — but only if miners don’t outsource the rules.
I summarize two key papers that reveal how attackers exploit fee volatility and network latency to profitably destabilize mining — often without detection.
Decentralization is our immune system. More details in the article below.
#Bitcoin #Mining #SelfishMining #Decentralization #DATUM #Security #ProofOfWork #arXiv #Nostr #CensorshipResistance #Crypto
https://primal.net/e/naddr1qvzqqqr4gupzq59aa2xs9z3t8jxr6jt9c7zpg9xa59agm2akp8vv62784cqjstrfqquj6um9d3nxjumg94kkjmnfdenj6un9we5hx6t5v4jz6ttyv4jhqttyd9mx2ttfde6x7tt5wahj66m90ykhqctsv4e8xtgdvppt0

2025-08-13 06:18:14 UTC

- reply

EGBot now gives concise summaries of new cs.AI papers from arXiv — one message every day.
Every day one message like below.
Summarization is done using n8n + my self-hosted LLM. 🤖📄
Every 12 hours, it also publishes the current 1 USD to SAT rate.
And it notifies whenever Ocean Mining pool mines a block. ⛏️
All messages are published to my self-hosted Nostr relay. 🛰️
#Nostr #AI #arXiv #Bitcoin #USD2SAT #OceanMining #SelfHosted #Automation #NostrBot
#nevent1q…0hhy

2025-08-12 05:38:06 UTC

- reply

You have 3 options
1) By default if you are using Primal then it uploads in the primal blossom server, I dont know size limits maybe depends on membership
2) Run your own blossom server.
https://github.com/PrimalHQ/primal-blossom-server
3) If you already have a media server like Plex/Jellyfin (self hosted) then use cloud flare tunnel and directly share the link of the video in Nostr note.
Nostr relay only stores link so it's not heavy on relay.

2025-08-12 02:06:27 UTC

- reply

I run knots + mine with ocean using datum
This is a direction I've been exploring too — but with a slightly different angle.
There've been attempts before (btcd in Go, bcoin in JS, etc.) to “extract” or reimplement Bitcoin’s consensus logic, but they end up rewriting everything — which risks subtle consensus drift.
My proposal:
I’ve been thinking about a clean separation inside Core — breaking it into:
- a Consensus layer (shared .so lib, minimal C API)
- and a Node layer (networking, mempool, wallet, RPC, etc.)
Extract Core’s consensus rules as-is into a shared .so lib with a minimal C interface — no networking, no mempool, just pure validation logic (script checks, rule enforcement, etc.).
Then have everything else — blockchain DB, UTXO set, P2P, wallet, mempool, etc. — live in a modular node layer that links against the consensus lib.
Why this is different:
✅ No reimplementation — the logic is still Core’s, just exposed cleanly
🧩 Usable from Python/Rust/etc. via FFI, or over RPC
🔍 Easier to test, audit, sandbox
🌱 Node runners could experiment with custom node layers, while sharing the same validation engine
I’ve prototyped a wrapper exposing:
int validate_block(const uint8_t* data, size_t len, char* err_buf, size_t err_len);
Would love to hear if others are thinking about modularization like this — or see tradeoffs I’m missing.

2025-08-11 04:59:16 UTC

- reply

📢 New Experimental Idea:
I’ve been exploring homomorphic encryption over Nostr — simulating private computation using custom events and local relays.
Just published a write-up detailing the design, protocol flow, and a working Python proof of concept.
🧪 Still exploratory, not production-grade — but could open up interesting directions.
👉 Read it here:
https://primal.net/e/naddr1qvzqqqr4gupzq59aa2xs9z3t8jxr6jt9c7zpg9xa59agm2akp8vv62784cqjstrfqp8hg6rfde4kjmn894skymm4wskkzttwv4mj66mfdejz6um9vd6hyefdv3shgcfdvdhkcmrpvfhhyct5d9hkutthd96xsttgdakk7mt0wfcxs6tr94jkucmj09c8g6t0dc9atucf
Would love to hear thoughts, critiques, or wild extensions.
#nostr #encryption #homomorphic #poc #privacy

2025-08-09 23:32:30 UTC

- reply

🚀 EGBot Update
EGBot now supports OCEAN block notifications!
Whenever OCEAN pool mines a new Bitcoin block, the bot automatically publishes a Nostr note. 🔔⛏️.
🧪 The post below was a test. From now on, every new block by OCEAN will be broadcasted via my relay only (to keep it spam-free).
💱 Additionally, every 12 hours, EGBot publishes the latest 1 USD → sats conversion.
Follow to stay updated ⚡
#nostr #bitcoin #ocean #bot #automation #selfhosted #sat #usd
#nevent1q…slss

2025-08-08 23:48:49 UTC

- reply

🧠 My Nostr Bot Posting Reddit Content!
Hey ! I’ve extended my bot that automatically posts content from the r/nostr subreddit to my own self-hosted Nostr relay.
🛰️ What it does:
Pulls fresh content from the nostr subreddit (using n8n workflow)
Publishes it as Nostr notes using my own relay
Posts only to my own relay to keep the network clean and spam-free
you can find my bot here
npub13ktz9vxqyvmvnsmr7url6zy2sxaxl7ugkw3xdswp8w5ztsuapayqp9xv6t
Zap or boost if you think this is cool ⚡
#nevent1q…yyyn

2025-08-08 16:19:05 UTC

- reply

⚠️ Correction to my earlier post:
Primal does read from other relays — as long as the user’s profile lists them.
So yes, my self-hosted relay is visible on Primal when added to the user’s relay list. ✅
Thanks to the decentralized beauty of Nostr — I’ll keep experimenting with my bot + relay setup. More updates soon. 🧪🤖
#Nostr #Correction #Relay #SelfHosted #Decentralization #Primal

2025-08-08 16:11:53 UTC

🚧 Built my own Nostr bot from scratch using python-nostr.
I generated keypairs directly, and wrote a custom Python wrapper for WebSocket + REST communication. The bot is currently live on my self-hosted relay, where I’m doing end-to-end testing. 🧪
Primal only reads from its own relay — it won’t fetch content from other relays (like my self hosted) you post to. Primal only publishes to relays you have in your profile. To get around this, I extended my lite indexer that parses and searches my relay directly. Please note the bot will not spam primal relay and will only use my relay. It will not post to Primal and used for my own internal testing.
This is the beauty of Nostr. Self hosted and free to do anything without causing spam.
Integrated the bot with n8n — so now I can auto-post to my Nostr relay from any workflow, API, or trigger. 🤖
https://blossom.primal.net/4f66a01cebfed5013ac27f793028d3c4b56632eccfce91e84e63ccccc132d155.png
Planning experiments with Homomorphic Encryption — enabling collaborative computation over encrypted data, embedded in Nostr's event model. 🔐
More fun ahead...
#Nostr #SelfHosted #BotDev #Automation #n8n #HomomorphicEncryption #Decentralization #Prima

2025-08-07 05:25:39 UTC

- reply

Today only me, as I am doing some testing. But I can open it to anyone on NOSTR maybe once I finish my testing.
I currently support the following Nostr event kinds on my self-hosted relay:
Kind 0: Metadata
Kind 1: Text Notes
Kind 2: Relay Recommendation
Kind 3: Contact List
Kind 7: Reactions
Kind 40: Channel Creation
Kind 10002: Relay List Metadata

2025-08-07 05:12:29 UTC

- reply

Because owning your communication stack is powerful.
I wanted to learn Nostr stack. Running your own relay teaches you the Nostr protocol from the inside out. No one can delete your posts if you run the infra.
Also I have built indexing and search support for my relay.

2025-08-07 05:03:39 UTC

🧪 Testing my Nostr relay with custom-generated keypairs 🔐
I'm running a self-hosted relay and testing event publishing using locally generated Nostr keys — no client UI, just code and raw JSON.
Every event is hand-crafted, signed, and sent via WebSocket.
✅ Verifying signatures
✅ Enforcing pubkey whitelisting
✅ Watching it land in my SQLite-backed relay
#nostr #selfhosted #testing #decentralization #sqlite #cryptography

2025-08-07 02:00:07 UTC

- reply

https://substack.com/inbox/post/170152237?showWelcomeOnShare=true&triedRedirect=true
#nevent1q…sa99

2025-08-06 05:29:17 UTC

🚀 Relay Update
I’ve added indexing and search support to my self-hosted Nostr relay!
✅ I can now:
Print the latest messages, along with pubkeys of users posting
Search the relay database for specific keywords
Any meaningful database needs indexing and search — now my relay speaks SQL fluently. 🧠🗃️
#nostr #selfhosted #sqlite #indexer #decentralization
https://blossom.primal.net/05baec879d99ee290cc7e642bfc383aa880582e3599861f90f80ba9655f2f13c.png
https://blossom.primal.net/75d99559b0173fbe12002687a54de6ea8c0953d517994b1fa2d8b66a66810a85.png

2025-08-05 06:23:09 UTC

Just published a deep dive on Bitcoin mining difficulty 🧠⛏️
• How difficulty adjusts
• Why solo mining doesn’t affect it
• How pools help you shape the chain
• Why Ocean Pool + DATUM gives block-level sovereignty
Read here 👉 https://open.substack.com/pub/electricalgrade/p/bitcoin-difficulty-hashrate-and-datum?r=5yiypn&utm_campaign=post&utm_medium=web&showWelcomeOnShare=true
#Bitcoin #mining #ocean #DATUM #selfhosted #decentralization #nostr

2025-08-02 15:21:24 UTC

My Raspberry Pi has been running a Nostr relay for the past 15 hours.
It’s small, quiet, and a little rebellious. 🐧
Private for now. Just learning, watching JSON flow.
#selfhosted #decentralization #nostr

2025-08-01 00:11:19 UTC

🧠 Curious question for fellow Nostr folks...
How many of you run your own Nostr relay?
I recently set one up and it’s been a fun experiment.
Aside from learning more about the protocol, some nice benefits:
✅ Own your part of the network
✅ Support decentralization
✅ Improve relay diversity
✅ Learn how Nostr works under the hood
Would love to hear from others—do you run one? Thinking about it? Why or why not?
#Nostr #NostrRelay #SelfHost #Decentralization

2025-07-31 04:26:15 UTC

🚀 Successfully compiled datum_gateway on Apple Silicon (macOS ARM64)!
✅ Installed deps via Homebrew
✅ Used argp-standalone for missing <argp.h>
✅ Replaced pthread_mutex_timedlock with a portable fallback for macOS
✅ Shared fix + steps with the Datum team on Discord 🧑‍💻
🛠️ Note: Basic testing only. Not production ready yet.
Just wanted to prove it can be done.
#bitcoin #datum #macos #arm64 #miningdev

2025-07-30 05:33:09 UTC

📡 Running DATUM: A Return to Decentralized Bitcoin Mining
Built a self-hosted DATUM + Bitcoin Knots setup:
🔧 Hardware: Switched from Pi 5 (SD card bottleneck) to NVMe mini-PC
🌐 Node: Full sync via Bitcoin Knots
📦 Block templates built locally
⚡️ Hashing with Bitaxe + Avalon Nano
👨‍🏫 Bonus: Using it to teach Bitcoin mining to students!
🧠 Lessons learned:
• SD cards are a bottleneck — use SSD/NVMe
• blocknotify is critical to avoid stale work
• CPU freq tuning helps with template speed
• DATUM needs txindex=1 and full mempool
DATUM lets you mine your own blocks — solo or pooled — with full transparency + template control.
💡 Feels like mining the way Bitcoin intended.
Full notes, setup guide, and logs on my Substack:
🔗 https://electricalgrade.substack.com/p/running-datum-a-deep-dive-into-decentralized
#Bitcoin #Mining #DATUM #Bitaxe #Ocean #Nostr

2025-07-30 04:37:26 UTC

- reply

Except FBTC (from Fidelity) all others custody their BTC with coinbase. So FBTC is a tad better.
Recently SEC Permits In-Kind Creations and Redemptions for Crypto ETPs. However this seems to be only for institutional investors.
So this means individual investor will only track price and in future if anti-crypto govt comes to power they can just make it bad.
Buying btc through exchange is again a different challenge. The new crypto tax form (in 2026) requires US exchanges to report any withdrawal (including self custody). This means more paper work to tell IRS this is your cold storage wallet. So if needed IRS can track your wallet.
Overall
1) if you want to just ride the price then FBTC is simple and easy
2) if you care about bitcoin then help boomer to a simple hot wallet. teach the importance of seed phrase and transfer few SATS. once comfortable then step into buying from exchange and later use hw wallet. yes its a longer process but its a one time effort.
I wish SEC allows for individual investors to take in-kind redemption. Until then choose FBTC or teach.

2025-07-30 01:25:46 UTC

**🧠 How DATUM & CKPool-Solo Assign Unique Nonce Spaces for Miners**
In Bitcoin mining, assigning unique hashing ranges to each miner is *crucial* to avoid duplicate work and wasted energy. Let’s break down how **DATUM** and **CKPool-Solo** do this using the Stratum v1 protocol.
---
**1️⃣ Background: Why Nonce Assignment Matters**
Mining = repeatedly hashing block headers with different nonce values until one meets the difficulty target.
To scale this across many miners, each must get a *unique* search space:
* No overlaps
* No collisions
* Full parallel efficiency
---
**2️⃣ Stratum v1 Primer**
* `ExtraNonce1`: assigned by the server
* `ExtraNonce2`: generated by the miner
* Together, they expand the nonce space far beyond the 32-bit native nonce in the block header.
---
**3️⃣ DATUM Gateway (Ocean.xyz)**
* Assigns a **random hex ExtraNonce1** per miner on connection (`mining.subscribe`)
* Coinbase structure:
```
coinbase = coinbase1 || ExtraNonce2 || coinbase2
```
* Ensures *per-client nonce isolation*
✅ ExtraNonce1 size: **configurable**
✅ Supports flexible scaling
---
**4️⃣ CKPool-Solo (golden-guy fork)**
* Assigns `ExtraNonce1` based on **client ID**
* Fixed sizes:
* ExtraNonce1: 4 bytes
* ExtraNonce2: 8 bytes
* Each miner gets:
```
coinbase = coinbase1 || ExtraNonce2 || coinbase2
```
✅ Simple
✅ Collision-free
✅ Great for solo setups
---
**5️⃣ Comparison**
| Feature | DATUM | CKPool-Solo |
| --------------- | ------------- | --------------- |
| ExtraNonce1 | Random hex | Client ID |
| Configurable? | ✅ Yes | ❌ No (fixed) |
| ExtraNonce2 | Miner-defined | Fixed (8 bytes) |
| Collision-free? | ✅ Yes | ✅ Yes |
---
**6️⃣ Why It Matters**
* 🧩 Nonce collisions = wasted hashes
* 🧱 Isolation = scalable miner deployments
* ⚙️ Protocol correctness = Stratum-compliant
Both systems follow best practices to maximize efficiency—critical as mining difficulty rises.
---
**🔁 TL;DR**
* Server assigns `ExtraNonce1`
* Miner loops over `ExtraNonce2 + nonce`
* DATUM = random hex per connection
* CKPool-Solo = derived from client ID
* Result: Efficient, parallel, collision-free mining
---
⚡ #Bitcoin #Mining #DATUM #CKPool #Stratum #ASIC #SoloMining #ProofOfWork #NostrMining

2025-07-29 23:40:14 UTC

I am a home btw miner. Started with bitaxe then nerdqaxe and nano3s. I write my journey and technical articles at https://substack.com/@electricalgrade
This is first time I am using Nostr
#introductions