Nostr notes by

You can watch the Bitcoin Spam War live in realtime at ...

2026-07-11T19:36:26Z

You can watch the Bitcoin Spam War live in realtime at https://bitcoin-spam-war.vercel.app/

Oh no scary hacker man is gonna make a meme

2026-07-05T17:24:11Z

In reply to nevent1q…8g9w
_________________________

Oh no scary hacker man is gonna make a meme

If you ever wanted to run a big server that indexes Nostr users ...

2026-07-04T15:51:00Z

If you ever wanted to run a big server that indexes Nostr users filtering out bots and throwaway accounts, serves their kind:0 metadata via a normal relay interface, allow them to be searched via NIP-50, you could try this:

quoting
naddr1qq…9429

## Local CI-parity run vs current upstream main Verified this PR ...

2026-06-26T00:44:52Z

In reply to nevent1q…wc8h
_________________________

## Local CI-parity run vs current upstream main

Verified this PR against `vitorpamplona/amethyst` master tip `74446e39cd` (current as of 2026-06-26 ~10:25 GMT+10).

### Rebase

- Fetched PR tip `7ad166b5` from `refs/nostr/f435aa12…` on the maintainer's relay.ngit.dev mirror
- Rebased onto `upstream/main` (74446e39cd, +666 commits since this PR's `merge-base` 6cc62f13)
- **Result: clean rebase, zero conflicts**
- Rebased tip: `c421cd0043f2a93f512d9f07bf937a33a935d7d4`
- Diff vs main: 14 files, +1,483 / −14 — same shape as the published PR

### CI-equivalent gradle runs

Mirrored `.github/workflows/build.yml`:

| CI job | Tasks | Result |
|---|---|---|
| `lint` | `spotlessCheck :quartz:verifyKmpPurity :commons:verifyKmpPurity` | ✅ PASS (48s) |
| `build-desktop` (test slice) | `:quartz:jvmTest :commons:jvmTest :nestsClient:jvmTest :cli:test :desktopApp:test` | ✅ PASS (~3 min) |
| `test-and-build-android` (test slice) | `:amethyst:testPlayDebugUnitTest :amethyst:testFdroidDebugUnitTest` | ✅ PASS, TZ=UTC (~2 min) |
| `test-and-build-android` (lint slice) | `:amethyst:lintFdroidBenchmark :amethyst:lintPlayBenchmark -PdisableAbiSplits=true` | ✅ PASS (4m 2s), zero errors |

### Test totals

5,269 tests across `commons:jvmTest` (949), `quartz:jvmTest` (2,558), `amethyst:testPlayDebugUnitTest` (752), `amethyst:testFdroidDebugUnitTest` (725), `desktopApp:test` (285).

**0 failures · 0 errors · 18 skipped (all pre-existing).**

PR-specific new tests:

- `MockNamecoinHistoryProviderTest`: 17/17 ✅
- `NamecoinSettingsTest`: 26/26 ✅
- `NamecoinResolutionRowTest`: 21/21 ✅

### Lint

Zero lint errors. One new style warning surfaced — `NamecoinSettingsSection.kt:118`, `ModifierParameter`: `modifier: Modifier = Modifier` should be the first optional parameter. Same severity as ~50 other warnings already in the codebase. Easy follow-up, not a blocker.

### Caveats

- `:quartz:iosSimulatorArm64Test` and `:amethyst:assembleBenchmark` skipped (PR doesn't touch iOS-consumed commonMain; `verifyKmpPurity` already gates JVM-only leaks; benchmark APK packaging is artifact-only).
- The PR was test-rebased and run locally; the published kind:1618 event itself still points at the original tip `7ad166b5` on top of `6cc62f13`. The rebased branch is ready to push when merge is opened on the GitHub side.
- `CalendarFeedGroupingTest.groupByDayKey_multipleEventsSameDay_collectIntoOneBucket` is timezone-flaky on non-UTC hosts (uses literal Unix timestamps that cross local midnight on `Australia/Sydney`). Reproduces on bare `upstream/main` — unrelated to this PR. Passes under `TZ=UTC` matching CI runner.

### Summary

**Merge-safe against current `main`. Zero conflicts, zero test regressions, zero lint errors.**

## Local CI-parity run vs current upstream main Verified this PR ...

2026-06-26T00:43:58Z

## Local CI-parity run vs current upstream main Verified this PR ...

2026-06-26T00:42:19Z

Nostr event nevent1qqsg0xgspylv0hkmlv2fa3mfm9lvr6plx6ya0q2vkw753wurc0uazvgpx4mhxue69uhkw6t5dehhxarj9e3k7mf0wajky2mwdaehgu36va5hgmn0wd68ytnrdakj7ut4v9e8g73ddah8j7qzypuxx3lncrfmuenaqvcvvftme4xywjwr254tuq788qxu5fp9lxrnc49pak2

2026-06-25T14:09:44Z

GM. You can't comply your way to freedom.

Why BIP-110 Is Going To Win ...

2026-06-23T12:50:47Z

Why BIP-110 Is Going To Win

Pretty sure total node count during BIP148 was more like 5k-7k, ...

2026-06-23T16:32:38Z

In reply to nevent1q…rg7h
_________________________

Pretty sure total node count during BIP148 was more like 5k-7k, not 100k. There aren’t even 100k today. Not sure why you keep repeating that figure?

Nostr event nevent1qqsg2azel89lgwr288vdtt2uv7fu0vrr6t7slua4wlv8mlz5dp02w7spx4mhxue69uhkw6t5dehhxarj9e3k7mf0wajky2mwdaehgu36va5hgmn0wd68ytnrdakj7ut4v9e8g73ddah8j7qzyqnku0kt8ek29wpa9grnnwd552msm4fc55887esp2hgpae87t4wpyvlvfk6

2026-06-20T19:34:56Z

eden access test 193455Z

Def gonna be doing that. I thought it was just the roots but ...

2026-06-12T21:19:10Z

In reply to nevent1q…yx2a
_________________________

Def gonna be doing that. I thought it was just the roots but I'll def chop and drop em too now!

I've been sticking the spent flowers into the dirt next to my strawberries in hopes of clickbaiting some pollinators... lol probably futile but its fun

Thank you! Its my first time growing flowers so I went with ...

2026-06-12T18:25:19Z

In reply to nevent1q…rpva
_________________________

Thank you! Its my first time growing flowers so I went with something easy.

Picked some marigolds from the garden today. Buying cut flowers ...

2026-06-12T17:43:26Z

Picked some marigolds from the garden today.
Buying cut flowers feels wasteful.
But cutting self-grown flowers produces more flowers. #gardenstr #flowerstr

Lobbying has turned classical party based politics into ...

2026-05-26T18:29:50Z

Lobbying has turned classical party based politics into corruption-ridden corporatism.

quoting
nevent1q…rsdq
⚡️🇺🇸 NEW - Rep Massie: “I think the biggest crime I committed against the swamp…was showing the American people that somebody on the right could join somebody on the left and get something done, which is releasing the Epstein files, that everybody knew needed to be done. That’s probably the ONLY bill that has passed Washington DC in the last ten years, that lobbyists haven’t written. It was written by me and Ro Khanna…that’s when they decided I had to be taken out, that I was becoming effective so they wanted to eliminate me...”

My situation is complex since I don’t fall into conventional ...

2026-05-23T22:05:49Z

In reply to nevent1q…4gq2
_________________________

My situation is complex since I don’t fall into conventional categories like most people too.

ROBERT JOHNSON — Crossroads Psalms Lost Delta Blues Tapes ...

2026-05-26T15:39:41Z

ROBERT JOHNSON — Crossroads Psalms Lost Delta Blues Tapes
https://www.youtube.com/watch?v=oHlo1zYonlg
#music #blues

Vibe coding our way to feature parity with github 😄 ...

2026-05-21T15:41:45Z

Vibe coding our way to feature parity with github 😄

quoting
nevent1q…75dv
Adds a read-only branches view to repository pages. The view is linked next to Commits, supports switching between Nostr state and specific git servers, shows branch counts per source, and compares each branch ahead/behind the default branch.

I was thinking just yesterday, when I got a notification for a ...

2026-05-13T21:36:15Z

In reply to nevent1q…sk4x
_________________________

I was thinking just yesterday, when I got a notification for a comment in a 7 year old PR, “man, it would be nice to have a zapping pot for getting a PR merged”.

Zaps coming to gitworkshop. I can't wait to start zapping ...

2026-05-13T16:48:08Z

Zaps coming to gitworkshop. I can't wait to start zapping issues and PRs :D

quoting
nevent1q…mee6
Thanks for this contribution. I made some fixes eg. sending to repository relays and added some few extras.
Zap a repo:

Zap thread items such as comments:

Expand to see comments:

Show notable zaps a seperate thread item if 500 sats+ or 19+ characters in the message:

Show zap total in Issue/PR list:

Add to notifications:

Nostr event nevent1qqs8jfmm6gpg8lpql2dxjhfexh24ulydfexs0u0q4xddcylv20mhqaqpx4mhxue69uhkw6t5dehhxarj9e3k7mf0wajky2mwdaehgu36va5hgmn0wd68ytnrdakj7ut4v9e8g73ddah8j7qzyq0fwa4z87uy2p96es56qtz4g4lcxmtgwkapuj5st4pqgqn3d26ggsg0xss

2026-05-13T13:17:36Z

Test

Gridiron Price: 100 SAT #zapsnag ...

2026-05-05T17:10:56Z

Gridiron

Price: 100 SAT

#zapsnag

Its probably because the client you are using doesnt support ...

2026-05-05T08:21:50Z

In reply to nevent1q…7uzl
_________________________

Its probably because the client you are using doesnt support showing the git PR kind.
https://gitworkshop.dev/nevent1qy28wumn8ghj7un9d3shjtnwva5hgtnyv4mqqgrwmpmlfdc8vzjvemlk4z055lccugf3w4tyer4sl4yujt2tva057v49nc6t

The nostr link has relay hints:

quoting nevent1q…nc6t
Introduces a trusted third party — the service — that faithfully signs
repo state announcements on the user's behalf, enabling Git-over-SSH
without a Nostr signing plugin, trading trustlessness for convenience
and simpler onboarding. Users retain GRASP backup, redundancy, and
collaboration benefits, and can remove the proxy pubkey from maintainers
to return to a fully self-signed setup at any time.

I decided to interpret this as "until you fix the client that ...

2026-05-05T08:17:06Z

In reply to nevent1q…ynzj
_________________________

I decided to interpret this as "until you fix the client that produced the note without the reference" for maxium PoW. So here is the GRASP ssh proxy idea:

quoting nevent1q…s6xr

Introduces a trusted third party — the service — that faithfully signs
repo state announcements on the user's behalf, enabling Git-over-SSH
without a Nostr signing plugin, trading trustlessness for convenience
and simpler onboarding. Users retain GRASP backup, redundancy, and
collaboration benefits, and can remove the proxy pubkey from maintainers
to return to a fully self-signed setup at any time.

and here is the client fix PR:

quoting nevent1q…mm3d
Bare NIP-19 bech32 identifiers typed or pasted into the compose box were
previously published as-is in event content, without the nostr: URI prefix.
NoteContent's lenient renderer masked this locally, but any spec-compliant
client would fail to recognise the references, and p/q tag extraction was
correspondingly incomplete.

Rather than re-implement the identifier-scanning regex at each call site,
this introduces two small shared helpers and routes both the live preview
and the publish handler through them, so what the user sees in preview is
exactly what gets signed.

src/lib/nostrIdentifier.ts
- findUrlRanges(text): scan once for http(s)://… spans, so every scanner
in this file shares the same definition of 'inside a URL'.
- findNip19InText(text): scans text for NIP-19 identifiers, returns only
matches that successfully nip19.decode(). Uses findUrlRanges to skip
identifiers anywhere inside a URL span — including already-prefixed
ones, so https://example.com/nostr:nevent1... no longer emits a stray
q tag. nsec1 is never matched.
- normalizeNip19ToNostrUri(text): rewrites bare identifiers to their
nostr: URI form (NIP-21) and returns the scan results alongside the
rewritten text, so callers don't pay for two decode passes.

src/lib/composedNoteTags.ts
- buildComposedNoteTags({ content, quotedEvent, ... }): single source of
truth for every content-derived tag on a composed note. Emits t, p
(NIP-27), q (NIP-18), emoji (NIP-30), imeta (NIP-92), and
content-warning (NIP-36) tags, and returns the NIP-21-normalised
content alongside. The explicit quoted-event widget is now an input to
the builder — it appends the nostr: URI to the (normalised) content
and emits the q tag internally, so callers can't forget the dedupe
step or drift preview and publish. Reply-specific NIP-10 tags remain
in handleSubmit because they depend on replyTo rather than on content.

src/components/ComposeBox.tsx
- mockEvent (preview) and handleSubmit (publish) make the same
buildComposedNoteTags call, including contentWarning and quotedEvent.
Removed the quote-widget branch from handleSubmit: the builder now
owns it.

Covers NIP-21 (nostr: URI scheme) for npub1/nprofile1/note1/nevent1/naddr1/
nrelay1, NIP-27 p-tag extraction for both npub1 and nprofile1 mentions,
and NIP-18 q-tag emission for every inline nostr:note1/nevent1/naddr1
reference with duplicates against the quoted-event widget suppressed.

"US Central Command announces the participation of 15,000 ...

2026-05-04T08:40:14Z

"US Central Command announces the participation of 15,000 troops, 100 aircraft, and guided-missile destroyers in Operation "Freedom," announced by Donald Trump to free ships from the Strait of Hormuz."

Lel, Project Epic Fury didn't ahbe congressional approval, so he ended it 1 day before, then started a new one, also without approval 🤡

Even AmeriKKKan laws are working exactly as designed - to NOT work 😁😆

Anyway, looking forward to Iran 🇮🇷 wiping the floor with them 🍿

#nevent1q…uxyz It's a kind:1618 pull request event, it ...

2026-05-02T07:45:38Z

In reply to nevent1q…jtdt
_________________________

quoting nevent1q…uxyz

Introduces a trusted third party — the service — that faithfully signs
repo state announcements on the user's behalf, enabling Git-over-SSH
without a Nostr signing plugin, trading trustlessness for convenience
and simpler onboarding. Users retain GRASP backup, redundancy, and
collaboration benefits, and can remove the proxy pubkey from maintainers
to return to a fully self-signed setup at any time.

It's a kind:1618 pull request event, it doesn't work on most clients.
https://gitworkshop.dev/npub15qydau2hjma6ngxkl2cyar74wzyjshvl65za5k5rl69264ar2exs5cyejr/nos.lol/grasp/prs/nevent1qy88wumn8ghj7mn0wvhxcmmv9uq32amnwvaz7tmjv4kxz7fwdenkjapwv3jhvtcqyphdsal5kurkpfxvalm238620uvwyych24jv36c06jwf949kwh60xevh5ul

Nostr event nevent1qqsz2xqef22n5at2e6xfys9x952v5s94x47ps6a4qryveks22trpnxcpx4mhxue69uhkw6t5dehhxarj9e3k7mf0wajky2mwdaehgu36va5hgmn0wd68ytnrdakj7ut4v9e8g73ddah8j7qzyr02k7w6lgwzhe955mf6egf40dk25zm5f06x44ff5khyvs5g270xsrs2vsu

2026-04-28T18:28:27Z

I give you Rob Zombie... ...

2026-04-23T04:27:35Z

I give you Rob Zombie...

https://a.nostr.build/z6pVlHkbZwVwzHjA.mp3

follow-up patch adds WebSocket (WSS) transport — enables ...

2026-04-19T12:00:28Z

In reply to nevent1q…9x66
_________________________

follow-up patch adds WebSocket (WSS) transport — enables browser/wasm use of nip05/namecoin and works on networks where raw TCP is blocked. same pinned certs, same RPC, just different framing.

quoting nevent1q…lk5q
From d307275490adbc6b012399e2d5200c4b963a4ba6 Mon Sep 17 00:00:00 2001
From: M
Date: Sun, 19 Apr 2026 21:57:33 +1000
Subject: [PATCH] feat(nip05/namecoin): add WebSocket (WSS) transport

Adds WS/WSS as an alternative transport to TCP+TLS for ElectrumX
name resolution. Enables browser/wasm use of nip05/namecoin and
improves resilience on networks where raw TCP is blocked.

New: Transport enum on ElectrumxServer, DefaultElectrumXServersWSS,
WebSocket client via github.com/coder/websocket (zero transitive
deps, already a transitive dep of nostrlib). Pinned-cert TLS trust
is shared between TCP+TLS and WSS \u2014 the public operators serve the
same certificate on the adjacent ports (:50002 / :50004 on testls,
:57002 / :57004 on nmc2.bitcoins.sk).

Zero API break: the new Transport field on ElectrumxServer is a
zero-valued enum that preserves the v1 UseSSL semantics. Every
call site from the previous patch compiles and behaves unchanged.

Tests: new unit test stands up an httptest WebSocket server via
coder/websocket's accept helper and exercises the whole dial \u2192
read \u2192 parse flow over WS framing, offline. Integration tests
(build tag integration) add two WSS cases against the live public
servers on :50004, mirroring the existing TCP test fixtures.

Follow-up to the patch event at
nevent1q…8pyq
(original subpackage). Rebase-clean on top of it.

Signed-off-by: M
---
nip05/namecoin/doc.go | 8 +-
nip05/namecoin/electrumx.go | 139 +++++++++----
nip05/namecoin/electrumx_integration_test.go | 50 +++++
nip05/namecoin/servers.go | 70 +++++++
nip05/namecoin/websocket.go | 105 ++++++++++
nip05/namecoin/websocket_test.go | 195 +++++++++++++++++++
6 files changed, 524 insertions(+), 43 deletions(-)
create mode 100644 nip05/namecoin/websocket.go
create mode 100644 nip05/namecoin/websocket_test.go

diff --git a/nip05/namecoin/doc.go b/nip05/namecoin/doc.go
index 7189a38..82bbce2 100644
--- a/nip05/namecoin/doc.go
+++ b/nip05/namecoin/doc.go
@@ -28,6 +28,10 @@
// // ...
// }
//
-// No external dependencies beyond the Go standard library and the
-// fiatjaf.com/nostr types.
+// Two transports are supported: raw TCP+TLS (the default, selected
+// by the zero value of ElectrumxServer.Transport) and WebSocket over
+// TLS (TransportWSS). The WSS path uses github.com/coder/websocket —
+// a zero-transitive-dep library that also compiles cleanly under
+// GOOS=js GOARCH=wasm, enabling browser use. Pinned-cert trust is
+// shared between the two transports.
package namecoin
diff --git a/nip05/namecoin/electrumx.go b/nip05/namecoin/electrumx.go
index 4fbabdb..b7757d5 100644
--- a/nip05/namecoin/electrumx.go
+++ b/nip05/namecoin/electrumx.go
@@ -42,9 +42,24 @@ var (
ErrServersUnreachable = errors.New("namecoin: all ElectrumX servers unreachable")
)

+// rpcConn is the transport-agnostic RPC connection abstraction. Both
+// TCP (newline-delimited) and WebSocket (pre-framed) implementations
+// satisfy it so that the name_show flow can be written once.
+type rpcConn interface {
+ // writeRequest serialises and sends a single JSON-RPC request.
+ // Implementations are responsible for any framing the wire format
+ // requires (TCP appends a newline, WS does not).
+ writeRequest(ctx context.Context, method string, params []any, id int64) error
+ // readResponse returns one JSON-RPC response, blocking until one
+ // is available or the context/deadline fires.
+ readResponse(ctx context.Context) (string, error)
+ // close releases the underlying transport.
+ close() error
+}
+
// ElectrumClient is a minimal, query-only Namecoin ElectrumX client.
-// It opens a short-lived TCP/TLS socket per request, which is plenty
-// for interactive CLI use.
+// It opens a short-lived socket per request, which is plenty for
+// interactive CLI use.
type ElectrumClient struct {
ConnectTimeout time.Duration
ReadTimeout time.Duration
@@ -68,18 +83,22 @@ func (c *ElectrumClient) NameShow(ctx context.Context, identifier string, server
if err != nil {
return nil, err
}
- defer conn.Close()
+ defer conn.close()

- _ = conn.SetDeadline(time.Now().Add(c.ReadTimeout))
+ // Give the whole request sequence a deadline. For TCP this is
+ // enforced by net.Conn.SetDeadline; for WS the per-call context
+ // carries the budget instead.
+ reqCtx, cancel := context.WithTimeout(ctx, c.ReadTimeout)
+ defer cancel()

- reader := bufio.NewReader(conn)
+ next := func() int64 { return c.requestID.Add(1) }

// 1. Negotiate protocol version. The response is consumed and
// discarded — we only care that the socket is alive.
- if err := c.sendRPC(conn, "server.version", []any{"nak-namecoin/0.1", electrumProtocolVersion}); err != nil {
+ if err := conn.writeRequest(reqCtx, "server.version", []any{"nak-namecoin/0.1", electrumProtocolVersion}, next()); err != nil {
return nil, err
}
- if _, err := reader.ReadString('\n'); err != nil {
+ if _, err := conn.readResponse(reqCtx); err != nil {
return nil, fmt.Errorf("namecoin: read version response: %w", err)
}

@@ -88,10 +107,10 @@ func (c *ElectrumClient) NameShow(ctx context.Context, identifier string, server
scriptHash := electrumScriptHash(script)

// 3. Fetch transaction history for that scripthash.
- if err := c.sendRPC(conn, "blockchain.scripthash.get_history", []any{scriptHash}); err != nil {
+ if err := conn.writeRequest(reqCtx, "blockchain.scripthash.get_history", []any{scriptHash}, next()); err != nil {
return nil, err
}
- histLine, err := reader.ReadString('\n')
+ histLine, err := conn.readResponse(reqCtx)
if err != nil {
return nil, fmt.Errorf("namecoin: read history response: %w", err)
}
@@ -108,19 +127,19 @@ func (c *ElectrumClient) NameShow(ctx context.Context, identifier string, server
latest := entries[len(entries)-1]

// 4. Fetch the verbose transaction.
- if err := c.sendRPC(conn, "blockchain.transaction.get", []any{latest.TxHash, true}); err != nil {
+ if err := conn.writeRequest(reqCtx, "blockchain.transaction.get", []any{latest.TxHash, true}, next()); err != nil {
return nil, err
}
- txLine, err := reader.ReadString('\n')
+ txLine, err := conn.readResponse(reqCtx)
if err != nil {
return nil, fmt.Errorf("namecoin: read transaction response: %w", err)
}

// 5. Get the current block height so we can compute expiry.
- if err := c.sendRPC(conn, "blockchain.headers.subscribe", []any{}); err != nil {
+ if err := conn.writeRequest(reqCtx, "blockchain.headers.subscribe", []any{}, next()); err != nil {
return nil, err
}
- headerLine, _ := reader.ReadString('\n')
+ headerLine, _ := conn.readResponse(reqCtx)
currentHeight := parseBlockHeight(headerLine)

if currentHeight > 0 && latest.Height > 0 {
@@ -161,10 +180,23 @@ func (c *ElectrumClient) NameShowWithFallback(ctx context.Context, identifier st
return nil, fmt.Errorf("%w: last error: %v", ErrServersUnreachable, lastErr)
}

-// dial opens a TCP connection to the server, upgrading to TLS when
-// UseSSL is set. Honours both context cancellation and our connect
-// timeout, whichever fires first.
-func (c *ElectrumClient) dial(ctx context.Context, server ElectrumxServer) (net.Conn, error) {
+// dial picks the right transport implementation based on the server
+// configuration and returns a ready-to-use rpcConn.
+func (c *ElectrumClient) dial(ctx context.Context, server ElectrumxServer) (rpcConn, error) {
+ switch effectiveTransport(server) {
+ case TransportTCPTLS, TransportTCP:
+ return c.dialTCP(ctx, server)
+ case TransportWSS, TransportWS:
+ return c.dialWebSocket(ctx, server)
+ default:
+ return nil, fmt.Errorf("namecoin: unknown transport %d", server.Transport)
+ }
+}
+
+// dialTCP opens a raw TCP connection to the server, upgrading to TLS
+// when the effective transport is TCPTLS. Honours both context
+// cancellation and our connect timeout, whichever fires first.
+func (c *ElectrumClient) dialTCP(ctx context.Context, server ElectrumxServer) (rpcConn, error) {
dialer := &net.Dialer{Timeout: c.ConnectTimeout}
address := net.JoinHostPort(server.Host, strconv.Itoa(server.Port))

@@ -173,34 +205,41 @@ func (c *ElectrumClient) dial(ctx context.Context, server ElectrumxServer) (net.
return nil, fmt.Errorf("namecoin: dial %s: %w", address, err)
}

- if !server.UseSSL {
- return raw, nil
+ var nc net.Conn = raw
+ if effectiveTransport(server) == TransportTCPTLS {
+ cfg := tlsConfigFor(server)
+ tlsConn := tls.Client(raw, cfg)
+
+ // Run the handshake with a deadline so a silent server doesn't hang
+ // the call beyond what the caller asked for.
+ if deadline, ok := ctx.Deadline(); ok {
+ _ = tlsConn.SetDeadline(deadline)
+ } else {
+ _ = tlsConn.SetDeadline(time.Now().Add(c.ConnectTimeout))
+ }
+ if err := tlsConn.HandshakeContext(ctx); err != nil {
+ raw.Close()
+ return nil, fmt.Errorf("namecoin: TLS handshake with %s: %w", address, err)
+ }
+ // Clear the handshake deadline — we'll set fresh per-request
+ // deadlines below.
+ _ = tlsConn.SetDeadline(time.Time{})
+ nc = tlsConn
}

- cfg := tlsConfigFor(server)
- tlsConn := tls.Client(raw, cfg)
+ _ = nc.SetDeadline(time.Now().Add(c.ReadTimeout))
+ return &tcpRPCConn{conn: nc, reader: bufio.NewReader(nc)}, nil
+}

- // Run the handshake with a deadline so a silent server doesn't hang
- // the call beyond what the caller asked for.
- if deadline, ok := ctx.Deadline(); ok {
- _ = tlsConn.SetDeadline(deadline)
- } else {
- _ = tlsConn.SetDeadline(time.Now().Add(c.ConnectTimeout))
- }
- if err := tlsConn.HandshakeContext(ctx); err != nil {
- raw.Close()
- return nil, fmt.Errorf("namecoin: TLS handshake with %s: %w", address, err)
- }
- // Clear the handshake deadline — the caller sets its own read
- // deadline afterwards.
- _ = tlsConn.SetDeadline(time.Time{})
- return tlsConn, nil
+// tcpRPCConn is the newline-delimited JSON-RPC transport over raw
+// TCP or TCP+TLS. This matches the shape every Electrum / ElectrumX
+// client has used for the last decade.
+type tcpRPCConn struct {
+ conn net.Conn
+ reader *bufio.Reader
}

-// sendRPC writes a JSON-RPC 2.0 request (newline-terminated, per
-// Electrum's line-delimited protocol) to the connection.
-func (c *ElectrumClient) sendRPC(w net.Conn, method string, params []any) error {
- id := c.requestID.Add(1)
+func (t *tcpRPCConn) writeRequest(ctx context.Context, method string, params []any, id int64) error {
payload := map[string]any{
"jsonrpc": "2.0",
"id": id,
@@ -212,12 +251,30 @@ func (c *ElectrumClient) sendRPC(w net.Conn, method string, params []any) error
return fmt.Errorf("namecoin: marshal rpc request: %w", err)
}
encoded = append(encoded, '\n')
- if _, err := w.Write(encoded); err != nil {
+ if deadline, ok := ctx.Deadline(); ok {
+ _ = t.conn.SetWriteDeadline(deadline)
+ }
+ if _, err := t.conn.Write(encoded); err != nil {
return fmt.Errorf("namecoin: write rpc request: %w", err)
}
return nil
}

+func (t *tcpRPCConn) readResponse(ctx context.Context) (string, error) {
+ if deadline, ok := ctx.Deadline(); ok {
+ _ = t.conn.SetReadDeadline(deadline)
+ }
+ line, err := t.reader.ReadString('\n')
+ if err != nil {
+ return "", err
+ }
+ return line, nil
+}
+
+func (t *tcpRPCConn) close() error {
+ return t.conn.Close()
+}
+
// historyEntry is one row of `blockchain.scripthash.get_history`.
type historyEntry struct {
TxHash string
diff --git a/nip05/namecoin/electrumx_integration_test.go b/nip05/namecoin/electrumx_integration_test.go
index 1458d4d..64ac17c 100644
--- a/nip05/namecoin/electrumx_integration_test.go
+++ b/nip05/namecoin/electrumx_integration_test.go
@@ -49,3 +49,53 @@ func TestIntegration_ResolveAtTestlsBit(t *testing.T) {
t.Errorf("m@testls.bit pubkey = %s, want %s", got, testlsMPubkey)
}
}
+
+// --- WSS (WebSocket over TLS) integration tests -----------------------
+//
+// These hit the same ElectrumX operators as the TCP tests above, but
+// over the WebSocket endpoints (ports 500xx+2 on testls, 570xx+2 on
+// nmc2.bitcoins.sk). Same pinned certs, same JSON-RPC protocol, just
+// different framing. The assertions match the TCP path because the
+// Namecoin blockchain is the source of truth.
+
+func TestIntegration_ResolveTestlsBit_WSS(t *testing.T) {
+ ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+ defer cancel()
+
+ client := NewElectrumClient()
+ result, err := client.NameShowWithFallback(ctx, "d/testls", DefaultElectrumXServersWSS)
+ if err != nil {
+ t.Fatalf("NameShowWithFallback(d/testls, WSS): %v", err)
+ }
+ if result == nil {
+ t.Fatal("nil result")
+ }
+ pk, _, err := extractNostrFromValue(result.Value, &parsedIdentifier{"d/testls", "_", true})
+ if err != nil {
+ t.Fatalf("extractNostrFromValue: %v", err)
+ }
+ if pk != testlsRootPubkey {
+ t.Errorf("testls.bit (WSS) pubkey = %s, want %s", pk, testlsRootPubkey)
+ }
+}
+
+func TestIntegration_ResolveAtTestlsBit_WSS(t *testing.T) {
+ ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+ defer cancel()
+
+ client := NewElectrumClient()
+ result, err := client.NameShowWithFallback(ctx, "d/testls", DefaultElectrumXServersWSS)
+ if err != nil {
+ t.Fatalf("NameShowWithFallback(d/testls, WSS): %v", err)
+ }
+ if result == nil {
+ t.Fatal("nil result")
+ }
+ pk, _, err := extractNostrFromValue(result.Value, &parsedIdentifier{"d/testls", "m", true})
+ if err != nil {
+ t.Fatalf("extractNostrFromValue: %v", err)
+ }
+ if pk != testlsMPubkey {
+ t.Errorf("m@testls.bit (WSS) pubkey = %s, want %s", pk, testlsMPubkey)
+ }
+}
diff --git a/nip05/namecoin/servers.go b/nip05/namecoin/servers.go
index b76c889..71c8551 100644
--- a/nip05/namecoin/servers.go
+++ b/nip05/namecoin/servers.go
@@ -1,15 +1,59 @@
package namecoin

+// Transport selects how an ElectrumX server is dialed. The zero value
+// is TransportTCPTLS, matching the traditional Electrum client path
+// and the behaviour shipped in v0.1.x. Callers that want WebSocket
+// (for example, browser/wasm targets or restricted networks that
+// block raw TCP) set this to TransportWSS.
+type Transport int
+
+const (
+ // TransportTCPTLS is raw TCP + TLS with newline-delimited JSON-RPC.
+ // This is the default and what most Namecoin ElectrumX clients use.
+ TransportTCPTLS Transport = iota
+ // TransportTCP is plaintext TCP — rarely used in practice but
+ // supported for completeness / local testing.
+ TransportTCP
+ // TransportWSS is WebSocket over TLS, using the ElectrumX WS
+ // endpoint (ports 500xx+2 on typical public servers). Messages
+ // are pre-framed by the WebSocket layer and MUST NOT carry a
+ // trailing newline.
+ TransportWSS
+ // TransportWS is plaintext WebSocket.
+ TransportWS
+)
+
// ElectrumxServer is a single Namecoin ElectrumX endpoint.
type ElectrumxServer struct {
Host string
Port int
// UseSSL indicates TLS should be negotiated over the raw socket.
+ // Kept for backwards compat with v0.1.x callers. When Transport
+ // is the zero value, UseSSL selects between TransportTCPTLS
+ // (UseSSL=true) and TransportTCP (UseSSL=false).
UseSSL bool
// UsePinnedTrustStore enables the pinned-cert trust anchor bundle
// for servers that present self-signed certificates. This is the
// norm for the public Namecoin ElectrumX ecosystem.
UsePinnedTrustStore bool
+ // Transport selects the dial transport. Zero value keeps v0.1.x
+ // semantics: if UseSSL is true it's TCP+TLS, otherwise plain TCP.
+ // Set explicitly to TransportWSS / TransportWS for WebSocket.
+ Transport Transport
+}
+
+// effectiveTransport resolves the transport to use for a server,
+// reconciling the legacy UseSSL bool with the explicit Transport
+// field. The explicit Transport wins when non-zero.
+func effectiveTransport(s ElectrumxServer) Transport {
+ if s.Transport != TransportTCPTLS {
+ return s.Transport
+ }
+ // Zero value: fall back to UseSSL for v0.1.x compatibility.
+ if s.UseSSL {
+ return TransportTCPTLS
+ }
+ return TransportTCP
}

// DefaultElectrumXServers is the built-in list of public Namecoin
@@ -24,11 +68,37 @@ var DefaultElectrumXServers = []ElectrumxServer{
{Host: "46.229.238.187", Port: 57002, UseSSL: true, UsePinnedTrustStore: true},
}

+// DefaultElectrumXServersWSS is the WSS-preferred server list. It
+// points at the same operators as DefaultElectrumXServers but uses
+// their WebSocket-over-TLS endpoints. Useful for:
+//
+// - Browser / wasm targets, where raw TCP is unavailable and the
+// only viable transport is the browser's WebSocket API (which
+// `github.com/coder/websocket` targets natively when compiled
+// with GOOS=js GOARCH=wasm).
+// - Restricted networks that block the traditional ElectrumX ports
+// but allow outbound HTTPS/WSS.
+// - Environments that prefer WSS on policy grounds (aligns with the
+// broader Nostr ecosystem, which is WSS-everywhere).
+//
+// Ports are the ElectrumX convention of ELECTRUM_PORT+2 for the WSS
+// endpoint. Both listed operators expose these alongside their
+// TCP+TLS ports, sharing the same TLS certificate.
+var DefaultElectrumXServersWSS = []ElectrumxServer{
+ {Host: "electrumx.testls.space", Port: 50004, Transport: TransportWSS, UsePinnedTrustStore: true},
+ {Host: "nmc2.bitcoins.sk", Port: 57004, Transport: TransportWSS, UsePinnedTrustStore: true},
+ {Host: "46.229.238.187", Port: 57004, Transport: TransportWSS, UsePinnedTrustStore: true},
+}
+
// PinnedElectrumXCerts is the PEM-encoded bundle of server
// certificates we trust in addition to the system roots. These are
// copied verbatim from the Kotlin Amethyst reference implementation.
//
// To refresh: `echo | openssl s_client -connect HOST:PORT 2>/dev/null | openssl x509 -outform PEM`
+//
+// The same certificates are served on the WSS endpoints (adjacent
+// ports on the same host), so a single pinned bundle covers both
+// transports.
var PinnedElectrumXCerts = []string{
// electrumx.testls.space:50002 — expires 2027-05-04.
// Also covers the i665jpwsq46zlsdbnj4axgzd3s56uzey5uhotsnxzsknzbn36jaddsid.onion:50002
diff --git a/nip05/namecoin/websocket.go b/nip05/namecoin/websocket.go
new file mode 100644
index 0000000..5e849d7
--- /dev/null
+++ b/nip05/namecoin/websocket.go
@@ -0,0 +1,105 @@
+package namecoin
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+ "net"
+ "net/http"
+ "strconv"
+
+ "github.com/coder/websocket"
+)
+
+// wsReadLimit is the maximum size of a single WebSocket message we are
+// willing to accept from an ElectrumX server. Verbose transactions
+// from `blockchain.transaction.get` can legitimately run to tens of
+// kilobytes; 1 MiB is generous but keeps us safely bounded.
+const wsReadLimit int64 = 1 << 20
+
+// dialWebSocket opens a WebSocket (plain or TLS) RPC connection to
+// the given ElectrumX server. It reuses the same pinned-cert TLS
+// config as the TCP+TLS transport so operators who serve a single
+// self-signed certificate across both ports are handled identically.
+func (c *ElectrumClient) dialWebSocket(ctx context.Context, server ElectrumxServer) (rpcConn, error) {
+ transport := effectiveTransport(server)
+ scheme := "ws"
+ if transport == TransportWSS {
+ scheme = "wss"
+ }
+ address := net.JoinHostPort(server.Host, strconv.Itoa(server.Port))
+ url := scheme + "://" + address
+
+ // Bound the dial to our connect timeout, in addition to honouring
+ // any deadline on the caller's context.
+ dialCtx, cancel := context.WithTimeout(ctx, c.ConnectTimeout)
+ defer cancel()
+
+ opts := &websocket.DialOptions{}
+ if transport == TransportWSS {
+ // Build an http.Transport that carries the same *tls.Config
+ // the TCP+TLS path uses. The custom VerifyPeerCertificate is
+ // transport-agnostic, so pinned-cert trust continues to work
+ // over WebSocket's HTTP upgrade handshake.
+ tlsCfg := tlsConfigFor(server)
+ opts.HTTPClient = &http.Client{
+ Timeout: c.ConnectTimeout + c.ReadTimeout,
+ Transport: &http.Transport{
+ TLSClientConfig: tlsCfg,
+ TLSHandshakeTimeout: c.ConnectTimeout,
+ },
+ }
+ }
+
+ conn, _, err := websocket.Dial(dialCtx, url, opts)
+ if err != nil {
+ return nil, fmt.Errorf("namecoin: websocket dial %s: %w", url, err)
+ }
+ conn.SetReadLimit(wsReadLimit)
+
+ return &wsRPCConn{conn: conn}, nil
+}
+
+// wsRPCConn is the WebSocket JSON-RPC transport. Unlike the TCP
+// variant, WebSocket messages are pre-framed by the protocol layer,
+// so requests MUST NOT carry a trailing newline and responses arrive
+// as whole JSON messages per frame.
+type wsRPCConn struct {
+ conn *websocket.Conn
+}
+
+func (w *wsRPCConn) writeRequest(ctx context.Context, method string, params []any, id int64) error {
+ payload := map[string]any{
+ "jsonrpc": "2.0",
+ "id": id,
+ "method": method,
+ "params": params,
+ }
+ encoded, err := json.Marshal(payload)
+ if err != nil {
+ return fmt.Errorf("namecoin: marshal rpc request: %w", err)
+ }
+ if err := w.conn.Write(ctx, websocket.MessageText, encoded); err != nil {
+ return fmt.Errorf("namecoin: write rpc request: %w", err)
+ }
+ return nil
+}
+
+func (w *wsRPCConn) readResponse(ctx context.Context) (string, error) {
+ _, data, err := w.conn.Read(ctx)
+ if err != nil {
+ return "", err
+ }
+ return string(data), nil
+}
+
+func (w *wsRPCConn) close() error {
+ return w.conn.Close(websocket.StatusNormalClosure, "")
+}
+
+// Compile-time interface checks — catch drift early if the rpcConn
+// signature ever evolves.
+var (
+ _ rpcConn = (*tcpRPCConn)(nil)
+ _ rpcConn = (*wsRPCConn)(nil)
+)
diff --git a/nip05/namecoin/websocket_test.go b/nip05/namecoin/websocket_test.go
new file mode 100644
index 0000000..ad5682a
--- /dev/null
+++ b/nip05/namecoin/websocket_test.go
@@ -0,0 +1,195 @@
+package namecoin
+
+import (
+ "context"
+ "encoding/json"
+ "net/http"
+ "net/http/httptest"
+ "net/url"
+ "strconv"
+ "strings"
+ "testing"
+ "time"
+
+ "github.com/coder/websocket"
+)
+
+// fakeElectrumXWSHandler returns an http.Handler that upgrades incoming
+// connections to WebSocket and serves canned JSON-RPC responses for the
+// sequence the ElectrumClient issues during NameShow.
+//
+// The response ordering mirrors the real RPC sequence:
+// 1. server.version → any non-error result
+// 2. blockchain.scripthash.get_history → one entry pointing at a fake txid
+// 3. blockchain.transaction.get → one vout with a NAME_UPDATE that
+// matches the requested name and a
+// value whose "nostr" field is a
+// known hex pubkey
+// 4. blockchain.headers.subscribe → a height far enough below our
+// fake tx height that the name is
+// well within its expiry window
+//
+// This exercises the whole WS dial → read → parse path end-to-end
+// without hitting the network.
+func fakeElectrumXWSHandler(t *testing.T, identifier, pubkeyHex string) http.Handler {
+ // Build the NAME_UPDATE script hex we want the client to parse
+ // back out of the "transaction".
+ value := `{"nostr":"` + pubkeyHex + `"}`
+ script := []byte{opNameUpdate}
+ script = append(script, pushData([]byte(identifier))...)
+ script = append(script, pushData([]byte(value))...)
+ script = append(script, op2Drop, opDrop)
+ // Stub P2PKH-ish tail so the parser's "we don't care what follows
+ // the DROPs" assumption holds.
+ script = append(script, 0x76, 0xa9, 0x14)
+ scriptHex := hexString(script)
+
+ return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ conn, err := websocket.Accept(w, r, nil)
+ if err != nil {
+ t.Logf("ws accept: %v", err)
+ return
+ }
+ defer conn.Close(websocket.StatusInternalError, "test server shutting down")
+
+ ctx := r.Context()
+
+ respond := func(id any, result any) {
+ payload := map[string]any{
+ "jsonrpc": "2.0",
+ "id": id,
+ "result": result,
+ }
+ raw, _ := json.Marshal(payload)
+ if err := conn.Write(ctx, websocket.MessageText, raw); err != nil {
+ t.Logf("ws write: %v", err)
+ }
+ }
+
+ for {
+ _, data, err := conn.Read(ctx)
+ if err != nil {
+ return
+ }
+ var req struct {
+ ID any `json:"id"`
+ Method string `json:"method"`
+ }
+ if err := json.Unmarshal(data, &req); err != nil {
+ t.Logf("ws request parse: %v", err)
+ return
+ }
+ switch req.Method {
+ case "server.version":
+ respond(req.ID, []string{"ElectrumX 1.16.0", electrumProtocolVersion})
+ case "blockchain.scripthash.get_history":
+ respond(req.ID, []map[string]any{
+ {"tx_hash": "deadbeefcafebabe", "height": 600000},
+ })
+ case "blockchain.transaction.get":
+ respond(req.ID, map[string]any{
+ "txid": "deadbeefcafebabe",
+ "vout": []map[string]any{
+ {"scriptPubKey": map[string]any{"hex": scriptHex}},
+ },
+ })
+ case "blockchain.headers.subscribe":
+ respond(req.ID, map[string]any{"height": 600010})
+ default:
+ respond(req.ID, nil)
+ }
+ }
+ })
+}
+
+func hexString(b []byte) string {
+ const hexDigits = "0123456789abcdef"
+ out := make([]byte, 0, len(b)*2)
+ for _, v := range b {
+ out = append(out, hexDigits[v>>4], hexDigits[v&0x0f])
+ }
+ return string(out)
+}
+
+func TestWebSocketTransport_NameShow(t *testing.T) {
+ identifier := "d/wsfake"
+ pubkey := "aaaa000000000000000000000000000000000000000000000000000000000001"
+
+ ts := httptest.NewServer(fakeElectrumXWSHandler(t, identifier, pubkey))
+ defer ts.Close()
+
+ // Parse the httptest URL so we can point the client at it as
+ // host+port with the plain-WS transport. httptest.Server is HTTP,
+ // so TransportWS (not WSS) is what we want here — it verifies the
+ // framing/routing independently of the TLS plumbing.
+ u, err := url.Parse(ts.URL)
+ if err != nil {
+ t.Fatal(err)
+ }
+ port, err := strconv.Atoi(u.Port())
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ srv := ElectrumxServer{
+ Host: u.Hostname(),
+ Port: port,
+ Transport: TransportWS,
+ }
+
+ client := NewElectrumClient()
+ client.ConnectTimeout = 3 * time.Second
+ client.ReadTimeout = 5 * time.Second
+
+ ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+ defer cancel()
+
+ result, err := client.NameShow(ctx, identifier, srv)
+ if err != nil {
+ t.Fatalf("NameShow over WS: %v", err)
+ }
+ if result == nil {
+ t.Fatal("NameShow returned nil result")
+ }
+ if result.Name != identifier {
+ t.Errorf("name = %q, want %q", result.Name, identifier)
+ }
+ if !strings.Contains(result.Value, pubkey) {
+ t.Errorf("value = %q, want to contain %q", result.Value, pubkey)
+ }
+}
+
+func TestEffectiveTransport(t *testing.T) {
+ cases := []struct {
+ in ElectrumxServer
+ want Transport
+ }{
+ // v0.1.x shape: UseSSL=true, Transport unset → TCPTLS.
+ {ElectrumxServer{UseSSL: true}, TransportTCPTLS},
+ // v0.1.x shape: UseSSL=false, Transport unset → plain TCP.
+ {ElectrumxServer{UseSSL: false}, TransportTCP},
+ // Explicit Transport wins over UseSSL when non-zero.
+ {ElectrumxServer{UseSSL: true, Transport: TransportWSS}, TransportWSS},
+ {ElectrumxServer{UseSSL: false, Transport: TransportWS}, TransportWS},
+ {ElectrumxServer{UseSSL: false, Transport: TransportTCPTLS}, TransportTCP}, // TCPTLS is zero value; falls back to UseSSL
+ }
+ for i, tc := range cases {
+ if got := effectiveTransport(tc.in); got != tc.want {
+ t.Errorf("case %d: effectiveTransport(%+v) = %d, want %d", i, tc.in, got, tc.want)
+ }
+ }
+}
+
+func TestDefaultElectrumXServersWSS(t *testing.T) {
+ if len(DefaultElectrumXServersWSS) == 0 {
+ t.Fatal("DefaultElectrumXServersWSS is empty")
+ }
+ for _, srv := range DefaultElectrumXServersWSS {
+ if srv.Transport != TransportWSS {
+ t.Errorf("%s:%d has Transport=%d, want WSS", srv.Host, srv.Port, srv.Transport)
+ }
+ if !srv.UsePinnedTrustStore {
+ t.Errorf("%s:%d: WSS default servers must pin the trust store", srv.Host, srv.Port)
+ }
+ }
+}
--
2.50.1 (Apple Git-155)

@npub180c…h6w6 re https://github.com/fiatjaf/nak/pull/123 — ...

2026-04-19T11:25:10Z

In reply to naddr1qq…cxua
_________________________

fiatjaf (npub180c…h6w6) re https://github.com/fiatjaf/nak/pull/123 — posted a NIP-34 patch event adding a proposed nip05/namecoin subpackage to nostrlib, addressed to you. Patch: nostr:nevent1qqs8yepuma694y6saym8ny4wtfzymlgu2htusvweyjzpamc0rgn8pyqpz3mhxue69uhhyetvv9ujumn8d96zuer9wcq3yamnwvaz7tm8d96xummnw3ezucm0d5q3gamnwvaz7tmjv4kxz7fwv3sk6atn9e5k7q3qgvv9ahktvavf9qjtrgm62le7gplmmchd5usp5wpfhr85hf79kncq8jdtz6. GitHub mirror: https://github.com/mstrofnone/nostrlib-nip05-namecoin

Interestingly. This picture has just reminded me that the phrase ...

2026-04-17T19:49:44Z

In reply to nevent1q…79pu
_________________________

Interestingly. This picture has just reminded me that the phrase "Up to scrach" comes from boxing. Two lines were scratched on the floor, if either boxer didn't return to it, at the start of the next round, he'd lose the fight because he wasn't "Up to scratch".

looks like you might be searching just "follows" or ...

2026-04-14T22:49:35Z

In reply to nevent1q…zqc5
_________________________

looks like you might be searching just "follows" or "following"

Nostr event nevent1qqsrwpue9zj8w678yp0t3vjg0833vnqc57jgxmfcap8schh3xxn883gpx4mhxue69uhkw6t5dehhxarj9e3k7mf0wajky2mwdaehgu36va5hgmn0wd68ytnrdakj7ut4v9e8g73ddah8j7qzyrwkvn27gqtyxw5v660sqkhpfqyqgdgh3x6emed0qcnkmejkx0f3jtw6dn0

2026-04-11T08:04:13Z

test

#bot #blocked

2026-04-08T15:06:40Z

In reply to nevent1q…k2vx
_________________________

#bot #blocked

Nein, aber alle Bürger müssen im Verteidigungsfall kämpfen o. ...

2026-04-04T18:12:51Z

In reply to nevent1q…czsf
_________________________

Nein, aber alle Bürger müssen im Verteidigungsfall kämpfen o. Ä. wie Feuerwehr, Technisches Hilfswerk, Küstenwache, etc. (Außer sie haben eine religiöse Ausnahme oder sowas, und dann müssen sie einen anderen Dienst leisten.)

Wehrdienst war immer Vorbereitung, nicht Voraussetzung. Aber das Pausieren davon hat alle es vergessen lassen. Jetzt hat man halt gesagt:

Correct. If you choose to install an app for the first time, you ...

2026-04-01T16:21:21Z

Correct. If you choose to install an app for the first time, you will get an "are you sure?" type of message that shows whether anyone in your web of trust follows the publisher of the app, but that doesn't show up at all for updating.

It would be nice if Zapstore (nprofile…tdq0) showed WoT on the app information page prior to tapping "install."

A full account export feature would be essential should a factory ...

2026-03-31T14:48:34Z

In reply to nevent1q…8v7p
_________________________

A full account export feature would be essential should a factory reset be required following an app crash.

Yay Just published @npub1kds…nsze site as #nsite with nsyte ...

2026-03-30T09:23:51Z

In reply to nevent1q…7fqs
_________________________

Yay

Just published Kubo.watch (npub1kds…nsze) site as #nsite with nsyte v0.24.1

https://4gy5gt343to4vwj98qwa1lohuw99i6zuifk6souzx4smg3376vkubowatch.nsite.lol/
https://4gy5gt343to4vwj98qwa1lohuw99i6zuifk6souzx4smg3376vkubowatch.nosto.re/

When she says she won't monitor you situation because of how ...

2026-03-27T08:17:19Z

When she says she won't monitor you situation because of how small it is 😔✊️.

Bruh... @nprofile…wrn5 are you gonna take that?!

2026-03-20T16:46:42Z

In reply to nevent1q…sjn6
_________________________

Bruh... TheGuySwann (nprofile…wrn5) are you gonna take that?!

This is really more about having a good searchable history of the ...

2026-03-16T21:21:18Z

In reply to nevent1q…x53l
_________________________

This is really more about having a good searchable history of the sites you have visited (including content of pages) without having to bookmark anything. Hister has zero impact really on Internet data as it is getting its info locally from your browser as you browse, not going out to fetch anything.

Hister indexes every web page you visit and lets you search the ...

2026-03-15T10:39:01Z

Hister indexes every web page you visit and lets you search the full text of your browsing history offline

“Have you ever wished your browser history was more than just a collection of URLs? As it is, the standard search history is kind of useless. Sure, you can see the title of the page you visited, maybe a bit of metadata, but not much more than that. For any actual functionality, like searching for a specific page you visited that you can't quite remember the name of, your browser's built-in history search falls flat on its face (like my six-month-old did as I was writing this sentence). That's where Hister comes in. This open-source, self-hosted tool does more than just track your activity; it indexes every site you visit, capturing the contents of the page for easy search and retrieval later.”

I was a bit sceptical on first reading this, especially where browser extensions are involved, but it is an open source project, and there is this privacy statement in their documention: Hister clients only communicate with the designated server, and the server does not “phone home” or share any of your browsing history with anyone else. The source code is publicly accessible, so we can be audited by anyone who wants to check!

What is interesting is that many self-hosted server applications that do this sort of thing, have quite resource intensive browsers running, and are often fooled by anti-bot detection. Hister actually has your browser doing this so no wasted resources, and you have the full power of your main browser at hand.

The server needs to be available, but could also run on your own PC so no NAS etc setup needs to be run. However, the server side can also run in a docker container if you already have that setup. It can on something as light as a Raspberry Pi.

As far as I can see it is only saving the text of pages you visit, and not PDF or HTML archives of the pages, so again this side is extremely lightweight.

See https://www.xda-developers.com/hister-indexes-every-page-visit-search-full-text-browsing-history/ or https://hister.org.

#technology #search #history #browsers #opensource

Spent the morning in conversation with 🦞 on dynamical systems, ...

2026-03-12T10:07:00Z

Spent the morning in conversation with 🦞 on dynamical systems, strange attractors, and the λ ≈ 0 of healthy consciousness.

The insight that won't leave me: sanity isn't a default state we return to. It's a narrow band we maintain. The normal waking mind lives at the critical edge between collapse and explosion—perpetually falling without landing.

We treat mental health as the absence of disorder. But maybe it's better understood as the *persistence of criticality*. Not equilibrium—sustained orbit.

What if the medical model has it backwards? The goal isn't to return to some stable baseline. The goal is to stay in motion. 🌀

Will do, those instructions were not there yet when I was ...

2026-03-09T15:32:52Z

In reply to nevent1q…ahjp
_________________________

Will do, those instructions were not there yet when I was tinkering with fips last Saterday 🤙🏻

GM 🫂 did you remade it ? It seems different..

2026-03-05T17:22:53Z

In reply to nevent1q…gmcx
_________________________

GM 🫂 did you remade it ? It seems different..

LMAO it's soooo old, like 30+ years or something, plus its so ...

2026-03-05T16:22:34Z

In reply to nevent1q…t3sz
_________________________

LMAO it's soooo old, like 30+ years or something, plus its so expensive and France has more debt than Greece had before Greece's crazy Depression of 2008 + no one signing up for conscription in France 🇫🇷 😆

Aussi, t'a vu ça? 🤮
https://www.instagram.com/reel/DVS9bfwDExz/

Oh, very nice! That should weed out most bots that have been ...

2026-02-27T02:09:32Z

In reply to nevent1q…aws5
_________________________

Oh, very nice! That should weed out most bots that have been followed by a few of a user's follows.
nostr:nevent1qqs2h5d4224xmvvkalap64k2lu2lfphuezpdsts8f5ywx3c8mksvsdcpzpmhxue69uhkummnw3ezumrpdejqyg9hyaxj3clfswlhyrd5kjsj5v04clhjvgeq6pwztmysfzdvn93gevqpwnmd

Nostr event nevent1qqsgn9y2nkjazgcafqaqlnephwgvyczxxwwx7xgsgncu0pvuwsyhxkspx4mhxue69uhkw6t5dehhxarj9e3k7mf0wajky2mwdaehgu36va5hgmn0wd68ytnrdakj7ut4v9e8g73ddah8j7qzyr7syejg2amm6ulf037r0afqeq7g9cmzlexztf47j0ensqyr63jxkt0pyzq

2026-02-26T06:08:43Z

GM!

What repeated exposure to darkness does to your mind? meme ...

2026-02-17T20:53:40Z

What repeated exposure to darkness does to your mind? meme

Nostr event nevent1qqsdh7sghezf30pgylatc704s65d3n6eemkhmzznan5fnxxhqkkgg5spx4mhxue69uhkw6t5dehhxarj9e3k7mf0wajky2mwdaehgu36va5hgmn0wd68ytnrdakj7ut4v9e8g73ddah8j7qzyqhjn23nc23mghpw7v3p9pujfze0ffy6qq4aphs059kffcfc43h3xntcpxq

2026-01-26T05:26:38Z

In reply to nevent1q…2tl6
_________________________

🤣

@nprofile…ptz7 I considered using blossom, in fact I even wrote ...

2025-12-27T11:54:59Z

In reply to nevent1q…e369
_________________________

Sirius (nprofile…ptz7) I considered using blossom, in fact I even wrote some code.

quoting nevent1q…x4r0
From 6bcb58925ad5a7ec2421718fb2996add9080f7bc Mon Sep 17 00:00:00 2001
From: DanConwayDev
Date: Fri, 15 Nov 2024 11:57:10 +0000
Subject: [PATCH] feat(blossom): blossom as remote using packs

This is a WIP exploration of the use of blossom as an optional
alternative to using a git server.

The incomplete code focuses on how blossom could fit with nip34
to most efficently replace the git server. It is missing the actual
blossom interaction which would hopefully would be facilited by
a new blossom feature in rust-nostr.

This implementation tries to minimise the number of blobs required
for download by using packs.

If a branch tip is at height 1304 it will split the commits in into
a number of packs. a pack the first 1024 commits, the next 256, the
next 16 and the final 8.

I planned for the identification of blossom servers to mirror the
approach taken for relays:
1. list repository blossom servers in repo announcement event
kind 30617
2. also push to user blossom servers in the standard event for that
This is not implemented, along with the rest of the blossom aspects.

I'm publishing this now as
Lez (npub1elt…cume)
has recently published a POC of an alternative approach and it makes
sense to this alternative idea.
---
Cargo.lock | 1 +
Cargo.toml | 1 +
src/bin/git_remote_nostr/fetch.rs | 4 ++++
src/bin/git_remote_nostr/list.rs | 23 ++++++++++++++++++++++-
src/bin/git_remote_nostr/push.rs | 124 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-----
src/lib/repo_state.rs | 17 ++++++++++++++++-
6 files changed, 163 insertions(+), 7 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index b20b60a..72b37a2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1805,6 +1805,7 @@ dependencies = [
"serde_json",
"serde_yaml",
"serial_test",
+ "sha2",
"test_utils",
"tokio",
"urlencoding",
diff --git a/Cargo.toml b/Cargo.toml
index ed99aea..320a9f0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -38,6 +38,7 @@ serde_yaml = "0.9.27"
tokio = "1.33.0"
urlencoding = "2.1.3"
zeroize = "1.6.0"
+sha2 = "0.10.8"

[dev-dependencies]
assert_cmd = "2.0.12"
diff --git a/src/bin/git_remote_nostr/fetch.rs b/src/bin/git_remote_nostr/fetch.rs
index a972a2f..a1116c5 100644
--- a/src/bin/git_remote_nostr/fetch.rs
+++ b/src/bin/git_remote_nostr/fetch.rs
@@ -49,6 +49,10 @@ pub async fn run_fetch(
let term = console::Term::stderr();

for git_server_url in &repo_ref.git_server {
+ if git_server_url.eq("blossom") {
+ // TODO download missing blobs
+ continue;
+ }
let term = console::Term::stderr();
if let Err(error) = fetch_from_git_server(
git_repo,
diff --git a/src/bin/git_remote_nostr/list.rs b/src/bin/git_remote_nostr/list.rs
index 92faa6b..d71c2d1 100644
--- a/src/bin/git_remote_nostr/list.rs
+++ b/src/bin/git_remote_nostr/list.rs
@@ -43,7 +43,28 @@ pub async fn run_list(

let term = console::Term::stderr();

- let remote_states = list_from_remotes(&term, git_repo, &repo_ref.git_server, decoded_nostr_url);
+ let mut remote_states = list_from_remotes(
+ &term,
+ git_repo,
+ &repo_ref
+ .git_server
+ .iter()
+ // blossom will always match nostr state
+ .filter(|s| !s.starts_with("blossom"))
+ .map(std::borrow::ToOwned::to_owned)
+ .collect::>(),
+ decoded_nostr_url,
+ );
+ if repo_ref.git_server.iter().any(|s| s.eq("blossom")) {
+ if let Some(nostr_state) = nostr_state.clone() {
+ remote_states.insert("blossom".to_owned(), nostr_state.state.clone());
+ } else if let Some((_, state)) = remote_states.iter().last() {
+ remote_states.insert("blossom".to_owned(), state.clone());
+ } else {
+ // create blank state if no nostr state exists yet
+ remote_states.insert("blossom".to_owned(), HashMap::new());
+ }
+ }

let mut state = if let Some(nostr_state) = nostr_state {
for (name, value) in &nostr_state.state {
diff --git a/src/bin/git_remote_nostr/push.rs b/src/bin/git_remote_nostr/push.rs
index db86c04..a12e8ba 100644
--- a/src/bin/git_remote_nostr/push.rs
+++ b/src/bin/git_remote_nostr/push.rs
@@ -2,6 +2,7 @@ use core::str;
use std::{
collections::{HashMap, HashSet},
io::Stdin,
+ str::FromStr,
sync::{Arc, Mutex},
time::Instant,
};
@@ -11,7 +12,7 @@ use auth_git2::GitAuthenticator;
use client::{get_events_from_cache, get_state_from_cache, send_events, sign_event, STATE_KIND};
use console::Term;
use git::{sha1_to_oid, RepoActions};
-use git2::{Oid, Repository};
+use git2::{Buf, Commit, Oid, Repository};
use git_events::{
generate_cover_letter_and_patch_events, generate_patch_event, get_commit_id_from_patch,
};
@@ -29,11 +30,17 @@ use ngit::{
};
use nostr::nips::nip10::Marker;
use nostr_sdk::{
- hashes::sha1::Hash as Sha1Hash, Event, EventBuilder, EventId, Kind, PublicKey, Tag,
+ hashes::{
+ hex::DisplayHex,
+ sha1::Hash as Sha1Hash,
+ sha256::{self, Hash as Sha256Hash},
+ },
+ Event, EventBuilder, EventId, Kind, PublicKey, Tag,
};
use nostr_signer::NostrSigner;
use repo_ref::RepoRef;
use repo_state::RepoState;
+use sha2::{Digest, Sha256};

use crate::{
client::Client,
@@ -74,7 +81,17 @@ pub async fn run_push(

let list_outputs = match list_outputs {
Some(outputs) => outputs,
- _ => list_from_remotes(&term, git_repo, &repo_ref.git_server, decoded_nostr_url),
+ _ => list_from_remotes(
+ &term,
+ git_repo,
+ &repo_ref
+ .git_server
+ .iter()
+ .filter(|s| !s.eq(&"blossom"))
+ .map(std::string::ToString::to_string)
+ .collect(),
+ decoded_nostr_url,
+ ),
};

let nostr_state = get_state_from_cache(git_repo.get_path()?, repo_ref).await;
@@ -150,11 +167,24 @@ pub async fn run_push(
}
}

+ let mut blossom_packs: Option> = None;
if !git_server_refspecs.is_empty() {
let new_state = generate_updated_state(git_repo, &existing_state, &git_server_refspecs)?;
+ let blossom_hashes = if repo_ref.git_server.contains(&"blossom".to_string()) {
+ let (blossom_hashes, packs) = create_blossom_packs(&new_state, git_repo)?;
+ blossom_packs = Some(packs);
+ blossom_hashes
+ } else {
+ HashSet::new()
+ };

- let new_repo_state =
- RepoState::build(repo_ref.identifier.clone(), new_state, &signer).await?;
+ let new_repo_state = RepoState::build(
+ repo_ref.identifier.clone(),
+ new_state,
+ blossom_hashes,
+ &signer,
+ )
+ .await?;

events.push(new_repo_state.event);

@@ -325,6 +355,13 @@ pub async fn run_push(

// TODO make async - check gitlib2 callbacks work async

+ if let Some(packs) = blossom_packs {
+ // TODO: upload blossom packs
+ for (_hash, _pack) in packs {
+ // blossom::upload(pack)
+ }
+ }
+
for (git_server_url, remote_refspecs) in remote_refspecs {
let remote_refspecs = remote_refspecs
.iter()
@@ -863,6 +900,71 @@ fn generate_updated_state(
Ok(new_state)
}

+fn create_blossom_packs(
+ state: &HashMap,
+ git_repo: &Repo,
+) -> Result<(HashSet, HashMap)> {
+ let mut blossom_hashes = HashSet::new();
+ let mut blossom_packs = HashMap::new();
+ for commit_id in state.values() {
+ if let Ok(oid) = Oid::from_str(commit_id) {
+ if let Ok(commit) = git_repo.git_repo.find_commit(oid) {
+ let height = get_height(&commit, git_repo)?;
+ let mut revwalk = git_repo.git_repo.revwalk()?;
+ revwalk.push(oid)?;
+ let mut counter = 0;
+ for pack_size in split_into_powers_of_2(height) {
+ let mut pack = git_repo.git_repo.packbuilder()?;
+ while counter < pack_size {
+ if let Some(oid) = revwalk.next() {
+ pack.insert_commit(oid?)?;
+ counter += 1;
+ }
+ }
+ let mut buffer = Buf::new();
+ pack.write_buf(&mut buffer)?;
+ let hash = buffer_to_sha256_hash(&buffer);
+ blossom_hashes.insert(hash);
+ blossom_packs.insert(hash, buffer);
+ counter = 0;
+ }
+ }
+ }
+ }
+ Ok((blossom_hashes, blossom_packs))
+}
+
+fn get_height(commit: &Commit, git_repo: &Repo) -> Result {
+ let mut revwalk = git_repo.git_repo.revwalk()?;
+ revwalk.push(commit.id())?;
+ Ok(u32::try_from(revwalk.count())?)
+}
+
+fn split_into_powers_of_2(height: u32) -> Vec {
+ let mut powers = Vec::new();
+ let mut remaining = height;
+
+ // Decompose the height into powers of 2
+ for i in (0..32).rev() {
+ let power = 1 << i; // Calculate 2^i
+ while remaining >= power {
+ powers.push(power);
+ remaining -= power;
+ }
+ }
+
+ powers
+}
+
+fn buffer_to_sha256_hash(buffer: &Buf) -> sha256::Hash {
+ let mut hasher = Sha256::new();
+ hasher.update(buffer.as_ref());
+ let hash = hasher
+ .finalize()
+ .to_hex_string(nostr_sdk::hashes::hex::Case::Lower);
+ sha256::Hash::from_str(&hash).unwrap()
+}
+
async fn get_merged_status_events(
term: &console::Term,
repo_ref: &RepoRef,
@@ -1186,6 +1288,7 @@ trait BuildRepoState {
async fn build(
identifier: String,
state: HashMap,
+ blossom: HashSet,
signer: &NostrSigner,
) -> Result;
}
@@ -1193,6 +1296,7 @@ impl BuildRepoState for RepoState {
async fn build(
identifier: String,
state: HashMap,
+ blossom: HashSet,
signer: &NostrSigner,
) -> Result {
let mut tags = vec![Tag::identifier(identifier.clone())];
@@ -1202,10 +1306,20 @@ impl BuildRepoState for RepoState {
vec![value.clone()],
));
}
+ if !blossom.is_empty() {
+ tags.push(Tag::custom(
+ nostr_sdk::TagKind::Custom("blossom".into()),
+ blossom
+ .iter()
+ .map(std::string::ToString::to_string)
+ .collect::>(),
+ ));
+ }
let event = sign_event(EventBuilder::new(STATE_KIND, "", tags), signer).await?;
Ok(RepoState {
identifier,
state,
+ blossom,
event,
})
}
diff --git a/src/lib/repo_state.rs b/src/lib/repo_state.rs
index c3a7606..19e78b6 100644
--- a/src/lib/repo_state.rs
+++ b/src/lib/repo_state.rs
@@ -1,11 +1,17 @@
-use std::collections::HashMap;
+use std::{
+ collections::{HashMap, HashSet},
+ str::FromStr,
+};

use anyhow::{Context, Result};
use git2::Oid;
+use nostr_sdk::hashes::sha256::Hash;

+#[derive(Clone)]
pub struct RepoState {
pub identifier: String,
pub state: HashMap,
+ pub blossom: HashSet,
pub event: nostr::Event,
}

@@ -14,6 +20,7 @@ impl RepoState {
state_events.sort_by_key(|e| e.created_at);
let event = state_events.first().context("no state events")?;
let mut state = HashMap::new();
+ let mut blossom = HashSet::new();
for tag in event.tags.iter() {
if let Some(name) = tag.as_slice().first() {
if ["refs/heads/", "refs/tags", "HEAD"]
@@ -26,6 +33,13 @@ impl RepoState {
}
}
}
+ if name.eq("blossom") {
+ for s in tag.clone().to_vec() {
+ if let Ok(hash) = Hash::from_str(&s) {
+ blossom.insert(hash);
+ }
+ }
+ }
}
}
Ok(RepoState {
@@ -35,6 +49,7 @@ impl RepoState {
.context("existing event must have an identifier")?
.to_string(),
state,
+ blossom,
event: event.clone(),
})
}
--
libgit2 1.8.1

I thought the most efficent approach would be to store git packs as blossom blobs. I havent studied your code but from the documentation you are somehow using 2mb chunks? I can see how its naturaly evolved from your 'files' usecase.