Stop a listing page from rewriting the next one's grid after navigation.

Switching between /mints, /fedimints and /lnurl-mints showed the right list
for a moment and then flashed back to the previous ecosystem's mints. The
client router keeps every page's script alive, and onReady re-runs each
setup on every arrival, so a visited page's setup also ran on the next page.
All three grids were marked with the same bare data-mint-grid, so the stale
setup found the new grid, fetched its own type and overwrote it.

Mark and query each grid by ecosystem (data-mint-grid="cashu" etc.), the way
the home page already scopes data-home-grid, so a stale setup finds nothing
and bails. Skip the render in hydrateMintGrid when the grid has already been
detached by the router. Document the re-run-everywhere contract on onReady,
and add a static wiring test so a bare marker cannot come back.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

.env.example

@@ -38,6 +38,11 @@ PUBLIC_API_URL=
 # Canonical origin for canonical links, OpenGraph tags and the sitemap.
 SITE_URL=https://cashumints.space
 
+# Plausible-compatible analytics script and the domain reported with each page view.
+# Leave either value empty to disable analytics.
+PLAUSIBLE_URL=https://analytics.azzamo.net/js/script.js
+PLAUSIBLE_DOMAIN=cashumints.space
+
 # Whether a rated mint's JSON-LD also carries the review-snippet-eligible Product
 # type next to Service (web/src/lib/schema.ts explains the trade). On by default;
 # set to 0 to ship the plain Service node on the next build, no code change needed.
@@ -91,6 +96,19 @@ SEO_PRODUCT_JSONLD=1
 # so reviews the old site published to snort/primal were invisible to it.
 RELAYS=wss://relay.cashumints.space,wss://nos.lol,wss://relay.azzamo.net,wss://relay.snort.social,wss://relay.primal.net
 
+# How many events a backfill has to read before it counts as having read anything.
+#
+# A backfill asks every relay above for the whole history of four kinds; on a working
+# relay list that is thousands of events. Under this floor, discovery logs
+# `ERROR discovery starvation suspected` and /api/health answers 503 with
+# `discovery_starved: true` until the next backfill clears it.
+#
+# This exists because a RELAYS list missing the relay that carries the announcement
+# archive returned about thirty events per backfill for a year, reported ok=true every
+# time, and left the index at eight mints with every health signal green. Lower it only
+# for a private or test relay that genuinely holds less; 1 disables the check.
+#BACKFILL_MIN_EVENTS=200
+
 # Profile relays for the BUILD (kind 0, prerendered reviewer names on the home
 # page). A wider pool than RELAYS on purpose: relay.cashumints.space holds no kind
 # 0 at all and snort/primal hold almost none, so the two aggregators below are what
@@ -151,6 +169,12 @@ FEDIMINT_OBSERVER_URL=https://observer.fedimint.org/api/federations
 # which is the literal BACKEND.md behaviour and ranks noticeably worse.
 SCORE_PRIOR_MEAN=3
 
+# How many mints one address may submit to `POST /api/index` in an hour. Ten is several
+# times what any honest use of the review dialog needs; raise it while exercising the
+# whole flow end to end, which trips ten in about a minute. Behind a proxy, the limiter
+# can only tell visitors apart if `X-Forwarded-For` is forwarded (see README, "API").
+# INDEX_RATE_LIMIT=10
+
 # ─── Tooling ─────────────────────────────────────────────────────────────────
 
 # Dev server Boneyard captures against (`pnpm bones`). Defaults to WEB_PORT.

NOTES-LNURL.md

@@ -0,0 +1,350 @@
+# NOTES-LNURL.md
+
+What the LNURL mint endpoints **actually** return, recorded from the live reference
+instance `https://lnurl.21mint.me` on 2026-08-21 and from a locally run
+[dni/lnurl-mint](https://github.com/dni/lnurl-mint) (commit `a70cae1`) used to
+reproduce the states the live instance does not currently exhibit.
+
+Same rule as NOTES.md: where the software's README and the wire disagree, the wire
+wins, and the disagreement is written down rather than quietly resolved.
+
+---
+
+## 1. The probe endpoint: `GET /.well-known/lnurlw/{username}`
+
+**This is the LNURL equivalent of Cashu's `/v1/info`, and it is not the endpoint the
+brief expected.** Findings, in the order they mattered:
+
+### `/p` does not exist
+
+The brief (and older readings of the project) describe `GET /p` as the LUD-06
+payRequest carrying the `withdrawLink` mint advertisement. It is a **404** on the live
+instance:
+
+```
+$ curl -i https://lnurl.21mint.me/p
+HTTP/2 404
+content-type: application/json
+
+{"detail":"Not Found"}
+```
+
+The repository's own README says so explicitly — the LUD-16 well-known alias is
+"this mint's **only** payRequest entry point (no separate bare `/p`)" — and
+`router.py` registers no such route. `/p/cb` (the callback) exists; bare `/p` never
+did. Note the body shape: `{"detail":"Not Found"}` with a real 404 status is FastAPI's
+*unmatched route* handler. Every **registered** route answers errors as LNURL does
+instead (see §5), so this shape is a reliable "this software does not have that
+endpoint" signal.
+
+### Both well-known aliases answer, and only one carries the limits
+
+| Endpoint | Carries |
+| --- | --- |
+| `GET /.well-known/lnurlp/{username}` | LUD-06 payRequest: `minSendable`/`maxSendable`, `metadata`, `withdrawLink` |
+| `GET /.well-known/lnurlw/{username}` | LUD-03-shaped withdrawRequest: `minWithdrawable`/`maxWithdrawable`, `defaultDescription`, `mintPubkey`, `payLink`, node identity |
+
+`{username}` is the configured `USERNAME` (default `mint`) **or** the LUD-16 reserved
+bare-domain `_`. Both resolve to the identical mint identity; `_` is used as the probe
+path because it needs no prior knowledge of the operator's chosen username.
+
+**The chosen primary probe endpoint is `/.well-known/lnurlw/_`**, because it is the one
+carrying the withdraw limits, the description, and the mint's node identity — every
+field the site renders. `/.well-known/lnurlp/_` is fetched as a **fallback only**, when
+the withdraw side does not answer.
+
+### Live response, `/.well-known/lnurlw/_`
+
+```json
+{
+  "tag": "withdrawRequest",
+  "callback": "https://lnurl.21mint.me/w",
+  "minWithdrawable": 5000,
+  "maxWithdrawable": 999899000,
+  "defaultDescription": "lnurlcash bearer note on lnurl.21mint.me",
+  "mintPubkey": "021ab89df9cbd28cdab8c71d228ca40deba1eaebd827f24849ec4f3e919c023555",
+  "payLink": "https://lnurl.21mint.me/.well-known/lnurlp/mint",
+  "nodeAlias": "Azzamo",
+  "nodeUri": "021ab89df9cbd28cdab8c71d228ca40deba1eaebd827f24849ec4f3e919c023555@145.239.92.138:9736",
+  "nodeColor": "#68f442",
+  "nodeCapacity": 30027500000,
+  "nodeNumChannels": 8,
+  "nodeNumPeers": 18
+}
+```
+
+Headers: `server: nginx/1.22.1`, `content-type: application/json`. **No version header
+of any kind**, on this or any other endpoint.
+
+Notes on the fields:
+
+- **All amounts are millisatoshi.** `minWithdrawable: 5000` is 5 sat;
+  `maxWithdrawable: 999899000` is 999,899 sat. `nodeCapacity` is msat too
+  (30,027,500 sat here). Divide by 1000 for display.
+- `maxWithdrawable` is **fee-adjusted**: it is `MAX_SENDABLE_MSAT` minus the mint fee
+  at that amount (`router.max_mintable_msat`), not the raw setting. Likewise
+  `minWithdrawable` is `MIN_MINT_MSAT`. So these two numbers are the bounds a freshly
+  minted note's *value* can fall into — which is exactly what a reader wants — and not
+  the bounds of what they must *pay*. The payRequest's `minSendable`/`maxSendable` are
+  the pay-side numbers, and they differ (11,000 vs 10,000 msat locally, because of the
+  1000 msat base fee).
+- `defaultDescription` is always `"lnurlcash bearer note on {host}"` — generated, never
+  operator-written. Useful as a description fallback and nothing more; it says what the
+  software is, not what this mint is.
+- **`k1` is absent.** The model declares it `str | None = None`; its absence from the
+  wire is the first proof that `response_model_exclude_none = True` is in force
+  (`error_handler.py:26`). That matters for everything in §3.
+
+### Live response, `/.well-known/lnurlp/_`
+
+```json
+{
+  "tag": "payRequest",
+  "callback": "https://lnurl.21mint.me/p/cb",
+  "minSendable": 6000,
+  "maxSendable": 1000000000,
+  "metadata": "[[\"text/plain\", \"Mint an lnurlcash bearer note on lnurl.21mint.me\"], [\"text/identifier\", \"_@lnurl.21mint.me\"], [\"text/plain\", \"Mint fees: 1000,100\"]]",
+  "withdrawLink": "https://lnurl.21mint.me/w"
+}
+```
+
+- `metadata` is a **JSON-encoded string containing a JSON array** of `[mime, value]`
+  pairs — parse twice.
+- `text/identifier` **echoes the username actually queried**. Querying `_` returns
+  `_@lnurl.21mint.me`; querying `mint` returns `mint@lnurl.21mint.me`. So the probe
+  cannot read the operator's real username off the `_` response. It reads it off
+  `payLink` on the withdraw side instead (`…/lnurlp/mint` → username `mint`), which is
+  built from `settings.username` unconditionally.
+- The `Mint fees: <base_msat>,<ppm>` entry is present only when a fee is configured;
+  its absence means fee-free, per spec.
+
+---
+
+## 2. Every other endpoint, and what it is worth to a probe
+
+| Endpoint | Live result | Verdict |
+| --- | --- | --- |
+| `GET /` | 200, 13,804 bytes of HTML, `<title>21 lnurl-mint</title>` | Fetched **only** for the onion address (§4) |
+| `GET /openapi.json` | 200, `info.version` = `"0.1.0"`, `info.title` = `"lnurl-mint"` | **The only version source there is** (§6) |
+| `GET /docs` | 200, Swagger UI | Ignored |
+| `GET /w` (no `k1`) | 200 `{"status":"ERROR","reason":"Request validation error: Field required \`k1\`."}` | Ignored — never a mint advertisement |
+| `GET /w?k1=deadbeef` | 200 `{"status":"ERROR","reason":"Unknown note."}` | Ignored — per-note, not per-mint |
+| `GET /verify/{hash}` | 200 `{"status":"ERROR","reason":"Not found"}` | **Useless as a capability probe** (§5) |
+| `GET /p` | 404 `{"detail":"Not Found"}` | Does not exist |
+
+The site probes **`/.well-known/lnurlw/_`, then `/.well-known/lnurlp/_` on failure, and
+`GET /openapi.json` + `GET /` opportunistically**. Nothing else is fetched, and nothing
+that mutates state is ever called — `/p/cb` would make the mint issue a real invoice on
+every probe cycle, which is not a thing a directory gets to do to a stranger's node.
+
+---
+
+## 3. The degraded state: no funding source (**empirically reproduced**)
+
+The README: *"Without one, minting and melting are unavailable (rotate/split/merge of
+existing notes still work)."* The question was whether that is visible over HTTP. It is.
+
+`_mint_address_response` (`router.py:480`) only populates the node fields
+`if funding_source.backend:`, and wraps the lookup in `try/except` that logs and leaves
+them `None` on failure. With `response_model_exclude_none = True`, `None` fields are
+**omitted from the wire entirely**.
+
+Run locally with no `FUNDINGSOURCE_*` set at all:
+
+```
+$ curl http://127.0.0.1:8137/.well-known/lnurlw/_
+{"tag":"withdrawRequest","callback":"https://lnurl.test/w","minWithdrawable":10000,
+ "maxWithdrawable":999999000,"defaultDescription":"lnurlcash bearer note on lnurl.test",
+ "payLink":"https://lnurl.test/.well-known/lnurlp/mint"}
+```
+
+`mintPubkey`, `nodeAlias`, `nodeUri`, `nodeColor`, `nodeCapacity`, `nodeNumChannels`
+and `nodeNumPeers` are **all gone**. The response is otherwise a completely valid
+withdrawRequest with real limits — the mint is up, serving, and answering. Its startup
+log says the rest out loud:
+
+```
+WARNING:root:No funding source configured (FUNDINGSOURCE_BACKEND unset) -
+minting, melting, and offline verification are all unavailable.
+```
+
+`/.well-known/lnurlp/_` **still answers normally** in this state (200, full payRequest),
+so the pay side is *not* a degraded-state signal — only the withdraw side is.
+
+### The detection rule, and the honest thing to say about it
+
+> **`mintPubkey` absent from a valid mint-address response ⇒ no funding source is
+> reachable ⇒ minting and melting are unavailable right now.**
+
+One bit, and it necessarily conflates two causes:
+
+1. no funding source was ever configured, and
+2. one was configured but the node is unreachable at this moment (`except Exception`
+   above catches it and returns the same reduced response).
+
+They are **not distinguishable over HTTP**, and the site does not try. It does not need
+to: the user-facing consequence is identical in both cases — nothing moves in or out
+over Lightning until it comes back — and that is exactly what the warning says. Calling
+it "no funding source" specifically would be a guess; calling it "minting and melting
+unavailable" is the observation.
+
+The same bit also carries two other meanings, which is worth stating plainly because
+three site features read it:
+
+- it is the `signed-notes` capability (`signing.mint_pubkey` needs the same funding
+  source, and the README ties them: *"without a funding source, both fields are simply
+  omitted"*), and
+- it is the canonical `d` identifier for the Nostr announcement (see
+  `docs/KIND-LNURL-MINT.md`).
+
+That last one is why the `d` rule has to be sticky: a mint indexed while its node was
+up must not silently change identity because its node had a bad minute. See the doc.
+
+---
+
+## 4. Tor / onion: HTML only, and only over clearnet
+
+`ONION_URL` is **never** in any JSON response. It appears in exactly one place: the
+one-pager's "Also via Tor" block (`frontend._tor_section`), and only when the request
+did *not* arrive over the onion host itself (otherwise `public_base_url` already made
+the onion the primary and the block would be a duplicate). A clearnet probe is
+therefore the case where it does show.
+
+Reproduced locally with `ONION_URL` set:
+
+```html
+<h2>Also via Tor</h2>
+  <div class="qr">…</div>
+  <button class="copy" data-copy="LNURL1…" title="Copy LNURL">LNURL1…</button>
+  <button class="copy" data-copy="mint@abcdefgh….onion" title="Copy lightning address">⚡ mint@…onion</button>
+```
+
+Cheaply parseable: scan the `GET /` body for a `*.onion` host. The live instance
+advertises none, so `onion` is absent there.
+
+**Caveat worth recording:** the fixture address in lnurl-mint's own tests
+(`abcdefghijklmnop1234567890abcdefghijklmnop1234567890abcdefgh.onion`) contains
+`0`, `1`, `8` and `9`, which are **not in base32's alphabet** — it is not a valid v3
+address. A strict `[a-z2-7]{56}` matcher rejects it. The site's matcher is deliberately
+looser (`[a-z0-9]{16,60}\.onion`) so that a real-but-unusual address is still shown;
+nothing is fetched over Tor, so a wrong match costs a displayed string and nothing more.
+
+---
+
+## 5. LUD-21 verify is **not** probe-detectable (and why the site does not pretend)
+
+`VERIFY_ENABLED=false` makes `/verify/{payment_hash}` raise `HTTPException(404, "Not
+found")`. An *enabled* endpoint asked about a payment hash it has never seen raises
+`HTTPException(404, "Not found")` too. Both then pass through
+`LnurlErrorResponseHandler`, which converts any `HTTPException` into
+`200 {"status": "ERROR", "reason": <detail>}`.
+
+Measured, same binary, both settings:
+
+```
+VERIFY_ENABLED=true   →  200 {"status":"ERROR","reason":"Not found"}
+VERIFY_ENABLED=false  →  200 {"status":"ERROR","reason":"Not found"}
+```
+
+**Byte-identical.** There is no status code, no header, and no reason string that
+separates them.
+
+The only place a `verify` URL is genuinely advertised is the response of `/p/cb` — the
+pay callback — and calling that **creates a real Lightning invoice on the operator's
+node**. Doing that every ten minutes, forever, to every mint in the index, is not
+acceptable behaviour for a directory.
+
+**Resolution:** `lud21` is an **announcement-only** capability. The probe never sets it
+and never clears it. If an operator declares it in their `features` tag, the site shows
+it; otherwise the row is simply absent. This is written into
+`docs/KIND-LNURL-MINT.md` as a normative property of the vocabulary, not left as an
+implementation quirk.
+
+---
+
+## 6. Version: `/openapi.json`, and only there
+
+No `Server`, `X-Powered-By` or any other header identifies the software — nginx fronts
+it and reports only itself. The one-pager's `<title>` is operator-configurable
+(`settings.title`; the live instance sets `"21 lnurl-mint"`), so it identifies nothing
+reliably.
+
+FastAPI's generated `GET /openapi.json` carries both:
+
+```json
+{"info": {"title": "lnurl-mint",
+          "description": "Minimal lnurlcash (LUD-25, Lightning bearer assets) mint - LUD-03/LUD-06 only.",
+          "version": "0.1.0"}}
+```
+
+- `info.title` = `"lnurl-mint"` — a genuine software fingerprint, hardcoded in
+  `server.py`, not operator-settable.
+- `info.version` = `__version__`, resolved from installed package metadata
+  (`lnurl_mint/__init__.py`), falling back to `LNURL_MINT_VERSION` or
+  `"0.0.0+unknown"`.
+
+Two observed values: the live instance reports `0.1.0`; a source checkout with no
+installed metadata reports `0.0.0+unknown`. The site stores `lnurl-mint/<version>`,
+and treats a `0.0.0+unknown` as **no version** rather than displaying it — it is the
+library's "I don't know" sentinel, not a release.
+
+The live instance still serves `/docs` from a jsdelivr CDN, whereas HEAD (`a70cae1`,
+*"report real version in openapi, vendor swagger ui for /docs"*) vendors it. So the
+deployed build predates that commit, and its `0.1.0` is the pre-commit hardcoded value.
+Recorded because it means **a version string from this endpoint is a weak signal**: it
+was not always wired to the real package version.
+
+---
+
+## 7. Error convention, and what "online" must therefore mean
+
+Every **registered** route returns HTTP **200** for its errors, with an LNURL body:
+
+```json
+{"status": "ERROR", "reason": "…"}
+```
+
+Only an **unregistered path** gives a real 404 (`{"detail":"Not Found"}`).
+
+Consequence, and it is the single most important parsing rule here: **HTTP 200 does not
+mean the mint is up.** A probe that stopped at the status code would call every
+misconfigured host, every `Unknown user.`, and every wrong-path hit "online".
+
+So the site's online test is on the parsed body, never the status:
+
+- `tag == "withdrawRequest"` **and** numeric `minWithdrawable`/`maxWithdrawable` → online
+  (or degraded, per §3);
+- `tag == "payRequest"` with numeric `minSendable`/`maxSendable` (fallback endpoint) → online;
+- anything else that parses as JSON — including `{"status":"ERROR"}` — → **invalid**, a
+  distinct third outcome that is neither online nor offline. It renders the
+  "Endpoint responding but invalid" banner, because a host that answers with something
+  that is not a mint advertisement is a different problem from a host that does not
+  answer at all.
+
+---
+
+## 8. Summary of what the endpoints expose beyond the withdraw params
+
+Everything below is real, observed, and stored in `ecosystem_json`:
+
+| Field | Source | Used for |
+| --- | --- | --- |
+| `mintPubkey` | lnurlw | `d` identifier, `signed-notes` feature, degraded detection, sidebar row |
+| `payLink` | lnurlw | Deriving the LUD-16 lightning address (`{username}@{host}`) |
+| `nodeAlias` | lnurlw | Identity header fallback name |
+| `nodeUri` | lnurlw | `pubkey@host:port` — the sidebar's node connect string |
+| `nodeColor` | lnurlw | Not rendered (a node's own colour is not this site's palette) |
+| `nodeCapacity` | lnurlw | msat, publicly announced channel capacity — sidebar |
+| `nodeNumChannels` / `nodeNumPeers` | lnurlw | Sidebar |
+| `defaultDescription` | lnurlw | Description fallback |
+| `minSendable` / `maxSendable` | lnurlp | Pay-side limits, distinct from withdraw limits |
+| `metadata` → `text/plain` | lnurlp | Description fallback, ranked above `defaultDescription` |
+| `metadata` → `text/identifier` | lnurlp | Confirms the lightning address |
+| `metadata` → `Mint fees:` | lnurlp | Mint fee disclosure (base msat, ppm) |
+| `info.version` / `info.title` | openapi | Software cell |
+| `*.onion` | `GET /` HTML | `onion` feature, sidebar row |
+
+`nodeCapacity` is explicitly the **publicly announced** capacity only — lnurl-mint
+sources it from the public graph (`lnd GetNodeInfo` / `cln listchannels`), never from a
+private `listfunds`/`ListChannels` view. Displaying it discloses nothing the node's own
+gossip does not already.

NOTES.md

@@ -130,6 +130,38 @@ are matched by bare domain (too loose, a review of `mint.minibits.cash/Bitcoin`
 `mint.minibits.cash/Anything`). The new backend fixes both directions: one normalizer, path is part
 of identity, applied to mints and reviews alike (see `api/src/normalize.ts`).
 
+### The slug is deterministic, not reversible
+
+Found while building on-demand indexing (`POST /api/index`), which is the first thing that
+has to turn a *page address* back into a *mint address* rather than the other way round.
+
+`mint.example.com/Bitcoin` slugs to `mint.example.com-bitcoin`, and so would a mint whose
+hostname really is `mint.example.com-bitcoin`. Looking a row up is unaffected — both
+spellings are stored, and the slug column is what the lookup uses — but *indexing* from a
+slug means opening a socket to whatever it decodes to, and guessing wrong there means
+probing, and possibly listing, somebody else's server.
+
+So `addressFromSlug` (shared/src/indexing.ts) only derives an address from the one
+unambiguous shape: a plain hostname, optionally with the `-3338` port suffix. Anything
+else returns null and the 404 page says it cannot work the address out from the link
+alone, offering the dialog where a reader can paste the full URL including its path.
+The `lnurl-` collision prefix is deliberately *not* stripped there either: a slug only
+takes that prefix at insert time, so a link carrying one describes a row that already
+exists and never reaches that code, while a hostname that merely begins `lnurl-` is a
+real possibility.
+
+Two URL shapes that fought the normalizer while testing this, both now covered by
+`api/src/check-index.ts`:
+
+- **The port suffix round trip.** `https://smilemoji.cash:3338` slugs to
+  `smilemoji.cash-3338`, which reads as a hostname with a trailing number until you know
+  the rule. The derivation has to put the colon back, and only for a 2 to 5 digit tail.
+- **Case, scheme and trailing slash together.** `MINT.600.WTF`, `http://mint.600.wtf`,
+  `mint.600.wtf/` and `https://mint.600.wtf:443/` are one mint, and the endpoint has to
+  answer "already indexed" for all four rather than creating a second row. They collapse
+  in `normalizeMintUrl`, before the row is looked up and before the in-flight map is
+  keyed, which is what makes the dedup and the lookup agree.
+
 ## Old scoring
 
 `src/hooks/usePopularMints.ts`:

api/package.json

@@ -4,14 +4,17 @@
   "private": true,
   "type": "module",
   "scripts": {
-    "dev": "node --env-file-if-exists=../.env --experimental-strip-types --watch src/index.ts",
-    "start": "node --env-file-if-exists=../.env --experimental-strip-types src/index.ts",
-    "seed": "node --env-file-if-exists=../.env --experimental-strip-types src/seed.ts",
-    "migrate": "node --env-file-if-exists=../.env --experimental-strip-types src/migrate.ts",
+    "build": "tsc -p tsconfig.json",
+    "dev": "node --env-file-if-exists=../.env --watch src/index.ts",
+    "start": "node --env-file-if-exists=../.env dist/index.js",
+    "seed": "node --env-file-if-exists=../.env src/seed.ts",
+    "migrate": "node --env-file-if-exists=../.env src/migrate.ts",
     "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "node --env-file-if-exists=../.env --experimental-strip-types src/check.ts",
-    "test:warnings": "node --env-file-if-exists=../.env --experimental-strip-types src/check-warnings.ts",
-    "test:offline": "node --env-file-if-exists=../.env --experimental-strip-types src/check-offline.ts"
+    "test": "node --env-file-if-exists=../.env src/check.ts",
+    "test:warnings": "node --env-file-if-exists=../.env src/check-warnings.ts",
+    "test:offline": "node --env-file-if-exists=../.env src/check-offline.ts",
+    "test:lnurl": "node --env-file-if-exists=../.env src/check-lnurl.ts",
+    "test:index": "node src/check-index.ts"
   },
   "dependencies": {
     "@cashumints/shared": "workspace:*",

api/src/announce.ts

@@ -0,0 +1,253 @@
+/**
+ * Publishing `kind:38174` announcements for LNURL mints this indexer has confirmed.
+ *
+ * **This writes to public relays.** Nostr has no delete that anyone is obliged to
+ * honour, so an event published here is on the network permanently, signed by this
+ * site's key and attributed to it. That is the whole reason for the gating below, and
+ * the reason it is two switches rather than one.
+ *
+ * Why publish at all: 38174 is a proposed kind (see `docs/KIND-LNURL-MINT.md`) and a
+ * proposed kind with no events is a document rather than a protocol. An indexer that
+ * has already probed a mint and confirmed what it serves is the one party in a position
+ * to put honest announcements on the network before any operator has heard of the kind.
+ *
+ * ## What is announced, and what deliberately is not
+ *
+ * Only what the probe actually **observed**. The vocabulary has eleven values; this
+ * publishes at most seven of them, and the four it never publishes are the point:
+ *
+ *   - `rotate`, `split`, `merge` — these are only provable by calling `/w/cb`, which
+ *     mutates or destroys a note. Not probeable, not published, even though the one
+ *     implementation in existence supports all three unconditionally. Inferring them
+ *     from a version string would be publishing a guess under this site's signature.
+ *   - `lud21` — genuinely undetectable: verify-disabled and unknown-payment-hash return
+ *     byte-identical responses. See NOTES-LNURL.md §5.
+ *
+ * An operator's own announcement can and should claim more; theirs is a statement about
+ * what they built, this is a statement about what was seen. When both exist the newer
+ * `created_at` wins, which is normal addressable-event behaviour and means an operator
+ * takes over their own listing simply by publishing one.
+ */
+import { finalizeEvent, getPublicKey, type EventTemplate } from 'nostr-tools/pure';
+import { SimplePool } from 'nostr-tools/pool';
+import * as nip19 from 'nostr-tools/nip19';
+import {
+  KIND_LNURL_ANNOUNCEMENT, lnurlIdentifier, observedFeatures, type LnurlFields,
+} from '@cashumints/shared';
+import { announceConfig } from './config.ts';
+import { getDb, getState, setState } from './db.ts';
+import { log } from './log.ts';
+import { parseEcosystem, type MintRow } from './mints.ts';
+
+/**
+ * Republish interval.
+ *
+ * An addressable event is replaced, not duplicated, so republishing is cheap — but it
+ * is still traffic to somebody else's relay and a new `created_at` on every cycle would
+ * make this site's announcement permanently outrank an operator's own. Content changes
+ * are published immediately; an unchanged announcement is refreshed once a week, which
+ * keeps it from ageing out of relays that prune.
+ */
+const REPUBLISH_AFTER_S = 7 * 24 * 60 * 60;
+
+/** State-table key holding what was last published for one mint, and when. */
+const stateKey = (url: string): string => `announce:${url}`;
+
+/**
+ * The secret key to sign with, as 32 bytes.
+ *
+ * Accepts an `nsec1…` or bare hex. Returns null — with a loud log line rather than a
+ * throw — for anything else: a misconfigured key must stop announcements and must not
+ * stop the indexer, which has a directory to serve either way.
+ */
+export function parseAnnounceKey(raw: string): Uint8Array | null {
+  const value = raw.trim();
+  if (!value) return null;
+
+  if (value.startsWith('nsec1')) {
+    try {
+      const decoded = nip19.decode(value);
+      if (decoded.type === 'nsec') return decoded.data;
+    } catch {
+      return null;
+    }
+    return null;
+  }
+
+  if (!/^[0-9a-f]{64}$/i.test(value)) return null;
+  return Uint8Array.from(Buffer.from(value, 'hex'));
+}
+
+/**
+ * The `features` this site is willing to sign for, from one mint's stored probe.
+ *
+ * Thin, and deliberately: the rule about what a probe may claim lives in
+ * `observedFeatures` in shared/, next to the vocabulary it draws from, so the list the
+ * page renders and the list this signs cannot drift apart. See that function for why
+ * `rotate`, `split`, `merge` and `lud21` are never among them.
+ */
+export function announcedFeatures(fields: LnurlFields): string[] {
+  return observedFeatures({
+    fundingAvailable: fields.funding_available,
+    maxWithdrawableMsat: fields.max_withdrawable_msat,
+    maxSendableMsat: fields.max_sendable_msat,
+    lightningAddress: fields.lightning_address,
+    mintPubkey: fields.mint_pubkey,
+    onionUrl: fields.onion_url,
+  });
+}
+
+/** The event this site would publish for one confirmed LNURL mint. */
+export function announcementTemplate(
+  row: MintRow,
+  fields: LnurlFields,
+  createdAt: number,
+): EventTemplate {
+  const tags: string[][] = [
+    ['d', lnurlIdentifier(fields.base_url, fields.mint_pubkey)],
+    ['u', fields.base_url],
+  ];
+
+  const features = announcedFeatures(fields);
+  if (features.length > 0) tags.push(['features', features.join(',')]);
+  // Only when the mint said so. Absent reads as mainnet per the kind document, and
+  // asserting mainnet on a mint that never claimed a network would be this site
+  // inventing the one fact that decides whether the money is real.
+  if (fields.network) tags.push(['n', fields.network]);
+
+  /*
+   * `content` is left empty unless the mint published a name of its own.
+   *
+   * Empty content means "use the publisher's kind 0", per NIP-87 and the kind document
+   * — and the publisher here is this site, whose kind 0 is this site. That is the
+   * honest default for an announcement this site wrote: it is not the mint speaking.
+   * A name the mint itself served (its node alias) is worth passing on, and nothing else
+   * from the row is, because everything else came from a previous announcement.
+   */
+  const content = row.name ? JSON.stringify({ name: row.name }) : '';
+
+  return { kind: KIND_LNURL_ANNOUNCEMENT, created_at: createdAt, tags, content };
+}
+
+/** Stable fingerprint of an announcement's meaning, for the change detector. */
+function fingerprint(template: EventTemplate): string {
+  return JSON.stringify([template.tags, template.content]);
+}
+
+/**
+ * Which rows are eligible.
+ *
+ * Confirmed by probing, and only that: `status = 'online'` with a base URL and a
+ * withdraw ceiling means an advertisement genuinely parsed at some point. A mint that
+ * has never answered, is offline, or is only "responding but invalid" is never
+ * announced — this site does not put its signature on the existence of something it has
+ * not seen.
+ *
+ * A `degraded-funding` mint **is** announced: it is up and serving, and the reduced
+ * `features` list already tells the whole story.
+ */
+function eligible(row: MintRow, fields: LnurlFields | null): fields is LnurlFields {
+  if (row.type !== 'lnurl' || row.status !== 'online') return false;
+  if (!fields?.base_url) return false;
+  if (fields.invalid_reason) return false;
+  return fields.max_withdrawable_msat !== null;
+}
+
+export interface AnnounceResult {
+  eligible: number;
+  published: number;
+  skipped: number;
+  failed: number;
+}
+
+/**
+ * Publish an announcement for every confirmed LNURL mint that needs one.
+ *
+ * Returns counts rather than throwing: a relay refusing an event is not a reason for a
+ * probe cycle to fail. Does nothing at all, and says why once, when announcing is off —
+ * which is the default and is how every deployment that has not opted in behaves.
+ */
+export async function announceLnurlMints(
+  now = Math.floor(Date.now() / 1000),
+): Promise<AnnounceResult> {
+  const empty: AnnounceResult = { eligible: 0, published: 0, skipped: 0, failed: 0 };
+  const settings = announceConfig();
+  if (!settings) return empty;
+
+  const secret = parseAnnounceKey(settings.secretKey);
+  if (!secret) {
+    log.error('announce disabled: ANNOUNCE_KEY is not an nsec or 64 hex characters');
+    return empty;
+  }
+
+  const db = await getDb();
+  const rows = await db.all<MintRow>(`SELECT * FROM mints WHERE type = 'lnurl'`);
+
+  const pool = new SimplePool();
+  const result: AnnounceResult = { ...empty };
+
+  try {
+    for (const row of rows) {
+      const fields = parseEcosystem<LnurlFields>(row);
+      if (!eligible(row, fields)) continue;
+      result.eligible++;
+
+      const template = announcementTemplate(row, fields, now);
+      const mark = fingerprint(template);
+
+      const previous = await getState(stateKey(row.url));
+      if (previous) {
+        try {
+          const { mark: lastMark, at } = JSON.parse(previous) as { mark: string; at: number };
+          if (lastMark === mark && now - at < REPUBLISH_AFTER_S) {
+            result.skipped++;
+            continue;
+          }
+        } catch {
+          // Unreadable marker: republish, which is the safe direction.
+        }
+      }
+
+      const event = finalizeEvent(template, secret);
+
+      /*
+       * `Promise.allSettled`, not `Promise.all`: one relay refusing the event (rate
+       * limits, a paid-relay policy, a write it does not accept) must not stop the
+       * others from taking it. One acceptance is a successful publish.
+       */
+      const outcomes = await Promise.allSettled(pool.publish(settings.relays, event));
+      const accepted = outcomes.filter((o) => o.status === 'fulfilled').length;
+
+      if (accepted === 0) {
+        result.failed++;
+        log.warn('announcement rejected by every relay', {
+          url: row.url,
+          d: template.tags[0]?.[1],
+          relays: settings.relays.length,
+        });
+        continue;
+      }
+
+      await setState(stateKey(row.url), JSON.stringify({ mark, at: now }));
+      result.published++;
+      log.info('announced lnurl mint', {
+        url: row.url,
+        d: template.tags[0]?.[1],
+        features: template.tags.find((t) => t[0] === 'features')?.[1] ?? '',
+        relays: `${accepted}/${settings.relays.length}`,
+        event: event.id,
+      });
+    }
+  } finally {
+    try {
+      pool.close(settings.relays);
+    } catch {
+      // A relay that is already gone throws on close. Nothing to do about it.
+    }
+  }
+
+  if (result.eligible > 0) {
+    log.info('announce cycle', { ...result, pubkey: getPublicKey(secret) });
+  }
+  return result;
+}

api/src/check-index.ts

@@ -0,0 +1,474 @@
+/**
+ * pnpm --filter ./api test:index
+ *
+ * The checks for on-demand indexing (`POST /api/index`). Same shape as `check.ts`: no
+ * framework, throws on the first failure, prints a count.
+ *
+ * Three things are being defended here, and they are in descending order of how bad it
+ * would be to get them wrong:
+ *
+ *   1. **SSRF.** This is the one endpoint that fetches an address a stranger chose, so
+ *      every refusal it makes is asserted against a resolver and a fetch that this file
+ *      controls. Nothing here touches the network: a rule that can only be exercised by
+ *      pointing the test at a real host is a rule that stops being exercised the first
+ *      time CI runs offline.
+ *   2. **Slug collapse.** Two spellings of one mint must never become two rows with half
+ *      its reviews on each. That is the bug the normalizer was written for, and this
+ *      endpoint is a new way to reintroduce it — a reader can now type the spelling
+ *      discovery never saw.
+ *   3. **Invite decoding**, which is what makes a Fedimint submission possible at all.
+ */
+import assert from 'node:assert/strict';
+import {
+  checkIndexInput,
+  federationIdFromInviteCode,
+  isNut06Info,
+  isPrivateIpAddress,
+  lnurlKey,
+  normalizeMintUrl,
+  typeForPath,
+} from '@cashumints/shared';
+import { checkDestination, safeFetchText, type FetchDeps } from './safe-fetch.ts';
+import { RATE_LIMIT, resetRateLimits, takeToken } from './rate-limit.ts';
+
+/** A real code off the relay pool, the same one `check.ts` parses an announcement from. */
+const REAL_INVITE =
+  'fed11qvqzggnhwden5te0v9cxjtn9vd3jue3wvfkxjmnyva6kzunyd9skutnwv46z7qqqzc28wumn8ghj7' +
+  'end9e3hgunz9e5k7tmhwvhszqfq4m9xejq0l3fsh5k4fvyks8mwmwdyzhpk9e909l3atczpxuqxlgss2f35eg';
+
+let checks = 0;
+function check(name: string, fn: () => void): void {
+  try {
+    fn();
+    checks++;
+  } catch (err) {
+    console.error(`FAIL: ${name}`);
+    throw err;
+  }
+}
+
+async function checkAsync(name: string, fn: () => Promise<void>): Promise<void> {
+  try {
+    await fn();
+    checks++;
+  } catch (err) {
+    console.error(`FAIL: ${name}`);
+    throw err;
+  }
+}
+
+/* ---------- address rules ---------- */
+
+check('every private, loopback and link-local range is refused', () => {
+  for (const address of [
+    '127.0.0.1', '127.1.2.3', '10.0.0.1', '10.255.255.255',
+    '172.16.0.1', '172.20.10.5', '172.31.255.255',
+    '192.168.0.1', '192.168.1.5',
+    '169.254.169.254',        // the cloud metadata endpoint, the reason this exists
+    '0.0.0.0', '100.64.0.1',  // this-network and carrier-grade NAT
+    '224.0.0.1', '255.255.255.255',
+    '::1', '::', 'fe80::1', 'fc00::1', 'fd12:3456::1', '::ffff:127.0.0.1', '::ffff:10.0.0.1',
+  ]) {
+    assert.equal(isPrivateIpAddress(address), true, `${address} must be refused`);
+  }
+});
+
+check('ordinary public addresses are not', () => {
+  for (const address of ['1.1.1.1', '8.8.8.8', '157.245.26.63', '172.15.0.1', '172.32.0.1', '2606:4700::1111']) {
+    assert.equal(isPrivateIpAddress(address), false, `${address} must be allowed`);
+  }
+});
+
+await checkAsync('a URL whose hostname is a private literal never reaches DNS', async () => {
+  // If any of these consulted the resolver, this one would throw rather than answer.
+  const explode: FetchDeps = {
+    resolve: () => {
+      throw new Error('a literal address must not be resolved');
+    },
+  };
+
+  for (const url of [
+    'https://127.0.0.1/v1/info',
+    'https://10.0.0.1/v1/info',
+    'https://172.16.4.4/v1/info',
+    'https://192.168.1.5/v1/info',
+    'https://169.254.169.254/latest/meta-data/',
+    'https://[::1]/v1/info',
+    'https://localhost/v1/info',
+    'https://mint.local/v1/info',
+    'https://abcdefghij234567.onion/v1/info',
+  ]) {
+    const verdict = await checkDestination(new URL(url), explode);
+    assert.equal(verdict?.kind, 'blocked', `${url} must be refused`);
+  }
+});
+
+await checkAsync('a public-looking name that resolves privately is refused', async () => {
+  const deps: FetchDeps = { resolve: async () => ['10.0.0.5'] };
+  const verdict = await checkDestination(new URL('https://internal.example.com'), deps);
+  assert.equal(verdict?.kind, 'blocked');
+
+  // One private answer among several is enough: the socket would pick one of them.
+  const mixed: FetchDeps = { resolve: async () => ['93.184.216.34', '127.0.0.1'] };
+  assert.equal((await checkDestination(new URL('https://mixed.example.com'), mixed))?.kind, 'blocked');
+
+  const public_: FetchDeps = { resolve: async () => ['93.184.216.34'] };
+  assert.equal(await checkDestination(new URL('https://mint.example.com'), public_), null);
+});
+
+await checkAsync('a name that does not resolve is unresolved, not blocked', async () => {
+  // The distinction the rugged-mint case turns on: a mint whose operator let the domain
+  // lapse must reach the Nostr lookup, not be rejected as an inadmissible address.
+  const gone: FetchDeps = { resolve: async () => null };
+  const verdict = await checkDestination(new URL('https://gone.example.com'), gone);
+  assert.equal(verdict?.kind, 'unresolved');
+
+  const outcome = await safeFetchText(
+    'https://gone.example.com/v1/info',
+    { accept: 'application/json' },
+    { ...gone, fetchImpl: (() => { throw new Error('must not connect'); }) as unknown as typeof fetch },
+  );
+  assert.equal(outcome.state, 'unreachable');
+});
+
+await checkAsync('http is refused outright: this endpoint is https only', async () => {
+  assert.equal((await checkDestination(new URL('http://mint.example.com')))?.kind, 'blocked');
+  assert.equal((await checkDestination(new URL('ftp://mint.example.com')))?.kind, 'blocked');
+});
+
+/* ---------- redirects ---------- */
+
+/** A fetch that answers from a table, and records every URL it was asked for. */
+function scriptedFetch(routes: Record<string, Response>): { fetch: typeof fetch; seen: string[] } {
+  const seen: string[] = [];
+  const impl = (async (input: unknown): Promise<Response> => {
+    const url = String(input);
+    seen.push(url);
+    const res = routes[url];
+    if (!res) throw new Error(`unexpected fetch of ${url}`);
+    return res;
+  }) as typeof fetch;
+  return { fetch: impl, seen };
+}
+
+await checkAsync('a redirect to a private address is refused before it is fetched', async () => {
+  const { fetch: impl, seen } = scriptedFetch({
+    'https://mint.example.com/v1/info': new Response(null, {
+      status: 302,
+      headers: { location: 'https://169.254.169.254/latest/meta-data/' },
+    }),
+  });
+
+  const outcome = await safeFetchText(
+    'https://mint.example.com/v1/info',
+    { accept: 'application/json' },
+    { fetchImpl: impl, resolve: async () => ['93.184.216.34'] },
+  );
+
+  assert.equal(outcome.state, 'blocked');
+  assert.match(outcome.state === 'blocked' ? outcome.reason : '', /redirected/);
+  // The crux: the metadata endpoint was never connected to, only reasoned about.
+  assert.deepEqual(seen, ['https://mint.example.com/v1/info']);
+});
+
+await checkAsync('a redirect to a name that resolves privately is refused too', async () => {
+  const { fetch: impl, seen } = scriptedFetch({
+    'https://mint.example.com/v1/info': new Response(null, {
+      status: 301,
+      headers: { location: 'https://internal.example.com/v1/info' },
+    }),
+  });
+
+  const outcome = await safeFetchText(
+    'https://mint.example.com/v1/info',
+    { accept: 'application/json' },
+    {
+      fetchImpl: impl,
+      resolve: async (host) => (host === 'mint.example.com' ? ['93.184.216.34'] : ['10.1.2.3']),
+    },
+  );
+
+  assert.equal(outcome.state, 'blocked');
+  assert.equal(seen.length, 1, 'the private hop must never be fetched');
+});
+
+await checkAsync('two redirects are followed, a third is not', async () => {
+  const ok = { 'content-type': 'application/json' };
+  const routes: Record<string, Response> = {
+    'https://a.example.com/v1/info': new Response(null, {
+      status: 302,
+      headers: { location: 'https://b.example.com/v1/info' },
+    }),
+    'https://b.example.com/v1/info': new Response(null, {
+      status: 302,
+      headers: { location: 'https://c.example.com/v1/info' },
+    }),
+    'https://c.example.com/v1/info': new Response('{"name":"ok"}', { headers: ok }),
+  };
+  const deps = { resolve: async () => ['93.184.216.34'] };
+
+  const two = await safeFetchText(
+    'https://a.example.com/v1/info',
+    { accept: 'application/json' },
+    { ...deps, fetchImpl: scriptedFetch(routes).fetch },
+  );
+  assert.equal(two.state, 'ok', 'two hops are within the cap');
+
+  const deeper = {
+    ...routes,
+    'https://c.example.com/v1/info': new Response(null, {
+      status: 302,
+      headers: { location: 'https://d.example.com/v1/info' },
+    }),
+  };
+  const three = scriptedFetch(deeper);
+  const over = await safeFetchText(
+    'https://a.example.com/v1/info',
+    { accept: 'application/json' },
+    { ...deps, fetchImpl: three.fetch },
+  );
+  assert.equal(over.state, 'unreachable');
+  assert.equal(three.seen.length, 3, 'the fourth address is never fetched');
+});
+
+await checkAsync('a body over the cap and a body of the wrong type are both refused', async () => {
+  const deps = { resolve: async () => ['93.184.216.34'] };
+
+  const big = scriptedFetch({
+    'https://mint.example.com/v1/info': new Response('x'.repeat(2048), {
+      headers: { 'content-type': 'application/json' },
+    }),
+  });
+  const capped = await safeFetchText(
+    'https://mint.example.com/v1/info',
+    { accept: 'application/json', maxBytes: 512 },
+    { ...deps, fetchImpl: big.fetch },
+  );
+  assert.equal(capped.state, 'unreachable');
+
+  const image = scriptedFetch({
+    'https://mint.example.com/v1/info': new Response('\x89PNG', {
+      headers: { 'content-type': 'image/png' },
+    }),
+  });
+  const wrongType = await safeFetchText(
+    'https://mint.example.com/v1/info',
+    { accept: 'application/json' },
+    { ...deps, fetchImpl: image.fetch },
+  );
+  assert.equal(wrongType.state, 'unreachable');
+  assert.match(wrongType.state === 'unreachable' ? wrongType.reason : '', /content type/);
+});
+
+/* ---------- slug collapse ---------- */
+
+check('every spelling of one mint collapses to one row key', () => {
+  const spellings = [
+    'https://mint.600.wtf',
+    'mint.600.wtf',
+    'mint.600.wtf/',
+    'https://mint.600.wtf/',
+    'https://MINT.600.WTF',
+    'http://mint.600.wtf',
+    'https://mint.600.wtf:443/',
+    '  https://mint.600.wtf/  ',
+  ].map((raw) => normalizeMintUrl(raw));
+
+  const urls = new Set(spellings.map((s) => s?.url));
+  const hosts = new Set(spellings.map((s) => s?.host));
+  assert.equal(urls.size, 1, `one canonical URL, got ${[...urls].join(', ')}`);
+  assert.equal(hosts.size, 1, `one routing slug, got ${[...hosts].join(', ')}`);
+  assert.equal([...urls][0], 'https://mint.600.wtf');
+  assert.equal([...hosts][0], 'mint.600.wtf');
+
+  // And the LNURL row key derived from it is one value too, since that is what the
+  // endpoint actually looks the row up by.
+  assert.equal(new Set(spellings.map((s) => lnurlKey(s!.url))).size, 1);
+});
+
+check('a path is still part of a mint identity, and still collapses per path', () => {
+  const withPath = ['https://mint.example.com/Bitcoin', 'mint.example.com/Bitcoin/'].map((raw) =>
+    normalizeMintUrl(raw),
+  );
+  assert.equal(new Set(withPath.map((s) => s?.url)).size, 1);
+  assert.notEqual(withPath[0]?.url, normalizeMintUrl('https://mint.example.com')?.url);
+});
+
+/* ---------- what the browser checks before it asks ---------- */
+
+check('the client-side pre-check accepts what the normalizer accepts', () => {
+  assert.deepEqual(checkIndexInput('lnurl', 'mint.600.wtf'), {
+    ok: true,
+    value: 'https://mint.600.wtf',
+  });
+  assert.deepEqual(checkIndexInput('cashu', ' https://21mint.me/ '), {
+    ok: true,
+    value: 'https://21mint.me',
+  });
+
+  assert.deepEqual(checkIndexInput('cashu', ''), { ok: false, reason: 'empty' });
+  assert.deepEqual(checkIndexInput('cashu', 'not a url at all'), { ok: false, reason: 'bad_url' });
+  // A private address fails the pre-check for the same reason the server refuses it.
+  assert.deepEqual(checkIndexInput('cashu', 'http://127.0.0.1:3338'), {
+    ok: false,
+    reason: 'bad_url',
+  });
+});
+
+check('an invite code pasted into a URL field is named as an invite code', () => {
+  const code = REAL_INVITE;
+  assert.deepEqual(checkIndexInput('cashu', code), { ok: false, reason: 'bad_invite' });
+  assert.deepEqual(checkIndexInput('lnurl', code), { ok: false, reason: 'bad_invite' });
+  assert.deepEqual(checkIndexInput('fedimint', code), { ok: true, value: code });
+  assert.deepEqual(checkIndexInput('fedimint', 'https://mint.example.com'), {
+    ok: false,
+    reason: 'bad_invite',
+  });
+});
+
+/* ---------- invite codes ---------- */
+
+check('a real invite code yields the federation id its announcement carries', () => {
+  // The `d` tag of the announcement this code came in: decoding must agree with it, or
+  // a federation submitted by code would get a second row beside the announced one.
+  assert.equal(
+    federationIdFromInviteCode(REAL_INVITE),
+    'aeca6cc80ffc530bd2d54b09681f6edb9a415c362e4af2fe3d5e04137006fa21',
+  );
+  assert.equal(federationIdFromInviteCode(REAL_INVITE.toUpperCase()), federationIdFromInviteCode(REAL_INVITE));
+});
+
+check('anything that is not an invite code decodes to nothing', () => {
+  for (const junk of [
+    '',
+    'fed1',
+    'fed11',
+    'https://mint.example.com',
+    `${REAL_INVITE}x`,                                   // checksum fails
+    REAL_INVITE.slice(0, -1),                            // truncated
+    REAL_INVITE.replace('fed11q', 'fed11p'),             // one flipped character
+    'lnbc1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq', // valid-ish bech32, wrong hrp
+  ]) {
+    assert.equal(federationIdFromInviteCode(junk), null, `${junk.slice(0, 24)} must not decode`);
+  }
+});
+
+/* ---------- what counts as a mint ---------- */
+
+check('a NUT-06 document is told apart from an arbitrary JSON endpoint', () => {
+  assert.ok(isNut06Info({ nuts: { '4': { methods: [] } } }));
+  assert.ok(isNut06Info({ pubkey: '03c21ef6'.padEnd(66, 'a'), name: 'x' }));
+  assert.ok(isNut06Info({ name: 'Some mint', version: 'cdk-mintd/0.17.5' }));
+
+  // The shapes a host that is not a mint actually answers with.
+  assert.ok(!isNut06Info({ status: 'ok' }));
+  assert.ok(!isNut06Info({ detail: 'Not Found' }));
+  assert.ok(!isNut06Info({ tag: 'withdrawRequest', minWithdrawable: 1 }));
+  assert.ok(!isNut06Info([]));
+  assert.ok(!isNut06Info('hello'));
+  assert.ok(!isNut06Info(null));
+  assert.ok(!isNut06Info({ nuts: {} }), 'an empty nuts object proves nothing');
+});
+
+/* ---------- rate limiting ---------- */
+
+check('the eleventh submission in an hour is refused, and refusals do not extend it', () => {
+  resetRateLimits();
+  const now = 1_800_000_000_000;
+
+  for (let i = 0; i < RATE_LIMIT; i++) {
+    assert.equal(takeToken('1.2.3.4', now + i).ok, true, `submission ${i + 1} must be allowed`);
+  }
+
+  const refused = takeToken('1.2.3.4', now + RATE_LIMIT);
+  assert.equal(refused.ok, false);
+  assert.ok(refused.retryAfter > 0 && refused.retryAfter <= 3600);
+
+  // Pressing the button again must not push the window out.
+  const again = takeToken('1.2.3.4', now + RATE_LIMIT + 1000);
+  assert.ok(again.retryAfter <= refused.retryAfter, 'a refusal must not extend the wait');
+
+  // A different address has its own budget.
+  assert.equal(takeToken('5.6.7.8', now + RATE_LIMIT).ok, true);
+
+  // An hour later the window has slid past the first submission.
+  assert.equal(takeToken('1.2.3.4', now + 3_600_001).ok, true);
+  resetRateLimits();
+});
+
+/* ---------- the deep-link routes ---------- */
+
+check('every deep link shape maps to the ecosystem that owns it', () => {
+  assert.deepEqual(typeForPath('/mint/mint.600.wtf'), { type: 'cashu', host: 'mint.600.wtf' });
+  assert.deepEqual(typeForPath('/lnurl-mint/mint.600.wtf'), { type: 'lnurl', host: 'mint.600.wtf' });
+  assert.deepEqual(typeForPath('/fedimint/fed-aeca6cc80ffc530b'), {
+    type: 'fedimint',
+    host: 'fed-aeca6cc80ffc530b',
+  });
+  // A trailing slash is the same page; anything else is not a mint page at all.
+  assert.deepEqual(typeForPath('/mint/x.example.com/'), { type: 'cashu', host: 'x.example.com' });
+  assert.equal(typeForPath('/mints'), null);
+  assert.equal(typeForPath('/'), null);
+  assert.equal(typeForPath('/mint/'), null);
+});
+
+/* ---------- one submission, one row ---------- */
+
+/*
+ * The dedup and the write path, against a throwaway in-memory database and with no
+ * network involved at all: a Fedimint submission is decoded rather than fetched, so it
+ * exercises `indexSubmission` end to end — the in-flight map, the insert, and the
+ * payload read back — without touching a relay or a mint.
+ *
+ * The import is deferred until after `DATABASE_URL` is set, because the config resolves
+ * its target on first use and this must not open the real database.
+ */
+process.env['DATABASE_URL'] = ':memory:';
+const { indexSubmission, inFlightCount } = await import('./index-mint.ts');
+const { closeDb } = await import('./db.ts');
+
+await checkAsync('two simultaneous submissions of one address share one probe', async () => {
+  assert.equal(inFlightCount(), 0);
+
+  const first = indexSubmission('fedimint', REAL_INVITE);
+  assert.equal(inFlightCount(), 1, 'the first submission claims the key immediately');
+
+  // Deliberately a different spelling of the same code: the key is the decoded
+  // federation id, so the two collapse before anything is written.
+  const second = indexSubmission('fedimint', REAL_INVITE.toUpperCase());
+  assert.equal(inFlightCount(), 1, 'the second submission joins the first, it does not start');
+
+  const [a, b] = await Promise.all([first, second]);
+  assert.equal(a, b, 'both callers get the same answer object');
+  assert.equal(a.status, 201);
+  assert.equal(inFlightCount(), 0, 'the entry is released when the work finishes');
+
+  const created = a.body as { host?: string; status?: string; invite_codes?: string[] };
+  assert.equal(created.host, 'fed-aeca6cc80ffc530b');
+  assert.equal(created.status, 'announced', 'nothing checks a federation, so nothing claims it is up');
+  assert.deepEqual(created.invite_codes, [REAL_INVITE.toLowerCase()]);
+
+  // And once it is a row, submitting it again is a lookup rather than a write.
+  const again = await indexSubmission('fedimint', REAL_INVITE);
+  assert.equal(again.status, 200);
+  assert.equal((again.body as { existing?: boolean }).existing, true);
+});
+
+await checkAsync('a submission of the wrong shape never reaches the work at all', async () => {
+  const junk = await indexSubmission('fedimint', 'fed11not-a-real-code');
+  assert.equal(junk.status, 422);
+  assert.equal((junk.body as { error?: string }).error, 'invalid_invite');
+  assert.equal(inFlightCount(), 0);
+
+  const wrongType = await indexSubmission('cashu-ish', 'https://mint.example.com');
+  assert.equal((wrongType.body as { error?: string }).error, 'bad_type');
+
+  // A private address is refused by the normalizer, before DNS and before the map.
+  const private_ = await indexSubmission('cashu', 'https://192.168.1.5');
+  assert.equal((private_.body as { error?: string }).error, 'blocked_host');
+  assert.equal(inFlightCount(), 0);
+});
+
+await closeDb();
+
+console.log(`ok, ${checks} index checks passed`);

api/src/check-lnurl.ts

@@ -0,0 +1,935 @@
+/**
+ * pnpm --filter ./api test:lnurl
+ *
+ * The LNURL ecosystem, checked against the two things it has to agree with: the
+ * responses recorded in `NOTES-LNURL.md`, and the rules written down in
+ * `docs/KIND-LNURL-MINT.md`. Those two documents are the specification; this file is
+ * what stops the code and the documents drifting apart in silence.
+ *
+ * Four groups:
+ *
+ *   1. **Parsers**, against verbatim captures of the live reference instance and of a
+ *      locally run mint with no funding source. Not hand-written approximations — the
+ *      bytes that were actually on the wire.
+ *   2. **The `d` rules**, including the sticky-identity case that the kind document
+ *      spends a section on and that a naive implementation gets wrong.
+ *   3. **The features vocabulary**, including the two negative cases that matter:
+ *      nothing invents `lud21`, and nothing invents `rotate`/`split`/`merge`.
+ *   4. **A full round trip** — announcement and review published to a real relay by this
+ *      site's own publisher, read back by the indexer's own parsers, resolved to a row.
+ *      The relay is `test-relay.ts`, in-process and on an ephemeral port, so this runs
+ *      in CI with nothing installed and never touches a public relay.
+ */
+import assert from 'node:assert/strict';
+import { finalizeEvent, generateSecretKey, getPublicKey } from 'nostr-tools/pure';
+import { SimplePool } from 'nostr-tools/pool';
+import * as nip19 from 'nostr-tools/nip19';
+import {
+  ANNOUNCEMENT_KINDS,
+  FEATURE_VOCABULARY,
+  KIND_LNURL_ANNOUNCEMENT,
+  KIND_REVIEW,
+  addressFromPayLink,
+  baseUrlFromKey,
+  ecosystemForKind,
+  featureStates,
+  getMintWarnings,
+  hasFeature,
+  hostIdentifier,
+  isMintPubkey,
+  lnurlIdentifier,
+  lnurlIdentifiers,
+  lnurlKey,
+  mintChip,
+  msatToSat,
+  normalizeLnurlNetwork,
+  normalizeNetwork,
+  onionFromHtml,
+  otherFeatures,
+  parseAdvertisement,
+  parseFeatures,
+  parseLnurlAnnouncement,
+  parsePayInfo,
+  parseRating,
+  parseSoftware,
+  reviewEcosystem,
+  type LnurlFields,
+  type NostrEventLike,
+} from '@cashumints/shared';
+import { announcedFeatures, announcementTemplate, parseAnnounceKey } from './announce.ts';
+import { announceConfig } from './config.ts';
+import type { MintRow } from './mints.ts';
+import { startTestRelay } from './test-relay.ts';
+
+let checks = 0;
+function check(name: string, fn: () => void): void {
+  try {
+    fn();
+    checks++;
+  } catch (err) {
+    console.error(`FAIL: ${name}`);
+    throw err;
+  }
+}
+
+async function checkAsync(name: string, fn: () => Promise<void>): Promise<void> {
+  try {
+    await fn();
+    checks++;
+  } catch (err) {
+    console.error(`FAIL: ${name}`);
+    throw err;
+  }
+}
+
+/* ------------------------------------------------------------------ *
+ * Captures. Verbatim, from NOTES-LNURL.md.
+ * ------------------------------------------------------------------ */
+
+/** `GET https://lnurl.21mint.me/.well-known/lnurlw/_`, 2026-08-21. */
+const LIVE_WITHDRAW = {
+  tag: 'withdrawRequest',
+  callback: 'https://lnurl.21mint.me/w',
+  minWithdrawable: 5000,
+  maxWithdrawable: 999899000,
+  defaultDescription: 'lnurlcash bearer note on lnurl.21mint.me',
+  mintPubkey: '021ab89df9cbd28cdab8c71d228ca40deba1eaebd827f24849ec4f3e919c023555',
+  payLink: 'https://lnurl.21mint.me/.well-known/lnurlp/mint',
+  nodeAlias: 'Azzamo',
+  nodeUri: '021ab89df9cbd28cdab8c71d228ca40deba1eaebd827f24849ec4f3e919c023555@145.239.92.138:9736',
+  nodeColor: '#68f442',
+  nodeCapacity: 30027500000,
+  nodeNumChannels: 8,
+  nodeNumPeers: 18,
+};
+
+/** `GET https://lnurl.21mint.me/.well-known/lnurlp/_`, same run. */
+const LIVE_PAY = {
+  tag: 'payRequest',
+  callback: 'https://lnurl.21mint.me/p/cb',
+  minSendable: 6000,
+  maxSendable: 1000000000,
+  metadata:
+    '[["text/plain", "Mint an lnurlcash bearer note on lnurl.21mint.me"], ' +
+    '["text/identifier", "_@lnurl.21mint.me"], ["text/plain", "Mint fees: 1000,100"]]',
+  withdrawLink: 'https://lnurl.21mint.me/w',
+};
+
+/**
+ * The same endpoint on a locally run mint with no `FUNDINGSOURCE_*` configured at all.
+ *
+ * Every node field is *absent* rather than null, because the software runs with
+ * `response_model_exclude_none`. This object is the degraded state, and it is the reason
+ * the probe can report one.
+ */
+const NO_FUNDING_WITHDRAW = {
+  tag: 'withdrawRequest',
+  callback: 'https://lnurl.test/w',
+  minWithdrawable: 10000,
+  maxWithdrawable: 999999000,
+  defaultDescription: 'lnurlcash bearer note on lnurl.test',
+  payLink: 'https://lnurl.test/.well-known/lnurlp/mint',
+};
+
+/* ------------------------------------------------------------------ *
+ * 1. Parsers
+ * ------------------------------------------------------------------ */
+
+check('the live mint advertisement parses into every field the site renders', () => {
+  const ad = parseAdvertisement(LIVE_WITHDRAW);
+  assert.ok(ad, 'the live advertisement must parse');
+  assert.equal(ad.minWithdrawableMsat, 5000);
+  assert.equal(ad.maxWithdrawableMsat, 999899000);
+  assert.equal(ad.defaultDescription, 'lnurlcash bearer note on lnurl.21mint.me');
+  assert.equal(ad.mintPubkey, '021ab89df9cbd28cdab8c71d228ca40deba1eaebd827f24849ec4f3e919c023555');
+  assert.equal(ad.nodeAlias, 'Azzamo');
+  assert.equal(ad.nodeCapacityMsat, 30027500000);
+  assert.equal(ad.nodeChannels, 8);
+  assert.equal(ad.nodePeers, 18);
+  assert.equal(ad.fundingAvailable, true);
+});
+
+check('millisatoshi limits become the sat figures the verdict strip shows', () => {
+  assert.equal(msatToSat(5000), 5);
+  assert.equal(msatToSat(999899000), 999899);
+  // Floored, not rounded: both numbers are bounds, and rounding a ceiling up would
+  // advertise a note larger than the mint will ever issue.
+  assert.equal(msatToSat(1999), 1);
+  assert.equal(msatToSat(999), 0);
+  assert.equal(msatToSat(null), null);
+  assert.equal(msatToSat(-1), null);
+});
+
+check('a missing mintPubkey is the degraded state, not a parse failure', () => {
+  const ad = parseAdvertisement(NO_FUNDING_WITHDRAW);
+  assert.ok(ad, 'a mint with no funding source still serves a valid advertisement');
+  assert.equal(ad.fundingAvailable, false);
+  assert.equal(ad.mintPubkey, null);
+  assert.equal(ad.nodeAlias, null);
+  assert.equal(ad.nodeUri, null);
+  // The limits are real and must still render. This is the whole point of the state.
+  assert.equal(msatToSat(ad.minWithdrawableMsat), 10);
+  assert.equal(msatToSat(ad.maxWithdrawableMsat), 999999);
+});
+
+check('an LNURL error body is not a mint advertisement, despite arriving as HTTP 200', () => {
+  // These endpoints answer their errors with 200. A probe keying on the status code
+  // would call every one of these "online".
+  assert.equal(parseAdvertisement({ status: 'ERROR', reason: 'Unknown user.' }), null);
+  assert.equal(parseAdvertisement({ status: 'ERROR', reason: 'Unknown note.' }), null);
+  assert.equal(parseAdvertisement({ detail: 'Not Found' }), null);
+  assert.equal(parseAdvertisement(LIVE_PAY), null, 'a payRequest is not a withdrawRequest');
+  assert.equal(parseAdvertisement(null), null);
+  assert.equal(parseAdvertisement('withdrawRequest'), null);
+  assert.equal(parseAdvertisement([]), null);
+});
+
+check('an advertisement with inverted or missing bounds is rejected', () => {
+  assert.equal(parseAdvertisement({ ...LIVE_WITHDRAW, minWithdrawable: 900, maxWithdrawable: 100 }), null);
+  assert.equal(parseAdvertisement({ ...LIVE_WITHDRAW, maxWithdrawable: undefined }), null);
+  assert.equal(parseAdvertisement({ ...LIVE_WITHDRAW, maxWithdrawable: 'lots' }), null);
+});
+
+check('a zero withdraw ceiling parses, because the warning needs to see it', () => {
+  // Rejecting this would turn "withdrawals disabled" into "offline", which is a
+  // different and much less useful thing to tell a reader.
+  const ad = parseAdvertisement({ ...LIVE_WITHDRAW, minWithdrawable: 0, maxWithdrawable: 0 });
+  assert.ok(ad);
+  assert.equal(ad.maxWithdrawableMsat, 0);
+});
+
+check('the payRequest metadata is parsed twice and yields fee, description and address', () => {
+  const pay = parsePayInfo(LIVE_PAY);
+  assert.ok(pay);
+  assert.equal(pay.minSendableMsat, 6000);
+  assert.equal(pay.maxSendableMsat, 1000000000);
+  assert.equal(pay.description, 'Mint an lnurlcash bearer note on lnurl.21mint.me');
+  assert.equal(pay.feeBaseMsat, 1000);
+  assert.equal(pay.feePpm, 100);
+  assert.equal(pay.withdrawLink, 'https://lnurl.21mint.me/w');
+});
+
+check('the "Mint fees:" entry never becomes the description', () => {
+  // It shares `text/plain` with the description, so a naive first-match reader shows
+  // "Mint fees: 1000,100" as what the mint is.
+  const pay = parsePayInfo({
+    ...LIVE_PAY,
+    metadata: '[["text/plain", "Mint fees: 2000,50"], ["text/plain", "A real description"]]',
+  });
+  assert.equal(pay?.description, 'A real description');
+  assert.equal(pay?.feeBaseMsat, 2000);
+  assert.equal(pay?.feePpm, 50);
+});
+
+check('a fee-free mint reports no fee rather than zero', () => {
+  const pay = parsePayInfo({ ...LIVE_PAY, metadata: '[["text/plain", "Just a mint"]]' });
+  assert.equal(pay?.feeBaseMsat, null);
+  assert.equal(pay?.feePpm, null);
+});
+
+check('unparseable metadata costs the description, not the whole response', () => {
+  const pay = parsePayInfo({ ...LIVE_PAY, metadata: 'not json at all' });
+  assert.ok(pay, 'the limits above the metadata are still good');
+  assert.equal(pay.minSendableMsat, 6000);
+  assert.equal(pay.description, null);
+});
+
+check('the lightning address comes from payLink, never from the echoed identifier', () => {
+  // `text/identifier` echoes whichever username was queried, so probing `_` gets back
+  // `_@host` — LUD-16's bare-domain form, and not a name to show a reader.
+  assert.equal(parsePayInfo(LIVE_PAY)?.identifier, '_@lnurl.21mint.me');
+  assert.equal(addressFromPayLink(LIVE_WITHDRAW.payLink), 'mint@lnurl.21mint.me');
+
+  assert.equal(addressFromPayLink('https://x.example/.well-known/lnurlp/_'), null);
+  assert.equal(addressFromPayLink('https://x.example/somewhere/else'), null);
+  assert.equal(addressFromPayLink(null), null);
+  assert.equal(addressFromPayLink('not a url'), null);
+});
+
+check('an onion address is found in the one-pager and nowhere else', () => {
+  const html =
+    '<h2>Also via Tor</h2><button class="copy" ' +
+    'data-copy="mint@abcdefghijklmnopqrstuvwxyz234567abcdefghijklmnopqrstuvwx.onion" ' +
+    'title="Copy lightning address">&#9889;</button>';
+  assert.equal(
+    onionFromHtml(html),
+    'abcdefghijklmnopqrstuvwxyz234567abcdefghijklmnopqrstuvwx.onion',
+  );
+  assert.equal(onionFromHtml('<h1>a mint with no tor section</h1>'), null);
+});
+
+check('the version comes from openapi, and the unknown sentinel is not a version', () => {
+  assert.equal(
+    parseSoftware({ info: { title: 'lnurl-mint', version: '0.1.0' } }),
+    'lnurl-mint/0.1.0',
+  );
+  // What a source checkout with no installed package metadata reports. It is the
+  // library saying "I do not know", not a release, and must not reach a reader.
+  assert.equal(parseSoftware({ info: { title: 'lnurl-mint', version: '0.0.0+unknown' } }), null);
+  assert.equal(parseSoftware({ info: { version: '1.2.3' } }), null);
+  assert.equal(parseSoftware({}), null);
+  assert.equal(parseSoftware(null), null);
+});
+
+/* ------------------------------------------------------------------ *
+ * 2. Identity: the `d` rules
+ * ------------------------------------------------------------------ */
+
+check('a mint pubkey is 66 hex characters beginning 02 or 03', () => {
+  assert.equal(isMintPubkey(LIVE_WITHDRAW.mintPubkey), true);
+  assert.equal(isMintPubkey('03' + 'a'.repeat(64)), true);
+  // A Cashu mint pubkey or a federation id is 64 characters, and must never be
+  // mistaken for one of these.
+  assert.equal(isMintPubkey('a'.repeat(64)), false);
+  assert.equal(isMintPubkey('04' + 'a'.repeat(64)), false);
+  assert.equal(isMintPubkey('021ab8'), false);
+  assert.equal(isMintPubkey(null), false);
+});
+
+check('the two `d` forms can never be confused for one another', () => {
+  const host = hostIdentifier('https://lnurl.21mint.me');
+  assert.equal(host, 'lnurl.21mint.me');
+  assert.equal(isMintPubkey(host), false, 'a host is never pubkey-shaped');
+  assert.ok(host.includes('.'), 'a host always contains a dot; a pubkey never does');
+});
+
+check('the `d` fallback drops the scheme and the trailing slash but keeps the path', () => {
+  assert.equal(hostIdentifier('https://mint.example.com/lnurl/'), 'mint.example.com/lnurl');
+  assert.equal(hostIdentifier('https://Mint.Example.com'), 'mint.example.com');
+});
+
+check('the identifier prefers the pubkey and falls back to the host', () => {
+  assert.equal(
+    lnurlIdentifier('https://lnurl.21mint.me', LIVE_WITHDRAW.mintPubkey),
+    LIVE_WITHDRAW.mintPubkey,
+  );
+  assert.equal(lnurlIdentifier('https://lnurl.21mint.me', null), 'lnurl.21mint.me');
+  // Junk in the pubkey position falls back rather than being published as a `d`.
+  assert.equal(lnurlIdentifier('https://lnurl.21mint.me', 'nonsense'), 'lnurl.21mint.me');
+});
+
+check('a mint that gained a pubkey is still reviewable under its old host identifier', () => {
+  // The case the kind document spends a section on. Reviews written before the mint had
+  // a funding source carry the host `d`; asking only for the current identifier would
+  // silently strand every one of them.
+  const both = lnurlIdentifiers('https://lnurl.21mint.me', LIVE_WITHDRAW.mintPubkey);
+  assert.deepEqual(both, [LIVE_WITHDRAW.mintPubkey, 'lnurl.21mint.me']);
+
+  const hostOnly = lnurlIdentifiers('https://lnurl.21mint.me', null);
+  assert.deepEqual(hostOnly, ['lnurl.21mint.me']);
+});
+
+check('the row key round-trips the base URL', () => {
+  const key = lnurlKey('https://lnurl.21mint.me');
+  assert.equal(key, 'lnurl:https://lnurl.21mint.me');
+  assert.equal(baseUrlFromKey(key), 'https://lnurl.21mint.me');
+  // Not an LNURL key, and must not be mistaken for one.
+  assert.equal(baseUrlFromKey('https://mint.example.com'), null);
+  assert.equal(baseUrlFromKey('fedimint:' + 'a'.repeat(64)), null);
+});
+
+/* ------------------------------------------------------------------ *
+ * 3. The features vocabulary
+ * ------------------------------------------------------------------ */
+
+check('the features tag splits like a modules tag, and tolerates what publishers write', () => {
+  assert.deepEqual(parseFeatures('mint,melt,rotate'), ['mint', 'melt', 'rotate']);
+  assert.deepEqual(parseFeatures('mint, melt,  rotate'), ['mint', 'melt', 'rotate']);
+  assert.deepEqual(parseFeatures('MINT,Melt'), ['mint', 'melt']);
+  assert.deepEqual(parseFeatures('mint,mint,melt'), ['mint', 'melt']);
+  assert.deepEqual(parseFeatures(''), []);
+  assert.deepEqual(parseFeatures(null), []);
+  // Junk tokens are dropped, not carried into a chip.
+  assert.deepEqual(parseFeatures('mint,<script>,melt'), ['mint', 'melt']);
+});
+
+check('an unrecognised feature is kept and shown, never dropped', () => {
+  // The kind document requires consumers to ignore tokens they do not know rather than
+  // reject the event, which is what lets the vocabulary grow without a new kind.
+  const features = parseFeatures('mint,melt,quantum-notes');
+  assert.deepEqual(features, ['mint', 'melt', 'quantum-notes']);
+  assert.deepEqual(otherFeatures(features), ['quantum-notes']);
+});
+
+check('the vocabulary is exactly what the kind document lists', () => {
+  assert.deepEqual([...FEATURE_VOCABULARY], [
+    'mint', 'melt', 'rotate', 'split', 'merge',
+    'lud06', 'lud03', 'lud16', 'lud21',
+    'signed-notes', 'onion',
+  ]);
+});
+
+check('the notes row is satisfied by any one of rotate, split or merge', () => {
+  assert.equal(hasFeature(['rotate'], 'notes'), true);
+  assert.equal(hasFeature(['split'], 'notes'), true);
+  assert.equal(hasFeature(['merge'], 'notes'), true);
+  assert.equal(hasFeature(['mint', 'melt'], 'notes'), false);
+});
+
+check('a funding outage marks mint, melt and signed-notes unavailable, and nothing else', () => {
+  const features = ['mint', 'melt', 'rotate', 'split', 'merge', 'lud16', 'lud21', 'signed-notes'];
+
+  const down = featureStates(features, false);
+  assert.equal(down.mint, 'unavailable');
+  assert.equal(down.melt, 'unavailable');
+  assert.equal(down['signed-notes'], 'unavailable');
+  // Exactly what still works with no Lightning node, and the reason this state is
+  // rendered rather than collapsed into "offline".
+  assert.equal(down.notes, 'ok');
+  assert.equal(down.lud16, 'ok');
+  assert.equal(down.lud21, 'ok');
+  assert.equal(down.onion, 'none');
+
+  const up = featureStates(features, true);
+  assert.equal(up.mint, 'ok');
+  assert.equal(up['signed-notes'], 'ok');
+
+  // Nothing probed yet is not a reason to doubt an operator's claim.
+  const unknown = featureStates(features, null);
+  assert.equal(unknown.mint, 'ok');
+});
+
+check('a feature that was never claimed stays absent even when funding is down', () => {
+  const states = featureStates(['rotate'], false);
+  assert.equal(states.mint, 'none', 'absent, not "unavailable" — it was never claimed');
+  assert.equal(states.notes, 'ok');
+});
+
+check('the network tag agrees with the Fedimint side, bitcoin included', () => {
+  for (const value of ['bitcoin', 'mainnet', 'MAIN', 'signet', 'regtest', 'testnet4', '', null]) {
+    assert.equal(
+      normalizeLnurlNetwork(value),
+      normalizeNetwork(value),
+      `the two normalizers disagree about ${JSON.stringify(value)}`,
+    );
+  }
+});
+
+/* ------------------------------------------------------------------ *
+ * 4. The announcement
+ * ------------------------------------------------------------------ */
+
+const ANNOUNCER = 'f'.repeat(64);
+
+function announcement(tags: string[][], content = ''): NostrEventLike {
+  return {
+    id: 'e'.repeat(64),
+    pubkey: ANNOUNCER,
+    kind: KIND_LNURL_ANNOUNCEMENT,
+    created_at: 1_780_000_000,
+    content,
+    tags,
+  };
+}
+
+check('kind 38174 is wired into the one table every ecosystem is read from', () => {
+  assert.equal(ANNOUNCEMENT_KINDS.lnurl, 38174);
+  assert.equal(ecosystemForKind(38174), 'lnurl');
+  assert.equal(ecosystemForKind('38174'), 'lnurl');
+  // The neighbours are untouched.
+  assert.equal(ecosystemForKind(38172), 'cashu');
+  assert.equal(ecosystemForKind(38173), 'fedimint');
+});
+
+check('a full announcement parses into every field a row needs', () => {
+  const parsed = parseLnurlAnnouncement(
+    announcement(
+      [
+        ['d', LIVE_WITHDRAW.mintPubkey],
+        ['u', 'https://lnurl.21mint.me'],
+        ['features', 'mint,melt,rotate,split,merge,lud06,lud03,lud16,lud21,signed-notes'],
+        ['n', 'mainnet'],
+      ],
+      JSON.stringify({ name: '21 Mint', about: 'Bearer notes.' }),
+    ),
+  );
+
+  assert.ok(parsed);
+  assert.equal(parsed.identifier, LIVE_WITHDRAW.mintPubkey);
+  assert.equal(parsed.mintPubkey, LIVE_WITHDRAW.mintPubkey);
+  assert.equal(parsed.baseUrl, 'https://lnurl.21mint.me');
+  assert.equal(parsed.slug, 'lnurl.21mint.me');
+  assert.equal(parsed.network, 'mainnet');
+  assert.equal(parsed.name, '21 Mint');
+  assert.equal(parsed.about, 'Bearer notes.');
+  assert.equal(parsed.announcerPubkey, ANNOUNCER);
+  assert.equal(parsed.features.length, 10);
+});
+
+check('an announcement by host parses, and carries no pubkey', () => {
+  const parsed = parseLnurlAnnouncement(
+    announcement([['d', 'lnurl.example.com'], ['u', 'https://lnurl.example.com']]),
+  );
+  assert.ok(parsed);
+  assert.equal(parsed.identifier, 'lnurl.example.com');
+  assert.equal(parsed.mintPubkey, null, 'a host `d` is not a pubkey and must not read as one');
+});
+
+check('an announcement with no usable `u` is rejected', () => {
+  // `u` is REQUIRED for this kind, unlike 38172: a host-form `d` has no scheme and is
+  // not fetchable, so without `u` there is no address at all.
+  assert.equal(parseLnurlAnnouncement(announcement([['d', 'lnurl.example.com']])), null);
+  assert.equal(
+    parseLnurlAnnouncement(announcement([['d', 'lnurl.example.com'], ['u', 'not a url']])),
+    null,
+  );
+  // An onion cannot be the canonical `u`; the normalizer refuses it for every ecosystem.
+  assert.equal(
+    parseLnurlAnnouncement(
+      announcement([['d', 'lnurl.example.com'], ['u', 'http://abcdefghijklmnop.onion']]),
+    ),
+    null,
+  );
+});
+
+check('an announcement with an unusable `d` is rejected', () => {
+  assert.equal(parseLnurlAnnouncement(announcement([['u', 'https://lnurl.example.com']])), null);
+  assert.equal(
+    parseLnurlAnnouncement(
+      announcement([['d', 'not an identifier'], ['u', 'https://lnurl.example.com']]),
+    ),
+    null,
+  );
+});
+
+check('a `d` naming one mint and a `u` naming another is accepted, deliberately', () => {
+  // Not a validation failure: a mint's `d` is its funding node's pubkey, which has no
+  // relationship to its hostname at all. Cross-checking them would reject exactly the
+  // events the identity rule exists to allow.
+  const parsed = parseLnurlAnnouncement(
+    announcement([['d', LIVE_WITHDRAW.mintPubkey], ['u', 'https://somewhere.else.example']]),
+  );
+  assert.ok(parsed);
+  assert.equal(parsed.baseUrl, 'https://somewhere.else.example');
+});
+
+check('hostile announcement content degrades to no metadata', () => {
+  for (const content of ['not json', '[]', 'null', '{"name": 12345}', '""']) {
+    const parsed = parseLnurlAnnouncement(
+      announcement([['d', 'lnurl.example.com'], ['u', 'https://lnurl.example.com']], content),
+    );
+    assert.ok(parsed, `content ${content} must not reject the announcement`);
+    assert.equal(parsed.name, null);
+  }
+
+  // A `javascript:` picture never reaches an img src.
+  const parsed = parseLnurlAnnouncement(
+    announcement(
+      [['d', 'lnurl.example.com'], ['u', 'https://lnurl.example.com']],
+      JSON.stringify({ picture: 'javascript:alert(1)' }),
+    ),
+  );
+  assert.equal(parsed?.picture, null);
+});
+
+/* ------------------------------------------------------------------ *
+ * 5. Reviews
+ * ------------------------------------------------------------------ */
+
+function review(tags: string[][], content = '[5/5] Good mint.'): NostrEventLike {
+  return {
+    id: 'd'.repeat(64),
+    pubkey: 'c'.repeat(64),
+    kind: KIND_REVIEW,
+    created_at: 1_780_000_100,
+    content,
+    tags,
+  };
+}
+
+check('a k=38174 review is filed under lnurl and nothing else', () => {
+  assert.equal(reviewEcosystem(review([['k', '38174']])), 'lnurl');
+  assert.equal(reviewEcosystem(review([['k', '38172']])), 'cashu');
+  assert.equal(reviewEcosystem(review([['k', '38173']])), 'fedimint');
+  // A review with no `k` is Cashu, because every one of those predates everything else.
+  assert.equal(reviewEcosystem(review([])), 'cashu');
+  // A kind this build has no ecosystem for belongs to nobody.
+  assert.equal(reviewEcosystem(review([['k', '39999']])), null);
+});
+
+check('the rating convention is identical across all three ecosystems', () => {
+  // A reader comparing a Cashu mint to an LNURL one must be comparing the same scale,
+  // so this uses the site's existing parser with no LNURL-specific path at all.
+  assert.equal(parseRating(review([['k', '38174']], '[4/5] Fast melts')), 4);
+  assert.equal(parseRating(review([['k', '38174'], ['rating', '2']])), 2);
+  assert.equal(parseRating(review([['k', '38174'], ['rating', '0.8']])), 4);
+  assert.equal(parseRating(review([['k', '38174']], 'no rating here')), null);
+});
+
+/* ------------------------------------------------------------------ *
+ * 6. Warnings
+ * ------------------------------------------------------------------ */
+
+const onlineMint = {
+  type: 'lnurl',
+  status: 'online' as const,
+  last_online: 1_786_999_910,
+  first_seen: 1_769_720_000,
+};
+const NOW = 1_787_000_000;
+
+check('a healthy LNURL mint gets no banner', () => {
+  const warnings = getMintWarnings(
+    { ...onlineMint, max_withdrawable_msat: 999899000, funding_available: true },
+    { now: NOW },
+  );
+  assert.deepEqual(warnings, []);
+});
+
+check('a zero withdraw ceiling is critical and says withdrawals are disabled', () => {
+  const warnings = getMintWarnings(
+    { ...onlineMint, max_withdrawable_msat: 0, funding_available: true },
+    { now: NOW },
+  );
+  assert.equal(warnings[0]?.kind, 'lnurl-withdrawals-disabled');
+  assert.equal(warnings[0]?.severity, 'critical');
+  assert.match(warnings[0]!.lead, /Withdrawals disabled/);
+  assert.equal(mintChip(warnings)?.label, 'No withdrawals');
+});
+
+check('never having probed is not "withdrawals disabled"', () => {
+  // `=== 0`, not falsy. null means nothing has looked yet.
+  const warnings = getMintWarnings(
+    { ...onlineMint, max_withdrawable_msat: null, funding_available: null },
+    { now: NOW },
+  );
+  assert.deepEqual(warnings, []);
+});
+
+check('an unreachable funding source is a warning that says what still works', () => {
+  const warnings = getMintWarnings(
+    { ...onlineMint, max_withdrawable_msat: 999899000, funding_available: false },
+    { now: NOW },
+  );
+  assert.equal(warnings[0]?.kind, 'lnurl-no-funding');
+  assert.equal(warnings[0]?.severity, 'warning');
+  assert.match(warnings[0]!.body, /rotated, split, or merged/);
+  assert.match(warnings[0]!.body, /nothing moves in or out/);
+  assert.equal(mintChip(warnings)?.label, 'No mint / melt');
+});
+
+check('a host responding with junk says so, rather than saying offline', () => {
+  const warnings = getMintWarnings(
+    {
+      ...onlineMint,
+      status: 'degraded',
+      max_withdrawable_msat: 999899000,
+      invalid_reason: 'mint replied: Unknown user.',
+    },
+    { now: NOW },
+  );
+  assert.equal(warnings[0]?.kind, 'lnurl-invalid');
+  assert.match(warnings[0]!.lead, /Endpoint responding but invalid/);
+  assert.match(warnings[0]!.body, /withdrawals may not work/);
+});
+
+check('the offline tiers are exactly the Cashu ones', () => {
+  const day = 86400;
+  const tiers: Array<[number, string]> = [
+    [2 * day, 'offline'],
+    [10 * day, 'offline-long'],
+    [40 * day, 'gone'],
+  ];
+
+  for (const [age, kind] of tiers) {
+    const warnings = getMintWarnings(
+      { type: 'lnurl', status: 'offline', last_online: NOW - age, first_seen: NOW - 200 * day },
+      { now: NOW },
+    );
+    assert.equal(warnings[0]?.kind, kind, `${age / day} days offline should be ${kind}`);
+
+    // The same input with `type: cashu` reaches the same tier, which is what makes
+    // "identical to Cashu" a checked claim rather than a comment.
+    const cashu = getMintWarnings(
+      { type: 'cashu', status: 'offline', last_online: NOW - age, first_seen: NOW - 200 * day },
+      { now: NOW },
+    );
+    assert.equal(cashu[0]?.kind, kind);
+    assert.equal(cashu[0]?.lead, warnings[0]?.lead, 'and says the same words');
+  }
+});
+
+check('a mint that never answered once lands in the top tier', () => {
+  const warnings = getMintWarnings(
+    { type: 'lnurl', status: 'offline', last_online: null, first_seen: NOW - 40 * 86400 },
+    { now: NOW },
+  );
+  assert.equal(warnings[0]?.kind, 'gone');
+});
+
+check('withdrawals disabled outranks an offline banner, and still says it is offline', () => {
+  const warnings = getMintWarnings(
+    {
+      type: 'lnurl',
+      status: 'offline',
+      last_online: NOW - 3 * 86400,
+      first_seen: NOW - 200 * 86400,
+      max_withdrawable_msat: 0,
+    },
+    { now: NOW },
+  );
+  assert.equal(warnings[0]?.kind, 'lnurl-withdrawals-disabled');
+  assert.match(warnings[0]!.body, /also been offline/);
+});
+
+check('an offline banner rescues the funding fact into its last sentence', () => {
+  const warnings = getMintWarnings(
+    {
+      type: 'lnurl',
+      status: 'offline',
+      last_online: NOW - 40 * 86400,
+      first_seen: NOW - 200 * 86400,
+      funding_available: false,
+    },
+    { now: NOW },
+  );
+  assert.equal(warnings[0]?.kind, 'gone');
+  assert.match(warnings[0]!.body, /Lightning node was also unreachable/);
+});
+
+check('no LNURL warning is ever derived from the features tag', () => {
+  // `features` is the operator's claim about what they built. A banner derived from a
+  // claim rather than an observation is the invention the Fedimint branch refuses to
+  // make, and this branch refuses it too.
+  const claimed = getMintWarnings(
+    { ...onlineMint, features: [], max_withdrawable_msat: 5000, funding_available: true } as never,
+    { now: NOW },
+  );
+  assert.deepEqual(claimed, []);
+});
+
+/* ------------------------------------------------------------------ *
+ * 7. The publisher
+ * ------------------------------------------------------------------ */
+
+const probedRow: MintRow = {
+  url: 'lnurl:https://lnurl.21mint.me',
+  host: 'lnurl.21mint.me',
+  type: 'lnurl',
+  name: '21 Mint',
+  description: null,
+  icon_url: null,
+  icon_file: null,
+  pubkey: null,
+  info_json: null,
+  ecosystem_json: null,
+  nuts_json: null,
+  version: 'lnurl-mint/0.1.0',
+  status: 'online',
+  consecutive_fails: 0,
+  last_online: 1_786_999_910,
+  last_probe: 1_786_999_910,
+  first_seen: 1_769_720_000,
+  updated_at: 1_786_999_910,
+};
+
+const probedFields: LnurlFields = {
+  lnurl_id: LIVE_WITHDRAW.mintPubkey,
+  base_url: 'https://lnurl.21mint.me',
+  features: [],
+  network: 'mainnet',
+  announced_at: null,
+  announcer_pubkey: null,
+  mint_pubkey: LIVE_WITHDRAW.mintPubkey,
+  funding_available: true,
+  probe_endpoint: '/.well-known/lnurlw/_',
+  invalid_reason: null,
+  min_withdrawable_msat: 5000,
+  max_withdrawable_msat: 999899000,
+  min_sendable_msat: 6000,
+  max_sendable_msat: 1000000000,
+  fee_base_msat: 1000,
+  fee_ppm: 100,
+  lightning_address: 'mint@lnurl.21mint.me',
+  onion_url: null,
+  node_alias: 'Azzamo',
+  node_uri: LIVE_WITHDRAW.nodeUri,
+  node_capacity_msat: 30027500000,
+  node_channels: 8,
+  node_peers: 18,
+  observed_features: ['mint', 'melt', 'lud06', 'lud03', 'lud16', 'signed-notes'],
+};
+
+check('announcing is off unless all three switches are set', () => {
+  assert.equal(announceConfig({}), null);
+  assert.equal(announceConfig({ ANNOUNCE_LNURL: 'true' }), null, 'no key, no publish');
+  assert.equal(
+    announceConfig({ ANNOUNCE_LNURL: 'true', ANNOUNCE_KEY: 'nsec1x' }),
+    null,
+    'no relays, no publish — there is deliberately no default',
+  );
+  assert.equal(
+    announceConfig({ ANNOUNCE_LNURL: 'false', ANNOUNCE_KEY: 'k', ANNOUNCE_RELAYS: 'wss://r' }),
+    null,
+  );
+
+  const on = announceConfig({
+    ANNOUNCE_LNURL: 'true',
+    ANNOUNCE_KEY: 'nsec1x',
+    ANNOUNCE_RELAYS: 'wss://one, wss://two, http://not-a-relay',
+  });
+  assert.deepEqual(on, { secretKey: 'nsec1x', relays: ['wss://one', 'wss://two'] });
+});
+
+check('the signing key accepts an nsec or hex, and refuses anything else', () => {
+  const secret = generateSecretKey();
+  const hex = Buffer.from(secret).toString('hex');
+  assert.deepEqual(parseAnnounceKey(hex), secret);
+  assert.deepEqual(parseAnnounceKey(nip19.nsecEncode(secret)), secret);
+  assert.equal(parseAnnounceKey('npub1abc'), null);
+  assert.equal(parseAnnounceKey('nsec1notvalid'), null);
+  assert.equal(parseAnnounceKey('deadbeef'), null);
+  assert.equal(parseAnnounceKey(''), null);
+});
+
+check('this site announces only what it observed', () => {
+  const features = announcedFeatures(probedFields);
+  assert.deepEqual(features, ['mint', 'melt', 'lud06', 'lud03', 'lud16', 'signed-notes']);
+
+  // The four it must never publish, and the reasons, from the kind document:
+  assert.ok(!features.includes('lud21'), 'verify is undetectable over HTTP');
+  for (const operation of ['rotate', 'split', 'merge']) {
+    assert.ok(
+      !features.includes(operation),
+      `${operation} is only provable by calling /w/cb, which mutates a stranger's note`,
+    );
+  }
+});
+
+check('a mint with no reachable node is announced without the funded capabilities', () => {
+  const features = announcedFeatures({ ...probedFields, funding_available: false });
+  assert.deepEqual(features, ['lud06', 'lud03', 'lud16']);
+  assert.ok(!features.includes('signed-notes'), 'note signing needs the same node');
+});
+
+check('a zero withdraw ceiling is never announced as melt', () => {
+  const features = announcedFeatures({ ...probedFields, max_withdrawable_msat: 0 });
+  assert.ok(!features.includes('melt'));
+  assert.ok(features.includes('mint'), 'the pay side is unaffected');
+});
+
+check('the announcement template is shaped exactly as the kind document says', () => {
+  const template = announcementTemplate(probedRow, probedFields, 1_787_000_000);
+  assert.equal(template.kind, 38174);
+  assert.deepEqual(template.tags[0], ['d', LIVE_WITHDRAW.mintPubkey]);
+  assert.deepEqual(template.tags[1], ['u', 'https://lnurl.21mint.me']);
+  assert.deepEqual(template.tags[2], ['features', 'mint,melt,lud06,lud03,lud16,signed-notes']);
+  assert.deepEqual(template.tags[3], ['n', 'mainnet']);
+  assert.equal(template.content, JSON.stringify({ name: '21 Mint' }));
+});
+
+check('a mint that never named a network is not assigned one', () => {
+  // Absent reads as mainnet, so asserting it would be this site inventing the one fact
+  // that decides whether the money is real.
+  const template = announcementTemplate(probedRow, { ...probedFields, network: null }, 1);
+  assert.equal(template.tags.some((t) => t[0] === 'n'), false);
+});
+
+check('an announcement this site wrote defers to its own kind 0 when there is no name', () => {
+  const template = announcementTemplate({ ...probedRow, name: null }, probedFields, 1);
+  assert.equal(template.content, '');
+});
+
+/* ------------------------------------------------------------------ *
+ * 8. The round trip, against a real relay
+ * ------------------------------------------------------------------ */
+
+await checkAsync('a 38174 announcement and a k=38174 review round-trip a relay', async () => {
+  const relay = await startTestRelay();
+  const pool = new SimplePool();
+
+  try {
+    const siteKey = generateSecretKey();
+    const sitePubkey = getPublicKey(siteKey);
+    const reviewerKey = generateSecretKey();
+
+    /* --- publish the announcement, using the publisher's own template builder --- */
+    const created = 1_787_000_000;
+    const announcementEvent = finalizeEvent(
+      announcementTemplate(probedRow, probedFields, created),
+      siteKey,
+    );
+    await Promise.allSettled(pool.publish([relay.url], announcementEvent));
+
+    /* --- publish a review of it, shaped as the kind document specifies --- */
+    const reviewEvent = finalizeEvent(
+      {
+        kind: KIND_REVIEW,
+        created_at: created + 60,
+        content: '[5/5] Rotations are instant and melts have never failed me.',
+        tags: [
+          ['k', String(KIND_LNURL_ANNOUNCEMENT)],
+          ['u', probedFields.base_url, 'lnurl'],
+          ['d', probedFields.lnurl_id],
+          ['a', `${KIND_LNURL_ANNOUNCEMENT}:${sitePubkey}:${probedFields.lnurl_id}`, relay.url],
+        ],
+      },
+      reviewerKey,
+    );
+    await Promise.allSettled(pool.publish([relay.url], reviewEvent));
+
+    /* --- read both back the way the indexer does --- */
+    const announcements = await pool.querySync(
+      [relay.url],
+      { kinds: [KIND_LNURL_ANNOUNCEMENT] },
+      { maxWait: 4000 },
+    );
+    assert.equal(announcements.length, 1, 'the relay should hold exactly one announcement');
+
+    const parsed = parseLnurlAnnouncement(announcements[0]!);
+    assert.ok(parsed, 'the indexer must be able to parse what the site published');
+    assert.equal(parsed.identifier, LIVE_WITHDRAW.mintPubkey);
+    assert.equal(parsed.baseUrl, 'https://lnurl.21mint.me');
+    assert.equal(parsed.mintPubkey, LIVE_WITHDRAW.mintPubkey);
+    assert.equal(parsed.network, 'mainnet');
+    assert.equal(parsed.announcerPubkey, sitePubkey);
+    assert.deepEqual(parsed.features, ['mint', 'melt', 'lud06', 'lud03', 'lud16', 'signed-notes']);
+    assert.equal(parsed.name, '21 Mint');
+
+    /* --- the review, asked for exactly as the targeted pass asks --- */
+    const reviews = await pool.querySync(
+      [relay.url],
+      {
+        kinds: [KIND_REVIEW],
+        '#k': [String(KIND_LNURL_ANNOUNCEMENT)],
+        '#d': lnurlIdentifiers(parsed.baseUrl, parsed.mintPubkey),
+      },
+      { maxWait: 4000 },
+    );
+    assert.equal(reviews.length, 1, 'the #d/#k filter the indexer uses must find it');
+    assert.equal(reviewEcosystem(reviews[0]!), 'lnurl');
+    assert.equal(parseRating(reviews[0]!), 5);
+
+    /* --- and by `u`, which is how a client that does not know this kind writes one --- */
+    const byUrl = await pool.querySync(
+      [relay.url],
+      { kinds: [KIND_REVIEW], '#u': [probedFields.base_url] },
+      { maxWait: 4000 },
+    );
+    assert.equal(byUrl.length, 1, 'the #u filter must find it too');
+
+    /* --- replacement: a second announcement for the same `d` replaces the first --- */
+    const updated = finalizeEvent(
+      announcementTemplate(
+        probedRow,
+        { ...probedFields, funding_available: false },
+        created + 3600,
+      ),
+      siteKey,
+    );
+    await Promise.allSettled(pool.publish([relay.url], updated));
+
+    const after = relay.byKind(KIND_LNURL_ANNOUNCEMENT);
+    assert.equal(after.length, 1, '38174 is addressable: the relay holds one, not two');
+    assert.equal(
+      after[0]?.tags.find((t) => t[0] === 'features')?.[1],
+      'lud06,lud03,lud16',
+      'and it is the newer one, with the funded capabilities dropped',
+    );
+  } finally {
+    pool.close([relay.url]);
+    await relay.close();
+  }
+});
+
+console.log(`ok, ${checks} LNURL checks passed`);

api/src/config.ts

@@ -112,6 +112,20 @@ export const config = {
   iconDir: process.env['ICON_DIR'] ?? path.join(apiRoot, 'data', 'icons'),
   relays: (process.env['RELAYS']?.split(',').map((r) => r.trim()).filter(Boolean) ??
     [...DEFAULT_RELAYS]) as string[],
+  /**
+   * The floor a backfill cycle has to clear before it counts as a real read.
+   *
+   * For about a year this deployment's RELAYS list did not include the relay carrying
+   * the kind 38000/38172 archive. Every backfill returned about thirty events, wrote
+   * them, reported ok=true, and the index sat at eight mints while every health signal
+   * stayed green. A backfill asks five relays for the whole history of four kinds; on a
+   * working relay set it comes back with thousands. Anything under this is not a quiet
+   * network, it is a misconfigured one, and it says so in the log and on /api/health.
+   *
+   * Raise it on a deployment that genuinely has more history, lower it for a local
+   * test relay. It is deliberately not zero-able: set it to 1 if you mean "off".
+   */
+  backfillMinEvents: int('BACKFILL_MIN_EVENTS', 200),
   probeIntervalMin: int('PROBE_INTERVAL_MIN', 10),
   discoveryIntervalMin: int('DISCOVERY_INTERVAL_MIN', 60),
   probeConcurrency: int('PROBE_CONCURRENCY', 8),
@@ -119,4 +133,39 @@ export const config = {
   userAgent: 'cashumints.space-indexer/1.0',
 } as const;
 
+/**
+ * Publishing `kind:38174` announcements, which is **off unless two switches are set**.
+ *
+ * One switch would be enough to make it work and is not enough to make it safe. This
+ * writes signed events to public relays, permanently and under this site's name, so
+ * turning it on has to be a thing somebody did on purpose rather than a thing that
+ * happened because a key was left in an env file from a test run:
+ *
+ *   ANNOUNCE_LNURL=true      the intent
+ *   ANNOUNCE_KEY=nsec1…      the identity it will be signed with
+ *   ANNOUNCE_RELAYS=wss://…  where, explicitly — there is deliberately no default
+ *
+ * The missing default on ANNOUNCE_RELAYS is the important one. Falling back to the
+ * site's read pool would mean the difference between a CI run against a local test relay
+ * and a permanent write to five public ones was a single unset variable.
+ *
+ * Returns null — never throws — when any of the three is missing, because a
+ * misconfigured publisher must not stop an indexer that still has a directory to serve.
+ * See the README section "Publishing LNURL mint announcements".
+ */
+export function announceConfig(
+  env: NodeJS.ProcessEnv = process.env,
+): { secretKey: string; relays: string[] } | null {
+  if (env['ANNOUNCE_LNURL']?.trim().toLowerCase() !== 'true') return null;
+
+  const secretKey = env['ANNOUNCE_KEY']?.trim() ?? '';
+  const relays = (env['ANNOUNCE_RELAYS'] ?? '')
+    .split(',')
+    .map((relay) => relay.trim())
+    .filter((relay) => relay.startsWith('ws://') || relay.startsWith('wss://'));
+
+  if (!secretKey || relays.length === 0) return null;
+  return { secretKey, relays };
+}
+
 export const startedAt = Math.floor(Date.now() / 1000);

api/src/discovery.ts

@@ -3,25 +3,29 @@ import type { Event as NostrEvent, Filter } from 'nostr-tools';
 import {
   ANNOUNCEMENT_KINDS,
   KIND_FEDIMINT_ANNOUNCEMENT,
+  KIND_LNURL_ANNOUNCEMENT,
   KIND_MINT_ANNOUNCEMENT,
   KIND_REVIEW,
-  isCashuMintReview,
   mintPubkeyRef,
   mintUrlSpellings,
   mintUrlsFromEvent,
   normalizeMintUrl,
   parseFedimintAnnouncement,
+  parseLnurlAnnouncement,
   parseRating,
   reviewEcosystem,
   reviewTargetId,
   reviewTargetKind,
   type FedimintAnnouncement,
+  type LnurlAnnouncement,
+  type LnurlFields,
+  type RelayHealth,
 } from '@cashumints/shared';
 import { config } from './config.ts';
-import { getDb, setState, getStateNumber } from './db.ts';
+import { getDb, setState, getState, getStateNumber } from './db.ts';
 import type { Sql } from './db-driver.ts';
 import { log } from './log.ts';
-import { insertMintIfNew, upsertFedimint } from './mints.ts';
+import { insertMintIfNew, upsertFedimint, upsertLnurl } from './mints.ts';
 
 const QUERY_LIMIT = 500;
 const MAX_WAIT_MS = 12_000;
@@ -36,11 +40,130 @@ export interface DiscoveryResult {
   newMints: string[];
   newReviews: number;
   ok: boolean;
+  /** What each configured relay actually did, in `config.relays` order. */
+  relays: RelayHealth[];
+  /** A backfill that came in under `config.backfillMinEvents`. */
+  starved: boolean;
 }
 
+/**
+ * What the last cycle did, kept so /api/health can answer for it.
+ *
+ * Written to the `state` table rather than held in memory, because the question it
+ * answers — "is discovery actually reading anything?" — has to survive the restart that
+ * would otherwise reset it to "no cycle yet, nothing to report". A process that crash
+ * loops would clear an in-memory flag on every attempt.
+ */
+export interface DiscoveryReport {
+  at: number;
+  mode: 'backfill' | 'incremental';
+  events: number;
+  ok: boolean;
+  relays: RelayHealth[];
+  starved: boolean;
+}
+
+/** `state` key holding the JSON of the above. */
+const REPORT_KEY = 'last_discovery_report';
+
+/**
+ * The last cycle's report, or null before any cycle has run.
+ *
+ * A row that will not parse reads as null — the same as no cycle — because the caller
+ * is a health endpoint and "I cannot tell you" must not be dressed up as "fine".
+ */
+export async function lastDiscoveryReport(): Promise<DiscoveryReport | null> {
+  const raw = await getState(REPORT_KEY);
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw) as DiscoveryReport;
+    return Array.isArray(parsed.relays) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Per-relay bookkeeping for one cycle.
+ *
+ * Every relay in `config.relays` gets a row up front, including the ones that are never
+ * reached, because a relay that produced no row at all is exactly the one worth naming:
+ * the year-long starvation was a relay list that connected cleanly and simply did not
+ * hold the archive, and the only field that would have shown it is a zero here.
+ *
+ * `events` counts what a relay sent *before* cross-relay deduplication, so five relays
+ * carrying the same 400 events report 400 each rather than 400 once and 0 four times.
+ * Attribution is the whole point; the deduplicated total is reported separately.
+ */
+class RelayTally {
+  private readonly rows = new Map<string, { events: number; subs: number; eoses: number; connected: boolean }>();
+
+  constructor(urls: readonly string[]) {
+    for (const url of urls) {
+      this.rows.set(url, { events: 0, subs: 0, eoses: 0, connected: false });
+    }
+  }
+
+  private row(url: string) {
+    let found = this.rows.get(url);
+    if (!found) {
+      found = { events: 0, subs: 0, eoses: 0, connected: false };
+      this.rows.set(url, found);
+    }
+    return found;
+  }
+
+  connected(url: string): void {
+    this.row(url).connected = true;
+  }
+
+  subscribed(url: string): void {
+    this.row(url).subs++;
+  }
+
+  event(url: string): void {
+    this.row(url).events++;
+  }
+
+  eose(url: string): void {
+    this.row(url).eoses++;
+  }
+
+  /** One row per configured relay, in configuration order. */
+  list(): RelayHealth[] {
+    return [...this.rows.entries()].map(([url, row]) => ({
+      url,
+      connected: row.connected,
+      events: row.events,
+      // A cycle asks a relay many questions. It only counts as having reached the end
+      // of the stream if it reached the end of every one of them.
+      eose: row.subs > 0 && row.eoses === row.subs,
+    }));
+  }
+}
+
+/**
+ * Long enough that the relay's own EOSE timer never wins.
+ *
+ * `Subscription` fires `oneose` both when an EOSE frame arrives and when its internal
+ * timer expires, so the two are indistinguishable from the callback. Pushing that timer
+ * out of reach and running the deadline here instead is what makes `eose` in the report
+ * mean "the relay said it was done" rather than "something gave up".
+ */
+const NEVER_EOSE_MS = 24 * 60 * 60 * 1000;
+
 let pool: SimplePool | null = null;
 
-function getPool(): SimplePool {
+/**
+ * The process's one relay pool.
+ *
+ * Exported because `relay-lookup.ts` asks the same relays a different question — "has
+ * anyone ever mentioned this address?", for a mint a reader just submitted that does
+ * not answer — and opening a second pool for it would mean a second set of sockets to
+ * the same five relays, with its own reconnect behaviour and its own lifetime to get
+ * wrong at shutdown.
+ */
+export function getPool(): SimplePool {
   pool ??= new SimplePool();
   return pool;
 }
@@ -54,12 +177,100 @@ export function closePool(): void {
   pool = null;
 }
 
+/**
+ * Ask every configured relay one filter, and record what each of them did.
+ *
+ * This replaces `pool.querySync(config.relays, …)`, which answers the same question and
+ * throws the attribution away: it merges five relays into one deduplicated array, so a
+ * relay list where four relays are empty and one carries everything is indistinguishable
+ * from five healthy ones. That indistinguishability is the bug this whole file is being
+ * changed for — a year of ~31-event backfills, `ok=true` every time.
+ *
+ * What it keeps from `querySync`, deliberately:
+ *
+ *   - One subscription per relay over the pool's existing sockets, so this is the same
+ *     number of connections as before.
+ *   - A single `alreadyHaveEvent` shared across all five. `AbstractRelay._onmessage`
+ *     consults it *before* `JSON.parse` and signature verification, so an event five
+ *     relays all carry is still verified once. Per-relay `querySync` calls would have
+ *     verified it five times, which at 500 events a page is real CPU.
+ *   - `receivedEvent`, which fires on the way past that check, so the per-relay count is
+ *     what the relay sent rather than what was new because of it.
+ *
+ * What it changes: the deadline is run here rather than by each `Subscription`'s own
+ * EOSE timer, so `oneose` firing means an EOSE frame actually arrived. See NEVER_EOSE_MS.
+ *
+ * Never throws. A relay that will not connect is a fact to record, not a reason to
+ * abandon the four that did.
+ */
+async function queryRelays(filter: Filter, tally: RelayTally | null): Promise<NostrEvent[]> {
+  const events: NostrEvent[] = [];
+  const known = new Set<string>();
+  const alreadyHaveEvent = (id: string): boolean => {
+    if (known.has(id)) return true;
+    known.add(id);
+    return false;
+  };
+
+  await Promise.all(
+    config.relays.map(async (url) => {
+      let relay;
+      try {
+        // The same connection budget subscribeMap would have used for this maxWait.
+        relay = await getPool().ensureRelay(url, {
+          connectionTimeout: Math.max(MAX_WAIT_MS * 0.8, MAX_WAIT_MS - 1000),
+        });
+      } catch {
+        // Left as connected=false in the tally, which is the whole report this needs.
+        return;
+      }
+      tally?.connected(url);
+
+      await new Promise<void>((resolve) => {
+        let settled = false;
+        let deadline: ReturnType<typeof setTimeout> | undefined;
+        const finish = (): void => {
+          if (settled) return;
+          settled = true;
+          if (deadline !== undefined) clearTimeout(deadline);
+          resolve();
+        };
+
+        try {
+          const sub = relay.subscribe([filter], {
+            onevent: (event) => events.push(event),
+            alreadyHaveEvent,
+            receivedEvent: () => tally?.event(url),
+            oneose: () => {
+              tally?.eose(url);
+              sub.close('closed automatically on eose');
+            },
+            onclose: finish,
+            eoseTimeout: NEVER_EOSE_MS,
+          });
+          tally?.subscribed(url);
+          deadline = setTimeout(() => sub.close('closed on maxWait'), MAX_WAIT_MS);
+        } catch {
+          // The socket went away between ensureRelay and the REQ.
+          finish();
+        }
+      });
+    }),
+  );
+
+  return events;
+}
+
 /**
  * Query one kind, paging backwards with `until` until a page yields nothing new.
  * Relays cap `limit` independently, so paging is the only way a fresh database
  * converges to the complete history.
  */
-async function fetchKind(kind: number, since: number | null): Promise<NostrEvent[]> {
+async function fetchKind(
+  kind: number,
+  since: number | null,
+  tally: RelayTally | null,
+): Promise<NostrEvent[]> {
   const seen = new Map<string, NostrEvent>();
   let until: number | undefined;
 
@@ -70,7 +281,7 @@ async function fetchKind(kind: number, since: number | null): Promise<NostrEvent
 
     let batch: NostrEvent[];
     try {
-      batch = await getPool().querySync(config.relays, filter, { maxWait: MAX_WAIT_MS });
+      batch = await queryRelays(filter, tally);
     } catch (err) {
       log.warn('relay query failed', {
         kind,
@@ -111,6 +322,7 @@ async function fetchKind(kind: number, since: number | null): Promise<NostrEvent
 async function fetchReviewsForMint(
   target: ReviewTarget,
   since: number | null,
+  tally: RelayTally | null,
 ): Promise<NostrEvent[]> {
   const filters: Filter[] = [];
   const base: Filter = { kinds: [KIND_REVIEW], limit: QUERY_LIMIT };
@@ -137,6 +349,27 @@ async function fetchReviewsForMint(
       '#d': [target.federationId],
       '#k': [String(KIND_FEDIMINT_ANNOUNCEMENT)],
     });
+  } else if (target.type === 'lnurl') {
+    /*
+     * Asked for by every identifier it has ever had, not just its current one.
+     *
+     * An LNURL mint's `d` is its funding node's pubkey when it has one and its host
+     * otherwise, so a mint that gained a funding source has reviews filed under both
+     * spellings — the older ones under the host, the newer under the pubkey. One `#d`
+     * filter carrying both is one round trip and finds all of them; asking for only the
+     * current identifier would silently strand the earlier half. See the kind document.
+     *
+     * `#u` is asked as well, and unlike a federation's invite codes an LNURL mint's URLs
+     * are short enough that no relay rejects the filter.
+     */
+    if (target.identifiers.length > 0) {
+      filters.push({
+        ...base,
+        '#d': target.identifiers,
+        '#k': [String(KIND_LNURL_ANNOUNCEMENT)],
+      });
+    }
+    filters.push({ ...base, '#u': mintUrlSpellings(target.baseUrl ?? target.url) });
   } else {
     if (target.pubkey) {
       filters.push({ ...base, '#d': [target.pubkey], '#k': [String(KIND_MINT_ANNOUNCEMENT)] });
@@ -145,11 +378,7 @@ async function fetchReviewsForMint(
   }
 
   const batches = await Promise.all(
-    filters.map((filter) =>
-      getPool()
-        .querySync(config.relays, filter, { maxWait: MAX_WAIT_MS })
-        .catch(() => [] as NostrEvent[]),
-    ),
+    filters.map((filter) => queryRelays(filter, tally).catch(() => [] as NostrEvent[])),
   );
 
   return batches.flat();
@@ -164,10 +393,14 @@ async function fetchReviewsForMint(
  */
 interface ReviewTarget {
   type: string;
-  /** Row key: the mint URL, or `fedimint:<id>`. */
+  /** Row key: the mint URL, `fedimint:<id>`, or `lnurl:<base url>`. */
   url: string;
   pubkey: string | null;
   federationId: string | null;
+  /** LNURL: every `d` this mint could be reviewed under. Empty for the others. */
+  identifiers: string[];
+  /** LNURL: the fetchable https URL inside the row key. */
+  baseUrl: string | null;
 }
 
 /**
@@ -201,6 +434,41 @@ async function ingestFedimints(
   }
 }
 
+/**
+ * Every LNURL mint the batch announces, inserted or refreshed.
+ *
+ * Deduped **by normalized base URL**, not by the `d` tag, which is the one place this
+ * genuinely differs from `ingestFedimints`. A federation has exactly one identity for
+ * life; an LNURL mint's identifier is its funding node's pubkey when it has one and its
+ * host otherwise, so the same mint legitimately announces under two different `d` values
+ * across its life. Keying on `d` would split it into two pages with half its reviews on
+ * each. The `u` tag is present in every form of the event, so it is the key.
+ *
+ * Newest announcement per URL wins inside the batch, for the same reason the Fedimint
+ * side does it: the same mint is announced by more than one npub and more than once, and
+ * writing each of those would be one UPDATE per event to reach the same final state.
+ */
+async function ingestLnurl(
+  events: Iterable<NostrEvent>,
+  now: number,
+  newRows: Set<string>,
+): Promise<void> {
+  const newest = new Map<string, LnurlAnnouncement>();
+
+  for (const event of events) {
+    const announcement = parseLnurlAnnouncement(event);
+    if (!announcement) continue;
+    const existing = newest.get(announcement.baseUrl);
+    if (existing && existing.announcedAt >= announcement.announcedAt) continue;
+    newest.set(announcement.baseUrl, announcement);
+  }
+
+  for (const announcement of newest.values()) {
+    const created = await upsertLnurl(announcement, now);
+    if (created) newRows.add(created);
+  }
+}
+
 /**
  * Every mint URL the batch points at, normalized and inserted if new.
  *
@@ -247,6 +515,18 @@ interface MintIndex {
   byFederation: Map<string, string>;
   /** Invite code to row key, for a review that carries `u` but no usable `d`. */
   byInvite: Map<string, string>;
+  /**
+   * Every LNURL identifier to its row key: the mint pubkey *and* the normalized host,
+   * both pointing at the same row.
+   *
+   * Kept apart from `byPubkey`, which is the Cashu index over `mints.pubkey`. An LNURL
+   * mint's key is its funding node's identity, not a Cashu mint pubkey, and mixing the
+   * two namespaces would let a review of one resolve to the other. Nothing writes
+   * `mints.pubkey` for an LNURL row, for exactly that reason.
+   */
+  byLnurlId: Map<string, string>;
+  /** Normalized base URL to row key, for a review that carries `u` but no usable `d`. */
+  byLnurlUrl: Map<string, string>;
 }
 
 async function loadMintIndex(): Promise<MintIndex> {
@@ -263,12 +543,30 @@ async function loadMintIndex(): Promise<MintIndex> {
   const byPubkey = new Map<string, string>();
   const byFederation = new Map<string, string>();
   const byInvite = new Map<string, string>();
+  const byLnurlId = new Map<string, string>();
+  const byLnurlUrl = new Map<string, string>();
 
   for (const row of rows) {
     byHost.set(row.host, row.url);
     // First writer wins, matching the LIMIT 1 the per-event query used.
     if (row.pubkey && !byPubkey.has(row.pubkey)) byPubkey.set(row.pubkey, row.url);
 
+    if (row.type === 'lnurl' && row.ecosystem_json) {
+      try {
+        const fields = JSON.parse(row.ecosystem_json) as Partial<LnurlFields>;
+        // Both identifiers, always: a mint announced by host and later by pubkey has
+        // reviews under each, and both belong to this one row.
+        for (const id of [fields.lnurl_id, fields.mint_pubkey]) {
+          if (id) byLnurlId.set(id.toLowerCase(), row.url);
+        }
+        if (fields.base_url) byLnurlUrl.set(fields.base_url, row.url);
+      } catch {
+        // Unparseable column: this row simply cannot be matched by identifier. It still
+        // has a page and still resolves by its key, which is honest.
+      }
+      continue;
+    }
+
     if (row.type !== 'fedimint' || !row.ecosystem_json) continue;
     try {
       const fields = JSON.parse(row.ecosystem_json) as {
@@ -283,7 +581,7 @@ async function loadMintIndex(): Promise<MintIndex> {
     }
   }
 
-  return { byHost, byPubkey, byFederation, byInvite };
+  return { byHost, byPubkey, byFederation, byInvite, byLnurlId, byLnurlUrl };
 }
 
 /**
@@ -303,6 +601,7 @@ function resolveReviewTarget(event: NostrEvent, index: MintIndex): string | null
    */
   const ecosystem = reviewEcosystem(event);
   if (ecosystem === 'fedimint') return resolveFedimintReview(event, index);
+  if (ecosystem === 'lnurl') return resolveLnurlReview(event, index);
   // A `k` naming a kind this build has no ecosystem for: not ours to file.
   if (ecosystem === null) return null;
 
@@ -344,6 +643,39 @@ function resolveFedimintReview(event: NostrEvent, index: MintIndex): string | nu
   return null;
 }
 
+/**
+ * Which LNURL mint a review is about.
+ *
+ * `d` first, matched against both identifiers a mint can have — its funding node's
+ * pubkey and its normalized host — because a mint that gained a funding source has
+ * reviews written under each and both name the same page.
+ *
+ * The `u` fallback is not the afterthought it is on the Fedimint side. An LNURL mint's
+ * `u` tag is a real, normalizable https URL, so a review that carries only an address
+ * resolves exactly as a Cashu review does, through the same normalizer. That matters
+ * for reviews written by clients that do not know this kind: `u` is the tag they are
+ * most likely to get right.
+ *
+ * A review of a mint this site has never seen resolves to nothing and is dropped, as it
+ * is for the other two ecosystems. There is no page to put it on.
+ */
+function resolveLnurlReview(event: NostrEvent, index: MintIndex): string | null {
+  const d = reviewTargetId(event);
+  if (d) {
+    const found = index.byLnurlId.get(d.trim().toLowerCase());
+    if (found) return found;
+  }
+
+  for (const raw of mintUrlsFromEvent(event)) {
+    const normalized = normalizeMintUrl(raw);
+    if (!normalized) continue;
+    const found = index.byLnurlUrl.get(normalized.url);
+    if (found) return found;
+  }
+
+  return null;
+}
+
 /** Postgres caps a statement at 65535 bounds parameters; this keeps every batch clear of it. */
 const INSERT_BATCH = 500;
 
@@ -402,8 +734,19 @@ async function ingestReviews(events: Iterable<NostrEvent>, index: MintIndex): Pr
      */
     const target = resolveReviewTarget(e, index);
     if (!target) continue;
-    const fedimint = reviewTargetKind(e) === KIND_FEDIMINT_ANNOUNCEMENT;
-    if (!fedimint && !isCashuMintReview(e) && mintUrlsFromEvent(e).length === 0) continue;
+    /*
+     * A review whose `k` names an ecosystem this build knows has already proved itself
+     * by resolving: `resolveReviewTarget` runs one resolver per ecosystem and returns a
+     * row only for an event whose `k` matches that resolver, so nothing here has to
+     * re-test it. Written against `ANNOUNCEMENT_KINDS` rather than against a list of
+     * kind numbers, so a fourth ecosystem needs no edit here either.
+     *
+     * The `u` clause is what keeps the legacy events: a great many kind 38000 on the
+     * network carry no `k` at all, every one of them is about a Cashu mint, and they are
+     * accepted on having a resolvable mint URL exactly as they always were.
+     */
+    const kindKnown = reviewTargetKind(e) !== null && reviewEcosystem(e) !== null;
+    if (!kindKnown && mintUrlsFromEvent(e).length === 0) continue;
 
     const k = reviewTargetKind(e);
 
@@ -449,6 +792,7 @@ export async function runDiscovery(backfill: boolean): Promise<DiscoveryResult>
   const since = lastRun === null ? null : Math.max(0, lastRun - 3600);
 
   const newMints = new Set<string>();
+  const tally = new RelayTally(config.relays);
   let newReviews = 0;
   let events = 0;
   let ok = true;
@@ -463,23 +807,25 @@ export async function runDiscovery(backfill: boolean): Promise<DiscoveryResult>
     const announcementsByType = new Map<string, NostrEvent[]>();
     await Promise.all(
       Object.entries(ANNOUNCEMENT_KINDS).map(async ([type, kind]) => {
-        announcementsByType.set(type, await fetchKind(kind, since));
+        announcementsByType.set(type, await fetchKind(kind, since, tally));
       }),
     );
 
     const announcements = announcementsByType.get('cashu') ?? [];
     const federations = announcementsByType.get('fedimint') ?? [];
-    events += announcements.length + federations.length;
+    const lnurlMints = announcementsByType.get('lnurl') ?? [];
+    events += announcements.length + federations.length + lnurlMints.length;
 
     await ingestMintUrls(announcements, now, newMints);
     await ingestFedimints(federations, now, newMints);
+    await ingestLnurl(lnurlMints, now, newMints);
 
     // Announcements alone miss mints that only ever appear in a review's `u` tag,
     // so reviews feed discovery too.
-    const reviews = await fetchKind(KIND_REVIEW, since);
+    const reviews = await fetchKind(KIND_REVIEW, since, tally);
     // The recent window catches anything a relay dropped from the unbounded query.
     const recent =
-      since === null ? await fetchKind(KIND_REVIEW, now - RECENT_WINDOW_S) : [];
+      since === null ? await fetchKind(KIND_REVIEW, now - RECENT_WINDOW_S, tally) : [];
 
     const byId = new Map<string, NostrEvent>();
     for (const e of [...reviews, ...recent]) byId.set(e.id, e);
@@ -505,15 +851,32 @@ export async function runDiscovery(backfill: boolean): Promise<DiscoveryResult>
 
     const targets: ReviewTarget[] = rows.map((row) => {
       let federationId: string | null = null;
-      if (row.type === 'fedimint' && row.ecosystem_json) {
+      let identifiers: string[] = [];
+      let baseUrl: string | null = null;
+
+      if (row.ecosystem_json) {
         try {
+          if (row.type === 'fedimint') {
             federationId =
               (JSON.parse(row.ecosystem_json) as { federation_id?: string }).federation_id ?? null;
+          } else if (row.type === 'lnurl') {
+            const fields = JSON.parse(row.ecosystem_json) as Partial<LnurlFields>;
+            baseUrl = fields.base_url ?? null;
+            // Deduped, because a mint with no funding source has `lnurl_id` and
+            // `mint_pubkey` describing the same thing and a relay filter listing one
+            // value twice is one wasted slot.
+            identifiers = [...new Set(
+              [fields.lnurl_id, fields.mint_pubkey]
+                .filter((id): id is string => Boolean(id))
+                .map((id) => id.toLowerCase()),
+            )];
+          }
         } catch {
           // Nothing to ask by. The global sweep above already had its chance.
         }
       }
-      return { type: row.type, url: row.url, pubkey: row.pubkey, federationId };
+
+      return { type: row.type, url: row.url, pubkey: row.pubkey, federationId, identifiers, baseUrl };
     });
 
     const CONCURRENCY = 6;
@@ -523,7 +886,7 @@ export async function runDiscovery(backfill: boolean): Promise<DiscoveryResult>
         while (cursor < targets.length) {
           const target = targets[cursor++];
           if (!target) continue;
-          const found = await fetchReviewsForMint(target, since);
+          const found = await fetchReviewsForMint(target, since, tally);
           if (found.length > 0) {
             events += found.length;
             newReviews += await ingestReviews(found, index);
@@ -541,14 +904,79 @@ export async function runDiscovery(backfill: boolean): Promise<DiscoveryResult>
     log.error('discovery failed', { reason: err instanceof Error ? err.message : String(err) });
   }
 
+  const mode = backfill ? 'backfill' : 'incremental';
+  const relays = tally.list();
+
+  /*
+   * Name the relay, every time, one line each.
+   *
+   * A relay that would not connect is worth saying on any cycle: the address is wrong,
+   * or it is down, and neither gets better by itself. A relay that connected and sent
+   * nothing is only news on a backfill — an incremental cycle asking for the last hour
+   * of four kinds legitimately comes back empty, and warning about that hourly would
+   * train everyone to skip the line that eventually matters.
+   */
+  for (const relay of relays) {
+    if (!relay.connected) {
+      log.warn('discovery relay unreachable', { relay: relay.url, mode });
+      continue;
+    }
+    if (backfill && relay.events === 0) {
+      log.warn('discovery relay returned no events', { relay: relay.url, mode });
+    } else if (!relay.eose) {
+      log.warn('discovery relay never reached EOSE', {
+        relay: relay.url,
+        mode,
+        events: relay.events,
+      });
+    }
+  }
+
+  /*
+   * The floor, and the flag the health endpoint reads.
+   *
+   * Only a backfill is measured against it. A backfill asks for the entire history of
+   * every announcement kind and every review, so on a working relay set it is thousands
+   * of events; an incremental cycle asks for one interval and is supposed to be small.
+   *
+   * The flag is sticky across incremental cycles: an hourly cycle that finds four
+   * events must not clear a starvation a backfill diagnosed, so a non-backfill carries
+   * forward whatever the last backfill concluded.
+   */
+  let starved: boolean;
+  if (backfill) {
+    starved = events < config.backfillMinEvents;
+    if (starved) {
+      log.error('discovery starvation suspected', {
+        events,
+        floor: config.backfillMinEvents,
+        relays: relays.length,
+        silent: relays.filter((r) => r.events === 0).length,
+        unreachable: relays.filter((r) => !r.connected).length,
+        hint: 'check RELAYS: a relay list missing the announcement archive looks exactly like this',
+      });
+    }
+  } else {
+    // No backfill has ever run in this deployment: nothing has confirmed the relay set
+    // reads anything, and saying "fine" would be the whole original bug.
+    starved = (await lastDiscoveryReport())?.starved ?? true;
+  }
+
+  const report: DiscoveryReport = { at: now, mode, events, ok, relays, starved };
+  // A report that cannot be written is not worth failing a cycle over; the cycle's own
+  // work is already committed, and health degrades on the stale timestamp instead.
+  await setState(REPORT_KEY, JSON.stringify(report)).catch(() => undefined);
+
   log.info('discovery cycle', {
-    mode: backfill ? 'backfill' : 'incremental',
+    mode,
     events,
     new_mints: newMints.size,
     new_reviews: newReviews,
     ok,
+    starved,
+    relays: relays.map((r) => `${r.url}=${r.connected ? r.events : 'down'}`).join(' '),
     ms: Date.now() - started,
   });
 
-  return { events, newMints: [...newMints], newReviews, ok };
+  return { events, newMints: [...newMints], newReviews, ok, relays, starved };
 }

api/src/index-mint.ts

@@ -0,0 +1,536 @@
+/**
+ * On-demand indexing: `POST /api/index`.
+ *
+ * The fifth endpoint, and the first one that writes. Everything else this API serves is
+ * a read of rows the probe and discovery loops put there on their own schedule; this is
+ * a reader saying "I have an address you do not know, look at it now" and getting a page
+ * back in the same request.
+ *
+ * It exists because of a specific failure the site had: opening `/lnurl-mint/mint.600.wtf`
+ * — a live, healthy mint — returned the 404 page, because the only way into the index
+ * was a Nostr announcement that nobody had published. A directory whose answer to "here
+ * is a mint you have not got" is a 404 is a directory that can only ever list what other
+ * people already listed.
+ *
+ * The order of the checks below is the whole design, and each step is only reached
+ * because the one above it did not settle the question:
+ *
+ *   1. **Already indexed?** Then there is nothing to do and nothing to fetch. Answering
+ *      from the row is not an optimisation, it is the correct answer: a mint's status is
+ *      the probe loop's business, and a submission is not a reason to re-probe it.
+ *   2. **Does it answer, as what it claims to be?** One probe, the standard timeout,
+ *      through the guarded fetcher in `safe-fetch.ts`.
+ *   3. **Does it answer as something else?** A Cashu mint pasted into the LNURL box is
+ *      the single most likely mistake, and "that address answered, but as a Cashu mint"
+ *      with a button to go there is worth far more than "invalid".
+ *   4. **Did it ever exist?** Silence over HTTPS is not proof of absence. One bounded
+ *      relay lookup separates a mint that rugged from an address nobody ever used —
+ *      see `relay-lookup.ts`, which is where that argument is made at length.
+ *
+ * A row written here is an ordinary row the moment it exists. The probe loop owns it
+ * from the next cycle, discovery will fill in its reviews, and nothing downstream can
+ * tell how it arrived.
+ */
+import {
+  fedimintKey,
+  federationIdFromInviteCode,
+  isIndexType,
+  isNut06Info,
+  lnurlKey,
+  normalizeMintUrl,
+  parseAdvertisement,
+  parsePayInfo,
+  PAY_INFO_PATH,
+  WITHDRAW_INFO_PATH,
+  type IndexFailure,
+  type IndexSource,
+  type IndexSuccess,
+  type IndexType,
+  type MintInfo,
+} from '@cashumints/shared';
+import { getDb } from './db.ts';
+import { log } from './log.ts';
+import { probeLnurl } from './lnurl-probe.ts';
+import {
+  insertFedimintFromInvite,
+  insertLnurlIfNew,
+  insertMintIfNew,
+  mintByHost,
+  mintByUrl,
+  upsertLnurl,
+  type MintRow,
+} from './mints.ts';
+import { applyLnurlResult, recordCashuOnline } from './probe.ts';
+import { getMintDetail, resetStatsCache } from './queries.ts';
+import { traceOnRelays } from './relay-lookup.ts';
+import { checkDestination, guardedTextFetcher, MAX_PROBE_BYTES, safeFetchText } from './safe-fetch.ts';
+import { cacheIcon } from './icons.ts';
+
+export interface IndexOutcome {
+  status: 200 | 201 | 404 | 422 | 429;
+  body: IndexSuccess | IndexFailure;
+}
+
+function fail(
+  status: 404 | 422 | 429,
+  error: IndexFailure['error'],
+  message: string,
+  extra: Partial<IndexFailure> = {},
+): IndexOutcome {
+  return { status, body: { error, message, ...extra } };
+}
+
+/**
+ * The response body for a row, in the shape `GET /api/mints/:host` returns.
+ *
+ * Read back through `getMintDetail` rather than assembled here, so the payload a
+ * freshly indexed mint arrives in is byte for byte the payload it will have on every
+ * request after this one. The 404 resolver renders the same page shell from both, and
+ * a second shape to keep in step would be a second shape to get wrong.
+ */
+async function payload(host: string, existing: boolean, source?: IndexSource): Promise<IndexOutcome> {
+  const detail = await getMintDetail(host);
+  if (!detail) {
+    // The row was written moments ago; a miss here means the write did not land.
+    return fail(422, 'invalid_response', 'The mint was indexed but could not be read back');
+  }
+  // The new row changes the counts three pages print in a sentence, and those are
+  // memoised for a minute. A reader who has just indexed a mint should see it counted.
+  if (!existing) resetStatsCache();
+  return {
+    status: existing ? 200 : 201,
+    body: { ...detail, existing, ...(source ? { indexed_from: source } : {}) },
+  };
+}
+
+/* ---------- what kind of bad input is this? ---------- */
+
+/**
+ * Why `normalizeMintUrl` said no.
+ *
+ * It answers null for everything, which is right for a discovery loop reading tags and
+ * wrong for a person who just typed something: "that is not a URL" and "we will not
+ * fetch a private address" are different mistakes with different fixes.
+ */
+function rejectionFor(input: string): IndexFailure['error'] {
+  const raw = input.trim();
+  const withScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(raw) ? raw : `https://${raw}`;
+  try {
+    const url = new URL(withScheme);
+    if (url.protocol !== 'https:' && url.protocol !== 'http:') return 'bad_input';
+    return url.hostname ? 'blocked_host' : 'bad_input';
+  } catch {
+    return 'bad_input';
+  }
+}
+
+/* ---------- cashu ---------- */
+
+/** What one guarded `/v1/info` request concluded. */
+type InfoProbe =
+  | { state: 'mint'; info: MintInfo; latencyMs: number }
+  | { state: 'answered'; detail: string }
+  | { state: 'blocked'; reason: string }
+  | { state: 'silent'; reason: string };
+
+async function probeCashuInfo(url: string): Promise<InfoProbe> {
+  const started = Date.now();
+  const outcome = await safeFetchText(`${url}/v1/info`, {
+    accept: 'application/json',
+    maxBytes: MAX_PROBE_BYTES,
+  });
+
+  if (outcome.state === 'blocked') return { state: 'blocked', reason: outcome.reason };
+  if (outcome.state === 'unreachable') return { state: 'silent', reason: outcome.reason };
+
+  if (outcome.status < 200 || outcome.status >= 300) {
+    return { state: 'answered', detail: `HTTP ${outcome.status} from /v1/info` };
+  }
+
+  let body: unknown;
+  try {
+    body = JSON.parse(outcome.body) as unknown;
+  } catch {
+    return { state: 'answered', detail: 'the response was not JSON' };
+  }
+
+  if (!isNut06Info(body)) {
+    return { state: 'answered', detail: 'the response was not a NUT-06 mint info document' };
+  }
+  return { state: 'mint', info: body, latencyMs: Date.now() - started };
+}
+
+/* ---------- lnurl ---------- */
+
+/**
+ * Is this host an LNURL mint, asked cheaply, for wrong-type detection only.
+ *
+ * The full `probeLnurl` fetches four endpoints and is what runs when LNURL is what was
+ * claimed. This is the other direction — a Cashu submission that did not answer as one
+ * — and only has to answer yes or no, so it reads the two advertisements and stops.
+ */
+async function looksLikeLnurl(url: string): Promise<boolean> {
+  const get = guardedTextFetcher();
+  const [withdraw, pay] = await Promise.all([
+    get(`${url}${WITHDRAW_INFO_PATH}`, 'application/json', MAX_PROBE_BYTES),
+    get(`${url}${PAY_INFO_PATH}`, 'application/json', MAX_PROBE_BYTES),
+  ]);
+
+  const parsed = (raw: { body: string } | null, parse: (value: unknown) => unknown): boolean => {
+    if (!raw) return false;
+    try {
+      return parse(JSON.parse(raw.body) as unknown) !== null;
+    } catch {
+      return false;
+    }
+  };
+
+  return parsed(withdraw, parseAdvertisement) || parsed(pay, parsePayInfo);
+}
+
+/** The same question the other way round, for an LNURL submission that did not parse. */
+async function looksLikeCashu(url: string): Promise<boolean> {
+  const probe = await probeCashuInfo(url);
+  return probe.state === 'mint';
+}
+
+/* ---------- writing a row that nothing answered for ---------- */
+
+/**
+ * Record a mint that Nostr remembers and HTTPS does not: the rugged-mint case.
+ *
+ * `consecutive_fails` is set straight to the offline threshold rather than to the one
+ * failure that actually happened, and that is deliberate. The ladder in `statusForFails`
+ * only ever counts upwards, so a row stored as `offline` with one failure behind it
+ * would be *promoted* to `degraded` by its next failed probe — a mint appearing to
+ * recover by staying dark. Three failures is what "offline" means everywhere else in
+ * this database, so that is what an offline row carries.
+ */
+async function markOfflineFromAnnouncement(
+  row: MintRow,
+  meta: { name: string | null; about: string | null; picture: string | null },
+  now: number,
+): Promise<void> {
+  const db = await getDb();
+  const iconFile = meta.picture ? await cacheIcon(row, meta.picture) : row.icon_file;
+
+  await db.run(
+    `UPDATE mints SET
+       name = COALESCE(name, ?),
+       description = COALESCE(description, ?),
+       icon_url = COALESCE(icon_url, ?),
+       icon_file = ?,
+       status = 'offline',
+       consecutive_fails = 3,
+       last_probe = ?,
+       updated_at = ?
+     WHERE url = ?`,
+    meta.name,
+    meta.about,
+    meta.picture,
+    iconFile,
+    now,
+    now,
+    row.url,
+  );
+
+  // One real failed probe, because one real probe really did fail. The uptime figure
+  // and the sparkline should show that this site looked and got nothing.
+  await db.run(
+    'INSERT INTO probes (mint_url, ts, ok, latency_ms) VALUES (?, ?, 0, NULL)',
+    row.url,
+    now,
+  );
+}
+
+/**
+ * The last resort for a URL nothing answered at: ask the relays, and index what they
+ * remember. Returns the outcome to send back, whichever way it went.
+ */
+async function fromRelays(
+  type: 'cashu' | 'lnurl',
+  url: string,
+  now: number,
+): Promise<IndexOutcome> {
+  const trace = await traceOnRelays(type, url);
+
+  if (!trace.found) {
+    return fail(
+      404,
+      'unverifiable',
+      'Nothing answered at that address, and no announcement or review of it exists on Nostr',
+    );
+  }
+
+  /*
+   * An LNURL announcement is written through the same path discovery uses, so the row
+   * carries its features, network and announcer exactly as it would have — but only when
+   * the announcement is about *this* address. A `#d` filter can also match an
+   * announcement whose `u` is a different URL under the same host identifier, and that
+   * one belongs to a different row.
+   */
+  const useAnnouncement = type === 'lnurl' && trace.lnurl?.baseUrl === url;
+
+  const created = useAnnouncement
+    ? await upsertLnurl(trace.lnurl!, now)
+    : type === 'lnurl'
+      ? await insertLnurlIfNew(url, now)
+      : await insertMintIfNew(url, now);
+
+  const key = created ?? (type === 'lnurl' ? lnurlKey(url) : url);
+  const row = await mintByUrl(key);
+  if (!row) return fail(422, 'invalid_response', 'The mint could not be indexed');
+
+  /*
+   * Only a row this call brought into being is marked offline.
+   *
+   * The `existing` check upstream means there is almost always one, but an upsert can
+   * land on a row that was already there — and a row the probe loop has an opinion about
+   * is not one an unreachable submission gets to overwrite. Its status is the loop's to
+   * decide; this returns what is on file instead.
+   */
+  if (created === null && row.status !== 'unknown') return payload(row.host, true);
+
+  await markOfflineFromAnnouncement(
+    row,
+    { name: trace.name, about: trace.about, picture: trace.picture },
+    now,
+  );
+
+  log.info('indexed from nostr', {
+    url: key,
+    type,
+    reviews: trace.reviews,
+    announced: trace.announcedAt !== null,
+  });
+
+  return payload(row.host, false, 'announcement');
+}
+
+/* ---------- the three type paths ---------- */
+
+async function indexFedimint(
+  code: string,
+  federationId: string,
+  now: number,
+): Promise<IndexOutcome> {
+  const key = fedimintKey(federationId);
+  await insertFedimintFromInvite(code, federationId, now);
+
+  const row = await mintByUrl(key);
+  if (!row) return fail(422, 'invalid_invite', 'The federation could not be indexed');
+
+  log.info('indexed from invite code', { url: key });
+  return payload(row.host, false, 'invite');
+}
+
+async function indexCashu(url: string, host: string, now: number): Promise<IndexOutcome> {
+  const probe = await probeCashuInfo(url);
+
+  if (probe.state === 'blocked') {
+    return fail(422, 'blocked_host', `That address cannot be checked: ${probe.reason}`);
+  }
+
+  if (probe.state === 'answered') {
+    if (await looksLikeLnurl(url)) {
+      return fail(422, 'wrong_type', 'That address answered as an LNURL mint, not a Cashu mint', {
+        detected_type: 'lnurl',
+      });
+    }
+    return fail(422, 'invalid_response', `That address answered, but ${probe.detail}`);
+  }
+
+  if (probe.state === 'silent') return fromRelays('cashu', url, now);
+
+  // A live mint. Insert, then write exactly what a successful probe writes.
+  await insertMintIfNew(url, now);
+  const row = await mintByUrl(url);
+  if (!row) {
+    /*
+     * The URL is fine and the mint answered, so the only way here is a slug already
+     * held by a different URL — `host/a-b` and `host/a/b` both slug to `host-a-b`. That
+     * is a real limitation of the routing scheme rather than anything the reader did,
+     * and it is worth saying so plainly instead of claiming their mint is invalid.
+     */
+    const holder = await mintByHost(host);
+    return fail(
+      422,
+      'invalid_response',
+      holder
+        ? `That mint's page address is already taken by ${holder.url}`
+        : 'The mint could not be indexed',
+    );
+  }
+
+  await recordCashuOnline(row, probe.info, probe.latencyMs, now);
+  log.info('indexed on demand', { url, type: 'cashu', status: 'online' });
+  return payload(row.host, false, 'probe');
+}
+
+async function indexLnurl(url: string, now: number): Promise<IndexOutcome> {
+  // The base URL's own address is checked once here, so a blocked host is reported as
+  // blocked rather than as four endpoints that happened not to answer.
+  let parsed: URL;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return fail(422, 'bad_input', 'That is not a URL');
+  }
+  const verdict = await checkDestination(parsed);
+  if (verdict?.kind === 'blocked') {
+    return fail(422, 'blocked_host', `That address cannot be checked: ${verdict.reason}`);
+  }
+  // A host whose name no longer resolves is the rugged case, not a bad submission.
+  if (verdict) return fromRelays('lnurl', url, now);
+
+  let result: Awaited<ReturnType<typeof probeLnurl>>;
+  try {
+    result = await probeLnurl(url, guardedTextFetcher());
+  } catch {
+    // Neither endpoint answered at all. It may still be a mint that used to be one.
+    return fromRelays('lnurl', url, now);
+  }
+
+  if (result.outcome === 'invalid') {
+    if (await looksLikeCashu(url)) {
+      return fail(422, 'wrong_type', 'That address answered as a Cashu mint, not an LNURL mint', {
+        detected_type: 'cashu',
+      });
+    }
+    return fail(
+      422,
+      'invalid_response',
+      `That address answered, but not as an LNURL mint: ${result.invalidReason ?? 'unrecognised response'}`,
+    );
+  }
+
+  const key = lnurlKey(url);
+  await insertLnurlIfNew(url, now);
+  const row = await mintByUrl(key);
+  if (!row) return fail(422, 'invalid_response', 'The mint could not be indexed');
+
+  await applyLnurlResult(row, result, now);
+  log.info('indexed on demand', { url: key, type: 'lnurl', status: 'online' });
+  return payload(row.host, false, 'probe');
+}
+
+/* ---------- the entry point ---------- */
+
+/**
+ * In-flight submissions, keyed by what they would create.
+ *
+ * Two readers pasting the same address at the same moment — which is exactly what
+ * happens when a link is shared — must produce one probe and one row, not a race
+ * between two inserts and two visits to a stranger's mint. The second caller awaits the
+ * first one's promise and gets its answer.
+ *
+ * Keyed on the *normalized* identifier rather than the raw input, so `mint.600.wtf` and
+ * `https://mint.600.wtf/` collapse into one entry for the same reason they collapse
+ * into one row.
+ */
+const inFlight = new Map<string, Promise<IndexOutcome>>();
+
+/** How many submissions are being worked on right now. For the checks. */
+export function inFlightCount(): number {
+  return inFlight.size;
+}
+
+/** How many probes may be in flight at once, across every submitter. */
+const MAX_IN_FLIGHT = 8;
+
+export async function indexSubmission(rawType: string, rawInput: unknown): Promise<IndexOutcome> {
+  if (!isIndexType(rawType)) {
+    return fail(422, 'bad_type', 'type must be one of cashu, fedimint or lnurl');
+  }
+  const type: IndexType = rawType;
+
+  if (typeof rawInput !== 'string' || rawInput.trim() === '') {
+    return fail(422, 'bad_input', 'input is required');
+  }
+  // Long enough for any real invite code (they run to ~400 characters), short enough
+  // that nothing absurd reaches a parser.
+  const input = rawInput.trim().slice(0, 2048);
+
+  let key: string;
+  let url = '';
+  let host = '';
+
+  if (type === 'fedimint') {
+    const federationId = federationIdFromInviteCode(input);
+    if (!federationId) return fail(422, 'invalid_invite', 'That is not a Fedimint invite code');
+    key = fedimintKey(federationId);
+  } else {
+    const normalized = normalizeMintUrl(input);
+    if (!normalized) {
+      const reason = rejectionFor(input);
+      return fail(
+        422,
+        reason,
+        reason === 'blocked_host'
+          ? 'That address is not a public one this site will check'
+          : 'That is not a mint URL',
+      );
+    }
+    url = normalized.url;
+    host = normalized.host;
+    key = type === 'lnurl' ? lnurlKey(url) : url;
+  }
+
+  /*
+   * The dedup check comes before every await that follows, and that ordering is the
+   * whole guarantee. An earlier version looked the row up first and registered the
+   * in-flight entry afterwards, which left a window: two requests that arrived in the
+   * same tick both got past the lookup before either had registered, and both probed.
+   * Nothing may be awaited between computing the key and claiming it.
+   */
+  const pending = inFlight.get(key);
+  if (pending) return pending;
+
+  if (inFlight.size >= MAX_IN_FLIGHT) {
+    /*
+     * A global ceiling on outbound probes, under the same reason code as the per-address
+     * limit because it is the same answer to the reader: not now, try shortly. The
+     * per-address budget already stops one browser tab from doing this; this stops many
+     * of them at once from turning this process into a load generator pointed at
+     * whatever host they picked.
+     */
+    return fail(429, 'rate_limited', 'Too many checks in flight right now', { retry_after: 30 });
+  }
+
+  const now = Math.floor(Date.now() / 1000);
+  const work = (async (): Promise<IndexOutcome> => {
+    /*
+     * Is this identifier already a row? The same lookup for all three types, by key
+     * first and then by routing slug, because the slug is what the insert path dedupes
+     * on — `https://mint.example.com/Bitcoin` and its lowercase spelling are one mint
+     * under two URLs, and answering "not indexed" for the second would create the
+     * duplicate the normalizer exists to prevent. Nothing is probed on this path.
+     */
+    const existing =
+      (await mintByUrl(key)) ?? (host ? await rowByHostOfType(host, type) : undefined);
+    if (existing) return payload(existing.host, true);
+
+    if (type === 'fedimint') {
+      return indexFedimint(input.toLowerCase(), key.slice('fedimint:'.length), now);
+    }
+    if (type === 'lnurl') return indexLnurl(url, now);
+    return indexCashu(url, host, now);
+  })().finally(() => inFlight.delete(key));
+
+  inFlight.set(key, work);
+  return work;
+}
+
+/**
+ * A row holding this routing slug, but only when it belongs to the ecosystem asked
+ * about.
+ *
+ * An LNURL mint and a Cashu mint can share a hostname, and the LNURL one then takes the
+ * `lnurl-` prefixed slug (see `insertLnurlIfNew`). Without the type test, submitting
+ * that LNURL mint's URL would find the *Cashu* row on the bare slug and answer "already
+ * indexed" with the wrong mint's page.
+ */
+async function rowByHostOfType(host: string, type: IndexType): Promise<MintRow | undefined> {
+  const row = await mintByHost(host);
+  return row && row.type === type ? row : undefined;
+}

api/src/index.ts

@@ -1,4 +1,5 @@
 import { serve } from '@hono/node-server';
+import { announceLnurlMints } from './announce.ts';
 import { config } from './config.ts';
 import { closeDb, getDb, pruneProbes } from './db.ts';
 import { closePool, runDiscovery } from './discovery.ts';
@@ -31,6 +32,20 @@ async function probeCycle(): Promise<void> {
   probeRunning = true;
   try {
     await track(probeAll());
+    /*
+     * Announcing runs after probing, in the same cycle, because it publishes only what
+     * the probe just confirmed — running it on its own timer would mean signing for a
+     * state that could be an interval old. Off by default; see `announceConfig`.
+     *
+     * Its own failures are caught here rather than allowed to mark the probe cycle
+     * failed: whether relays accepted an event says nothing about whether this site
+     * successfully checked its mints.
+     */
+    await track(announceLnurlMints()).catch((err: unknown) => {
+      log.error('announce cycle failed', {
+        reason: err instanceof Error ? err.message : String(err),
+      });
+    });
   } catch (err) {
     log.error('probe cycle failed', { reason: err instanceof Error ? err.message : String(err) });
   } finally {

api/src/lnurl-probe.ts

@@ -0,0 +1,274 @@
+/**
+ * Checking an LNURL mint.
+ *
+ * Unlike a federation, which has no public endpoint and is checked by reading somebody
+ * else's index, an LNURL mint answers over HTTPS and this site checks it itself — the
+ * same relationship it has with a Cashu mint. What differs is that "answered" and
+ * "working" are two questions here rather than one, and the endpoint layout is not what
+ * the software's own README describes. `NOTES-LNURL.md` records what is actually on the
+ * wire; the three rules that shape this file are:
+ *
+ *   1. **There is no bare `/p`.** The mint advertisement — withdraw limits, description,
+ *      mint pubkey, node identity — lives at `/.well-known/lnurlw/_`. The payRequest at
+ *      `/.well-known/lnurlp/_` carries the pay-side limits and the fee, and is the
+ *      fallback when the withdraw side does not answer.
+ *   2. **HTTP 200 proves nothing.** Every registered route returns 200 with an LNURL
+ *      `{"status":"ERROR"}` body for its errors. Only the parsed body decides.
+ *   3. **Absence is the signal.** `None` fields are dropped from responses entirely, so
+ *      a missing `mintPubkey` is how "the funding source is not reachable" reaches the
+ *      wire. That is the degraded-but-online state.
+ *
+ * Nothing here calls anything that mutates. `/p/cb` would make the mint issue a real
+ * invoice on its operator's node, and `/w/cb` burns notes; neither is something a
+ * directory gets to do to a stranger on a ten minute timer. The cost of that restraint
+ * is that LUD-21 verify cannot be detected at all — see the kind document, which makes
+ * that normative rather than incidental.
+ */
+import {
+  PAY_INFO_PATH,
+  WITHDRAW_INFO_PATH,
+  addressFromPayLink,
+  onionFromHtml,
+  parseAdvertisement,
+  parsePayInfo,
+  parseSoftware,
+  type LnurlAdvertisement,
+  type LnurlPayInfo,
+} from '@cashumints/shared';
+import { config } from './config.ts';
+import { readBodyBounded } from './http.ts';
+
+/**
+ * Body caps, per endpoint.
+ *
+ * The JSON documents are a few hundred bytes; 64KB is room for a mint with an unusually
+ * chatty metadata blob and nothing more. The one-pager is real HTML with an inline QR
+ * SVG — 13.8KB on the live instance — so it gets its own, larger cap. Both bound an
+ * untrusted server, in bytes, on top of the abort timer that bounds it in seconds.
+ */
+const MAX_JSON_BYTES = 64 * 1024;
+const MAX_HTML_BYTES = 512 * 1024;
+
+/** What one probe of one LNURL mint concluded. */
+export interface LnurlProbeResult {
+  /**
+   * `online` — a mint advertisement parsed, and the mint's Lightning node answered.
+   * `degraded-funding` — an advertisement parsed, but the node behind it did not, so
+   *   minting and melting are unavailable while rotate/split/merge still work. Still
+   *   an `ok` probe: the mint is up, and this is what warnings are for.
+   * `invalid` — the host answered with something that is not a mint advertisement.
+   *   Neither up nor down, and counted as a failed probe with a reason attached.
+   */
+  outcome: 'online' | 'degraded-funding' | 'invalid';
+  latencyMs: number;
+  /** Which path answered. Stored so a page can say what was actually checked. */
+  endpoint: string;
+  advertisement: LnurlAdvertisement | null;
+  pay: LnurlPayInfo | null;
+  lightningAddress: string | null;
+  onionUrl: string | null;
+  software: string | null;
+  /** Short, human-readable, and only set when `outcome` is `invalid`. */
+  invalidReason: string | null;
+}
+
+/**
+ * How this module reaches a mint.
+ *
+ * A parameter rather than a hard-wired `fetch`, because there are two callers with
+ * genuinely different threat models. The probe loop checks addresses that reached the
+ * database through discovery or the seed list, and uses the plain fetcher below.
+ * `POST /api/index` checks an address a stranger typed thirty seconds ago, and passes
+ * the guarded one from `safe-fetch.ts`, which resolves DNS and refuses private ranges
+ * before a socket opens. The parsing, the endpoint layout and every rule about what
+ * counts as a mint are identical either way, which is the point of the seam.
+ */
+export type TextFetcher = (
+  url: string,
+  accept: string,
+  maxBytes: number,
+) => Promise<{ body: string; status: number } | null>;
+
+/** A fetch that is bounded in time and in bytes, and never throws for a caller. */
+const fetchBounded: TextFetcher = async (
+  url: string,
+  accept: string,
+  maxBytes: number,
+): Promise<{ body: string; status: number } | null> => {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), config.probeTimeoutMs);
+
+  try {
+    const res = await fetch(url, {
+      signal: controller.signal,
+      headers: { Accept: accept, 'User-Agent': config.userAgent },
+      redirect: 'follow',
+    });
+
+    const body = await readBodyBounded(res, maxBytes);
+    if (!body) return null;
+    return { body: body.toString('utf8'), status: res.status };
+  } catch {
+    // Timed out, DNS failure, TLS failure, connection reset. All the same to a caller:
+    // nothing was learned.
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+};
+
+/**
+ * What one JSON endpoint did.
+ *
+ * Three outcomes, not two, and the middle one is why this is not simply
+ * `Promise<unknown | null>`: a host that answered with something that will not parse is
+ * *reachable*, and the site owes its readers a different sentence for that than for a
+ * host that is not there at all. Collapsing them would file every misconfigured proxy
+ * and every parked domain under "offline".
+ */
+type JsonProbe =
+  | { state: 'unreachable' }
+  | { state: 'unparseable'; status: number }
+  | { state: 'parsed'; value: unknown; status: number };
+
+async function fetchJson(url: string, get: TextFetcher): Promise<JsonProbe> {
+  const res = await get(url, 'application/json', MAX_JSON_BYTES);
+  if (!res) return { state: 'unreachable' };
+  try {
+    return { state: 'parsed', value: JSON.parse(res.body) as unknown, status: res.status };
+  } catch {
+    return { state: 'unparseable', status: res.status };
+  }
+}
+
+/** The parsed body, or null for anything that did not parse. */
+function jsonValue(probe: JsonProbe): unknown {
+  return probe.state === 'parsed' ? probe.value : null;
+}
+
+/**
+ * The reason string for a response that arrived but was not a mint advertisement.
+ *
+ * Kept short and specific, because it is what the "responding but invalid" banner shows
+ * underneath and because the three cases are genuinely different problems: a host that
+ * is not this software at all, a host that is but is refusing, and a host serving
+ * something that is not JSON.
+ */
+function invalidReasonFor(probe: JsonProbe): string {
+  if (probe.state === 'unreachable') return 'no response';
+  if (probe.state === 'unparseable') {
+    // Almost always an HTML error page from a proxy, or a parked domain. The status
+    // code is the only part of it worth repeating back.
+    return `HTTP ${probe.status}, and the body was not JSON`;
+  }
+
+  const body = probe.value;
+  if (body === null || body === undefined) return 'empty JSON response';
+  if (typeof body !== 'object' || Array.isArray(body)) return 'response was not a JSON object';
+
+  const record = body as Record<string, unknown>;
+  // The LNURL error convention: 200 with a status/reason pair. Common and informative.
+  if (record['status'] === 'ERROR') {
+    const reason = typeof record['reason'] === 'string' ? record['reason'].slice(0, 120) : '';
+    return reason ? `mint replied: ${reason}` : 'mint replied with an LNURL error';
+  }
+  if (typeof record['tag'] === 'string') return `unexpected tag "${String(record['tag']).slice(0, 40)}"`;
+  if (record['detail'] !== undefined) return 'endpoint not found on this host';
+  return 'response was not a mint advertisement';
+}
+
+/**
+ * Probe one LNURL mint.
+ *
+ * The withdraw side first, because it is the only endpoint carrying everything the site
+ * renders. The payRequest is fetched too, but for different reasons in the two cases:
+ * alongside a good advertisement it adds the fee, the pay-side limits and a
+ * human-written description; when the advertisement failed it is the fallback that can
+ * still prove the host is a live LNURL mint whose withdraw alias is simply configured
+ * under a username this probe cannot guess.
+ *
+ * The two opportunistic reads — the one-pager for a Tor address, `/openapi.json` for a
+ * version — never affect the outcome. A mint is not less online because its operator
+ * turned off the docs endpoint.
+ */
+export async function probeLnurl(
+  baseUrl: string,
+  get: TextFetcher = fetchBounded,
+): Promise<LnurlProbeResult> {
+  const started = Date.now();
+
+  const [withdrawProbe, payProbe] = await Promise.all([
+    fetchJson(`${baseUrl}${WITHDRAW_INFO_PATH}`, get),
+    fetchJson(`${baseUrl}${PAY_INFO_PATH}`, get),
+  ]);
+
+  const advertisement = parseAdvertisement(jsonValue(withdrawProbe));
+  const pay = parsePayInfo(jsonValue(payProbe));
+  const latencyMs = Date.now() - started;
+
+  const base = {
+    latencyMs,
+    advertisement,
+    pay,
+    lightningAddress: addressFromPayLink(advertisement?.payLink) ?? null,
+  };
+
+  if (!advertisement && !pay) {
+    /*
+     * Nothing parsed on either side. Distinguish "the host said something" from "the
+     * host said nothing at all": a timeout is an ordinary failed probe and feeds the
+     * consecutive-fails machinery as a plain offline, while a reply that is not a mint
+     * advertisement is the invalid state and gets to say why.
+     */
+    const answered =
+      withdrawProbe.state !== 'unreachable' || payProbe.state !== 'unreachable';
+    if (!answered) throw new Error('no response from either LNURL endpoint');
+
+    /*
+     * Report on whichever endpoint actually said something, preferring the withdraw
+     * side. A host whose withdraw alias times out while its payRequest returns an HTML
+     * error page should say what the payRequest did, not "no response".
+     */
+    const reported = withdrawProbe.state === 'unreachable' ? payProbe : withdrawProbe;
+
+    return {
+      ...base,
+      outcome: 'invalid',
+      endpoint: withdrawProbe.state === 'unreachable' ? PAY_INFO_PATH : WITHDRAW_INFO_PATH,
+      onionUrl: null,
+      software: null,
+      invalidReason: invalidReasonFor(reported),
+    };
+  }
+
+  // Only worth two extra requests once the host has proved it is a mint.
+  const [html, openapi] = await Promise.all([
+    get(`${baseUrl}/`, 'text/html', MAX_HTML_BYTES),
+    fetchJson(`${baseUrl}/openapi.json`, get),
+  ]);
+
+  const extras = {
+    onionUrl: html ? onionFromHtml(html.body) : null,
+    software: parseSoftware(jsonValue(openapi)),
+    invalidReason: null,
+  };
+
+  if (!advertisement) {
+    /*
+     * The payRequest answered and the withdraw alias did not.
+     *
+     * Still online — the host is demonstrably a live LNURL mint — but the site has no
+     * withdraw limits, no mint pubkey and no node identity for it, and `funding_available`
+     * stays unknown rather than being guessed at from the pay side. `/.well-known/lnurlp/_`
+     * is recorded as the endpoint so the page says what was actually checked.
+     */
+    return { ...base, ...extras, outcome: 'online', endpoint: PAY_INFO_PATH };
+  }
+
+  return {
+    ...base,
+    ...extras,
+    outcome: advertisement.fundingAvailable ? 'online' : 'degraded-funding',
+    endpoint: WITHDRAW_INFO_PATH,
+  };
+}

api/src/mints.ts

@@ -1,6 +1,6 @@
 import {
-  fedimintKey, fedimintSlug, normalizeMintUrl,
-  type FedimintAnnouncement, type FedimintFields,
+  LNURL_SLUG_PREFIX, fedimintKey, fedimintSlug, lnurlIdentifier, lnurlKey, normalizeMintUrl,
+  type FedimintAnnouncement, type FedimintFields, type LnurlAnnouncement, type LnurlFields,
 } from '@cashumints/shared';
 import { getDb } from './db.ts';
 import { log } from './log.ts';
@@ -18,7 +18,7 @@ const reportedSkips = new Set<string>();
 export interface MintRow {
   url: string;
   host: string;
-  /** 'cashu' or 'fedimint'. Rows written before the column existed default to 'cashu'. */
+  /** 'cashu', 'fedimint' or 'lnurl'. Rows written before the column existed default to 'cashu'. */
   type: string;
   name: string | null;
   description: string | null;
@@ -26,7 +26,10 @@ export interface MintRow {
   icon_file: string | null;
   pubkey: string | null;
   info_json: string | null;
-  /** Type-specific data. `FedimintFields` for a federation, null for a Cashu mint. */
+  /**
+   * Type-specific data: `FedimintFields` for a federation, `LnurlFields` for an LNURL
+   * mint, null for a Cashu one. Read it back through `parseEcosystem`.
+   */
   ecosystem_json: string | null;
   nuts_json: string | null;
   version: string | null;
@@ -106,11 +109,23 @@ export async function insertMintIfNew(
 
 /* ---------- fedimint ---------- */
 
-/** Read a federation row's type-specific columns back out. */
-export function parseEcosystem(row: Pick<MintRow, 'ecosystem_json'>): FedimintFields | null {
+/**
+ * Read a row's type-specific column back out.
+ *
+ * Generic, defaulting to `FedimintFields` so every existing call site reads exactly as
+ * it did. The caller already knows the row's `type` — it is what decided to call this
+ * at all — so the type argument is a statement of what was stored, not a guess.
+ *
+ * A column that will not parse degrades to null rather than throwing. Such a row still
+ * has a page and still resolves by its key; it simply has no ecosystem-specific fields
+ * on it, which is honest and is better than a probe cycle dying on one bad row.
+ */
+export function parseEcosystem<T = FedimintFields>(
+  row: Pick<MintRow, 'ecosystem_json'>,
+): T | null {
   if (!row.ecosystem_json) return null;
   try {
-    return JSON.parse(row.ecosystem_json) as FedimintFields;
+    return JSON.parse(row.ecosystem_json) as T;
   } catch {
     return null;
   }
@@ -196,12 +211,282 @@ export async function upsertFedimint(
   return null;
 }
 
+/**
+ * Insert a federation from an invite code alone, with no announcement behind it.
+ *
+ * For `POST /api/index`: a reader pastes the one thing they have, and there is nothing
+ * else to go on. The id comes out of the code itself (`federationIdFromInviteCode`), so
+ * the row is keyed exactly as an announced one would be and the two can never become
+ * two rows for one federation.
+ *
+ * `announced` rather than `unknown`, and the distinction is the same one the status
+ * carries everywhere else: `unknown` means nothing has checked yet, `announced` means
+ * there is nothing this site *can* check. A federation has no public endpoint, so an
+ * invite code is exactly as much as anyone will ever be able to confirm from here until
+ * the observer lookup covers it.
+ *
+ * Returns the row key when a row was created, null when one already existed.
+ */
+export async function insertFedimintFromInvite(
+  code: string,
+  federationId: string,
+  now = Math.floor(Date.now() / 1000),
+): Promise<string | null> {
+  const db = await getDb();
+  const url = fedimintKey(federationId);
+
+  const fields: FedimintFields = {
+    federation_id: federationId,
+    invite_codes: [code.trim().toLowerCase()],
+    // Everything an announcement would have carried. Discovery fills these in when one
+    // turns up, and until then the page says only what the code itself proves.
+    modules: [],
+    network: null,
+    announced_at: null,
+    announcer_pubkey: null,
+    status_source: null,
+  };
+
+  const result = await db.run(
+    `INSERT INTO mints (url, host, type, ecosystem_json, status, first_seen, updated_at)
+     VALUES (?, ?, 'fedimint', ?, 'announced', ?, ?)
+     ON CONFLICT DO NOTHING`,
+    url,
+    fedimintSlug(federationId),
+    JSON.stringify(fields),
+    now,
+    now,
+  );
+
+  return result.changes > 0 ? url : null;
+}
+
 /** Every federation row, for the probe cycle and for review resolution. */
 export async function fedimintRows(): Promise<MintRow[]> {
   const db = await getDb();
   return db.all<MintRow>(`SELECT * FROM mints WHERE type = 'fedimint'`);
 }
 
+/* ---------- lnurl ---------- */
+
+/**
+ * The routing slug an LNURL mint gets, given what the table already holds.
+ *
+ * `mints.host` carries a UNIQUE index across every ecosystem, so a Cashu mint and an
+ * LNURL mint on one hostname would compete for a single slug and — with the existing
+ * insert path — the loser would silently not be tracked at all. That is the one outcome
+ * worth writing code to avoid: a mint that exists, is reviewable, and has no page.
+ *
+ * So the clean slug is used whenever it is free, which is very nearly always, and a
+ * colliding row takes `lnurl-` in front instead. Decided once at insert and then stored,
+ * never recomputed: a mint that took the prefixed slug keeps it even if the row it
+ * collided with later disappears, because its URL is already indexed and linked and a
+ * silently moving page is worse than a slightly long one.
+ */
+async function lnurlSlug(preferred: string, url: string): Promise<string | null> {
+  const db = await getDb();
+
+  const takenBy = async (slug: string): Promise<string | null> => {
+    const row = await db.get<{ url: string }>('SELECT url FROM mints WHERE host = ?', slug);
+    return row && row.url !== url ? row.url : null;
+  };
+
+  const clash = await takenBy(preferred);
+  if (!clash) return preferred;
+
+  const prefixed = LNURL_SLUG_PREFIX + preferred;
+  const secondClash = await takenBy(prefixed);
+  if (!secondClash) {
+    log.info('lnurl slug taken, using prefixed form', { url, slug: prefixed, existing: clash });
+    return prefixed;
+  }
+
+  log.warn('lnurl slug collision, mint not tracked', { url, slug: preferred, existing: clash });
+  return null;
+}
+
+/** The `ecosystem_json` an LNURL row starts life with, before anything has probed it. */
+function blankLnurlFields(baseUrl: string, identifier: string): LnurlFields {
+  return {
+    lnurl_id: identifier,
+    base_url: baseUrl,
+    features: [],
+    network: null,
+    announced_at: null,
+    announcer_pubkey: null,
+    mint_pubkey: null,
+    funding_available: null,
+    probe_endpoint: null,
+    invalid_reason: null,
+    min_withdrawable_msat: null,
+    max_withdrawable_msat: null,
+    min_sendable_msat: null,
+    max_sendable_msat: null,
+    fee_base_msat: null,
+    fee_ppm: null,
+    lightning_address: null,
+    onion_url: null,
+    node_alias: null,
+    node_uri: null,
+    node_capacity_msat: null,
+    node_channels: null,
+    node_peers: null,
+    observed_features: [],
+  };
+}
+
+/**
+ * Insert an LNURL mint by URL alone, with no announcement behind it.
+ *
+ * For the seed list and for operators added by hand. `status` starts `unknown` and the
+ * very next probe cycle decides it, exactly as a seeded Cashu mint works — nothing here
+ * claims the mint is up, and `insertMintIfNew`'s rule that an existing row is never
+ * touched applies just as strictly.
+ *
+ * Returns the row key when a row was created, null otherwise.
+ */
+export async function insertLnurlIfNew(
+  rawUrl: string,
+  now = Math.floor(Date.now() / 1000),
+): Promise<string | null> {
+  const normalized = normalizeMintUrl(rawUrl);
+  if (!normalized) {
+    if (!reportedSkips.has(rawUrl)) {
+      reportedSkips.add(rawUrl);
+      log.warn('skipped lnurl url', { url: rawUrl.slice(0, 80) });
+    }
+    return null;
+  }
+
+  const db = await getDb();
+  const url = lnurlKey(normalized.url);
+
+  const existing = await db.get<{ url: string }>('SELECT url FROM mints WHERE url = ?', url);
+  if (existing) return null;
+
+  const host = await lnurlSlug(normalized.host, url);
+  if (host === null) return null;
+
+  const result = await db.run(
+    `INSERT INTO mints (url, host, type, ecosystem_json, status, first_seen, updated_at)
+     VALUES (?, ?, 'lnurl', ?, 'unknown', ?, ?)
+     ON CONFLICT DO NOTHING`,
+    url,
+    host,
+    JSON.stringify(blankLnurlFields(normalized.url, lnurlIdentifier(normalized.url, null))),
+    now,
+    now,
+  );
+
+  return result.changes > 0 ? url : null;
+}
+
+/**
+ * Insert or refresh an LNURL mint from a kind 38174 announcement.
+ *
+ * **Deduped on the normalized base URL, not on the `d` tag**, and that is the whole
+ * reason this function is not a copy of `upsertFedimint`. An LNURL mint's identifier is
+ * its funding node's pubkey when it has one and its host otherwise, so the same mint
+ * legitimately appears under two different `d` values across its life — announced by
+ * host before a funding source was configured, by pubkey afterwards. Keying rows on `d`
+ * would split one mint into two pages with half its reviews on each. The `u` tag is the
+ * one value present in every form of the event, so it is the key.
+ *
+ * Unlike `insertMintIfNew` this does update an existing row, because an announcement is
+ * the only source of `features`, the network and the operator's own name for the mint.
+ * Older announcements are ignored (`announced_at` goes forwards only) so a replayed
+ * event from last year cannot overwrite this week's capability list.
+ *
+ * Two things are deliberately never written here:
+ *
+ *   - **The status columns.** Whether a mint is up is a probe's answer. An announcement
+ *     is not evidence of anything being up.
+ *   - **Anything a probe learned.** `mint_pubkey`, the limits, the address, the node
+ *     fields and `funding_available` are all carried over from the existing row
+ *     untouched. In particular a `mint_pubkey` already observed is *never* cleared by an
+ *     announcement that lacks one: identity is sticky, per the kind document.
+ *
+ * Returns the row's key when a row was created, null when one was merely updated.
+ */
+export async function upsertLnurl(
+  announcement: LnurlAnnouncement,
+  now = Math.floor(Date.now() / 1000),
+): Promise<string | null> {
+  const db = await getDb();
+  const url = lnurlKey(announcement.baseUrl);
+
+  const existing = await db.get<MintRow>('SELECT * FROM mints WHERE url = ?', url);
+  const previous = existing ? parseEcosystem<LnurlFields>(existing) : null;
+
+  if (previous && (previous.announced_at ?? 0) > announcement.announcedAt) return null;
+
+  /*
+   * The stored pubkey wins over the announcement's.
+   *
+   * A probe reads `mintPubkey` off the mint itself; an announcement is a stranger's
+   * claim about it. Where both exist the observed one is the better evidence, and where
+   * only the announcement has one it is still worth keeping, so this prefers the probe
+   * and falls back rather than overwriting in either direction.
+   */
+  const mintPubkey = previous?.mint_pubkey ?? announcement.mintPubkey;
+
+  const fields: LnurlFields = {
+    ...(previous ?? blankLnurlFields(announcement.baseUrl, announcement.identifier)),
+    lnurl_id: lnurlIdentifier(announcement.baseUrl, mintPubkey),
+    base_url: announcement.baseUrl,
+    features: announcement.features,
+    network: announcement.network,
+    announced_at: announcement.announcedAt,
+    announcer_pubkey: announcement.announcerPubkey,
+    mint_pubkey: mintPubkey,
+  };
+
+  if (!existing) {
+    const host = await lnurlSlug(announcement.slug, url);
+    if (host === null) return null;
+
+    await db.run(
+      `INSERT INTO mints (url, host, type, name, description, icon_url, ecosystem_json,
+                          status, first_seen, updated_at)
+       VALUES (?, ?, 'lnurl', ?, ?, ?, ?, 'unknown', ?, ?)
+       ON CONFLICT DO NOTHING`,
+      url,
+      host,
+      announcement.name,
+      announcement.about,
+      announcement.picture,
+      JSON.stringify(fields),
+      now,
+      now,
+    );
+    return url;
+  }
+
+  await db.run(
+    `UPDATE mints SET
+       name = COALESCE(?, name),
+       description = COALESCE(?, description),
+       icon_url = COALESCE(?, icon_url),
+       ecosystem_json = ?,
+       updated_at = ?
+     WHERE url = ?`,
+    announcement.name,
+    announcement.about,
+    announcement.picture,
+    JSON.stringify(fields),
+    now,
+    url,
+  );
+
+  return null;
+}
+
+/** Every LNURL row, for the probe cycle and for review resolution. */
+export async function lnurlRows(): Promise<MintRow[]> {
+  const db = await getDb();
+  return db.all<MintRow>(`SELECT * FROM mints WHERE type = 'lnurl'`);
+}
+
 /** Canonical mint URL for a normalized slug, or null if no such mint is tracked. */
 export async function mintUrlByHost(host: string): Promise<string | null> {
   const db = await getDb();

api/src/probe.ts

@@ -1,10 +1,14 @@
-import { parseNuts, type FedimintFields, type MintInfo } from '@cashumints/shared';
+import {
+  lnurlIdentifier, observedFeatures, parseNuts,
+  type FedimintFields, type LnurlFields, type MintInfo,
+} from '@cashumints/shared';
 import { config } from './config.ts';
 import { getDb, setState } from './db.ts';
 import { fetchObserverIndex, OBSERVER_SOURCE, type ObserverIndex } from './fedimint-observer.ts';
 import { readBodyBounded } from './http.ts';
 import { cacheIcon } from './icons.ts';
 import { log } from './log.ts';
+import { probeLnurl } from './lnurl-probe.ts';
 import { allMintRows, mintByUrl, parseEcosystem, type MintRow } from './mints.ts';
 
 export interface ProbeResult {
@@ -28,45 +32,24 @@ export function statusForFails(fails: number): 'online' | 'degraded' | 'offline'
  */
 const MAX_INFO_BYTES = 256 * 1024;
 
-async function fetchInfo(url: string): Promise<{ info: MintInfo; latencyMs: number }> {
-  const started = Date.now();
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), config.probeTimeoutMs);
-
-  try {
-    const res = await fetch(`${url}/v1/info`, {
-      signal: controller.signal,
-      headers: { Accept: 'application/json', 'User-Agent': config.userAgent },
-      redirect: 'follow',
-    });
-    if (!res.ok) throw new Error(`HTTP ${res.status}`);
-
-    const body = await readBodyBounded(res, MAX_INFO_BYTES);
-    if (!body) throw new Error(`info larger than ${MAX_INFO_BYTES} bytes or unreadable`);
-
-    const info = JSON.parse(body.toString('utf8')) as MintInfo;
-    if (!info || typeof info !== 'object') throw new Error('not a JSON object');
-
-    return { info, latencyMs: Date.now() - started };
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
 /**
- * Probe one mint and write the result.
+ * Write everything a successful Cashu probe learned, and record the probe.
  *
- * On failure the cached metadata columns are deliberately left untouched. That cache is
- * what lets an offline mint still render its full page, which is acceptance criterion #1.
+ * Split out of `probeMint` because the on-demand indexer has already made this exact
+ * request: a reader pastes a mint URL, `POST /api/index` fetches `/v1/info` once
+ * through the guarded fetcher to decide whether the address is a mint at all, and then
+ * needs the row to end up in precisely the state a probe cycle would have left it in.
+ * Re-probing to achieve that would hit a stranger's mint twice for one submission and
+ * would leave two ways for "what a good probe writes" to drift apart.
  */
-export async function probeMint(row: MintRow): Promise<ProbeResult> {
+export async function recordCashuOnline(
+  row: MintRow,
+  info: MintInfo,
+  latencyMs: number,
+  now = Math.floor(Date.now() / 1000),
+): Promise<void> {
   const db = await getDb();
-  const now = Math.floor(Date.now() / 1000);
-
-  try {
-    const { info, latencyMs } = await fetchInfo(row.url);
   const nuts = parseNuts(info.nuts);
-
   const iconFile = await cacheIcon(row, info.icon_url ?? null);
 
   await db.run(
@@ -105,6 +88,46 @@ export async function probeMint(row: MintRow): Promise<ProbeResult> {
     now,
     latencyMs,
   );
+}
+
+async function fetchInfo(url: string): Promise<{ info: MintInfo; latencyMs: number }> {
+  const started = Date.now();
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), config.probeTimeoutMs);
+
+  try {
+    const res = await fetch(`${url}/v1/info`, {
+      signal: controller.signal,
+      headers: { Accept: 'application/json', 'User-Agent': config.userAgent },
+      redirect: 'follow',
+    });
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+
+    const body = await readBodyBounded(res, MAX_INFO_BYTES);
+    if (!body) throw new Error(`info larger than ${MAX_INFO_BYTES} bytes or unreadable`);
+
+    const info = JSON.parse(body.toString('utf8')) as MintInfo;
+    if (!info || typeof info !== 'object') throw new Error('not a JSON object');
+
+    return { info, latencyMs: Date.now() - started };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/**
+ * Probe one mint and write the result.
+ *
+ * On failure the cached metadata columns are deliberately left untouched. That cache is
+ * what lets an offline mint still render its full page, which is acceptance criterion #1.
+ */
+export async function probeMint(row: MintRow): Promise<ProbeResult> {
+  const db = await getDb();
+  const now = Math.floor(Date.now() / 1000);
+
+  try {
+    const { info, latencyMs } = await fetchInfo(row.url);
+    await recordCashuOnline(row, info, latencyMs, now);
 
     const changed = row.status !== 'online';
     if (changed) log.info('mint state change', { url: row.url, from: row.status, to: 'online' });
@@ -251,6 +274,297 @@ async function checkFederations(rows: MintRow[], now: number): Promise<ProbeResu
   return results;
 }
 
+/* ---------- lnurl ---------- */
+
+/**
+ * Probe one LNURL mint and write the result.
+ *
+ * Same shape as `probeMint` and the same guarantee: on failure the cached metadata
+ * columns are left untouched, which is what lets an offline LNURL mint still render its
+ * full page with a banner over it and a working review form. The rug-review guarantee
+ * covers all three ecosystems, and this is the half of it that lives in the indexer.
+ *
+ * Three outcomes rather than two, and the middle one is the point:
+ *
+ *   - **online** — an advertisement parsed and the mint's Lightning node answered.
+ *   - **degraded-funding** — an advertisement parsed and the node did not. The mint is
+ *     up: it is serving, its limits are real, and rotate/split/merge still work. It is
+ *     recorded as a *successful* probe with `funding_available: false`, which the
+ *     warnings turn into "minting and melting unavailable". Storing it as `degraded`
+ *     status instead would be wrong twice over — that value already means "one or two
+ *     checks failed" here, and none did — and this is exactly the shape the Cashu side
+ *     already uses for a mint that answers perfectly while refusing to move sats.
+ *   - **invalid** — the host answered with something that is not a mint advertisement.
+ *     Counted as a failed probe, because nothing about the mint was confirmed, but with
+ *     `invalid_reason` recorded so the page can say "responding but invalid" instead of
+ *     the flatly wrong "offline".
+ */
+async function probeLnurlMint(row: MintRow): Promise<ProbeResult> {
+  const now = Math.floor(Date.now() / 1000);
+  const previous = parseEcosystem<LnurlFields>(row);
+  const baseUrl = previous?.base_url ?? row.url.replace(/^lnurl:/, '');
+
+  try {
+    return await applyLnurlResult(row, await probeLnurl(baseUrl), now);
+  } catch (err) {
+    return await recordLnurlFailure(row, previous, err, now);
+  }
+}
+
+/**
+ * Write what one LNURL probe concluded, whichever of the three things it concluded.
+ *
+ * Split out of `probeLnurlMint` for the same reason `recordCashuOnline` was: the
+ * on-demand indexer runs `probeLnurl` itself, through the guarded fetcher, and the row
+ * it creates has to land in exactly the state a probe cycle would have left it in. One
+ * writer, two callers.
+ */
+export async function applyLnurlResult(
+  row: MintRow,
+  result: Awaited<ReturnType<typeof probeLnurl>>,
+  now = Math.floor(Date.now() / 1000),
+): Promise<ProbeResult> {
+  const db = await getDb();
+  const previous = parseEcosystem<LnurlFields>(row);
+  const baseUrl = previous?.base_url ?? row.url.replace(/^lnurl:/, '');
+
+  if (result.outcome === 'invalid') {
+    const fails = row.consecutive_fails + 1;
+    const status = statusForFails(fails);
+    const fields: LnurlFields = {
+      ...(previous ?? emptyLnurlFields(baseUrl)),
+      invalid_reason: result.invalidReason,
+      probe_endpoint: result.endpoint,
+    };
+
+    await db.run(
+      `UPDATE mints SET consecutive_fails = ?, status = ?, ecosystem_json = ?,
+                        last_probe = ?, updated_at = ?
+       WHERE url = ?`,
+      fails,
+      status,
+      JSON.stringify(fields),
+      now,
+      now,
+      row.url,
+    );
+    await db.run(
+      'INSERT INTO probes (mint_url, ts, ok, latency_ms) VALUES (?, ?, 0, NULL)',
+      row.url,
+      now,
+    );
+
+    const changed = row.status !== status;
+    if (changed) {
+      log.info('mint state change', {
+        url: row.url, from: row.status, to: status, fails, reason: result.invalidReason,
+      });
+    }
+    return { url: row.url, ok: false, latencyMs: null, status, changed };
+  }
+
+  const ad = result.advertisement;
+  /*
+   * `mint_pubkey` is sticky: `?? previous?.mint_pubkey` and never the other way round.
+   * A node that was unreachable for this one request drops the field from the
+   * response, and letting that clear a pubkey the site has already seen would change
+   * the mint's Nostr identity — its `d` tag — every time its node hiccuped. See
+   * "When a mint gains a pubkey after being announced by host" in the kind document.
+   */
+  const mintPubkey = ad?.mintPubkey ?? previous?.mint_pubkey ?? null;
+
+  const fields: LnurlFields = {
+    ...(previous ?? emptyLnurlFields(baseUrl)),
+    lnurl_id: lnurlIdentifier(baseUrl, mintPubkey),
+    base_url: baseUrl,
+    mint_pubkey: mintPubkey,
+    /*
+     * Left as whatever it was when the payRequest fallback answered and the withdraw
+     * side did not: that endpoint carries no node section at all, so its silence is
+     * not evidence either way. Only a parsed advertisement gets to set this.
+     */
+    funding_available: ad ? ad.fundingAvailable : previous?.funding_available ?? null,
+    probe_endpoint: result.endpoint,
+    invalid_reason: null,
+    min_withdrawable_msat: ad?.minWithdrawableMsat ?? previous?.min_withdrawable_msat ?? null,
+    max_withdrawable_msat: ad?.maxWithdrawableMsat ?? previous?.max_withdrawable_msat ?? null,
+    min_sendable_msat: result.pay?.minSendableMsat ?? previous?.min_sendable_msat ?? null,
+    max_sendable_msat: result.pay?.maxSendableMsat ?? previous?.max_sendable_msat ?? null,
+    fee_base_msat: result.pay?.feeBaseMsat ?? null,
+    fee_ppm: result.pay?.feePpm ?? null,
+    lightning_address: result.lightningAddress ?? previous?.lightning_address ?? null,
+    onion_url: result.onionUrl ?? null,
+    node_alias: ad?.nodeAlias ?? null,
+    node_uri: ad?.nodeUri ?? null,
+    node_capacity_msat: ad?.nodeCapacityMsat ?? null,
+    node_channels: ad?.nodeChannels ?? null,
+    node_peers: ad?.nodePeers ?? null,
+    /*
+     * What this probe actually saw, kept beside — never merged into — whatever the
+     * operator announced. It is the only capability list a mint nobody has announced
+     * has, which today is every LNURL mint on the network, and it is what the page
+     * renders when `features` is empty. `displayFeatures` does the joining.
+     */
+    observed_features: observedFeatures({
+      fundingAvailable: ad ? ad.fundingAvailable : null,
+      maxWithdrawableMsat: ad?.maxWithdrawableMsat ?? null,
+      maxSendableMsat: result.pay?.maxSendableMsat ?? null,
+      lightningAddress: result.lightningAddress,
+      mintPubkey,
+      onionUrl: result.onionUrl,
+    }),
+  };
+
+  const iconFile = await cacheIcon(row, row.icon_url);
+
+  /*
+   * `COALESCE(description, ?)`, the opposite way round from the Cashu probe.
+   *
+   * There, `/v1/info` is the mint's own word about itself and rightly overwrites a
+   * cached value. Here the candidate is a string the mint *software* generates —
+   * "Mint an lnurlcash bearer note on {host}" is a template, not a sentence anyone
+   * wrote — so it fills a gap and never displaces an operator's own announcement
+   * metadata.
+   *
+   * `name` is deliberately not written at all. The only candidate the endpoints offer
+   * is `nodeAlias`, and that is the *Lightning node's* name, not the mint's: the
+   * software's own one-pager prints it under a "Node" heading, separate from the
+   * mint's title. Calling a mint after its node would be a small invention, and the
+   * existing fallback — the hostname — is both true and what a reader typed to get
+   * here. The alias is kept in `ecosystem_json` and shown in the sidebar, where it is
+   * labelled as what it is.
+   */
+  await db.run(
+    `UPDATE mints SET
+       description = COALESCE(description, ?),
+       icon_file = ?,
+       ecosystem_json = ?,
+       version = COALESCE(?, version),
+       status = 'online',
+       consecutive_fails = 0,
+       last_online = ?,
+       last_probe = ?,
+       updated_at = ?
+     WHERE url = ?`,
+    result.pay?.description ?? ad?.defaultDescription ?? null,
+    iconFile,
+    JSON.stringify(fields),
+    result.software,
+    now,
+    now,
+    now,
+    row.url,
+  );
+
+  await db.run(
+    'INSERT INTO probes (mint_url, ts, ok, latency_ms) VALUES (?, ?, 1, ?)',
+    row.url,
+    now,
+    result.latencyMs,
+  );
+
+  const changed = row.status !== 'online' || previous?.funding_available !== fields.funding_available;
+  if (changed) {
+    log.info('mint state change', {
+      url: row.url,
+      from: row.status,
+      to: 'online',
+      funding: fields.funding_available === false ? 'unavailable' : 'ok',
+    });
+  }
+
+  return { url: row.url, ok: true, latencyMs: result.latencyMs, status: 'online', changed };
+}
+
+/**
+ * Write a failed LNURL probe: the host said nothing at all.
+ *
+ * Its own function only because two callers reach it — the probe cycle and the
+ * on-demand indexer, which treats a host that never answered as a candidate for the
+ * Nostr lookup rather than as a failure to report immediately.
+ */
+async function recordLnurlFailure(
+  row: MintRow,
+  previous: LnurlFields | null,
+  err: unknown,
+  now: number,
+): Promise<ProbeResult> {
+  const db = await getDb();
+  const fails = row.consecutive_fails + 1;
+  const status = statusForFails(fails);
+
+  /*
+   * A host that said nothing at all is offline, not invalid. Clearing `invalid_reason`
+   * here matters: a mint that spent a day serving junk and then went dark should stop
+   * showing "responding but invalid" the moment it stops responding.
+   */
+  if (previous?.invalid_reason) {
+    await db.run(
+      'UPDATE mints SET ecosystem_json = ? WHERE url = ?',
+      JSON.stringify({ ...previous, invalid_reason: null } satisfies LnurlFields),
+      row.url,
+    );
+  }
+
+  await db.run(
+    `UPDATE mints SET consecutive_fails = ?, status = ?, last_probe = ?, updated_at = ?
+     WHERE url = ?`,
+    fails,
+    status,
+    now,
+    now,
+    row.url,
+  );
+  await db.run(
+    'INSERT INTO probes (mint_url, ts, ok, latency_ms) VALUES (?, ?, 0, NULL)',
+    row.url,
+    now,
+  );
+
+  const changed = row.status !== status;
+  if (changed) {
+    log.info('mint state change', {
+      url: row.url,
+      from: row.status,
+      to: status,
+      fails,
+      reason: err instanceof Error ? err.message : String(err),
+    });
+  }
+
+  return { url: row.url, ok: false, latencyMs: null, status, changed };
+}
+
+/** The `ecosystem_json` shape a row falls back to when its own will not parse. */
+function emptyLnurlFields(baseUrl: string): LnurlFields {
+  return {
+    lnurl_id: lnurlIdentifier(baseUrl, null),
+    base_url: baseUrl,
+    features: [],
+    network: null,
+    announced_at: null,
+    announcer_pubkey: null,
+    mint_pubkey: null,
+    funding_available: null,
+    probe_endpoint: null,
+    invalid_reason: null,
+    min_withdrawable_msat: null,
+    max_withdrawable_msat: null,
+    min_sendable_msat: null,
+    max_sendable_msat: null,
+    fee_base_msat: null,
+    fee_ppm: null,
+    lightning_address: null,
+    onion_url: null,
+    node_alias: null,
+    node_uri: null,
+    node_capacity_msat: null,
+    node_channels: null,
+    node_peers: null,
+    observed_features: [],
+  };
+}
+
 /** Run `tasks` with at most `limit` in flight. */
 async function pooled<T>(items: T[], limit: number, fn: (item: T) => Promise<unknown>): Promise<void> {
   let cursor = 0;
@@ -270,16 +584,26 @@ export async function probeAll(rows?: MintRow[]): Promise<ProbeResult[]> {
   const started = Date.now();
   const now = Math.floor(Date.now() / 1000);
 
-  // Two ecosystems, two entirely different checks: an HTTP fetch per mint, and one
-  // lookup covering every federation. Split here rather than inside the worker so the
-  // federations are not each waiting behind a slot in the mint pool.
-  const mints = targets.filter((row) => row.type !== 'fedimint');
+  /*
+   * Three ecosystems, three checks.
+   *
+   * Two of them are an HTTP fetch per row and one is a single lookup covering every
+   * federation, so the federations are split out rather than each waiting behind a slot
+   * in the fetch pool. Cashu and LNURL mints share that pool — they are the same kind of
+   * work, a handful of small HTTPS requests each — and are told apart inside the worker
+   * by `type` rather than by two pools that would each idle waiting for the other.
+   *
+   * The default arm is Cashu, not LNURL: a row of some type this build has never heard
+   * of is far more likely to be an older ecosystem than a newer one, and `/v1/info` is
+   * what every row written before the column existed means.
+   */
   const federations = targets.filter((row) => row.type === 'fedimint');
+  const fetched = targets.filter((row) => row.type !== 'fedimint');
 
   const results: ProbeResult[] = [];
   const [, federationResults] = await Promise.all([
-    pooled(mints, config.probeConcurrency, async (row) => {
-      results.push(await probeMint(row));
+    pooled(fetched, config.probeConcurrency, async (row) => {
+      results.push(row.type === 'lnurl' ? await probeLnurlMint(row) : await probeMint(row));
     }),
     checkFederations(federations, now),
   ]);
@@ -288,7 +612,8 @@ export async function probeAll(rows?: MintRow[]): Promise<ProbeResult[]> {
   const online = results.filter((r) => r.ok).length;
   const changed = results.filter((r) => r.changed).length;
   log.info('probe cycle', {
-    mints: mints.length,
+    mints: fetched.filter((row) => row.type !== 'lnurl').length,
+    lnurl: fetched.filter((row) => row.type === 'lnurl').length,
     federations: federations.length,
     online,
     down: results.length - online,

api/src/queries.ts

@@ -3,6 +3,7 @@ import {
   compareMints,
   NEUTRAL_PRIOR_MEAN,
   parseNuts,
+  readCapabilities,
   type Health,
   type MintDetail,
   type MintInfo,
@@ -11,10 +12,12 @@ import {
   type MintType,
   type ProbeSample,
   type RatingDistribution,
+  type LnurlFields,
   type Stats,
 } from '@cashumints/shared';
 import { config, startedAt } from './config.ts';
 import { getDb, getStateNumber, getState } from './db.ts';
+import { lastDiscoveryReport } from './discovery.ts';
 import { mintByHost, parseEcosystem, type MintRow } from './mints.ts';
 
 /**
@@ -104,6 +107,39 @@ function round1(n: number | null): number | null {
   return n === null ? null : Math.round(n * 10) / 10;
 }
 
+/**
+ * The NUT numbers a row publishes.
+ *
+ * `nuts_json` is what the prober wrote and wins; `info.nuts` is the raw NUT-06 object it
+ * was derived from, kept as a fallback for rows written before that column existed. One
+ * function so a list card and a detail page can never read a different answer off the
+ * same row.
+ */
+function rowNuts(row: MintRow, info: MintInfo | null): string[] {
+  if (row.nuts_json) {
+    try {
+      const parsed = JSON.parse(row.nuts_json) as string[];
+      if (parsed.length > 0) return parsed;
+    } catch {
+      // Fall through to the info object below.
+    }
+  }
+  return info ? parseNuts(info.nuts) : [];
+}
+
+/**
+ * One list item.
+ *
+ * The chip fields at the bottom are why this now parses `info_json`. The alternative was
+ * what /mints and /lnurl-mints used to do: fetch `GET /api/mints/:host` once per mint to
+ * read two booleans off each one. That is an acceptable price for a build machine
+ * rendering fifty-five cards once a night and an unacceptable one for every browser that
+ * opens the page, which is what the list has to survive now that it hydrates.
+ *
+ * Facts, not sentences. `capabilities` is two booleans and `mintChip` turns them into
+ * "Melt only" in the reader's language, wherever the card is being drawn. Rendering the
+ * label here would ship one language to twenty-four locales.
+ */
 function toListItem(row: MintRow, agg: AggRow | undefined, mean: number, now: number): MintListItem {
   const base = {
     review_count: agg?.review_count ?? 0,
@@ -112,6 +148,15 @@ function toListItem(row: MintRow, agg: AggRow | undefined, mean: number, now: nu
     last_review_at: agg?.last_review_at ?? null,
   };
 
+  const info = parseInfo(row.info_json);
+  // A federation and an LNURL mint have no `info_json` and so get null, which is the
+  // honest value: not "both NUTs are enabled", but "there is nothing here to read".
+  const capabilities = info ? readCapabilities(info.nuts) : null;
+
+  // Only the two facts the LNURL chip is drawn from, not the whole ecosystem blob: this
+  // payload is fetched by every visitor on three pages.
+  const lnurl = row.type === 'lnurl' ? parseEcosystem<LnurlFields>(row) : null;
+
   return {
     url: row.url,
     host: row.host,
@@ -125,6 +170,14 @@ function toListItem(row: MintRow, agg: AggRow | undefined, mean: number, now: nu
     score: bayesianScore(base, mean, now),
     last_review_at: base.last_review_at,
     version: row.version,
+    nuts: rowNuts(row, info),
+    capabilities,
+    ...(lnurl
+      ? {
+          max_withdrawable_msat: lnurl.max_withdrawable_msat ?? null,
+          funding_available: lnurl.funding_available ?? null,
+        }
+      : {}),
   };
 }
 
@@ -231,16 +284,9 @@ export async function getMintDetail(host: string): Promise<MintDetail | null> {
 
   const item = toListItem(row, agg.get(row.url), mean, now);
   const info = parseInfo(row.info_json);
-
-  let nuts: string[] = [];
-  if (row.nuts_json) {
-    try {
-      nuts = JSON.parse(row.nuts_json) as string[];
-    } catch {
-      nuts = [];
-    }
-  }
-  if (nuts.length === 0 && info) nuts = parseNuts(info.nuts);
+  // `item.nuts` is the same read, through `rowNuts`. It used to be computed a second
+  // time here with a subtly different fallback rule; one function now answers for both.
+  const nuts = item.nuts;
 
   /*
    * Type-specific columns are spread across the payload rather than nested under a key.
@@ -289,7 +335,8 @@ export async function getStats(): Promise<Stats> {
    * COUNT(*) FILTER, not SUM(status = 'online'): Postgres has no implicit cast from
    * boolean to integer, so the SQLite spelling is a type error there.
    */
-  const [counts, federations, reviews, fedimintReviews] = await Promise.all([
+  const [counts, federations, lnurl, lnurlFunding, reviews, fedimintReviews, lnurlReviews] =
+    await Promise.all([
     db.get<{ total: number; online: number; offline: number; degraded: number }>(
       `SELECT
          COUNT(*)                                      AS total,
@@ -306,6 +353,24 @@ export async function getStats(): Promise<Stats> {
          COUNT(*) FILTER (WHERE status = 'announced')  AS announced
        FROM mints WHERE type = 'fedimint'`,
     ),
+    db.get<{ total: number; online: number; offline: number }>(
+      `SELECT
+         COUNT(*)                                      AS total,
+         COUNT(*) FILTER (WHERE status = 'online')     AS online,
+         COUNT(*) FILTER (WHERE status = 'offline')    AS offline
+       FROM mints WHERE type = 'lnurl'`,
+    ),
+    /*
+     * The degraded-funding count is read in JavaScript rather than in SQL, because the
+     * flag lives inside `ecosystem_json` and neither a `LIKE '%"funding_available":false%'`
+     * (which depends on how the two drivers happen to serialise) nor a JSON operator
+     * (which SQLite and Postgres spell differently) is portable. There are a handful of
+     * these rows, the whole result is memoised for a minute, and a correct answer on
+     * both backends is worth one small scan.
+     */
+    db.all<{ ecosystem_json: string | null }>(
+      `SELECT ecosystem_json FROM mints WHERE type = 'lnurl' AND status = 'online'`,
+    ),
     db.get<{ n: number; last: number | null }>(
       `WITH latest AS (${LATEST_REVIEWS}) SELECT COUNT(*) AS n, MAX(created_at) AS last FROM latest`,
     ),
@@ -314,8 +379,19 @@ export async function getStats(): Promise<Stats> {
        SELECT COUNT(*) AS n FROM latest
        WHERE mint_url IN (SELECT url FROM mints WHERE type = 'fedimint')`,
     ),
+    db.get<{ n: number }>(
+      `WITH latest AS (${LATEST_REVIEWS})
+       SELECT COUNT(*) AS n FROM latest
+       WHERE mint_url IN (SELECT url FROM mints WHERE type = 'lnurl')`,
+    ),
     ]);
 
+  let lnurlDegradedFunding = 0;
+  for (const row of lnurlFunding) {
+    const fields = parseEcosystem<LnurlFields>(row);
+    if (fields?.funding_available === false) lnurlDegradedFunding++;
+  }
+
   const cashuTotal = counts?.total ?? 0;
 
   const value: Stats = {
@@ -332,6 +408,11 @@ export async function getStats(): Promise<Stats> {
     fedimint_offline: federations?.offline ?? 0,
     fedimint_announced: federations?.announced ?? 0,
     fedimint_reviews: fedimintReviews?.n ?? 0,
+    lnurl_total: lnurl?.total ?? 0,
+    lnurl_online: lnurl?.online ?? 0,
+    lnurl_offline: lnurl?.offline ?? 0,
+    lnurl_degraded_funding: lnurlDegradedFunding,
+    lnurl_reviews: lnurlReviews?.n ?? 0,
   };
 
   statsCache = { at: now, value };
@@ -343,28 +424,55 @@ export function resetStatsCache(): void {
   statsCache = null;
 }
 
-/** Health bypasses the stats cache: it is the endpoint you page on. */
+/**
+ * Health bypasses the stats cache: it is the endpoint you page on.
+ *
+ * Three things can degrade it, and they are three different failures:
+ *
+ *   probeStale         nothing has checked a mint in three intervals
+ *   !discoveryOk       the last discovery cycle threw
+ *   report.starved     the last backfill read less than BACKFILL_MIN_EVENTS
+ *
+ * The third is the one added after the postmortem, and it is the only one that would
+ * have caught a year of the index sitting at eight mints: the cycles were completing,
+ * `ok` was true, the probes were fresh, and the relay list simply did not contain the
+ * relay holding the archive. "Ran without throwing" is not the same claim as "read
+ * anything", and only the second one is worth a green light.
+ *
+ * A deployment with an empty database reports degraded until its first backfill lands,
+ * because until then nothing has confirmed the relay set reads anything at all. That is
+ * intended: it holds `cashumints-web.service` at its health gate rather than letting it
+ * publish a site built from nothing.
+ */
 export async function getHealth(): Promise<Health> {
   const now = Math.floor(Date.now() / 1000);
   const db = await getDb();
 
-  const [lastProbe, lastDiscovery, discoveryOkRaw, tracked] = await Promise.all([
+  const [lastProbe, lastDiscovery, discoveryOkRaw, tracked, report] = await Promise.all([
     getStateNumber('last_probe_at'),
     getStateNumber('last_discovery_at'),
     getState('last_discovery_ok'),
     db.get<{ n: number }>('SELECT COUNT(*) AS n FROM mints'),
+    lastDiscoveryReport(),
   ]);
 
   const discoveryOk = discoveryOkRaw !== '0';
   const staleAfter = config.probeIntervalMin * 60 * 3;
   const probeStale = lastProbe === null || now - lastProbe > staleAfter;
+  // No report at all is starvation by default: see the note above.
+  const starved = report?.starved ?? true;
 
   return {
-    status: probeStale || !discoveryOk ? 'degraded' : 'ok',
+    status: probeStale || !discoveryOk || starved ? 'degraded' : 'ok',
     uptime_s: now - startedAt,
     last_probe_at: lastProbe,
     last_discovery_at: lastDiscovery,
     mints_tracked: tracked?.n ?? 0,
     updated_at: now,
+    discovery_relays: report?.relays ?? [],
+    last_discovery_events: report?.events ?? null,
+    last_discovery_mode: report?.mode ?? null,
+    discovery_starved: starved,
+    backfill_min_events: config.backfillMinEvents,
   };
 }

api/src/rate-limit.ts

@@ -0,0 +1,92 @@
+/**
+ * A per-address budget for the one endpoint that does work on a stranger's behalf.
+ *
+ * Every other route reads rows this process already has. `POST /api/index` resolves
+ * DNS, opens a socket to an address somebody chose, and may query five relays, so it is
+ * the one place where a loop in a browser tab costs this server real outbound work —
+ * and costs whoever is at the other end an unexpected visitor.
+ *
+ * In-process and in-memory, deliberately. The alternatives were considered and both are
+ * worse here: a table would put a write on the path of every submission for a counter
+ * that may be forgotten at any time, and doing it in nginx would put the limit in a
+ * file the application cannot see, cannot test, and does not ship — this repository's
+ * README documents an nginx block that a deployment is free to edit, so a limit that
+ * lives only there is a limit that silently varies per deployment. The cost of keeping
+ * it here is that a restart forgives everyone and a second process would double the
+ * allowance; at ten an hour, neither matters. BACKEND.md records the choice.
+ */
+
+/**
+ * Submissions one address may make per window.
+ *
+ * Ten by default, which is BACKEND.md's number and is several times what any honest use
+ * of the dialog needs. `INDEX_RATE_LIMIT` raises or lowers it, which exists for two
+ * real cases rather than as reflexive configurability: exercising the whole flow
+ * end to end trips a limit of ten in about a minute, and a deployment behind a proxy
+ * that does not forward the client address has every visitor sharing one bucket until
+ * it does. Both are better served by a number than by a code change.
+ */
+export const RATE_LIMIT = (() => {
+  const raw = Number.parseInt(process.env['INDEX_RATE_LIMIT'] ?? '', 10);
+  return Number.isFinite(raw) && raw > 0 ? raw : 10;
+})();
+
+/** The window those submissions are counted over. */
+export const RATE_WINDOW_MS = 60 * 60 * 1000;
+
+/** Addresses tracked at once. Past this the oldest bucket is dropped, not the newest. */
+const MAX_TRACKED = 5000;
+
+const hits = new Map<string, number[]>();
+
+export interface RateVerdict {
+  ok: boolean;
+  /** Submissions left in this window after this one. */
+  remaining: number;
+  /** Seconds until the oldest counted submission falls out of the window. */
+  retryAfter: number;
+}
+
+/**
+ * Count one submission from `key`, and say whether it is allowed.
+ *
+ * A sliding window over timestamps rather than a fixed bucket, so ten submissions at
+ * 10:59 do not give a fresh ten at 11:00. A refused submission is *not* counted: being
+ * over the limit should not extend the wait every time the reader presses the button
+ * again, which is what turns a rate limit into a lockout.
+ */
+export function takeToken(key: string, now = Date.now()): RateVerdict {
+  const cutoff = now - RATE_WINDOW_MS;
+  const recent = (hits.get(key) ?? []).filter((at) => at > cutoff);
+
+  if (recent.length >= RATE_LIMIT) {
+    hits.set(key, recent);
+    const oldest = recent[0] ?? now;
+    return {
+      ok: false,
+      remaining: 0,
+      retryAfter: Math.max(1, Math.ceil((oldest + RATE_WINDOW_MS - now) / 1000)),
+    };
+  }
+
+  recent.push(now);
+  hits.set(key, recent);
+
+  if (hits.size > MAX_TRACKED) sweep(cutoff);
+
+  return { ok: true, remaining: RATE_LIMIT - recent.length, retryAfter: 0 };
+}
+
+/** Drop every bucket with nothing left in the window. Called only when the map grows. */
+function sweep(cutoff: number): void {
+  for (const [key, times] of hits) {
+    const live = times.filter((at) => at > cutoff);
+    if (live.length === 0) hits.delete(key);
+    else hits.set(key, live);
+  }
+}
+
+/** Forget every counter. For tests, which must not inherit each other's budgets. */
+export function resetRateLimits(): void {
+  hits.clear();
+}

api/src/relay-lookup.ts

@@ -0,0 +1,173 @@
+/**
+ * "Has anyone ever heard of this mint?"
+ *
+ * The last question `POST /api/index` asks before giving up, and the one that makes the
+ * rugged-mint case work. A reader pastes an address; nothing answers at it. That is two
+ * different situations wearing the same silence:
+ *
+ *   - a typo, a dead domain, an address nobody has ever used — nothing to index; or
+ *   - a mint that ran for two years, took people's money, and went dark last week.
+ *
+ * The second is exactly the mint somebody most wants to write a review of, and it is
+ * the one this site exists to keep a page for. HTTP cannot tell them apart, but Nostr
+ * can: a mint that was ever real has an announcement, or reviews, or both, and a typo
+ * has neither. So before answering "we cannot verify that", the endpoint spends one
+ * bounded query asking the relay pool.
+ *
+ * Bounded is the operative word. This runs inside a request a person is waiting on, so
+ * it gets one round of filters and `RELAY_LOOKUP_MS` to answer them; whatever has
+ * arrived by then is the answer. The discovery loop is where exhaustive paging lives —
+ * it runs on a timer, with nobody watching — and the row this creates is an ordinary
+ * row that the next discovery cycle will fill in properly.
+ */
+import type { Event as NostrEvent, Filter } from 'nostr-tools';
+import {
+  KIND_LNURL_ANNOUNCEMENT,
+  KIND_MINT_ANNOUNCEMENT,
+  KIND_REVIEW,
+  hostIdentifier,
+  mintUrlSpellings,
+  parseAnnouncementMetadata,
+  parseLnurlAnnouncement,
+  reviewEcosystem,
+  type LnurlAnnouncement,
+} from '@cashumints/shared';
+import { config } from './config.ts';
+import { getPool } from './discovery.ts';
+import { log } from './log.ts';
+
+/**
+ * How long the relays get, in total, for the whole lookup.
+ *
+ * Three seconds, which is the number BACKEND.md now records for this endpoint. It is
+ * chosen against the two facts that matter: the pool's own `querySync` resolves as soon
+ * as every relay has sent EOSE, which on this pool is usually well under a second, and
+ * the request this sits inside has already spent up to five seconds failing to reach
+ * the mint. Eight seconds of a reader watching a spinner is the outer bound of what
+ * this feature may cost, and three is what buys nearly all of the recall — the events
+ * being asked for are single, indexed, tag-filtered lookups, not a sweep.
+ */
+export const RELAY_LOOKUP_MS = 3000;
+
+/** Bounded so a hostile or confused relay cannot answer with a hundred thousand rows. */
+const LOOKUP_LIMIT = 60;
+
+/** What the relays remember about an address that does not answer over HTTPS. */
+export interface RelayTrace {
+  /** True when anything at all was found: an announcement, or a review, or both. */
+  found: boolean;
+  /** How many kind 38000 events name this address. Nothing is stored from them here. */
+  reviews: number;
+  /** Metadata from the newest announcement, when there was one. */
+  name: string | null;
+  picture: string | null;
+  about: string | null;
+  announcerPubkey: string | null;
+  announcedAt: number | null;
+  /** The parsed 38174, for an LNURL mint: the only source of its features and network. */
+  lnurl: LnurlAnnouncement | null;
+}
+
+const EMPTY: RelayTrace = {
+  found: false,
+  reviews: 0,
+  name: null,
+  picture: null,
+  about: null,
+  announcerPubkey: null,
+  announcedAt: null,
+  lnurl: null,
+};
+
+/**
+ * Run several filters against the pool at once, with one deadline over all of them.
+ *
+ * `querySync`'s own `maxWait` bounds each call, but a relay that accepts a connection
+ * and then never sends EOSE can outlive it; the race is what guarantees the caller gets
+ * an answer inside the budget whatever the sockets do.
+ */
+async function query(filters: Filter[]): Promise<NostrEvent[]> {
+  const started = Date.now();
+  const events = new Map<string, NostrEvent>();
+
+  const work = Promise.all(
+    filters.map((filter) =>
+      getPool()
+        .querySync(config.relays, filter, { maxWait: RELAY_LOOKUP_MS })
+        .then((batch) => {
+          for (const event of batch) events.set(event.id, event);
+        })
+        .catch(() => undefined),
+    ),
+  );
+
+  await Promise.race([work, new Promise((resolve) => setTimeout(resolve, RELAY_LOOKUP_MS))]);
+
+  log.info('relay trace', { filters: filters.length, events: events.size, ms: Date.now() - started });
+  return [...events.values()];
+}
+
+/**
+ * Everything the relays know about one unreachable address.
+ *
+ * The filters are the same ones the discovery loop uses to resolve a review, asked in
+ * the other direction: there, "which mint is this review about?"; here, "are there any
+ * reviews, and any announcement, for this address?". Reusing `mintUrlSpellings` is what
+ * makes the two agree — a mint announced with a trailing slash is found by an address
+ * typed without one.
+ */
+export async function traceOnRelays(type: string, url: string): Promise<RelayTrace> {
+  const spellings = mintUrlSpellings(url);
+  const announcementKind = type === 'lnurl' ? KIND_LNURL_ANNOUNCEMENT : KIND_MINT_ANNOUNCEMENT;
+
+  const filters: Filter[] = [
+    { kinds: [announcementKind], '#u': spellings, limit: LOOKUP_LIMIT },
+    { kinds: [KIND_REVIEW], '#u': spellings, limit: LOOKUP_LIMIT },
+  ];
+
+  /*
+   * An LNURL mint with no funding source is announced — and reviewed — under its bare
+   * host in `d` rather than under a pubkey, and a client that only writes `d` leaves no
+   * `u` to match on. One extra filter covers those; a Cashu mint's `d` is a pubkey
+   * nobody can derive from a URL, so it has no equivalent.
+   */
+  if (type === 'lnurl') {
+    const identifier = hostIdentifier(url);
+    filters.push({ kinds: [announcementKind, KIND_REVIEW], '#d': [identifier], limit: LOOKUP_LIMIT });
+  }
+
+  const events = await query(filters);
+  if (events.length === 0) return EMPTY;
+
+  let reviews = 0;
+  let newest: NostrEvent | null = null;
+
+  for (const event of events) {
+    if (event.kind === KIND_REVIEW) {
+      // A review found by `#u` could be about any ecosystem; only count the ones whose
+      // `k` agrees, so a federation review carrying a stray URL is not evidence here.
+      if (reviewEcosystem(event) === type) reviews++;
+      continue;
+    }
+    if (event.kind !== announcementKind) continue;
+    if (!newest || event.created_at > newest.created_at) newest = event;
+  }
+
+  if (!newest) {
+    return reviews > 0 ? { ...EMPTY, found: true, reviews } : EMPTY;
+  }
+
+  const lnurl = type === 'lnurl' ? parseLnurlAnnouncement(newest) : null;
+  const meta = parseAnnouncementMetadata(newest.content);
+
+  return {
+    found: true,
+    reviews,
+    name: lnurl?.name ?? meta.name,
+    picture: lnurl?.picture ?? meta.picture,
+    about: lnurl?.about ?? meta.about,
+    announcerPubkey: newest.pubkey,
+    announcedAt: newest.created_at,
+    lnurl,
+  };
+}

api/src/safe-fetch.ts

@@ -0,0 +1,288 @@
+/**
+ * Fetching a URL a stranger typed.
+ *
+ * Every other fetch in this codebase goes to an address that reached the database
+ * through discovery or the seed list. `POST /api/index` is the first one that does not:
+ * a reader pastes something, and this server opens a socket to it. That inverts who the
+ * untrusted party is — it is no longer just the *response* that cannot be trusted, it
+ * is the *destination* — so this module exists to answer one question before any packet
+ * leaves: is that address somewhere this server has any business connecting to?
+ *
+ * Four rules, and each is here because leaving it out is a known exploit:
+ *
+ *   1. **https only.** Not http-upgraded-to-https, not any other scheme. `file:` reads
+ *      the disk, `gopher:` used to be a way to make a server speak arbitrary protocols,
+ *      and plaintext http to a stranger's address is a downgrade nobody asked for.
+ *   2. **Resolve first, judge the addresses, then connect.** A hostname check alone
+ *      stops `http://127.0.0.1` and nothing else: `internal.example.com` is a perfectly
+ *      ordinary public name that resolves to `10.0.0.5`, and only DNS can say so. Every
+ *      address the name resolves to is checked, not the first: a name with one public
+ *      and one private A record must be refused, not raced.
+ *   3. **Every redirect hop is a new destination.** A public URL that 302s to
+ *      `http://169.254.169.254/latest/meta-data/` is the cloud-metadata attack in its
+ *      classic form. Redirects are followed manually, capped at two, and each hop goes
+ *      through the same check as the first.
+ *   4. **Bounded in bytes, in time, and in content type.** A stranger's server can be
+ *      slow forever and large forever; `readBodyBounded` and an abort timer cap both,
+ *      and a response that is not the media type asked for is not read at all.
+ *
+ * What this cannot close is the DNS rebinding window: the name is resolved here, and
+ * the socket resolves it again a moment later, and a hostile resolver can answer
+ * differently the second time. Closing it means dialing the vetted IP with the hostname
+ * pinned for TLS, and Node exposes no supported way to do that through `fetch` (undici's
+ * dispatchers are not a public API here). The exposure is a single GET whose body is
+ * parsed as JSON and discarded unless it is a valid mint advertisement, so the practical
+ * gain from a rebind is one unauthenticated GET — noted here rather than left implicit.
+ */
+import { lookup } from 'node:dns/promises';
+import { isBlockedHostname, isPrivateIpAddress } from '@cashumints/shared';
+import { config } from './config.ts';
+import { readBodyBounded } from './http.ts';
+
+/** BACKEND.md's cap for this endpoint: no probe response may exceed it. */
+export const MAX_PROBE_BYTES = 256 * 1024;
+
+/** How many redirects a probe follows before giving up. */
+export const MAX_REDIRECTS = 2;
+
+/**
+ * What one guarded fetch did.
+ *
+ * `blocked` and `unreachable` are kept apart because the endpoint answers them
+ * differently: a blocked address is a refusal this site made and can explain, while an
+ * unreachable one is a mint that may still be real and falls through to the Nostr
+ * lookup. Collapsing them would file "you may not point us at 10.0.0.1" under "we
+ * checked Nostr and found nothing", which is not what happened.
+ */
+export type FetchOutcome =
+  | { state: 'ok'; status: number; body: string; contentType: string | null; url: string }
+  | { state: 'blocked'; reason: string }
+  | { state: 'unreachable'; reason: string };
+
+/**
+ * The two pieces of the outside world this module touches.
+ *
+ * Injectable so the SSRF rules can be tested without a network: `check-index.ts` hands
+ * in a resolver that answers `10.0.0.1` for an ordinary-looking name, and a fetch that
+ * returns a redirect to a private address, and asserts that neither is ever connected
+ * to. Those are the two attacks this file exists to stop, and a rule that is only
+ * exercised against the real internet is a rule that is not exercised.
+ */
+export interface FetchDeps {
+  resolve?: (hostname: string) => Promise<string[] | null>;
+  fetchImpl?: typeof fetch;
+}
+
+/** Every address a hostname resolves to, or null when it does not resolve at all. */
+async function resolveAll(hostname: string): Promise<string[] | null> {
+  try {
+    const records = await lookup(hostname, { all: true, verbatim: true });
+    const addresses = records.map((record) => record.address).filter(Boolean);
+    return addresses.length > 0 ? addresses : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Why an address was not connected to.
+ *
+ * Two kinds, and keeping them apart is load-bearing rather than tidy. `blocked` is a
+ * refusal this site made — the address is one it will not fetch, whoever asked — and
+ * the endpoint reports it as such. `unresolved` is the network saying nothing, and a
+ * name that no longer resolves is the *normal* state of a mint whose operator walked
+ * away: that submission has to fall through to the Nostr lookup, not be rejected as if
+ * the reader had typed something inadmissible.
+ */
+export interface DestinationVerdict {
+  kind: 'blocked' | 'unresolved';
+  reason: string;
+}
+
+/**
+ * May this server connect to this URL?
+ *
+ * Returns null when it may. Exported because the on-demand indexer runs it once up
+ * front — before it decides whether to probe at all — and because the redirect loop
+ * below runs it again on every hop.
+ */
+export async function checkDestination(
+  target: URL,
+  deps: FetchDeps = {},
+): Promise<DestinationVerdict | null> {
+  const blocked = (reason: string): DestinationVerdict => ({ kind: 'blocked', reason });
+
+  if (target.protocol !== 'https:') return blocked('only https addresses are checked');
+
+  const hostname = target.hostname.toLowerCase().replace(/^\[|\]$/g, '');
+  if (!hostname) return blocked('no hostname');
+  // localhost, .onion, .local, a bare label, an IP literal in a private range: all
+  // refusable without asking a resolver anything.
+  if (isBlockedHostname(target.hostname)) return blocked('not a public address');
+
+  // An IP literal has already been judged by the line above; a name has to be resolved.
+  if (/^[\d.]+$/.test(hostname) || hostname.includes(':')) return null;
+
+  const addresses = await (deps.resolve ?? resolveAll)(hostname);
+  if (addresses === null) return { kind: 'unresolved', reason: 'the address does not resolve' };
+
+  // Every answer, not the first: a name with one public and one private record must be
+  // refused outright rather than depending on which one the socket happens to pick.
+  const private_ = addresses.find((address) => isPrivateIpAddress(address));
+  return private_ === undefined ? null : blocked(`resolves to a private address (${private_})`);
+}
+
+/**
+ * A response's media type, without its parameters. `application/json; charset=utf-8`
+ * and `application/json` are the same answer.
+ */
+function mediaType(res: Response): string | null {
+  const header = res.headers.get('content-type');
+  return header ? (header.split(';')[0] ?? '').trim().toLowerCase() : null;
+}
+
+/**
+ * Is this media type plausible for what was asked for?
+ *
+ * Deliberately lenient in one direction only. A mint serving JSON as `text/plain` is a
+ * misconfiguration this site should still read — several real ones do — so anything
+ * text-shaped or unlabelled passes. What it refuses is a response that is *positively*
+ * something else: an image, a video, an archive, an executable. Those are never a mint
+ * advertisement, and reading 256KB of one to find out costs bandwidth for nothing.
+ */
+function plausibleType(type: string | null, accept: string): boolean {
+  if (type === null) return true; // Unlabelled. The parser is the real check.
+  if (type.startsWith('text/') || type.includes('json') || type.includes('xml')) return true;
+  if (accept.includes('html') && type.includes('html')) return true;
+  return false;
+}
+
+export interface SafeFetchOptions {
+  accept: string;
+  maxBytes?: number;
+  timeoutMs?: number;
+}
+
+/**
+ * GET a stranger's URL, following at most two redirects and checking every hop.
+ *
+ * `redirect: 'manual'` rather than `follow`, which is the crux: with `follow`, undici
+ * resolves and connects to the redirect target itself and this code never sees the
+ * address. Doing the hops by hand is what makes rule 3 above enforceable at all.
+ */
+export async function safeFetchText(
+  rawUrl: string,
+  options: SafeFetchOptions,
+  deps: FetchDeps = {},
+): Promise<FetchOutcome> {
+  const maxBytes = options.maxBytes ?? MAX_PROBE_BYTES;
+  const timeoutMs = options.timeoutMs ?? config.probeTimeoutMs;
+
+  let target: URL;
+  try {
+    target = new URL(rawUrl);
+  } catch {
+    return { state: 'blocked', reason: 'not a URL' };
+  }
+
+  /*
+   * One timer for the whole chain, not one per hop.
+   *
+   * Otherwise two redirects turn the endpoint's "standard 5s timeout" into fifteen
+   * seconds of a reader watching a spinner, and a hostile server can extend that for
+   * as long as the redirect cap allows.
+   */
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+
+  try {
+    for (let hop = 0; hop <= MAX_REDIRECTS; hop++) {
+      const verdict = await checkDestination(target, deps);
+      if (verdict) {
+        // A name that does not resolve is not a refusal, it is a mint that is not there,
+        // and the caller has a whole extra step for that case.
+        if (verdict.kind === 'unresolved') {
+          return { state: 'unreachable', reason: verdict.reason };
+        }
+        return {
+          state: 'blocked',
+          reason:
+            hop === 0
+              ? verdict.reason
+              : `redirected to an address we will not fetch: ${verdict.reason}`,
+        };
+      }
+
+      let res: Response;
+      try {
+        res = await (deps.fetchImpl ?? fetch)(target, {
+          signal: controller.signal,
+          redirect: 'manual',
+          headers: { Accept: options.accept, 'User-Agent': config.userAgent },
+        });
+      } catch (err) {
+        return {
+          state: 'unreachable',
+          reason: err instanceof Error ? err.message : 'connection failed',
+        };
+      }
+
+      if (res.status >= 300 && res.status < 400) {
+        const location = res.headers.get('location');
+        // Drain rather than leak the socket: a redirect body is never read.
+        await res.body?.cancel().catch(() => undefined);
+        if (!location) return { state: 'unreachable', reason: `HTTP ${res.status} with no target` };
+        if (hop === MAX_REDIRECTS) return { state: 'unreachable', reason: 'too many redirects' };
+        try {
+          target = new URL(location, target);
+        } catch {
+          return { state: 'unreachable', reason: 'redirect target is not a URL' };
+        }
+        continue;
+      }
+
+      const type = mediaType(res);
+      if (!plausibleType(type, options.accept)) {
+        await res.body?.cancel().catch(() => undefined);
+        return { state: 'unreachable', reason: `unexpected content type ${type ?? 'none'}` };
+      }
+
+      const body = await readBodyBounded(res, maxBytes);
+      if (!body) {
+        return { state: 'unreachable', reason: `body larger than ${maxBytes} bytes or unreadable` };
+      }
+
+      return {
+        state: 'ok',
+        status: res.status,
+        body: body.toString('utf8'),
+        contentType: type,
+        url: target.href,
+      };
+    }
+
+    // Unreachable in practice: the loop returns or continues, and the last iteration
+    // refuses to continue. Kept so the function has one type on every path.
+    return { state: 'unreachable', reason: 'too many redirects' };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/**
+ * The `TextFetcher` shape `probeLnurl` takes, backed by the guarded fetch above.
+ *
+ * The probe loop keeps its own plain fetcher: those rows are addresses this site chose
+ * to track and have already been through `normalizeMintUrl`. This one is for the path
+ * where the address arrived seconds ago from a stranger.
+ */
+export function guardedTextFetcher(deps: FetchDeps = {}) {
+  return async (
+    url: string,
+    accept: string,
+    maxBytes: number,
+  ): Promise<{ body: string; status: number } | null> => {
+    const outcome = await safeFetchText(url, { accept, maxBytes }, deps);
+    return outcome.state === 'ok' ? { body: outcome.body, status: outcome.status } : null;
+  };
+}

api/src/seed.ts

@@ -10,7 +10,7 @@
 import { closeDb, getDb } from './db.ts';
 import { closePool, runDiscovery } from './discovery.ts';
 import { log } from './log.ts';
-import { insertMintIfNew } from './mints.ts';
+import { insertLnurlIfNew, insertMintIfNew } from './mints.ts';
 import { probeAll } from './probe.ts';
 import { listMints } from './queries.ts';
 
@@ -54,6 +54,23 @@ const SEED_MINTS = [
   'https://kashu.me',
 ];
 
+/**
+ * LNURL mints, seeded by URL alone.
+ *
+ * Short for the obvious reason: `kind:38174` is a proposed kind (see
+ * `docs/KIND-LNURL-MINT.md`) and there are no announcements on the network yet, so
+ * unlike Cashu — where this list was read off real 38172 events — there is nothing to
+ * read it off. This is the reference instance the ecosystem was built against, and
+ * discovery takes over the moment operators start announcing.
+ *
+ * Seeded with no status: `insertLnurlIfNew` writes `unknown` and the first probe cycle
+ * decides, exactly as it does for a Cashu mint. Being on this list is not a claim that
+ * a mint is up, and is not an endorsement of it.
+ */
+const SEED_LNURL = [
+  'https://lnurl.21mint.me',
+];
+
 function pad(s: string, width: number): string {
   return s.length > width ? `${s.slice(0, width - 1)}…` : s.padEnd(width);
 }
@@ -64,7 +81,15 @@ async function main(): Promise<void> {
 
   let added = 0;
   for (const url of SEED_MINTS) if (await insertMintIfNew(url)) added++;
-  log.info('seed list ingested', { listed: SEED_MINTS.length, added });
+
+  let addedLnurl = 0;
+  for (const url of SEED_LNURL) if (await insertLnurlIfNew(url)) addedLnurl++;
+
+  log.info('seed list ingested', {
+    listed: SEED_MINTS.length + SEED_LNURL.length,
+    added: added + addedLnurl,
+    lnurl: addedLnurl,
+  });
 
   await probeAll();
   const discovery = await runDiscovery(true);
@@ -109,6 +134,7 @@ async function main(): Promise<void> {
 
   const mints = listed.filter((m) => m.type === 'cashu');
   const federations = listed.filter((m) => m.type === 'fedimint');
+  const lnurlMints = listed.filter((m) => m.type === 'lnurl');
   const count = (rows: typeof listed, status: string) =>
     rows.filter((m) => m.status === status).length;
   const reviews = listed.reduce((sum, m) => sum + m.review_count, 0);
@@ -128,6 +154,10 @@ async function main(): Promise<void> {
       `${count(federations, 'offline')} reported down, ` +
       `${count(federations, 'announced')} announced only)`,
   );
+  console.log(
+    `${lnurlMints.length} LNURL mints (${count(lnurlMints, 'online')} online, ` +
+      `${count(lnurlMints, 'offline')} offline)`,
+  );
   console.log(`${reviews} reviews indexed`);
 
   closePool();

api/src/server.ts

@@ -1,9 +1,41 @@
 import { Hono } from 'hono';
+import type { Context } from 'hono';
 import { cors } from 'hono/cors';
 import { serveStatic } from '@hono/node-server/serve-static';
 import path from 'node:path';
 import { config } from './config.ts';
+import { indexSubmission } from './index-mint.ts';
 import { getHealth, getMintDetail, getStats, listMints } from './queries.ts';
+import { RATE_LIMIT, takeToken } from './rate-limit.ts';
+
+/** The largest `POST /api/index` body read. A JSON object with two short strings. */
+const MAX_BODY_BYTES = 8 * 1024;
+
+/**
+ * Who is submitting, for the rate limiter.
+ *
+ * The socket's peer address, unless that peer is the loopback interface — in which case
+ * this process is behind the reverse proxy the README documents, every request has the
+ * same peer, and `X-Forwarded-For` is the only thing that tells two visitors apart.
+ *
+ * The *last* entry of that header, not the first. nginx's `$proxy_add_x_forwarded_for`
+ * appends the peer it actually saw to whatever the client sent, so the first entry is a
+ * value a client can write for itself — a free way around the limit — and the last is
+ * the one the proxy vouched for. When the peer is not loopback the header is ignored
+ * entirely, because then there is no proxy to have vouched for anything.
+ */
+function clientKey(c: Context): string {
+  const socket = (c.env as { incoming?: { socket?: { remoteAddress?: string } } } | undefined)
+    ?.incoming?.socket;
+  const peer = socket?.remoteAddress ?? '';
+
+  const loopback = peer === '' || peer === '::1' || peer === '127.0.0.1' || peer.startsWith('::ffff:127.');
+  if (!loopback) return peer;
+
+  const forwarded = c.req.header('x-forwarded-for') ?? '';
+  const hops = forwarded.split(',').map((hop) => hop.trim()).filter(Boolean);
+  return hops[hops.length - 1] ?? peer ?? 'unknown';
+}
 
 export function createApp(): Hono {
   const app = new Hono();
@@ -41,6 +73,49 @@ export function createApp(): Hono {
     return c.json(detail);
   });
 
+  /*
+   * The one endpoint that writes: index a mint nobody has announced yet.
+   *
+   * It is a POST because it creates a row, and it is rate limited because it is the
+   * only route that makes this server fetch an address somebody else chose. Everything
+   * it actually does lives in `index-mint.ts`; what is here is the shape of the request
+   * and the two things that can only be decided at the edge — who is asking, and how
+   * much body to read from them.
+   */
+  app.post('/api/index', async (c) => {
+    const verdict = takeToken(clientKey(c));
+    if (!verdict.ok) {
+      c.header('Retry-After', String(verdict.retryAfter));
+      return c.json(
+        {
+          error: 'rate_limited',
+          message: `At most ${RATE_LIMIT} submissions an hour from one address`,
+          retry_after: verdict.retryAfter,
+        },
+        429,
+      );
+    }
+
+    // An invite code runs to a few hundred characters; nothing legitimate is near this.
+    const declared = Number(c.req.header('content-length') ?? '0');
+    if (Number.isFinite(declared) && declared > MAX_BODY_BYTES) {
+      return c.json({ error: 'bad_input', message: 'Request body too large' }, 422);
+    }
+
+    let body: { type?: unknown; input?: unknown };
+    try {
+      body = (await c.req.json()) as { type?: unknown; input?: unknown };
+    } catch {
+      return c.json({ error: 'bad_input', message: 'Body must be JSON' }, 422);
+    }
+
+    const outcome = await indexSubmission(String(body?.type ?? ''), body?.input);
+    if (outcome.status === 429 && 'retry_after' in outcome.body) {
+      c.header('Retry-After', String(outcome.body.retry_after ?? 30));
+    }
+    return c.json(outcome.body, outcome.status);
+  });
+
   // Cached mint icons, so an offline mint keeps its icon.
   app.use(
     '/icons/*',

api/src/test-relay.ts

@@ -0,0 +1,311 @@
+/**
+ * A Nostr relay, in one file, for tests.
+ *
+ * Enough of NIP-01 to accept an EVENT, answer a REQ and close a subscription, plus the
+ * addressable-replacement rule, which is not optional here: the whole point of the
+ * round-trip test is a `kind:38174`, and an addressable kind that a relay stores twice
+ * would let a broken publisher pass.
+ *
+ * Written rather than depended on, deliberately. The alternatives were a real relay
+ * binary (which CI would have to install and keep running) or a `ws` dependency added to
+ * the lockfile for test-only code. Node 22 ships a WebSocket *client* — which is what
+ * nostr-tools uses — but no server, so the handshake and framing below are the actual
+ * cost of not adding either, and RFC 6455 is small when the only frames that matter are
+ * short unfragmented text ones.
+ *
+ * **Not for production.** No authentication, no persistence, no NIP-42, no rate limits,
+ * no fragmentation support beyond a single continuation, and everything lives in a Map
+ * until the process exits. `api/src/check-lnurl.ts` is the only caller.
+ */
+import { createHash } from 'node:crypto';
+import { createServer, type IncomingMessage, type Server } from 'node:http';
+import type { Duplex } from 'node:stream';
+
+/** RFC 6455's fixed handshake GUID. */
+const WS_GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11';
+
+interface StoredEvent {
+  id: string;
+  pubkey: string;
+  kind: number;
+  created_at: number;
+  content: string;
+  tags: string[][];
+  sig?: string;
+}
+
+type Filter = Record<string, unknown>;
+
+/* ---------- framing ---------- */
+
+/** Encode one unfragmented text frame, server to client, never masked. */
+function encodeText(text: string): Buffer {
+  const payload = Buffer.from(text, 'utf8');
+  const length = payload.length;
+
+  let header: Buffer;
+  if (length < 126) {
+    header = Buffer.from([0x81, length]);
+  } else if (length < 65536) {
+    header = Buffer.alloc(4);
+    header[0] = 0x81;
+    header[1] = 126;
+    header.writeUInt16BE(length, 2);
+  } else {
+    header = Buffer.alloc(10);
+    header[0] = 0x81;
+    header[1] = 127;
+    header.writeBigUInt64BE(BigInt(length), 2);
+  }
+
+  return Buffer.concat([header, payload]);
+}
+
+interface DecodedFrame {
+  opcode: number;
+  payload: Buffer;
+  /** Total bytes consumed, so the caller can advance its buffer. */
+  size: number;
+}
+
+/**
+ * Decode one frame from the front of `buffer`, or null when it is not all there yet.
+ *
+ * Client frames are always masked, per the spec, so the mask is applied unconditionally
+ * when the bit is set and ignored when it is not — a browser or Node client never omits
+ * it, and a test relay has no reason to reject one that did.
+ */
+function decodeFrame(buffer: Buffer): DecodedFrame | null {
+  if (buffer.length < 2) return null;
+
+  const first = buffer[0]!;
+  const second = buffer[1]!;
+  const opcode = first & 0x0f;
+  const masked = (second & 0x80) !== 0;
+  let length = second & 0x7f;
+  let offset = 2;
+
+  if (length === 126) {
+    if (buffer.length < offset + 2) return null;
+    length = buffer.readUInt16BE(offset);
+    offset += 2;
+  } else if (length === 127) {
+    if (buffer.length < offset + 8) return null;
+    const big = buffer.readBigUInt64BE(offset);
+    // A test relay has no business buffering a 4GB frame.
+    if (big > 8n * 1024n * 1024n) throw new Error('frame too large');
+    length = Number(big);
+    offset += 8;
+  }
+
+  let mask: Buffer | null = null;
+  if (masked) {
+    if (buffer.length < offset + 4) return null;
+    mask = buffer.subarray(offset, offset + 4);
+    offset += 4;
+  }
+
+  if (buffer.length < offset + length) return null;
+
+  const payload = Buffer.from(buffer.subarray(offset, offset + length));
+  if (mask) {
+    for (let i = 0; i < payload.length; i++) payload[i] = payload[i]! ^ mask[i % 4]!;
+  }
+
+  return { opcode, payload, size: offset + length };
+}
+
+/* ---------- filters ---------- */
+
+function matchesFilter(event: StoredEvent, filter: Filter): boolean {
+  const ids = filter['ids'] as string[] | undefined;
+  if (ids && !ids.includes(event.id)) return false;
+
+  const authors = filter['authors'] as string[] | undefined;
+  if (authors && !authors.includes(event.pubkey)) return false;
+
+  const kinds = filter['kinds'] as number[] | undefined;
+  if (kinds && !kinds.includes(event.kind)) return false;
+
+  const since = filter['since'] as number | undefined;
+  if (typeof since === 'number' && event.created_at < since) return false;
+
+  const until = filter['until'] as number | undefined;
+  if (typeof until === 'number' && event.created_at > until) return false;
+
+  // `#e`, `#p`, `#d`, `#k`, `#u`: match any value of that single-letter tag.
+  for (const [key, wanted] of Object.entries(filter)) {
+    if (!key.startsWith('#') || key.length !== 2) continue;
+    const name = key.slice(1);
+    const values = wanted as string[];
+    const present = event.tags.filter((t) => t[0] === name).map((t) => t[1]);
+    if (!present.some((value) => value !== undefined && values.includes(value))) return false;
+  }
+
+  return true;
+}
+
+/**
+ * The storage key for an event.
+ *
+ * Addressable kinds (30000–39999) are keyed by `kind:pubkey:d`, so a second announcement
+ * from the same publisher for the same mint replaces the first instead of accumulating —
+ * which is exactly the behaviour `kind:38174` depends on and therefore exactly what a
+ * test of it must reproduce. Everything else is keyed by its own id.
+ */
+function storageKey(event: StoredEvent): string {
+  if (event.kind >= 30000 && event.kind < 40000) {
+    const d = event.tags.find((t) => t[0] === 'd')?.[1] ?? '';
+    return `${event.kind}:${event.pubkey}:${d}`;
+  }
+  if (event.kind === 0 || event.kind === 3 || (event.kind >= 10000 && event.kind < 20000)) {
+    return `${event.kind}:${event.pubkey}`;
+  }
+  return event.id;
+}
+
+/* ---------- the relay ---------- */
+
+export interface TestRelay {
+  /** `ws://127.0.0.1:<port>`, ready to hand to a pool. */
+  url: string;
+  /** Every event currently stored, newest first. */
+  events(): StoredEvent[];
+  /** Events of one kind, newest first. */
+  byKind(kind: number): StoredEvent[];
+  close(): Promise<void>;
+}
+
+/**
+ * Start a relay on an ephemeral port.
+ *
+ * Port 0 rather than a fixed one so two tests, or two CI jobs on one machine, cannot
+ * collide — the caller reads the real port back off `url`.
+ */
+export async function startTestRelay(): Promise<TestRelay> {
+  const stored = new Map<string, StoredEvent>();
+  const sockets = new Set<Duplex>();
+
+  const server: Server = createServer((_req, res) => {
+    // Not a websocket upgrade. NIP-11 would go here on a real relay.
+    res.writeHead(426, { 'Content-Type': 'text/plain' });
+    res.end('websocket only');
+  });
+
+  server.on('upgrade', (req: IncomingMessage, socket: Duplex) => {
+    const key = req.headers['sec-websocket-key'];
+    if (typeof key !== 'string') {
+      socket.destroy();
+      return;
+    }
+
+    const accept = createHash('sha1').update(key + WS_GUID).digest('base64');
+    socket.write(
+      'HTTP/1.1 101 Switching Protocols\r\n' +
+        'Upgrade: websocket\r\n' +
+        'Connection: Upgrade\r\n' +
+        `Sec-WebSocket-Accept: ${accept}\r\n\r\n`,
+    );
+
+    sockets.add(socket);
+    socket.on('close', () => sockets.delete(socket));
+    socket.on('error', () => sockets.delete(socket));
+
+    const send = (message: unknown): void => {
+      if (!socket.destroyed) socket.write(encodeText(JSON.stringify(message)));
+    };
+
+    let buffer = Buffer.alloc(0);
+
+    socket.on('data', (chunk: Buffer) => {
+      buffer = Buffer.concat([buffer, chunk]);
+
+      for (;;) {
+        let frame: DecodedFrame | null;
+        try {
+          frame = decodeFrame(buffer);
+        } catch {
+          socket.destroy();
+          return;
+        }
+        if (!frame) break;
+        buffer = buffer.subarray(frame.size);
+
+        if (frame.opcode === 0x8) {
+          socket.end();
+          return;
+        }
+        // Ping: answer with a pong carrying the same payload, per the spec.
+        if (frame.opcode === 0x9) {
+          const pong = encodeText('');
+          pong[0] = 0x8a;
+          socket.write(pong);
+          continue;
+        }
+        if (frame.opcode !== 0x1) continue;
+
+        let message: unknown;
+        try {
+          message = JSON.parse(frame.payload.toString('utf8'));
+        } catch {
+          continue;
+        }
+        if (!Array.isArray(message)) continue;
+
+        const [verb, ...rest] = message as [string, ...unknown[]];
+
+        if (verb === 'EVENT') {
+          const event = rest[0] as StoredEvent | undefined;
+          if (!event?.id) continue;
+          const existing = stored.get(storageKey(event));
+          // Older replacement for an addressable kind: keep what is there, and still
+          // answer OK, which is what a real relay does.
+          if (!existing || existing.created_at <= event.created_at) {
+            stored.set(storageKey(event), event);
+          }
+          send(['OK', event.id, true, '']);
+          continue;
+        }
+
+        if (verb === 'REQ') {
+          const subId = rest[0] as string;
+          const filters = rest.slice(1) as Filter[];
+          const all = [...stored.values()].sort((a, b) => b.created_at - a.created_at);
+
+          for (const filter of filters) {
+            const limit = typeof filter['limit'] === 'number' ? (filter['limit'] as number) : Infinity;
+            let sent = 0;
+            for (const event of all) {
+              if (sent >= limit) break;
+              if (!matchesFilter(event, filter)) continue;
+              send(['EVENT', subId, event]);
+              sent++;
+            }
+          }
+          send(['EOSE', subId]);
+          continue;
+        }
+
+        if (verb === 'CLOSE') {
+          send(['CLOSED', rest[0] as string, '']);
+        }
+      }
+    });
+  });
+
+  await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+  const address = server.address();
+  if (!address || typeof address === 'string') throw new Error('relay did not bind a port');
+
+  return {
+    url: `ws://127.0.0.1:${address.port}`,
+    events: () => [...stored.values()].sort((a, b) => b.created_at - a.created_at),
+    byKind: (kind) =>
+      [...stored.values()].filter((e) => e.kind === kind).sort((a, b) => b.created_at - a.created_at),
+    close: async () => {
+      for (const socket of sockets) socket.destroy();
+      sockets.clear();
+      await new Promise<void>((resolve) => server.close(() => resolve()));
+    },
+  };
+}

api/tsconfig.json

@@ -7,7 +7,22 @@
     "strict": true,
     "noUncheckedIndexedAccess": true,
     "noImplicitOverride": true,
-    "noEmit": true,
+    /*
+     * This project is compiled now, rather than run straight off `src/*.ts`.
+     *
+     * The reason is a fifteen-hour crash loop: the unit's ExecStart named `src/index.ts`,
+     * the host's `/usr/bin/node` was 20, and native type stripping is 22.18 and newer, so
+     * every start died on ERR_UNKNOWN_FILE_EXTENSION and systemd restarted it 464 times
+     * without anything going red. Emitting plain `.js` removes the host's Node version
+     * from the set of things that can break a deploy.
+     *
+     * `rewriteRelativeImportExtensions` is what lets the source keep its explicit `.ts`
+     * specifiers — which is what makes `node --watch src/index.ts` work in development —
+     * while the emitted files import `./config.js` and run anywhere.
+     */
+    "outDir": "dist",
+    "rootDir": "src",
+    "sourceMap": true,
     "allowImportingTsExtensions": true,
     "rewriteRelativeImportExtensions": true,
     "skipLibCheck": true,

deploy/alert.env.example

@@ -0,0 +1,23 @@
+# /etc/cashumints/alert.env
+#
+# Read by cashumints-alert@.service, which systemd starts when any of the three units
+# fails. Everything here is optional: with the file absent or both values empty, an
+# alert is still written to the journal at ERROR priority and is readable with
+#
+#     journalctl -p err -t cashumints-alert
+#
+# Set one or both to have failures leave the machine.
+#
+# Install it root-owned and not world-readable — a webhook URL is a capability:
+#     sudo install -d -m 0755 /etc/cashumints
+#     sudo install -m 0640 -o root -g root deploy/alert.env.example /etc/cashumints/alert.env
+#     sudo systemctl daemon-reload
+
+# An ntfy topic URL. Free and public at ntfy.sh; pick a topic name nobody will guess,
+# because anyone who knows it can read and post to it.
+#NTFY_URL=https://ntfy.sh/cashumints-alerts-CHANGE-ME
+
+# Anything that accepts a JSON POST. The body carries `unit`, `host`, `at`, `text` and
+# `content` — the last of which is what Discord and most Slack-compatible endpoints read,
+# so one payload fits all three.
+#WEBHOOK_URL=https://discord.com/api/webhooks/…

deploy/cashumints-alert@.service

@@ -0,0 +1,101 @@
+# /etc/systemd/system/cashumints-alert@.service
+#
+# The unit that makes a failure audible.
+#
+# The other three units each carry `OnFailure=cashumints-alert@%n.service`, so systemd
+# starts one of these with the failed unit's name as the instance — `%i` below is
+# literally `cashumints.service`, `cashumints-web.service` or `cashumints-site.service`.
+#
+# Why it exists: the API once crash looped 464 times over fifteen hours and nothing said
+# so. `Restart=on-failure` with no start limit is an infinite loop that never reaches a
+# `failed` state, so the journal filled with identical lines nobody was reading and
+# every signal stayed green. The other half of the fix is StartLimitBurst= in each unit,
+# which turns the loop into a failure; this is what carries that failure off the machine.
+#
+# Install:
+#     sudo install -m 0644 deploy/cashumints-alert@.service /etc/systemd/system/
+#     sudo install -d -m 0755 /etc/cashumints
+#     sudo install -m 0640 -o root -g root deploy/alert.env.example /etc/cashumints/alert.env
+#     sudo systemctl daemon-reload
+#
+# No [Install] section and never enabled: OnFailure= starts it, and a unit that also
+# started at boot would page on every reboot.
+
+[Unit]
+Description=Notify that %i failed
+# No OnFailure= here. An alerter that alerts about its own failure is a loop, and this
+# one is written so its worst case is a journal line rather than a retry.
+
+[Service]
+Type=oneshot
+
+# The one file an operator edits, and the only reason this unit is configurable at all.
+# Absent is a supported state — the leading `-` says so — and then the ExecStart below
+# still writes to the journal at ERROR, which is what `systemctl status` and
+# `journalctl -p err` read. See alert.env.example.
+EnvironmentFile=-/etc/cashumints/alert.env
+
+# So `journalctl -t cashumints-alert` finds every alert, whichever unit triggered it.
+SyslogIdentifier=cashumints-alert
+
+# Everything is inside one shell so the "nothing configured" branch is reachable without
+# a second unit. The pieces, in order:
+#
+#   - `printf '<3>…'` on stdout. systemd reads that syslog prefix off a journal stream
+#     and files the line at priority 3, ERROR, so `journalctl -p err` is a complete
+#     history of failures on a host with no webhook configured at all. `<4>` is warning.
+#     A prefix rather than systemd-cat, so the unit needs nothing from the filesystem it
+#     has just sandboxed itself away from.
+#   - NTFY_URL is a topic URL (https://ntfy.sh/your-topic). It gets a plain-text body
+#     naming the failed unit, plus the header names ntfy understands.
+#   - WEBHOOK_URL gets a JSON POST instead, for Discord, Slack or anything that speaks
+#     `{"content": …}` — every key is sent, so one payload fits all of them.
+#   - `--max-time 10` and a `||` fallback on each: an alert that hangs would hold the
+#     failed unit's job open, and an alert that fails must not itself become a second
+#     failed unit for somebody to notice. The shell ends in `true` for the same reason.
+#
+# `%i` is the failed unit's name, passed as an argument rather than interpolated into
+# the shell text: systemd expands specifiers before /bin/sh ever sees the line, and a
+# unit name is not a thing to trust to quoting.
+ExecStart=/bin/sh -c '\
+  UNIT="$1"; \
+  HOST="$(hostname)"; \
+  WHEN="$(date -Is)"; \
+  TEXT="$UNIT failed on $HOST at $WHEN"; \
+  printf "<3>%s\\n" "$TEXT"; \
+  if [ -n "$NTFY_URL" ]; then \
+    /usr/bin/curl -fsS --max-time 10 \
+      -H "Title: cashumints: $UNIT failed" \
+      -H "Priority: high" \
+      -H "Tags: rotating_light" \
+      -d "$TEXT" "$NTFY_URL" >/dev/null \
+      || printf "<3>%s\\n" "alert: POST to NTFY_URL failed"; \
+  fi; \
+  if [ -n "$WEBHOOK_URL" ]; then \
+    /usr/bin/curl -fsS --max-time 10 \
+      -H "Content-Type: application/json" \
+      -d "{\\"unit\\":\\"$UNIT\\",\\"host\\":\\"$HOST\\",\\"at\\":\\"$WHEN\\",\\"text\\":\\"$TEXT\\",\\"content\\":\\"$TEXT\\"}" \
+      "$WEBHOOK_URL" >/dev/null \
+      || printf "<3>%s\\n" "alert: POST to WEBHOOK_URL failed"; \
+  fi; \
+  if [ -z "$NTFY_URL" ] && [ -z "$WEBHOOK_URL" ]; then \
+    printf "<4>%s\\n" "alert: no NTFY_URL or WEBHOOK_URL in /etc/cashumints/alert.env, journal only"; \
+  fi; \
+  true' _ %i
+
+# It sends one HTTP request and writes one line. It needs no identity of its own, and
+# DynamicUser gives it a throwaway one rather than sharing `nobody` with everything else
+# on the host that also could not be bothered to make a user.
+DynamicUser=yes
+NoNewPrivileges=true
+PrivateDevices=true
+ProtectSystem=strict
+ProtectHome=true
+ProtectKernelTunables=true
+ProtectKernelModules=true
+ProtectControlGroups=true
+RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6
+RestrictSUIDSGID=true
+LockPersonality=true
+# An alert that cannot reach the network in ten seconds is not worth a stuck job.
+TimeoutStartSec=30

deploy/cashumints-site.service

@@ -0,0 +1,67 @@
+# /etc/systemd/system/cashumints-site.service
+#
+# Serves the built site on loopback. nginx proxies to it and never opens a file itself,
+# which is the point: when nginx held a `root` inside /home/cashumints, every directory
+# down to dist had to be traversable by www-data, and the one that was not took the
+# whole site down as a blanket 404 with nothing in the error log naming the cause.
+#
+# This is a long-running daemon, unlike cashumints-web.service next to it — that one is
+# the oneshot that produces what this one serves.
+
+[Unit]
+Description=cashumints.space static site server
+Wants=network-online.target
+After=network-online.target
+# Give up after five failures in two minutes instead of restarting forever. A process
+# that cannot start will not start on the 4000th attempt either, and `failed` in
+# `systemctl status` is a far louder signal than a journal scrolling past. The window
+# matches cashumints.service; see the note there for why it is 120s and not 60s. These
+# two are [Unit] keys; systemd ignores them under [Service] with only a warning.
+StartLimitIntervalSec=120
+StartLimitBurst=5
+
+# Carry a failure off the machine. `%n` is this unit's own name, so the alert says
+# which one died. cashumints-alert@.service writes to the journal at ERROR always and
+# curls NTFY_URL or WEBHOOK_URL from /etc/cashumints/alert.env when either is set.
+OnFailure=cashumints-alert@%n.service
+# Not Requires=cashumints.service: the pages are prerendered, so the site keeps serving
+# a correct-as-of-last-build copy while the API is down. Only the islands go quiet.
+
+[Service]
+Type=simple
+User=cashumints
+Group=cashumints
+WorkingDirectory=/home/cashumints/CashuMints.space/web
+
+# The tree comes from cashumints-web.service, which rsyncs it here after a build.
+# Serving web/dist directly would mean a rebuild empties the site for the length of it.
+StateDirectory=cashumints
+Environment=NODE_ENV=production
+Environment=SITE_PORT=8789
+Environment=SITE_HOST=127.0.0.1
+Environment=WEB_ROOT=/var/lib/cashumints/web
+ExecStart=/usr/bin/node server.mjs
+
+Restart=on-failure
+RestartSec=5s
+KillSignal=SIGTERM
+# In-flight responses finish; idle keep-alive connections are closed at once.
+TimeoutStopSec=15s
+UMask=0027
+
+NoNewPrivileges=true
+PrivateTmp=true
+PrivateDevices=true
+ProtectSystem=strict
+# Read-only rather than absent: server.mjs itself lives under /home/cashumints.
+ProtectHome=read-only
+ReadWritePaths=/var/lib/cashumints
+ProtectKernelTunables=true
+ProtectKernelModules=true
+ProtectControlGroups=true
+RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6
+RestrictSUIDSGID=true
+LockPersonality=true
+
+[Install]
+WantedBy=multi-user.target

deploy/cashumints-web.service

@@ -0,0 +1,141 @@
+# /etc/systemd/system/cashumints-web.service
+#
+# The frontend is static: `output: 'static'` in astro.config.mjs, and the whole site is
+# produced ahead of time. There is no frontend build to keep alive, so this unit is a
+# build rather than a daemon — one shot of `pnpm build`, which compiles shared/, renders
+# a social card per mint and prerenders every page from the live API. The daemon that
+# hands the result out is cashumints-site.service.
+#
+# Run it after a deploy, and only after a deploy:
+#     sudo systemctl start cashumints-web
+#
+# There used to be a cashumints-web.timer firing this at 03:30 every night, because the
+# mint list was a snapshot of whatever the API held when the build ran and a nightly
+# rebuild was the only way it ever changed. The list hydrates from the API after paint
+# now, so a new mint, a new review count and a changed status all reach the page within
+# a second of load, and rebuilding 2,000 pages at 03:30 to refresh numbers that refresh
+# themselves is 20 minutes of CPU for nothing.
+#
+# What a build still produces, and therefore what a deploy is still for: the prerendered
+# HTML a crawler reads, the social card per mint, the sitemap, and a `/mint/{host}` page
+# for every mint known at build time. A mint indexed since the last deploy has no page of
+# its own until the next one; the 404 fallback resolves it against the live API, so it is
+# readable and reviewable in the meantime. That was already true between nightly builds.
+#
+# There is deliberately no [Install] section — this belongs to a deploy, not to a boot.
+
+[Unit]
+Description=Rebuild the cashumints.space static site
+# Every page's data comes from the API over loopback, so the API has to be up.
+# Requires= rather than Wants=: a dead API should abort the build, not replace a good
+# site with an empty one.
+Requires=cashumints.service
+After=cashumints.service network-online.target
+Wants=network-online.target
+
+# Carry a failure off the machine. `%n` is this unit's own name, so the alert says
+# which one died. cashumints-alert@.service writes to the journal at ERROR always and
+# curls NTFY_URL or WEBHOOK_URL from /etc/cashumints/alert.env when either is set.
+OnFailure=cashumints-alert@%n.service
+
+[Service]
+Type=oneshot
+User=cashumints
+Group=cashumints
+WorkingDirectory=/home/cashumints/CashuMints.space
+
+# Where the published copy lands. Shared with the API and the site server, and created
+# by systemd with this unit's ownership if it is not there yet.
+StateDirectory=cashumints
+
+Environment=NODE_ENV=production
+# Where the build reaches the API. Must match PORT= in cashumints.service.
+Environment=API_URL=http://127.0.0.1:8788
+Environment=SITE_URL=https://cashumints.space
+# Browser-facing origin. Empty means same origin: islands fetch /api/... and nginx
+# forwards it. Set this only if the API ever moves to its own hostname. Declared here
+# even though it is empty, because systemd's environment wins over .env — so what a
+# production build emits cannot drift with an edit to that file.
+Environment=PUBLIC_API_URL=
+
+# After= orders the start; it does not wait for the port to accept connections. At boot
+# the API is still opening its database and probing, so block until it reports healthy
+# rather than letting the first fetch die on ECONNREFUSED. /api/health answers 503 until
+# it is genuinely ready, and curl -f treats that as a failure, so the loop keeps waiting.
+ExecStartPre=/usr/bin/timeout 90 /bin/sh -c 'until curl -sf -o /dev/null http://127.0.0.1:8788/api/health; do sleep 1; done'
+
+# Then: does the API actually have an index to build a site out of?
+#
+# Health answering 200 says the process is up and its last backfill read something. It
+# does not say how many mints are in the table, and those are different questions — the
+# year of ~31-event backfills had a healthy API serving a real, complete, correct list of
+# eight mints. A build against that succeeds, prerenders eight cards, and rsync happily
+# replaces fifty-five with eight.
+#
+# So count the list before spending twenty minutes building from it. Below the floor
+# this exits non-zero, systemd abandons the unit at ExecStartPre, and — because publishing
+# is ExecStartPost, after the build — the previously published site is never touched. The
+# site stays exactly as it was and the OnFailure alert says why.
+#
+# Counted by the `"host":` key, one per item, rather than by counting `{`: the list
+# payload carries a nested object per mint (its NUT capability switches), so brace
+# counting would report roughly double. No jq: it is not installed on this host and a
+# build gate should not add a dependency to run.
+#
+# `Q` is a double-quote character, built with printf rather than written literally,
+# because this whole command is already inside systemd's single quotes and a quote of
+# either kind in the grep pattern would end the argument early.
+#
+# A curl that fails for any reason leaves `n` empty, `$${n:-0}` reads that as zero, and
+# zero is below every floor — so an API that fell over between the health check above and
+# this line refuses the build rather than sailing through it.
+Environment=MIN_MINTS_FOR_BUILD=20
+ExecStartPre=/bin/sh -c 'Q=$$(printf "\\042"); \
+  n=$$(curl -sf --max-time 30 http://127.0.0.1:8788/api/mints | grep -o "$${Q}host$${Q}:" | wc -l); \
+  if [ "$${n:-0}" -lt "$$MIN_MINTS_FOR_BUILD" ]; then \
+    printf "<3>%s\\n" "refusing to build: /api/mints returned $${n:-0} mints, floor is $$MIN_MINTS_FOR_BUILD. Previous site left untouched."; \
+    exit 1; \
+  fi; \
+  printf "%s\\n" "build gate: $$n mints, floor $$MIN_MINTS_FOR_BUILD"'
+# Check `which pnpm` on the host: a corepack or pnpm-home install sits outside /usr/bin,
+# and systemd's PATH does not include it.
+ExecStart=/usr/bin/pnpm build
+
+# Publish, as a separate step from building.
+#
+# `astro build` empties dist before it writes, so the site server cannot read dist
+# directly — a rebuild would be a minute of 404s. It serves this copy instead, and the
+# copy is only touched once a build has succeeded: a failed build leaves the previous
+# site up rather than replacing it with a half-written one, which is the same reason
+# Requires=cashumints.service is above and the same reason the mint-count gate is an
+# ExecStartPre rather than a check after the fact.
+#
+# --delay-updates stages the changed files and renames them in at the end, so the window
+# where the tree is a mix of two builds is a rename rather than a whole transfer, and
+# --delete-after keeps removals from landing before their replacements. Unchanged files
+# — every hashed asset and card, which is nearly all of it — are not touched at all.
+ExecStartPost=/usr/bin/rsync -a --delete-after --delay-updates web/dist/ /var/lib/cashumints/web/
+
+# ~200 prerendered pages plus a card per mint. Minutes, not seconds, on a small VPS, and
+# TimeoutStartSec is what bounds a Type=oneshot.
+TimeoutStartSec=1800
+# A build should not starve the API it is reading from.
+Nice=10
+
+# The site server runs as cashumints and reads its own files, so this no longer has to
+# be world-readable — it was 0022 for nginx, back when nginx opened the files as
+# www-data. Kept at 0022 anyway: rsync preserves these modes into the published copy,
+# and a readable static site is easier to inspect than one that needs sudo.
+UMask=0022
+
+NoNewPrivileges=true
+PrivateTmp=true
+PrivateDevices=true
+# ProtectHome is deliberately absent, unlike in cashumints.service: this unit writes
+# inside /home/cashumints — web/dist, web/public/og, web/src/generated and the pnpm
+# store are all under it.
+ProtectSystem=full
+ProtectKernelTunables=true
+ProtectKernelModules=true
+ProtectControlGroups=true
+RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6

deploy/cashumints.service

@@ -0,0 +1,70 @@
+# /etc/systemd/system/cashumints.service
+[Unit]
+Description=cashumints.space indexer and API
+Wants=network-online.target
+After=network-online.target
+# Stop after five failures in two minutes rather than restarting forever.
+#
+# The window is 120s and not 60s because RestartSec=5s below means five attempts take
+# a little over twenty seconds of restarts plus however long each attempt lives before
+# it dies. A process that fails *slowly* — a database that times out, a port that takes
+# four seconds to refuse — can spread five failures past a sixty second window and reset
+# the counter forever, which is the loop this is supposed to stop. 120s covers that.
+#
+# The failure this exists for: ExecStart named a .ts file, /usr/bin/node was 20, and
+# every start died in under a second. 464 restarts over fifteen hours, and because
+# Restart=on-failure without a start limit never reaches a `failed` state, nothing
+# anywhere went red. Both keys belong to [Unit] — under [Service] systemd only warns and
+# ignores them.
+StartLimitIntervalSec=120
+StartLimitBurst=5
+
+# Carry a failure off the machine. `%n` is this unit's own name, so the alert says
+# which one died. cashumints-alert@.service writes to the journal at ERROR always and
+# curls NTFY_URL or WEBHOOK_URL from /etc/cashumints/alert.env when either is set.
+OnFailure=cashumints-alert@%n.service
+
+[Service]
+Type=simple
+User=cashumints
+Group=cashumints
+WorkingDirectory=/home/cashumints/CashuMints.space/api
+
+# StateDirectory creates /var/lib/cashumints with the service user's ownership.
+StateDirectory=cashumints
+Environment=NODE_ENV=production
+Environment=PORT=8788
+Environment=DB_PATH=/var/lib/cashumints/cashumints.db
+Environment=ICON_DIR=/var/lib/cashumints/icons
+
+# Compiled JavaScript, run by the distribution's own node.
+#
+# This line used to read `src/index.ts`, which made every start depend on the host
+# having Node 22.18 or newer for native type stripping. A host with Node 20 answered
+# that with ERR_UNKNOWN_FILE_EXTENSION in under a second, 464 times over fifteen hours,
+# and nothing anywhere went red. `pnpm build` now emits api/dist, so what runs here is
+# ordinary ESM and any Node from 20.18 up will start it.
+#
+# Deliberately /usr/bin/node and nothing else: an nvm or fnm path is invisible to this
+# unit's ProtectHome and breaks silently at the next version bump.
+ExecStart=/usr/bin/node --env-file-if-exists=../.env dist/index.js
+
+Restart=on-failure
+RestartSec=5s
+KillSignal=SIGTERM
+TimeoutStopSec=30s
+UMask=0027
+
+NoNewPrivileges=true
+PrivateTmp=true
+ProtectSystem=strict
+ProtectHome=read-only
+ReadWritePaths=/var/lib/cashumints
+PrivateDevices=true
+ProtectKernelTunables=true
+ProtectKernelModules=true
+ProtectControlGroups=true
+RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6
+
+[Install]
+WantedBy=multi-user.target

deploy/nginx.conf

@@ -0,0 +1,160 @@
+# /etc/nginx/sites-available/cashumints.space
+#
+# nginx terminates TLS and proxies. It opens no file belonging to this project — not the
+# built site, not an icon — and that is deliberate.
+#
+# It used to point a `root` at web/dist. Because nginx runs as www-data and everything
+# this project owns runs as cashumints, that arrangement required every directory from /
+# down to dist to be traversable by a user with no other business in the tree. A home
+# directory at its default 0700 anywhere in that chain broke the entire site, and it
+# broke it invisibly: `try_files` treats a permission error as a plain miss, so the
+# symptom was a blanket 404, or an internal-redirect loop that ended in a 500 with the
+# real cause named nowhere.
+#
+# Two upstreams now, both on loopback, both owned by the same user that built what they
+# serve:
+#
+#     127.0.0.1:8789   cashumints-site.service   the prerendered site
+#     127.0.0.1:8788   cashumints.service        /api/* and /icons/*
+#
+# Routing that used to live here lives with the thing that owns it. The locale 404 rule
+# in particular was a hand-maintained alternation of 23 codes in a file that is not in
+# the repository; adding a language meant remembering to edit it, and forgetting was
+# silent. web/server.mjs resolves those from the built tree.
+
+proxy_cache_path /var/cache/nginx/cashumints
+                 levels=1:2
+                 keys_zone=cashumints:10m
+                 max_size=256m
+                 inactive=10m
+                 use_temp_path=off;
+
+# Keep a few connections open to each upstream rather than reconnecting per request.
+# Both processes hold idle sockets longer than nginx does, so nginx is always the side
+# that closes and there is no window where it reuses a socket the upstream just dropped
+# — that race is what produces sporadic 502s under load.
+upstream cashumints_site {
+  server 127.0.0.1:8789;
+  keepalive 16;
+}
+
+upstream cashumints_api {
+  server 127.0.0.1:8788;
+  keepalive 8;
+}
+
+server {
+  listen 80;
+  listen [::]:80;
+  server_name cashumints.space;
+
+  location /.well-known/acme-challenge/ {
+    root /var/www/html;
+  }
+
+  location / {
+    return 301 https://cashumints.space$request_uri;
+  }
+}
+
+server {
+  listen 443 ssl http2;
+  listen [::]:443 ssl http2;
+  server_name cashumints.space;
+
+  # nginx 1.25 and later want `http2 on;` on its own line and warn about the form above.
+  # Left as is because it is the form that works on both, and Debian 12 ships 1.22.
+
+  ssl_certificate /etc/letsencrypt/live/cashumints.space/fullchain.pem;
+  ssl_certificate_key /etc/letsencrypt/live/cashumints.space/privkey.pem;
+  include /etc/letsencrypt/options-ssl-nginx.conf;
+  ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;
+
+  # Set here rather than upstream: this is the only part of the stack that knows a
+  # request arrived over TLS. Add `preload` only once you are content never to serve
+  # this name over plain HTTP again.
+  add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
+
+  # The upstreams send no Content-Encoding, so compression is nginx's to do. gzip_proxied
+  # any is required — without it nginx refuses to compress a proxied response at all.
+  gzip on;
+  gzip_proxied any;
+  gzip_vary on;
+  gzip_comp_level 5;
+  gzip_min_length 1024;
+  gzip_types text/plain text/css text/javascript application/javascript application/json
+             application/manifest+json application/xml image/svg+xml;
+
+  # Nothing here accepts an upload. The API's largest body is an 8 KB JSON submission,
+  # and rejecting the oversized ones at the edge keeps them off the Node process.
+  client_max_body_size 16k;
+
+  # Both upstreams are a process on this machine. A slow response is a bug, not a
+  # network condition, and failing fast beats holding a worker for a minute.
+  proxy_connect_timeout 2s;
+  proxy_read_timeout 30s;
+  proxy_send_timeout 30s;
+
+  # HTTP/1.1 with an empty Connection header is what makes the keepalive pools above
+  # work; the default 1.0 opens a new socket per request.
+  proxy_http_version 1.1;
+  proxy_set_header Connection "";
+
+  # Every proxied location includes Debian's /etc/nginx/proxy_params, which sets Host,
+  # X-Real-IP, X-Forwarded-For and X-Forwarded-Proto. That include is load-bearing, not
+  # decorative: the API's rate limiter reads the last hop of X-Forwarded-For to tell two
+  # visitors apart, and without it every request arrives from the loopback peer and
+  # shares one bucket. On a distro that ships no proxy_params, set those four by hand.
+  # Do not also set X-Forwarded-For alongside the include — declaring it twice is what
+  # produces nginx's "could not build optimal proxy_headers_hash" warning.
+
+  # The prerendered site. Cache-Control comes from server.mjs — a year and immutable for
+  # anything with a content hash in its name, revalidate-every-time for markup — so
+  # there is nothing to restate here.
+  location / {
+    proxy_pass http://cashumints_site;
+    include proxy_params;
+  }
+
+  # Health must always reflect the live process.
+  location = /api/health {
+    proxy_pass http://cashumints_api;
+    proxy_cache off;
+    # add_header replaces rather than merges: declaring one here drops every add_header
+    # inherited from the server block, so HSTS has to be restated alongside it.
+    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
+    add_header Cache-Control "no-store" always;
+    include proxy_params;
+  }
+
+  # Briefly cache the read-heavy endpoints.
+  location ~ ^/api/(mints|stats)(?:/|$|\?) {
+    proxy_pass http://cashumints_api;
+    proxy_cache cashumints;
+    proxy_cache_valid 200 30s;
+    proxy_cache_valid 404 10s;
+    proxy_cache_use_stale updating error timeout http_500 http_502 http_503;
+    proxy_cache_background_update on;
+    proxy_cache_lock on;
+    # Restated for the same reason as in /api/health above.
+    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
+    add_header X-Cache-Status $upstream_cache_status always;
+    include proxy_params;
+  }
+
+  location /api/ {
+    proxy_pass http://cashumints_api;
+    include proxy_params;
+  }
+
+  location /icons/ {
+    proxy_pass http://cashumints_api;
+    proxy_cache cashumints;
+    proxy_cache_valid 200 1d;
+    include proxy_params;
+  }
+
+  # No error_page and no try_files. A miss is the site server's 404 page, in the right
+  # language and with a 404 status; an nginx error page here would replace it with a
+  # blank one and hide which upstream failed.
+}

docs/KIND-LNURL-MINT.md

@@ -0,0 +1,384 @@
+# NIP-87 extension: `kind:38174`, LNURL mint announcements
+
+`draft` `optional`
+
+> **Status.** This is a proposed extension to [NIP-87][nip87], written to be submitted
+> as a PR to [nostr-protocol/nips][nips]. It is not part of NIP-87 today. It is
+> implemented and published by [cashumints.space](https://cashumints.space), which is
+> also where the reference indexer for it lives. Nothing here changes 38172, 38173 or
+> 38000; a client that implements only NIP-87 as written keeps working unchanged, and
+> gets partial support for these events for free (see [Reviews](#reviews)).
+
+[nip87]: https://github.com/nostr-protocol/nips/blob/master/87.md
+[nips]: https://github.com/nostr-protocol/nips
+
+---
+
+## Rationale
+
+NIP-87 gives ecash mints a way to be discovered, and gives users a way to recommend
+them: an operator publishes an addressable announcement, a user publishes a
+`kind:38000` naming the announcement's kind in a `k` tag, and a client queries by that
+`k` to find recommendations for one ecosystem without seeing the others.
+
+It covers exactly two ecosystems, one kind each: `38172` for Cashu, `38173` for
+Fedimint. A third has since shipped — **lnurlcash** ([LUD-25][lud25]), Lightning bearer
+notes served over plain [LUD-03][lud03] `withdrawRequest` and [LUD-06][lud06]
+`payRequest`, implemented by [dni/lnurl-mint][lnurlmint] — and it has no kind. The
+result today is that an lnurlcash mint either goes unannounced or is announced as
+something it is not.
+
+The pattern generalises cleanly, and this document does nothing but apply it:
+
+- an LNURL mint has a **stable identifier** (its funding node's public key) → `d`
+- it has an **address you connect to** (its https base URL) → `u`
+- it runs on a **network** → `n`
+- it has a **capability list** → `features`, the analogue of `nuts` and `modules`
+
+The one thing genuinely new here is the capability vocabulary, because Cashu's NUT
+numbers and Fedimint's module names have no LNURL equivalent to borrow. It is defined
+in full below, and every value in it is grounded in a specific code path in
+`lnurl-mint`, because a vocabulary that outruns any implementation is a wish list.
+
+[lud25]: https://github.com/lnurl/luds/blob/luds/25.md
+[lud03]: https://github.com/lnurl/luds/blob/luds/03.md
+[lud06]: https://github.com/lnurl/luds/blob/luds/06.md
+[lud16]: https://github.com/lnurl/luds/blob/luds/16.md
+[lud21]: https://github.com/lnurl/luds/blob/luds/21.md
+[lnurlmint]: https://github.com/dni/lnurl-mint
+
+---
+
+## Choosing the kind number
+
+`38174` — the next free slot in the NIP-87 family.
+
+Checked before claiming it, on 2026-08-21:
+
+| Source | Result |
+| --- | --- |
+| [`nips/README.md`][nipsreadme] kind index | `38172` and `38173` listed; `38174` **absent**, and nothing else in `38100–38199` is assigned |
+| GitHub search over `nostr-protocol/nips`, issues **and** PRs, for `38174` | **0 results** (open or closed) |
+
+`38174` is in the *addressable* range (`30000 ≤ kind < 40000`), which is required: an
+announcement must be replaceable per `(pubkey, kind, d)` so an operator can update
+their capability list in place, exactly as 38172 and 38173 are.
+
+**If `38174` is claimed before this is merged**, take the next free kind in the same
+range, prefer keeping the family contiguous, and record the collision and the
+replacement here — implementations read the kind from one constant
+(`KIND_LNURL_ANNOUNCEMENT`) precisely so that this is a one-line change.
+
+[nipsreadme]: https://github.com/nostr-protocol/nips/blob/master/README.md
+
+---
+
+## The announcement event
+
+LNURL mints SHOULD publish `kind:38174` to announce their capabilities and how to reach
+them.
+
+```json
+{
+  "kind": 38174,
+  "pubkey": "<publisher-pubkey>",
+  "content": "<optional-kind:0-style-metadata>",
+  "tags": [
+    ["d", "021ab89df9cbd28cdab8c71d228ca40deba1eaebd827f24849ec4f3e919c023555"],
+    ["u", "https://lnurl.21mint.me"],
+    ["features", "mint,melt,rotate,split,merge,lud06,lud03,lud16,lud21,signed-notes"],
+    ["n", "mainnet"]
+  ]
+}
+```
+
+### `d` — the identifier
+
+The `d` tag MUST be one of the following, in this order of preference:
+
+1. **The mint's `mintPubkey`**, lowercase hex, when the mint advertises one. This is
+   the funding node's own identity key — a 33-byte compressed secp256k1 public key, 66
+   hex characters, beginning `02` or `03` — exposed on the mint-address endpoint
+   whenever a funding source is configured, and the same key the mint signs notes with
+   under LUD-25 offline verification.
+2. **The normalized host**, when it does not: the lowercase hostname, plus `:port` if
+   non-default, plus the base path with no trailing slash, and **no scheme**. For
+   `https://mint.example.com/lnurl/` that is `mint.example.com/lnurl`.
+
+The two forms are unambiguous by construction: form 1 is always exactly 66 hex
+characters, form 2 always contains a `.` and never matches `^[0-9a-f]{66}$`.
+
+#### When a mint gains a pubkey after being announced by host
+
+This is not hypothetical. `mintPubkey` is present only while a funding source is
+configured **and reachable**; a mint run without one — or announced during an outage —
+legitimately has no pubkey to publish, and gains one later.
+
+The rules, which exist so that identity never silently forks:
+
+- **Prefer the pubkey once it exists.** A publisher that has been announcing by host
+  and learns a `mintPubkey` SHOULD begin publishing under the pubkey `d`.
+- **The identifier is sticky.** Once a mint has been announced under a pubkey `d`, a
+  publisher MUST NOT revert to the host form because the node happened to be
+  unreachable at publish time. Absence of `mintPubkey` in one response is a statement
+  about the node's availability in that instant, not about the mint's identity.
+- **The old announcement SHOULD be left in place**, not deleted. It is addressable, so
+  it stays queryable, and reviews already pointing at the host `d` keep resolving.
+  Publishers MAY additionally re-publish the host-`d` event with the same `u` tag so
+  both identifiers lead to the same live address.
+- **Consumers MUST accept either.** An indexer resolving a review's `d` SHOULD try, in
+  order: exact match on a known `mintPubkey`; exact match on a known normalized host;
+  then fall back to the `u` tag. It MUST NOT treat the two identifiers for one mint as
+  two mints — deduplication is by **normalized base URL** (`u`), which is the one value
+  present in every form of the event.
+
+### `u` — the address
+
+The https base URL of the mint, with no trailing slash: `https://lnurl.21mint.me`.
+
+`u` is REQUIRED in this kind, unlike in 38172 where it is a SHOULD. An LNURL mint's
+`d` may be a bare host string with no scheme, which is not fetchable, so without `u`
+there would be events carrying no usable address at all. Multiple `u` tags MAY appear;
+the first is canonical. `.onion` addresses MUST NOT be the canonical `u` — they belong
+in `features` as `onion` and are discovered from the mint itself.
+
+Everything a client needs hangs off this base:
+
+| Path | Role |
+| --- | --- |
+| `{u}/.well-known/lnurlw/_` | mint advertisement: withdraw limits, `mintPubkey`, node identity |
+| `{u}/.well-known/lnurlp/_` | LUD-06 payRequest (also `{u}/.well-known/lnurlp/{username}`) |
+| `{u}/w?k1=…` | LUD-03 withdrawRequest for one note |
+| `{u}/w/cb` | melt / rotate / split / merge |
+| `{u}/p/cb` | LUD-06 callback, mints a note |
+| `{u}/verify/{payment_hash}` | LUD-21, when `lud21` is advertised |
+
+`_` is [LUD-16][lud16]'s reserved bare-domain username and reaches the same identity as
+the operator's configured username, so a consumer can probe without knowing it.
+
+### `n` — the network
+
+Same values and same meaning as NIP-87: `mainnet`, `testnet`, `signet` or `regtest`.
+Absent reads as `mainnet`. Consumers SHOULD accept `bitcoin` as a synonym for
+`mainnet`, because every Fedimint announcement in the wild writes it and publishers
+copy each other.
+
+### `features` — the capability list
+
+One tag, one comma-separated list of lowercase tokens, the direct analogue of Cashu's
+`nuts` and Fedimint's `modules`:
+
+```json
+["features", "mint,melt,rotate,split,merge,lud06,lud03,lud16,lud21,signed-notes"]
+```
+
+Consumers MUST tolerate whitespace after commas, MUST lowercase before comparing, and
+MUST ignore tokens they do not recognise rather than rejecting the event — that is what
+lets this vocabulary grow without a new kind.
+
+#### The vocabulary
+
+Every value below names something `lnurl-mint` actually implements. The "Grounded in"
+column is the specific thing that makes the claim checkable.
+
+**Note operations** — the four branches of the LUD-25 callback `GET /w/cb`, plus
+minting. These are what the mint *does*.
+
+| Value | Meaning | Grounded in |
+| --- | --- | --- |
+| `mint` | A new bearer note can be created by paying a Lightning invoice; the payment preimage becomes the note. | `router.get_pay_callback` (`/p/cb`). **Requires a funding source** — it issues the invoice. Also refused outright while `SUNSET_MINT` is on. |
+| `melt` | A note can be redeemed back to a BOLT-11 payment. | `/w/cb` with a `pr` parameter. **Requires a funding source** — it pays the invoice. |
+| `rotate` | A note's secret can be replaced by one the holder generates, without changing its value. | `/w/cb` with neither `pr` nor `amount`; the holder supplies `h = sha256(new secret)`. No funding source needed. |
+| `split` | One note becomes two, of a chosen amount and the remainder. | `/w/cb` with `amount`; holder supplies `h` and `h2`. No funding source needed. Refused while `SUNSET_MINT` is on, since it grows outstanding liability. |
+| `merge` | Several notes become one worth their sum. | `/w/cb` with multiple `k1`. No funding source needed. |
+
+The `mint`/`melt` versus `rotate`/`split`/`merge` division is not cosmetic: it is
+exactly the line a missing funding source falls along. Without one the service still
+runs and the last three still work, while nothing moves in or out over Lightning. That
+is a real, distinct state, and consumers should be able to render it — see
+[Availability is not capability](#availability-is-not-capability).
+
+**LNURL sub-specifications** — the wire formats spoken, so a wallet knows what to expect.
+
+| Value | Meaning | Grounded in |
+| --- | --- | --- |
+| `lud06` | Serves a LUD-06 `payRequest` and its callback. | `router.get_lnaddress` returns `tag: "payRequest"`; `/p/cb` returns `pr`. |
+| `lud03` | Serves a LUD-03 `withdrawRequest` per note, informational, never burning. | `router.get_withdraw` (`GET /w?k1=`). Advertised as `callback` on the mint-address response. |
+| `lud16` | Payable at a lightning address, `{username}@{host}` and the bare-domain `_@{host}`. | `/.well-known/lnurlp/{username}`, with `text/identifier` in the payRequest metadata. |
+| `lud21` | Serves `GET /verify/{payment_hash}` so a wallet with no node can poll settlement. | `router.verify_invoice`, gated on `VERIFY_ENABLED`. **Announcement-only** — see below. |
+
+**Optional extras.**
+
+| Value | Meaning | Grounded in |
+| --- | --- | --- |
+| `signed-notes` | The mint advertises a `mintPubkey` and returns recoverable signatures over each new note, so a holder can verify issuer and amount offline. | `signing.mint_pubkey` / `signing.sign_note`; `sig`/`sig2` on the `/w/cb` response. Requires a funding source (it signs via the node's `signmessage`). |
+| `onion` | The mint also answers on a Tor hidden service. | `ONION_URL`; advertised in the one-pager's "Also via Tor" block, and used as the callback base when a request arrives over it. |
+
+**Not in the vocabulary, deliberately:** anything about fees (they are already disclosed
+in the payRequest `metadata` as `Mint fees: <base_msat>,<ppm>`, which is authoritative
+and live), anything about the mint's balance or liability, and anything a consumer would
+have to take on trust with no way to check.
+
+#### Availability is not capability
+
+`features` says what the mint **implements**. It does not say what is **working right
+now**. A mint whose funding node is unreachable still implements `mint` and `melt`; it
+just cannot perform them this minute.
+
+Consumers that probe SHOULD present these as two different things. The concrete, checkable
+signal, for `lnurl-mint`: if a mint-address response omits `mintPubkey` while still
+returning valid `minWithdrawable`/`maxWithdrawable`, the funding source is not reachable,
+and `mint`, `melt` and `signed-notes` are unavailable until it is — while `rotate`,
+`split` and `merge` continue to work normally.
+
+Consumers MUST NOT rewrite the announcement's `features` from a probe. The announcement
+is the operator's statement of what they built; the probe is an observation about a
+moment.
+
+#### What a prober may and may not conclude
+
+This matters enough to be normative, because two of these are counter-intuitive and one
+is a trap.
+
+| Value | Probe-detectable? | How |
+| --- | --- | --- |
+| `lud06`, `lud16` | **Yes** | `/.well-known/lnurlp/_` returns `tag: "payRequest"`; `payLink` on the withdraw side names the address. |
+| `lud03` | **Yes** | The mint-address response's `callback` points at `/w`. |
+| `signed-notes` | **Yes** | `mintPubkey` present on the mint-address response. |
+| `onion` | **Yes** | A `*.onion` host in the one-pager at `GET /`. Never in any JSON. |
+| `mint`, `melt` | **Partly** | Implementation cannot be probed without minting; *availability* is the `mintPubkey` bit above. |
+| `rotate`, `split`, `merge` | **No** | Only `/w/cb` proves them, and calling it mutates or destroys a stranger's note. |
+| `lud21` | **No — and this is the trap** | See below. |
+
+**`lud21` cannot be probed.** `VERIFY_ENABLED=false` makes `/verify/{hash}` raise a 404
+with detail `"Not found"`. An *enabled* endpoint asked about an unknown payment hash
+raises a 404 with detail `"Not found"` too. Both are then converted by the LNURL error
+handler into an identical `200 {"status":"ERROR","reason":"Not found"}`. The two states
+are byte-identical on the wire — verified against a live instance and a local build of
+both configurations. The only genuine advertisement of a `verify` URL is in the response
+to `/p/cb`, and calling that **creates a real invoice on the operator's node**, which no
+directory should be doing on a timer.
+
+So `lud21` is announcement-only: a prober MUST NOT set it, and MUST NOT clear it either.
+
+### `content`
+
+Optional, and exactly NIP-87's rule: a stringified kind-0-style metadata object
+(`name`, `picture`, `about`, …). **If `content` is empty, consumers should fall back to
+the `kind:0` of the event's `pubkey`** for the mint's display information.
+
+```json
+{"name": "21 Mint", "picture": "https://lnurl.21mint.me/icon.png", "about": "lnurlcash bearer notes, mainnet."}
+```
+
+Consumers MUST treat `content` as untrusted text written by anyone: unparseable JSON,
+wrong types and hostile strings degrade to "no metadata", never to an error and never to
+unescaped output.
+
+---
+
+## Reviews
+
+There is **no new review kind**. A review of an LNURL mint is a plain NIP-87
+`kind:38000` whose `k` tag names `38174`:
+
+```json
+{
+  "kind": 38000,
+  "pubkey": "<reviewer-pubkey>",
+  "content": "[5/5] Rotations are instant and melts have never failed me.",
+  "tags": [
+    ["k", "38174"],
+    ["d", "021ab89df9cbd28cdab8c71d228ca40deba1eaebd827f24849ec4f3e919c023555"],
+    ["u", "https://lnurl.21mint.me", "lnurl"],
+    ["a", "38174:<announcer-pubkey>:021ab89df9cbd28cdab8c71d228ca40deba1eaebd827f24849ec4f3e919c023555", "wss://relay.cashumints.space"]
+  ]
+}
+```
+
+Reusing `38000` is the whole point of doing it this way. An existing NIP-87 client that
+knows nothing about `38174` still sees a well-formed recommendation event from an author
+it follows, still reads the rating and the text, and still knows it is *not* about Cashu
+or Fedimint because the `k` tag says a kind it does not recognise. It half-understands
+these reviews for free, and degrades to ignoring them rather than to misfiling them.
+
+- **`k`** — REQUIRED, `"38174"`. This is what separates an LNURL review from a Cashu one,
+  and it is load-bearing: a Cashu mint's pubkey and an LNURL mint's `mintPubkey` are both
+  66-hex-character `d` values, so a resolver keying on `d` alone could file one as the
+  other.
+- **`d`** — the announcement's identifier, per the `d` rules above. As NIP-87 says, this
+  can be computed from the mint's own pubkey even when no announcement event exists.
+- **`u`** — OPTIONAL, the mint's https base URL. A third element MAY carry the free-form
+  marker `lnurl`, matching how NIP-87's own example marks `cashu` and `fedimint`.
+- **`a`** — OPTIONAL, `38174:<announcer-pubkey>:<d>` plus a relay hint, pointing at the
+  announcement event itself.
+
+### Rating
+
+Ratings follow this site's existing convention (NOTES.md), unchanged across all three
+ecosystems, because a reader comparing a Cashu mint to an LNURL one must be comparing
+the same scale:
+
+1. a `["rating", "<n>"]` tag with `n` in `1..5`, else
+2. a `["rating", "<f>"]` tag with `f` in `0..1`, scaled to `1..5` (NIP-87 suggests this
+   form), else
+3. an `[N/5]` prefix on `content`, which is how the great majority of real reviews on
+   the network encode it.
+
+Unparseable means **no rating**, and the review is excluded from averages. It is never
+defaulted to 5.
+
+---
+
+## Query patterns
+
+Recommendations for LNURL mints from people a user follows:
+
+```json
+["REQ", "<id>", {"kinds": [38000], "authors": ["<user>", "<contacts…>"], "#k": ["38174"]}]
+```
+
+Every review of one specific mint:
+
+```json
+["REQ", "<id>", {"kinds": [38000], "#k": ["38174"], "#d": ["021ab8…3555"]}]
+```
+
+Announcements, directly:
+
+```json
+["REQ", "<id>", {"kinds": [38174]}]
+["REQ", "<id>", {"kinds": [38174], "#d": ["021ab8…3555"]}]
+```
+
+All three ecosystems in one subscription, which is what an aggregator actually opens:
+
+```json
+["REQ", "<id>", {"kinds": [38172, 38173, 38174]}]
+["REQ", "<id>", {"kinds": [38000], "#k": ["38172", "38173", "38174"]}]
+```
+
+As NIP-87 already warns for `38172`/`38173`: querying announcements directly, with no
+web of trust between the reader and the publisher, will surface whatever anyone chose to
+publish. Clients doing that SHOULD apply spam prevention or restrict to relays they
+trust. Nothing about an announcement is evidence that the mint behind it is honest, or
+even that it exists.
+
+---
+
+## Reference implementation
+
+- **Constant and parse rules** — `shared/src/nostr.ts` (`KIND_LNURL_ANNOUNCEMENT`,
+  `ANNOUNCEMENT_KINDS`), `shared/src/lnurl.ts` (vocabulary, `d` rules, announcement
+  parser).
+- **Discovery and review resolution** — `api/src/discovery.ts`.
+- **Probing** — `api/src/lnurl-probe.ts`. What it found on a live instance, and every
+  ambiguity it had to resolve, is recorded in `NOTES-LNURL.md`.
+- **Publishing 38174** — `api/src/announce.ts`. Off by default; see the README section
+  "Publishing LNURL mint announcements" before turning it on, because it writes to
+  public relays.
+
+The implementation and this document are meant to be checked against each other:
+`api/src/check-lnurl.ts` asserts the `d` rules, the vocabulary, the tag shapes and the
+round trip described here, so a change to one that is not a change to the other fails
+the test suite.

docs/dynamic-mint-data.md

@@ -0,0 +1,361 @@
+# Dynamic mint data: analysis
+
+**Status:** analysis only. No code or config was changed.
+
+**Goal:** new and updated mints, stats, and reviews should appear on the list (and related list surfaces) immediately, without waiting for the nightly static rebuild.
+
+**Current architecture (important correction):** nginx does **not** serve `web/dist` as files. Production is:
+
+```
+browser → nginx :443 → cashumints-site (web/server.mjs :8789) → published copy of dist
+                      → cashumints_api  (Hono :8788)          → /api/*, /icons/*
+```
+
+`cashumints-web.timer` rebuilds at **03:30** daily, then `rsync`s `web/dist/` to `WEB_ROOT` (`/var/lib/cashumints/web`). Markup is a snapshot of whatever the API returned at that build.
+
+---
+
+## 1. Data flow audit
+
+There are **no Astro content collections**. Every dynamic page either fetches the Hono API at **build time** (`web/src/lib/api.ts`, `API_URL`, default `http://127.0.0.1:8787` / prod `8788`) or hydrates in the browser from `/api/…` and/or Nostr.
+
+Astro “islands” here are **not** React/Vue/Svelte with `client:load`. There is **zero** `client:*` usage. Runtime behaviour is vanilla `<script>` modules in `.astro` files, bundled by Vite, re-run on view transitions via `onReady()`.
+
+### 1.1 Every route under `web/src/pages`
+
+| Route | `getStaticPaths` | Build-time data | Client-side at runtime |
+|---|---|---|---|
+| `[...locale]/index.astro` (`/`, `/es`, …) | `localePaths` (one HTML page per locale) | `fetchMints`, `fetchFedimints`, `fetchLnurlMints`, `fetchStats`, `fetchHealth`; N+1 `fetchMint` / `fetchFedimint` / `fetchLnurlMint` for the top 6 of each; `fetchLatestReviews()` from relays via `nostr-build.ts` | **PulseTicker** refreshes `/api/stats` + `/api/health`. Search form is GET to `/mints`. Review carousel is **not** re-queried. ColorBends is WebGL only. |
+| `[...locale]/mints.astro` | `localePaths` | `fetchMints()` then **one `fetchMint(host)` per mint** for NUT chips | Search / sort / hide-offline only rearrange **already-rendered** cards. **No live refetch.** |
+| `[...locale]/fedimints.astro` | `localePaths` | `fetchFedimints()` (no N+1; no NUT chips) | Same client filter/sort as `/mints`. **No live refetch.** |
+| `[...locale]/lnurl-mints.astro` | `localePaths` | `fetchLnurlMints()` + N+1 `fetchLnurlMint` for chips | Same. **No live refetch.** |
+| `[...locale]/mint/[host].astro` | `localePathsFor` over **every cashu mint known at build** | `fetchMints()` + `fetchMint(host)` per mint, shared across locales | **MintLive** → `GET /api/mints/:host`. **Reviews** → Nostr via `nostr-tools` `SimplePool`. |
+| `[...locale]/fedimint/[id].astro` | same pattern, `fetchFedimints` | federation detail | Same two islands. |
+| `[...locale]/lnurl-mint/[host].astro` | same pattern, `fetchLnurlMints` | LNURL detail | Same two islands. |
+| `[...locale]/reviews.astro` | `localePaths` | `fetchAllListings()`, `fetchStats()`, `fetchReviewFeed(…, 30)` from relays | **Re-queries relays** (`feed-client.ts` `loadFeed`), paginates, filters. This is the working “live list” pattern. |
+| `[...locale]/wallets.astro` | `localePaths` | Hardcoded wallet array in the page | None |
+| `[...locale]/about.astro` | `localePaths` | `fetchStats()` for counts in copy | None |
+| `[...locale]/privacy.astro`, `terms.astro`, `disclaimer.astro` | `localePaths` | i18n catalogs only | None |
+| `[...locale]/404.astro` + `pages/404.astro` | prefixed locales / English `/404` | None (static 404 shell) | **NotFound resolver:** `GET /api/mints/:host`, on miss `POST /api/index`, then reviews panel |
+| `sitemap.xml.ts` | n/a (endpoint at build) | `fetchMints` / `fetchFedimints` / `fetchLnurlMints`; `isIndexableMint` filter | n/a |
+| `robots.txt.ts` | n/a | `SITE_URL` only; `Disallow: /api/`, `/icons/` | n/a |
+
+24 locales (`en` plus 23 prefixes). List pages are ~24 HTML files each. Mint detail pages are `mints × locales` (README ballpark: ~55 cashu mints × 24 ≈ 1,300+ pages, plus federations and LNURL).
+
+### 1.2 Why `/mints` shows only a subset, with stale stats and reviews
+
+**Not pagination.** `fetchMints()` calls `GET /api/mints?type=cashu` with **no `limit`**. `listMints()` in the API returns every matching row, sorted by score. The optional `?limit=` query is unused by the site.
+
+**Not an `isIndexableMint` filter on the grid.** Unreachable, unreviewed mints still render as cards. That predicate only drops them from JSON-LD `ItemList` and the sitemap.
+
+**The list is a frozen HTML snapshot.** `mints.astro` does:
+
+```ts
+const mints = await fetchMints();
+const capabilities = await Promise.all(
+  mints.map((mint) => fetchMint(mint.host).then(…).catch(() => null)),
+);
+```
+
+then maps every item to `<MintCard>`. After publish, those cards do not change until the next `cashumints-web.timer` run.
+
+What that freezes:
+
+| Card field | Source at build | Live counterpart |
+|---|---|---|
+| Presence of the mint | API `mints` table at 03:30 | Discovery + `POST /api/index` write new rows immediately |
+| `review_count`, `rating_avg`, `score`, `last_review_at` | SQL aggregates of **ingested** Nostr reviews | Relays (and the API, once discovery has ingested) |
+| `status`, `last_online` | last probe stored in the DB | `GET /api/mints/:host` (what MintLive already uses) |
+| Melt-only / frozen chip | N+1 detail fetch of cached `/v1/info` | same detail payload |
+
+**Why a mint can exist “on the site” but not on the list:** the 404 resolver (`NotFound.astro`) looks up `/mint/{host}` against the **live** API and, if missing, calls `POST /api/index`. That mint becomes reviewable at once. It does **not** get a card on `/mints` until rebuild. Same for Review-by-URL. The README states this as intended:
+
+> Mint pages are prerendered, so new mints and new review counts appear at the next build. … an unbuilt mint still resolves through the client-side fallback on the 404 page.
+
+**Why reviews look wrong on the list and right on the detail page:** `/mints` never talks to Nostr. It prints `MintListItem.review_count` / `rating_avg` from the API snapshot. The detail page’s `Reviews.astro` calls `loadReviews(subject)` against relays and replaces the panel. A review written today is on the detail page as soon as relays answer; the list card still shows yesterday’s count.
+
+**Home page extra subset:** `mints.slice(0, 6)` (and the same for federations / LNURL). “Latest reviews” is a **build-time** relay read (`fetchLatestReviews(…, 10)`), unlike `/reviews`, which re-queries on load.
+
+### 1.3 How the mint detail page fetches Nostr (the pattern that works)
+
+**Component:** `web/src/components/Reviews.astro`  
+Root: `[data-reviews-panel]` with `data-subject={JSON.stringify(subject)}`.  
+Script imports `loadReviews` / `loadProfiles` from `web/src/lib/reviews-client.ts`.
+
+**Library:** [`nostr-tools`](https://github.com/nbd-wtf/nostr-tools) **v2.10.4** — `SimplePool` from `nostr-tools/pool`, plus `nip19`. **Not NDK.**
+
+**Relays** (`DEFAULT_RELAYS` in `shared/src/nostr.ts`, overridable with `PUBLIC_REVIEW_RELAYS`):
+
+- `wss://relay.cashumints.space`
+- `wss://nos.lol`
+- `wss://relay.azzamo.net`
+- `wss://relay.snort.social`
+- `wss://relay.primal.net`
+
+Profiles add `wss://purplepag.es` and `wss://relay.nostr.net`.
+
+**Query:** kind `38000` (addressable reviews), two OR’d filters, `limit: 500`, `maxWait: 8000` ms:
+
+1. `#d` = mint pubkey (plus LNURL alternate ids) and `#k` = announcement kind
+2. `#u` = URL spellings (legacy Cashu reviews; federations skip this)
+
+Newest event per author wins. In-tab cache 5 minutes. Empty result is treated as a relay error if the API had counted reviews.
+
+**Live status (API, not Nostr):** `MintLive.astro` is a hidden `[data-mint-live={host}]` marker. Its script `fetch(`${apiBase}/api/mints/${host}`)` and patches the status chip, banner, limits, and NUT/module/feature rows. `apiBase` is `import.meta.env.PUBLIC_API_URL`, empty in production → same-origin `/api/…`.
+
+**Unbuilt mint URLs:** `server.mjs` serves the locale 404. `NotFound.astro` derives the address from the path, `GET /api/mints/:host`, then `POST /api/index` on miss, then dispatches `cashumints:subject` so the same Reviews island starts.
+
+---
+
+## 2. API coverage
+
+All routes are in `api/src/server.ts`. CORS is enabled on `/api/*` and `/icons/*` (`hono/cors`, default allow-all). Production uses **same origin** (`PUBLIC_API_URL=` empty; nginx proxies `/api/` and `/icons/`), so browsers never hit a cross-origin API unless that env is set.
+
+### 2.1 Existing endpoints
+
+#### `GET /api/mints`
+
+- Query: `?type=cashu|fedimint|lnurl` (unknown type → empty array); optional `?limit=N`
+- No type filter → **entire index**, each item tagged `type`
+- **No default limit.** Full list.
+- Response: `MintListItem[]`
+
+```ts
+{
+  url: string;
+  host: string;
+  name: string | null;
+  icon: string | null;          // "/icons/…" or null
+  type: 'cashu' | 'fedimint' | 'lnurl' | string;
+  status: 'online' | 'degraded' | 'offline' | 'unknown' | 'announced';
+  last_online: number | null;   // unix
+  review_count: number;         // ingested, one-per-author
+  rating_avg: number | null;    // 1 decimal
+  score: number;                // Bayesian, from those aggregates
+  last_review_at: number | null;
+  version: string | null;
+}
+```
+
+**This is enough to rebuild the `/mints` grid** (name, icon, rating, count, status, sort keys). It is **not** enough for melt-only / frozen chips (`nuts` / capabilities) or for true sentiment bars (`rating_distribution`). Those currently require N+1 `GET /api/mints/:host`.
+
+#### `GET /api/mints/:host`
+
+- 404 `{ error, message }` if unknown
+- Response: `MintDetail` = list item plus:
+
+```ts
+{
+  description, pubkey, info /* NUT-06 */, nuts: string[],
+  first_seen, last_probe, updated_at,
+  rating_distribution: { '1'..'5': number },
+  reviews_90d, uptime_30d, probes_recent: { ts, ok, latency_ms }[],
+  // fedimint extras when type=fedimint: federation_id, invite_codes, modules, …
+  // lnurl extras when type=lnurl: features, funding_available, withdraw bounds, …
+}
+```
+
+Used by MintLive and the 404 resolver. **No review bodies.**
+
+#### `GET /api/stats`
+
+In-process memo **60s**. Cashu `mints_*` counts are cashu-only.
+
+```ts
+{
+  mints_total, mints_online, mints_offline, mints_degraded,
+  reviews_total, last_review_at, updated_at,
+  cashu_total,  // same as mints_total
+  fedimint_total, fedimint_online, fedimint_offline, fedimint_announced, fedimint_reviews,
+  lnurl_total, lnurl_online, lnurl_offline, lnurl_degraded_funding, lnurl_reviews
+}
+```
+
+PulseTicker already consumes this live.
+
+#### `GET /api/health`
+
+`Cache-Control: no-store`. `{ status, uptime_s, last_probe_at, last_discovery_at, mints_tracked, updated_at }`. 503 when degraded.
+
+#### `POST /api/index`
+
+The only write. Body `{ type, input }`. Rate limit **10/hour/IP** (`INDEX_RATE_LIMIT`). Success 200/201: `MintDetail & { existing, indexed_from? }`. Failures: `bad_input`, `blocked_host`, `wrong_type`, `unverifiable`, `rate_limited`, etc.
+
+#### `GET /icons/:file`
+
+Static files, `Cache-Control: public, max-age=86400`.
+
+### 2.2 Gaps
+
+| Need | Exists? | Notes |
+|---|---|---|
+| Full mint / federation / LNURL lists | **Yes** | `/api/mints?type=…` |
+| Per-mint stats (status, uptime, distribution, probes) | **Yes** | `/api/mints/:host` |
+| Review **bodies** / recent review text | **No HTTP endpoint** | Live only via Nostr (`reviews-client.ts`, `feed-client.ts`). API stores ratings for aggregates, not content for the UI. |
+| List payload with NUT chips / LNURL chips | **No** | List item has no `nuts`, no `rating_distribution`. Today: N+1 at **build**. Client-side N+1 per visitor would be wasteful. |
+| Global review feed JSON | **No** | `/reviews` talks to relays, not the API. |
+| Snapshot JSON in `dist` | **None** | No checked-in mint dump. Stale data **is** the prerendered HTML. |
+
+Discovery itself is not the list cap (`QUERY_LIMIT` 500 × `MAX_PAGES` 20). The visible cap is **whatever was in the DB when `astro build` ran**.
+
+---
+
+## 3. Option analysis
+
+### 3a. Client-side hydration (keep static build)
+
+Keep `output: 'static'`, `server.mjs`, nginx, and the timer. On `/mints` (and twins), fetch the live API after load and rebuild the grid — the same idea as Reviews / PulseTicker / MintLive.
+
+**What already exists to copy**
+
+- PulseTicker: prerender numbers, then `fetch(`${apiBase}/api/stats`)`.
+- `/reviews`: prerender ~30 cards, then `loadFeed()` replaces them.
+- MintLive: patch in place from `/api/mints/:host`.
+- `/mints` script already sorts/filters on `data-*` (`data-score`, `data-rating`, `data-reviews`, `data-last-review`, `data-status`, …). New cards only need those attributes.
+
+**There are no `client:load` islands to add.** Work is extra `<script>` in the list pages (or a shared module) plus an HTML builder for a card, because `MintCard.astro` cannot run in the browser.
+
+Concrete changes:
+
+| File | Change |
+|---|---|
+| `web/src/pages/[...locale]/mints.astro` | After paint, `fetch('/api/mints?type=cashu')`, rebuild `[data-mint-grid]`, update `[data-result-count]`. Keep prerendered cards as noscript / first-paint fallback. |
+| `web/src/pages/[...locale]/fedimints.astro` | Same, `?type=fedimint`. |
+| `web/src/pages/[...locale]/lnurl-mints.astro` | Same, `?type=lnurl`. |
+| `web/src/lib/mint-cards.ts` (**new**) | Browser HTML for one card, mirroring `MintCard.astro` (same pattern as `review-cards.ts`). |
+| `web/src/lib/api.ts` | Optional: a tiny browser `fetch` helper using `apiBase` from `client.ts` (build-time `API_URL` must **not** ship to the browser). |
+| `web/src/pages/[...locale]/index.astro` | Optional but needed for “immediately”: refresh top-6 grids from the same list endpoint; optionally reuse `/reviews`’s `loadFeed` for the carousel (today that strip is build-only). |
+| `web/src/components/MintCard.astro` | Untouched if the JS builder is a parallel renderer; or extract shared markup helpers. |
+
+**Chips:** either (i) leave prerendered chips stale, (ii) add `nuts` / chip flags to `MintListItem` + `toListItem()` in `api/src/queries.ts` (small, one-time API change), or (iii) N+1 detail fetches from every browser (do not do this).
+
+**New mint click path:** hydrated list → `/mint/{newhost}` → 404 HTML → NotFound resolver → live page. Already designed. No SSR required for that URL to work.
+
+**Dependencies:** none new (`nostr-tools` already in `web`). No adapter. No nginx / systemd change for the site server.
+
+**Config:** none if `PUBLIC_API_URL` stays empty.
+
+### 3b. Hybrid SSR (`@astrojs/node`, `prerender = false`)
+
+Astro 5 dropped `output: 'hybrid'`. Pattern: install an adapter, keep `output: 'static'`, set `export const prerender = false` on routes that must run per request.
+
+Concrete changes:
+
+| File / unit | Change |
+|---|---|
+| `web/package.json` | Add `@astrojs/node`. `start` would become something like `node dist/server/entry.mjs` instead of `node server.mjs`. |
+| `web/astro.config.mjs` | `import node from '@astrojs/node'`; `adapter: node({ mode: 'standalone' })`. `output` can stay `'static'`. |
+| `web/src/pages/[...locale]/mints.astro` (and fedimints / lnurl-mints; maybe `index.astro`) | `export const prerender = false`. Drop `getStaticPaths` **or** keep it only if those routes stay static. SSR pages fetch `fetchMints()` **per request**. |
+| `web/server.mjs` | **Cannot stay as the only server.** Node adapter emits `dist/server/entry.mjs` plus `dist/client/` for assets. Locale 404s, ETag/cache policy, path jail, and “refuse empty root” all live in `server.mjs` today and would need reimplementation or a wrapper. |
+| `cashumints-site.service` | `ExecStart` → adapter entry; `WEB_ROOT` layout changes (`client/` vs flat dist). |
+| `cashumints-web.service` | `rsync` of `web/dist/` is wrong for `client/` + `server/`. Publish + restart model changes. A failed SSR process takes down **HTML**, not only islands. |
+| nginx | Still reverse-proxy; upstream may stay `:8789` if the adapter listens there. `proxy_read_timeout` 30s is fine for API-backed SSR. |
+
+SSR **does not** by itself refresh review **bodies** on the list (there are none). It **does** make list HTML match the API on every request, including for crawlers, and can emit real 200s for new `/mint/{host}` if that route is also `prerender = false` (today new hosts are **404** until rebuild).
+
+Per-request cost: `/mints` already does N+1 detail fetches for chips × 24 locales if you SSR all locales naively. Needs a cache or list-payload chips.
+
+### 3c. Caching layers
+
+**In-repo**
+
+| Layer | TTL | Affects |
+|---|---|---|
+| `getStats()` memo (`api/src/queries.ts`) | 60s | `/api/stats` |
+| Review / feed `SimplePool` caches in the tab | 5 min | detail reviews, `/reviews` |
+| Icons | 1 day (`max-age=86400`) | `/icons/*` |
+| `GET /api/mints`, `/api/stats`, `/api/mints/:host` | **no** `Cache-Control` from Hono (except health `no-store`) | nginx fills the gap |
+
+**nginx** (`README.md` sample; not in this repo)
+
+```nginx
+proxy_cache_path … keys_zone=cashumints:10m max_size=256m inactive=10m;
+
+location ~ ^/api/(mints|stats)(?:/|$|\?) {
+  proxy_cache cashumints;
+  proxy_cache_valid 200 30s;
+  proxy_cache_valid 404 10s;
+  proxy_cache_use_stale updating error timeout http_500 http_502 http_503;
+  proxy_cache_background_update on;
+  proxy_cache_lock on;
+}
+location /icons/ { proxy_cache …; proxy_cache_valid 200 1d; }
+location = /api/health { proxy_cache off; }
+```
+
+**HTML** from `server.mjs`: `Cache-Control: public, max-age=0, must-revalidate` + ETag. Browsers revalidate; they do not keep a 24h stale `/mints`.
+
+**Implications**
+
+- Client-side list fetch: **30s** nginx micro-cache is desirable (thundering herd). Not the 24h bug.
+- After `POST /api/index`, a new mint can be missing from `GET /api/mints` for up to 30s (404 cache 10s on unknown host). Acceptable; optional `Cache-Control: s-maxage=30` on the API to make it explicit.
+- SSR `/mints` would still sit behind that 30s API cache unless the SSR process talks to the API on loopback **bypassing nginx** (`API_URL=http://127.0.0.1:8788`), which the **build** already does. An SSR Node process on the same machine should keep using loopback, not `https://cashumints.space/api`.
+- No purge/invalidation API exists. Not needed for 30s TTL.
+
+**Rate limits:** only `POST /api/index`. `GET /api/mints` is unbounded. A list page per visitor is one small JSON payload (~tens of mints), not a risk.
+
+---
+
+## 4. Recommendation
+
+**Do 3a (client-side hydration of the list from `GET /api/mints`).** Least infrastructure change that fixes: full live mint list, live card stats, live review **counts** on the list.
+
+Do **not** move `/mints` to SSR for this goal. That replaces `server.mjs`, the publish path, and systemd, to solve a problem the API + existing island style already solve. Use SSR later only if you need **200 + HTML** for mint URLs that do not exist at build time (SEO for brand-new hosts). Those URLs already **work** for humans via the 404 resolver.
+
+### Why 3a is enough
+
+1. The API already returns the full cashu list with scores and review aggregates.
+2. Same-origin `/api` is already proxied; PulseTicker proves browser → API works in production.
+3. New mints already resolve on click (404 → `POST /api/index`). Hydrating the list is the missing half.
+4. Review **text** on `/mints` was never a list feature; card counts come from the API. Once the list refetches, counts match what MintLive/stats use (discovery-ingested). Bodies stay on the detail page via Nostr, as now.
+5. `/reviews` already has live bodies.
+
+### Effort
+
+**Small–medium, ~1–2 days** for `/mints` + fedimints + lnurl-mints + a shared card renderer. Another half day if the home top grids and “latest reviews” strip should match.
+
+Optional extra (half day): add chip fields to `GET /api/mints` so the client does not N+1.
+
+### Files that would be touched (3a)
+
+**Required for the list pages**
+
+- `web/src/pages/[...locale]/mints.astro`
+- `web/src/pages/[...locale]/fedimints.astro`
+- `web/src/pages/[...locale]/lnurl-mints.astro`
+- `web/src/lib/mint-cards.ts` (new; browser card HTML + `fetch` against `apiBase`)
+
+**Likely**
+
+- `web/src/pages/[...locale]/index.astro` (top-6 + “all N mints” count; otherwise home still lies)
+- `web/src/components/MintCard.astro` only if extracting shared helpers rather than duplicating markup
+
+**Optional API (chips)**
+
+- `shared/src/types.ts` (`MintListItem`)
+- `api/src/queries.ts` (`toListItem`)
+
+**Not required:** `astro.config.mjs`, `web/package.json` (unless you add a test), `web/server.mjs`, nginx, systemd units, `@astrojs/node`.
+
+### Risks
+
+| Risk | Severity | Mitigation |
+|---|---|---|
+| **SEO:** crawlers see the prerendered subset | Medium if you **replace** HTML with an empty grid. Low if you **keep** build-time cards and enhance. Google does not run the same JS as users. | Keep prerendered cards. Hydration only adds/updates. `ItemList` JSON-LD stays a snapshot; acceptable. |
+| **New mint URLs return HTTP 404** until rebuild | Low for UX (resolver fills in). Medium for SEO of a mint indexed today. | Out of scope for list freshness. SSR on `mint/[host].astro` is the fix if needed. |
+| **Nostr relay latency** | Does not apply to the **list** if you use the API. Applies to `/reviews` and detail panels already (8–9s timeout, bones, retry). | Do not query relays on `/mints`. |
+| **API rate limits** | None on GET. | — |
+| **CORS** | None while `PUBLIC_API_URL` is empty (same origin). Hono already sends CORS if the API is split later. | Do not bake `API_URL` (`127.0.0.1`) into browser code. |
+| **nginx 30s cache** | Cards can lag indexing by 30s | Fine. Loopback SSR would skip it; client fetch will not. |
+| **Card markup drift** | JS builder vs `MintCard.astro` | One HTML helper, or accept a short duplication like `review-cards.ts` vs the Astro card. |
+| **View transitions** | Cards use `data-vt-*` names applied on click | Preserve those attributes in the builder. |
+| **i18n** | Card strings must use `useI18n()` in the island, not build-time `t` | Same as Reviews / PulseTicker. |
+| **Home “latest reviews”** | Still nightly unless you reuse `loadFeed` | Separate follow-up; `/reviews` is already live. |
+
+### Suggested sequence (when implementing)
+
+1. Hydrate `/mints` from `GET /api/mints?type=cashu`; keep prerendered fallback.
+2. Repeat for `/fedimints` and `/lnurl-mints`.
+3. Hydrate the home top grids (and the “all N” link) from the same endpoints.
+4. Only if chips go stale in a way users notice: extend the list payload.
+5. Revisit SSR only for mint-detail **status codes** / OG / sitemap freshness — not for the list.

package.json

@@ -4,7 +4,7 @@
   "version": "2.0.0",
   "type": "module",
   "engines": {
-    "node": ">=20"
+    "node": ">=20.18"
   },
   "scripts": {
     "dev": "pnpm --parallel --filter ./api --filter ./web dev",
@@ -12,7 +12,8 @@
     "dev:web": "pnpm --filter ./web dev",
     "seed": "pnpm --filter ./api seed",
     "bones": "pnpm --filter ./web bones",
-    "build": "pnpm --filter ./shared build && pnpm --filter ./web build",
+    "build": "pnpm --filter ./shared build && pnpm --filter ./api build && pnpm --filter ./web build",
+    "start": "pnpm --filter ./web start",
     "check:links": "pnpm --filter ./web check:links",
     "typecheck": "pnpm -r typecheck",
     "check:i18n": "pnpm --filter ./web check:i18n",

shared/src/fedimint.ts

@@ -300,3 +300,201 @@ export function shortInviteCode(code: string, head = 14, tail = 8): string {
   if (code.length <= head + tail + 1) return code;
   return `${code.slice(0, head)}…${code.slice(-tail)}`;
 }
+
+/* ---------- decoding an invite code ---------- */
+
+/**
+ * Decoding one, which until now nothing in this codebase did.
+ *
+ * `isInviteCode` above is a shape check, and a shape check is all the *display* side
+ * has ever needed: a code arrives inside an announcement that already carries the
+ * federation id in its `d` tag, and the code itself is handed to a wallet verbatim.
+ *
+ * On-demand indexing changes that. A reader pasting an invite code into the review
+ * dialog hands over the only thing they have, and there is no announcement beside it
+ * to read an id off — so the id has to come out of the code, or the federation cannot
+ * be keyed, deduped against what is already indexed, or given a page.
+ *
+ * Two layers, both small and both self-contained (a bech32 dependency for one function
+ * would be the tail wagging the dog):
+ *
+ *   1. **bech32m**, per BIP-350: the same alphabet and checksum as bech32 with a
+ *      different constant. Fedimint uses bech32m, so a code that verifies under the
+ *      *bech32* constant is rejected rather than accepted — it would mean the code was
+ *      produced by something else.
+ *   2. **fedimint's consensus encoding** of `Vec<InviteCodePart>`: a BigSize count, then
+ *      per part a BigSize tag, a BigSize length and that many bytes. Tag 1 is the
+ *      federation id, 32 bytes. Everything else — guardian API URLs (tag 0), an API
+ *      secret (tag 2), anything a later fedimint adds — is skipped by its length
+ *      without being understood, which is what the tag/length framing is for.
+ *
+ * Written against real codes off the relay pool, not against a reading of the Rust, and
+ * `check-index.ts` asserts it still decodes them.
+ */
+
+/** bech32's alphabet, and its two checksum constants. `1` is deliberately not in it. */
+const BECH32_CHARSET = 'qpzry9x8gf2tvdw0s3jn54khce6mua7l';
+const BECH32M_CONST = 0x2bc830a3;
+const GENERATOR = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3];
+
+function bech32Polymod(values: readonly number[]): number {
+  let chk = 1;
+  for (const value of values) {
+    const top = chk >> 25;
+    chk = ((chk & 0x1ffffff) << 5) ^ value;
+    for (let i = 0; i < 5; i++) if ((top >> i) & 1) chk ^= GENERATOR[i]!;
+  }
+  return chk >>> 0;
+}
+
+function hrpExpand(hrp: string): number[] {
+  const out: number[] = [];
+  for (const char of hrp) out.push(char.charCodeAt(0) >> 5);
+  out.push(0);
+  for (const char of hrp) out.push(char.charCodeAt(0) & 31);
+  return out;
+}
+
+/**
+ * The payload bytes of a bech32m string, or null if it is not a valid one.
+ *
+ * Length capped well above any real invite code: the checksum is only meaningful over
+ * a string somebody could plausibly have produced, and an unbounded input here would
+ * be an unbounded loop below.
+ */
+function decodeBech32m(input: string): { hrp: string; bytes: Uint8Array } | null {
+  if (input.length < 8 || input.length > 4000) return null;
+  // Mixed case is invalid in bech32; one case throughout is not.
+  if (input !== input.toLowerCase() && input !== input.toUpperCase()) return null;
+
+  const value = input.toLowerCase();
+  const split = value.lastIndexOf('1');
+  if (split < 1 || split + 7 > value.length) return null;
+
+  const hrp = value.slice(0, split);
+  for (const char of hrp) {
+    const code = char.charCodeAt(0);
+    if (code < 33 || code > 126) return null;
+  }
+
+  const data: number[] = [];
+  for (const char of value.slice(split + 1)) {
+    const index = BECH32_CHARSET.indexOf(char);
+    if (index === -1) return null;
+    data.push(index);
+  }
+
+  if (bech32Polymod([...hrpExpand(hrp), ...data]) !== BECH32M_CONST) return null;
+
+  // Five-bit groups to eight, dropping the checksum and the final partial group.
+  const payload = data.slice(0, -6);
+  const bytes: number[] = [];
+  let acc = 0;
+  let bits = 0;
+  for (const group of payload) {
+    acc = (acc << 5) | group;
+    bits += 5;
+    while (bits >= 8) {
+      bits -= 8;
+      bytes.push((acc >> bits) & 0xff);
+    }
+  }
+  // Leftover bits must be zero padding, and there must be fewer than five of them.
+  if (bits >= 5 || ((acc << (8 - bits)) & 0xff) !== 0) return null;
+
+  return { hrp, bytes: Uint8Array.from(bytes) };
+}
+
+/** A cursor over the decoded bytes, reading fedimint's BigSize integers and blobs. */
+class ByteReader {
+  private at = 0;
+  constructor(private readonly bytes: Uint8Array) {}
+
+  get done(): boolean {
+    return this.at >= this.bytes.length;
+  }
+
+  /**
+   * Lightning's BigSize, which is what fedimint encodes a `u64` as: one byte under
+   * 0xfd, otherwise a marker and 2, 4 or 8 big-endian bytes.
+   *
+   * Returns null rather than throwing when the buffer runs out, so a truncated code is
+   * a rejected code and not an exception a caller has to catch.
+   */
+  bigSize(): number | null {
+    const first = this.byte();
+    if (first === null) return null;
+    if (first < 0xfd) return first;
+
+    const width = first === 0xfd ? 2 : first === 0xfe ? 4 : 8;
+    let value = 0;
+    for (let i = 0; i < width; i++) {
+      const next = this.byte();
+      if (next === null) return null;
+      // Above 2^53 nothing here is a real length or tag anyway, and the arithmetic
+      // stops being exact, so an absurd value is refused rather than rounded.
+      value = value * 256 + next;
+      if (value > Number.MAX_SAFE_INTEGER) return null;
+    }
+    return value;
+  }
+
+  bytesOf(length: number): Uint8Array | null {
+    if (length < 0 || this.at + length > this.bytes.length) return null;
+    const slice = this.bytes.subarray(this.at, this.at + length);
+    this.at += length;
+    return slice;
+  }
+
+  private byte(): number | null {
+    return this.at < this.bytes.length ? this.bytes[this.at++]! : null;
+  }
+}
+
+/** The tag fedimint gives the federation id inside an invite code. */
+const INVITE_PART_FEDERATION_ID = 1;
+/** A federation id is a 32 byte hash. A part of any other length is not one. */
+const FEDERATION_ID_BYTES = 32;
+/** Real codes carry two or three parts. This only has to stop a hostile count. */
+const MAX_INVITE_PARTS = 64;
+
+function toHex(bytes: Uint8Array): string {
+  let out = '';
+  for (const byte of bytes) out += byte.toString(16).padStart(2, '0');
+  return out;
+}
+
+/**
+ * The federation id inside an invite code, or null if the code is not one.
+ *
+ * Null covers every way a pasted string can fail — wrong prefix, a typo the checksum
+ * catches, valid bech32m that is not an invite code, an invite code with no federation
+ * id part — because a caller has exactly one thing to say about all of them ("that is
+ * not an invite code") and telling them apart would be telling a stranger which of
+ * their guesses was closest.
+ */
+export function federationIdFromInviteCode(code: string): string | null {
+  const raw = code?.trim();
+  if (!raw || !/^fed1[a-z0-9]+$/i.test(raw)) return null;
+
+  const decoded = decodeBech32m(raw);
+  // `fed1` is the human-readable part; the `1` after it is bech32's separator.
+  if (!decoded || decoded.hrp !== 'fed1') return null;
+
+  const reader = new ByteReader(decoded.bytes);
+  const parts = reader.bigSize();
+  if (parts === null || parts === 0 || parts > MAX_INVITE_PARTS) return null;
+
+  for (let i = 0; i < parts; i++) {
+    const tag = reader.bigSize();
+    const length = tag === null ? null : reader.bigSize();
+    const value = length === null ? null : reader.bytesOf(length);
+    if (value === null) return null;
+
+    if (tag === INVITE_PART_FEDERATION_ID && value.length === FEDERATION_ID_BYTES) {
+      return toHex(value);
+    }
+  }
+
+  return null;
+}

shared/src/index.ts

@@ -5,3 +5,5 @@ export * from './score.js';
 export * from './nuts.js';
 export * from './warnings.js';
 export * from './fedimint.js';
+export * from './lnurl.js';
+export * from './indexing.js';

shared/src/indexing.ts

@@ -0,0 +1,208 @@
+/**
+ * On-demand indexing: the contract `POST /api/index` speaks.
+ *
+ * Both ends of that request are in this repository — the API answers it, the 404
+ * resolver and the review-by-URL dialog send it — so the shapes live here rather than
+ * being written out twice and drifting. The reason codes in particular are the whole
+ * point of this file: the API decides *what happened*, the browser decides *what to
+ * say about it*, and a typo in a string literal must not be the thing that silently
+ * turns a precise sentence into a generic one.
+ *
+ * The endpoint itself is documented in BACKEND.md. What is here is only what both
+ * sides need to agree on: which types are indexable, what a valid submission looks
+ * like before any network call, and what comes back.
+ */
+import { federationIdFromInviteCode, isInviteCode } from './fedimint.js';
+import { normalizeMintUrl } from './normalize.js';
+import type { MintDetail, MintInfo } from './types.js';
+
+/** The three ecosystems a reader can hand this site an identifier for. */
+export const INDEXABLE_TYPES = ['cashu', 'fedimint', 'lnurl'] as const;
+export type IndexType = (typeof INDEXABLE_TYPES)[number];
+
+export function isIndexType(value: unknown): value is IndexType {
+  return typeof value === 'string' && (INDEXABLE_TYPES as readonly string[]).includes(value);
+}
+
+/**
+ * Why a submission did not become a row.
+ *
+ * Every one of these is a different sentence to a reader, which is why they are not
+ * collapsed into a generic failure:
+ *
+ *   `bad_type`         the `type` field was not one of the three
+ *   `bad_input`        the input is not a URL (or an invite code) at all
+ *   `blocked_host`     it resolves somewhere this server will not fetch from
+ *   `wrong_type`       the host answered, as a *different* ecosystem's mint
+ *   `invalid_response` the host answered, as nothing this site recognises
+ *   `invalid_invite`   the invite code does not decode
+ *   `unverifiable`     nothing answered, and Nostr has never heard of it either
+ *   `rate_limited`     too many submissions from one address this hour
+ */
+export type IndexFailureReason =
+  | 'bad_type'
+  | 'bad_input'
+  | 'blocked_host'
+  | 'wrong_type'
+  | 'invalid_response'
+  | 'invalid_invite'
+  | 'unverifiable'
+  | 'rate_limited';
+
+/** How a row that did not already exist came to be written. */
+export type IndexSource = 'probe' | 'announcement' | 'invite';
+
+export interface IndexFailure {
+  error: IndexFailureReason;
+  /** English, for a log or a `curl`. The browser renders its own translated copy. */
+  message: string;
+  /**
+   * The ecosystem this address *does* look like, when the answer said so.
+   *
+   * Only ever set beside `wrong_type`, and it is what lets the dialog offer "this looks
+   * like a Cashu mint, review it there instead" with a button rather than making the
+   * reader work out which page they wanted.
+   */
+  detected_type?: IndexType;
+  /** Seconds until the next submission is accepted. Only beside `rate_limited`. */
+  retry_after?: number;
+}
+
+/** 200 or 201: the same payload `GET /api/mints/:host` returns, plus how it got there. */
+export type IndexSuccess = MintDetail & {
+  /** True when the identifier was already indexed and nothing was probed. */
+  existing: boolean;
+  /** Absent on an `existing` hit: nothing was written, so nothing wrote it. */
+  indexed_from?: IndexSource;
+};
+
+export type IndexResponse = IndexSuccess | IndexFailure;
+
+export function isIndexFailure(body: IndexResponse): body is IndexFailure {
+  return typeof (body as IndexFailure).error === 'string';
+}
+
+/**
+ * The client-side pre-check, run before any network call.
+ *
+ * Deliberately shallow: it answers "could this possibly be an address of this kind?"
+ * and nothing more. Whether the mint exists, answers, or is what it claims is the
+ * server's question, and asking the browser to guess would only produce a second
+ * opinion to disagree with. What it does catch is the common typo — an empty box, a
+ * sentence, a `fed1…` pasted into the Cashu field — before a request goes out.
+ *
+ * Returns the value to submit, which is the input with the scheme the normalizer would
+ * add, so the dialog can show the reader what it is about to check.
+ */
+export function checkIndexInput(
+  type: IndexType,
+  input: string,
+): { ok: true; value: string } | { ok: false; reason: 'empty' | 'bad_url' | 'bad_invite' } {
+  const raw = input.trim();
+  if (!raw) return { ok: false, reason: 'empty' };
+
+  if (type === 'fedimint') {
+    return isInviteCode(raw) && federationIdFromInviteCode(raw) !== null
+      ? { ok: true, value: raw.toLowerCase() }
+      : { ok: false, reason: 'bad_invite' };
+  }
+
+  // A pasted invite code in a URL field is a wrong-field mistake, not a malformed URL,
+  // and saying "that is an invite code" is more use than "that is not a URL".
+  if (isInviteCode(raw)) return { ok: false, reason: 'bad_invite' };
+
+  const normalized = normalizeMintUrl(raw);
+  return normalized ? { ok: true, value: normalized.url } : { ok: false, reason: 'bad_url' };
+}
+
+/**
+ * Is this body a NUT-06 mint info document?
+ *
+ * The probe needs a test that a Cashu mint passes and an arbitrary JSON endpoint fails,
+ * because `/v1/info` on a host that is not a mint is very often a 200 with *something*
+ * on it — an API index, a health check, a framework's error object. NUT-06 makes every
+ * field optional, so the test is "does it carry any of the things only a mint has":
+ * a `nuts` object, or a mint pubkey, or the name/version pair a mint's info always has.
+ *
+ * Kept here rather than in the prober because the wrong-type detection on the LNURL
+ * path runs the same test against the same document, and two spellings of "is this a
+ * Cashu mint" is exactly how a submission ends up filed under both ecosystems.
+ */
+export function isNut06Info(body: unknown): body is MintInfo {
+  if (!body || typeof body !== 'object' || Array.isArray(body)) return false;
+  const info = body as Record<string, unknown>;
+
+  const nuts = info['nuts'];
+  if (nuts && typeof nuts === 'object' && !Array.isArray(nuts) && Object.keys(nuts).length > 0) {
+    return true;
+  }
+  // A mint pubkey is 33 compressed bytes, exactly as an LNURL mint's is.
+  if (typeof info['pubkey'] === 'string' && /^0[23][0-9a-f]{64}$/i.test(info['pubkey'])) {
+    return true;
+  }
+  return typeof info['name'] === 'string' && typeof info['version'] === 'string';
+}
+
+/**
+ * The route a page for this listing lives at, given its type and routing slug.
+ *
+ * One table, because three pages, the 404 resolver, the review dialog and the sitemap
+ * all have to agree on it, and the failure mode of disagreeing is a link to a page that
+ * does not exist. Locale prefixing is the caller's job (`localePath`).
+ */
+export const MINT_ROUTES: Record<IndexType, string> = {
+  cashu: '/mint',
+  fedimint: '/fedimint',
+  lnurl: '/lnurl-mint',
+};
+
+/** `/mint/mint.example.com`, unprefixed. */
+export function mintPath(type: string, host: string): string {
+  const base = MINT_ROUTES[type as IndexType] ?? MINT_ROUTES.cashu;
+  return `${base}/${host}`;
+}
+
+/**
+ * Which ecosystem a page path belongs to, or null when it is not a listing page.
+ *
+ * The 404 resolver's first question: the reader asked for *something*, and whether
+ * this build has any business indexing it on their behalf is decided entirely by the
+ * shape of the path they used.
+ */
+export function typeForPath(path: string): { type: IndexType; host: string } | null {
+  const match = /^\/(mint|fedimint|lnurl-mint)\/([^/]+)\/?$/.exec(path);
+  if (!match?.[1] || !match[2]) return null;
+
+  const type: IndexType =
+    match[1] === 'fedimint' ? 'fedimint' : match[1] === 'lnurl-mint' ? 'lnurl' : 'cashu';
+  return { type, host: decodeURIComponent(match[2]) };
+}
+
+/**
+ * The address a `/mint/{slug}` or `/lnurl-mint/{slug}` deep link implies, or null when
+ * the slug cannot be turned back into one.
+ *
+ * Routing slugs are deterministic but not reversible: `mint.example.com/Bitcoin` becomes
+ * `mint.example.com-bitcoin`, and so would a mint at `mint.example.com-bitcoin` if one
+ * existed. Looking a row up by slug is unaffected — that is what the column is for — but
+ * *indexing* from a slug means fetching an address, and guessing which of two readings a
+ * hyphen had would mean probing the wrong host and possibly indexing it.
+ *
+ * So only the unambiguous shape is derived: a plain hostname, optionally with the port
+ * suffix the slug spells `-3338`. Everything else returns null, and the caller says it
+ * cannot look this one up from the link alone and offers the dialog, where the reader
+ * can paste the address including its path.
+ *
+ * The `lnurl-` collision prefix is deliberately *not* stripped. A slug only takes that
+ * prefix at insert time, so a link carrying one describes a row that exists and never
+ * reaches this function; a slug that merely starts with those characters is far more
+ * likely to be a mint whose hostname begins `lnurl-`, and turning it into a different
+ * host would mean probing — and possibly indexing — somebody else's server.
+ */
+export function addressFromSlug(slug: string): string | null {
+  const value = slug.trim().toLowerCase();
+  const match = /^([a-z0-9-]+(?:\.[a-z0-9-]+)*\.[a-z]{2,})(?:-(\d{2,5}))?$/.exec(value);
+  if (!match?.[1]) return null;
+
+  return `https://${match[1]}${match[2] ? `:${match[2]}` : ''}`;
+}

shared/src/lnurl.ts

@@ -0,0 +1,714 @@
+/**
+ * LNURL mints: what a `kind:38174` announcement contains, what the mint's own endpoints
+ * return, and the handful of derived values the API, the pages and the islands all have
+ * to agree on.
+ *
+ * The kind is this site's own proposed NIP-87 extension, specified in
+ * `docs/KIND-LNURL-MINT.md`. That document and this file are meant to be read together:
+ * every rule below is stated there normatively, and `api/src/check-lnurl.ts` asserts the
+ * two have not drifted apart.
+ *
+ * The endpoint parsing was written against the live reference instance and against a
+ * locally run build of the mint software, not against a reading of the README — the same
+ * rule NOTES.md sets for the Cashu side. `NOTES-LNURL.md` records what was actually on
+ * the wire. Four places where the wire and the prose disagreed, all resolved for the wire:
+ *
+ *   - There is no bare `/p`. The payRequest lives only at `/.well-known/lnurlp/{username}`,
+ *     and `/p` is a hard 404. The mint advertisement — limits, description, pubkey, node
+ *     identity — is on the *withdraw* side, `/.well-known/lnurlw/{username}`.
+ *   - Every registered route answers its errors with **HTTP 200** and an LNURL
+ *     `{"status":"ERROR"}` body. A status code proves nothing; only the parsed body does.
+ *   - `None` fields are dropped from responses entirely, so "no funding source" shows up
+ *     as `mintPubkey` and the node fields being *absent*, not null.
+ *   - LUD-21 verify cannot be distinguished from an unknown payment hash. It is
+ *     announcement-only; nothing here infers it.
+ *
+ * Every amount on the wire is millisatoshi. Nothing in this file rounds; `msatToSat`
+ * is where that decision is made once.
+ */
+import {
+  sanitizeDisplayText, sanitizePictureUrl, tagValue, tagValues, type NostrEventLike,
+} from './nostr.js';
+import { displayDomain, normalizeMintUrl } from './normalize.js';
+
+/** The scheme on the synthetic `mints.url` an LNURL row is keyed by. */
+export const LNURL_KEY_SCHEME = 'lnurl:';
+
+/**
+ * Routing-slug prefix, used **only** on collision.
+ *
+ * `mints.host` is globally unique across every ecosystem, so an LNURL mint and a Cashu
+ * mint on the same hostname would fight over one slug and the loser would silently not
+ * be tracked. Almost always they do not collide, and the LNURL mint keeps the clean
+ * `lnurl.21mint.me` slug; when one does, the row takes `lnurl-` in front rather than
+ * vanishing. See `insertLnurlMint` for why that is decided at insert time and then never
+ * revisited.
+ */
+export const LNURL_SLUG_PREFIX = 'lnurl-';
+
+/**
+ * The primary key an LNURL row uses.
+ *
+ * Namespaced rather than storing the bare URL, for the same reason `fedimint:` is: the
+ * column is the table's primary key across all three ecosystems, and one host serving
+ * both a Cashu mint and an LNURL mint must produce two rows, not a collision. The base
+ * URL is recoverable in full, so nothing is lost by the prefix.
+ */
+export function lnurlKey(baseUrl: string): string {
+  return LNURL_KEY_SCHEME + baseUrl;
+}
+
+/** The base URL inside an `lnurl:` key, or null if that is not what this is. */
+export function baseUrlFromKey(key: string): string | null {
+  if (!key.startsWith(LNURL_KEY_SCHEME)) return null;
+  const url = key.slice(LNURL_KEY_SCHEME.length);
+  return url.startsWith('https://') ? url : null;
+}
+
+/* ---------- identity ---------- */
+
+/**
+ * A mint pubkey: the funding node's identity key, 33 bytes compressed, 66 hex characters
+ * beginning `02` or `03`.
+ *
+ * Strict about the length and the prefix on purpose. This value becomes the `d` tag, and
+ * the whole reason the two `d` forms are unambiguous is that one of them is exactly this
+ * shape and the other never is.
+ */
+export function isMintPubkey(value: unknown): value is string {
+  return typeof value === 'string' && /^0[23][0-9a-f]{64}$/i.test(value);
+}
+
+/**
+ * The `d` fallback: a mint's normalized host, with no scheme and no trailing slash.
+ *
+ * `https://mint.example.com/lnurl/` becomes `mint.example.com/lnurl`. Always contains a
+ * dot and never matches `isMintPubkey`, which is what keeps the two forms apart.
+ */
+export function hostIdentifier(baseUrl: string): string {
+  return displayDomain(baseUrl).toLowerCase();
+}
+
+/**
+ * The canonical `d` for a mint, given whatever is known about it.
+ *
+ * Pubkey when there is one, host otherwise — and the pubkey is *sticky*: a caller
+ * passing a previously known pubkey keeps it even when the current probe found none,
+ * because a node being unreachable for one request is not a change of identity. See
+ * "When a mint gains a pubkey after being announced by host" in the kind document.
+ */
+export function lnurlIdentifier(baseUrl: string, mintPubkey: string | null | undefined): string {
+  return isMintPubkey(mintPubkey) ? mintPubkey.toLowerCase() : hostIdentifier(baseUrl);
+}
+
+/**
+ * Both identifiers a review of this mint could carry, for a `#d` relay filter and for
+ * resolution.
+ *
+ * A mint announced by host before it had a funding source, and by pubkey afterwards, has
+ * reviews pointing at both. Asking for only the current one strands the older half.
+ */
+export function lnurlIdentifiers(
+  baseUrl: string,
+  mintPubkey: string | null | undefined,
+): string[] {
+  const host = hostIdentifier(baseUrl);
+  return isMintPubkey(mintPubkey) ? [mintPubkey.toLowerCase(), host] : [host];
+}
+
+/* ---------- features ---------- */
+
+/**
+ * Note operations: the four branches of LUD-25's `/w/cb`, plus minting.
+ *
+ * Split into two groups because that is where a missing funding source cuts. `mint` and
+ * `melt` both need the node — one issues an invoice, the other pays one — while
+ * `rotate`, `split` and `merge` only rewrite this mint's own book and keep working with
+ * no node at all. That distinction is the whole reason the degraded state is worth
+ * rendering rather than collapsing into "offline".
+ */
+export const FUNDED_FEATURES = ['mint', 'melt'] as const;
+export const NOTE_FEATURES = ['rotate', 'split', 'merge'] as const;
+
+/** The LNURL sub-specifications a mint can speak. */
+export const SPEC_FEATURES = ['lud06', 'lud03', 'lud16', 'lud21'] as const;
+
+/** Optional extras, both of which are genuinely visible from outside. */
+export const EXTRA_FEATURES = ['signed-notes', 'onion'] as const;
+
+/**
+ * The whole vocabulary, and the only values this build has an opinion about.
+ *
+ * Anything else in a `features` tag is kept and shown as its own chip rather than
+ * dropped: the kind document requires consumers to ignore tokens they do not recognise,
+ * and rendering an unknown capability under its published name says exactly as much as
+ * it should.
+ */
+export const FEATURE_VOCABULARY: readonly string[] = [
+  ...FUNDED_FEATURES, ...NOTE_FEATURES, ...SPEC_FEATURES, ...EXTRA_FEATURES,
+];
+
+/**
+ * The named rows on the mint page's Features panel, in display order.
+ *
+ * `notes` is a row and not a feature: the three note-rewriting operations are one thing
+ * to a reader ("can I reshape what I hold?") and always ship together, so one row
+ * satisfied by any of them beats three rows that are always identical. Every other row
+ * is one vocabulary value.
+ */
+export const HIGHLIGHT_FEATURES = [
+  'mint', 'melt', 'notes', 'lud16', 'lud21', 'signed-notes', 'onion',
+] as const;
+export type HighlightFeature = (typeof HIGHLIGHT_FEATURES)[number];
+
+/** Which vocabulary values satisfy each named row. */
+export const FEATURE_ALIASES: Record<string, readonly string[]> = {
+  mint: ['mint'],
+  melt: ['melt'],
+  notes: ['rotate', 'split', 'merge'],
+  lud16: ['lud16'],
+  lud21: ['lud21'],
+  'signed-notes': ['signed-notes'],
+  onion: ['onion'],
+};
+
+/**
+ * Rows whose row is only as good as the funding source behind it.
+ *
+ * A mint that implements minting, melting and note signing still cannot do any of them
+ * while its node is unreachable, and the panel says so rather than showing a tick that
+ * is not true today. `rotate`/`split`/`merge` are deliberately absent from this set:
+ * they are exactly what still works.
+ */
+export const FUNDING_DEPENDENT: readonly HighlightFeature[] = ['mint', 'melt', 'signed-notes'];
+
+/**
+ * Plain-language names, and the English source of truth for them.
+ *
+ * The catalogs carry a translation per key under `lnurl.feature.`; anything neither
+ * knows renders as its own published token, which is still a true label.
+ */
+export const FEATURE_NAMES_EN: Record<string, string> = {
+  mint: 'Mint via Lightning (LUD-06)',
+  melt: 'Melt to Lightning',
+  notes: 'Rotate / split / merge notes',
+  lud16: 'Lightning address',
+  lud21: 'Payment verification (LUD-21)',
+  'signed-notes': 'Signed notes (offline verification)',
+  onion: 'Tor address',
+  rotate: 'Rotate a note',
+  split: 'Split a note',
+  merge: 'Merge notes',
+  lud06: 'LUD-06 payRequest',
+  lud03: 'LUD-03 withdrawRequest',
+};
+
+/**
+ * Split a `features` tag: `"mint,melt,rotate,lud06"`.
+ *
+ * Comma separated, but whitespace is tolerated because a publisher writing
+ * `"mint, melt"` meant the same thing — the same latitude `parseModules` gives a
+ * `modules` tag. Lowercased, deduped, order preserved, and bounded so a hostile tag
+ * cannot become a thousand chips on a page.
+ */
+export function parseFeatures(value: string | null | undefined): string[] {
+  if (!value) return [];
+  const out: string[] = [];
+  const seen = new Set<string>();
+  for (const part of value.split(/[,\s]+/)) {
+    const feature = part.trim().toLowerCase();
+    if (!feature || feature.length > 32 || seen.has(feature)) continue;
+    if (!/^[a-z0-9_-]+$/.test(feature)) continue;
+    seen.add(feature);
+    out.push(feature);
+    if (out.length >= 40) break;
+  }
+  return out;
+}
+
+/** Which named row a vocabulary value belongs to, or null for the chip list. */
+export function highlightFeatureFor(feature: string): HighlightFeature | null {
+  const name = feature.toLowerCase();
+  for (const key of HIGHLIGHT_FEATURES) {
+    if (FEATURE_ALIASES[key]?.includes(name)) return key;
+  }
+  return null;
+}
+
+/** True when this mint claims anything satisfying one of the named rows. */
+export function hasFeature(features: readonly string[], key: HighlightFeature): boolean {
+  const aliases = FEATURE_ALIASES[key] ?? [];
+  return features.some((feature) => aliases.includes(feature.toLowerCase()));
+}
+
+/** Features with no named row of their own, for the chip list under the seven. */
+export function otherFeatures(features: readonly string[]): string[] {
+  return features.filter((feature) => highlightFeatureFor(feature) === null);
+}
+
+/**
+ * What one row of the Features panel says.
+ *
+ * Three states rather than two, which is the one place this panel is richer than the
+ * Fedimint Modules panel it is modelled on: a capability can be published, and still be
+ * unavailable this minute because the node behind it is unreachable. Collapsing that
+ * into "supported" would show a tick beside something that would fail if tried.
+ */
+export type FeatureState = 'ok' | 'unavailable' | 'none';
+
+/**
+ * The state of every named row, given what was announced and what the probe saw.
+ *
+ * The announcement decides whether a capability exists at all; the probe can only take
+ * one away, and only the three that depend on a funding source. That asymmetry is
+ * normative in the kind document: a prober never rewrites an operator's `features`.
+ *
+ * `fundingAvailable` is null when nothing has probed yet, which reads as "no reason to
+ * doubt it" rather than as a failure.
+ */
+export function featureStates(
+  features: readonly string[],
+  fundingAvailable: boolean | null,
+): Record<HighlightFeature, FeatureState> {
+  const out = {} as Record<HighlightFeature, FeatureState>;
+  for (const key of HIGHLIGHT_FEATURES) {
+    if (!hasFeature(features, key)) {
+      out[key] = 'none';
+      continue;
+    }
+    out[key] =
+      fundingAvailable === false && FUNDING_DEPENDENT.includes(key) ? 'unavailable' : 'ok';
+  }
+  return out;
+}
+
+/**
+ * The features a probe can honestly claim, from what it observed.
+ *
+ * Every entry has an observation behind it, and the four that are missing are the
+ * point. `rotate`, `split` and `merge` are only provable by calling `/w/cb`, which
+ * mutates or destroys a stranger's note; `lud21` is genuinely undetectable, because a
+ * disabled verify endpoint and an unknown payment hash return byte-identical responses
+ * (NOTES-LNURL.md §5). None of the four is inferred from a version string.
+ *
+ * Two callers, one definition, deliberately: the page renders this beside an operator's
+ * announced list, and the publisher signs it into a `kind:38174`. Those must not be
+ * able to disagree about what this site claims to have seen.
+ *
+ * The order is the vocabulary's own, so two runs over one mint produce identical
+ * output and the publisher's change detector does not fire on a reordering.
+ */
+export function observedFeatures(probe: {
+  fundingAvailable: boolean | null;
+  maxWithdrawableMsat: number | null;
+  maxSendableMsat: number | null;
+  lightningAddress: string | null;
+  mintPubkey: string | null;
+  onionUrl: string | null;
+}): string[] {
+  const features: string[] = [];
+
+  /*
+   * `mint` and `melt` each need two things: the mint advertising the relevant side,
+   * and a funding source that can actually perform it. A mint whose node is unreachable
+   * implements both and can do neither, and this site only ever saw it in the state
+   * where it could not — so it does not say otherwise.
+   */
+  const funded = probe.fundingAvailable === true;
+  if (funded && probe.maxSendableMsat !== null) features.push('mint');
+  if (funded && (probe.maxWithdrawableMsat ?? 0) > 0) features.push('melt');
+
+  if (probe.maxSendableMsat !== null) features.push('lud06');
+  // The advertisement's `callback` is `/w`, the LUD-03 withdrawRequest, and parsing the
+  // advertisement at all is what proves it was served.
+  if (probe.maxWithdrawableMsat !== null) features.push('lud03');
+  if (probe.lightningAddress) features.push('lud16');
+  if (probe.mintPubkey && funded) features.push('signed-notes');
+  if (probe.onionUrl) features.push('onion');
+
+  return features;
+}
+
+/**
+ * What the Features panel renders: what the operator announced, plus what was observed.
+ *
+ * A union, and it has to be one. The announcement is the operator's claim about what
+ * they built and is the richer list — only they can tell you that notes rotate. The
+ * probe is this site's own observation and is the *only* list for a mint nobody has
+ * announced yet, which today is every LNURL mint on the network.
+ *
+ * Announced values come first so an operator's own ordering survives. Note that this is
+ * a display concern and nothing else: `LnurlFields.features` still holds the
+ * announcement verbatim, and the publisher still signs only `observedFeatures`. The
+ * kind document's rule is that a prober never rewrites an operator's list, and nothing
+ * here does — it renders two lists side by side.
+ */
+export function displayFeatures(
+  announced: readonly string[] | null | undefined,
+  observed: readonly string[] | null | undefined,
+): string[] {
+  return [...new Set([...(announced ?? []), ...(observed ?? [])])];
+}
+
+/* ---------- amounts ---------- */
+
+/**
+ * Millisatoshi to satoshi, floored.
+ *
+ * Floored rather than rounded because both of the numbers this converts are *bounds*: a
+ * `maxWithdrawable` rounded up advertises a note larger than the mint will ever issue,
+ * and a `minWithdrawable` rounded down advertises one it will refuse. Flooring keeps the
+ * displayed range inside the real one at both ends, which is the safe direction to be
+ * wrong in. Sub-sat amounts floor to 0, which is true and is what the "withdrawals
+ * disabled" warning keys on.
+ */
+export function msatToSat(msat: number | null | undefined): number | null {
+  if (typeof msat !== 'number' || !Number.isFinite(msat) || msat < 0) return null;
+  return Math.floor(msat / 1000);
+}
+
+/* ---------- the mint's own endpoints ---------- */
+
+/** The path the mint advertisement lives on. `_` is LUD-16's reserved bare-domain name. */
+export const WITHDRAW_INFO_PATH = '/.well-known/lnurlw/_';
+/** The LUD-06 payRequest, used as a fallback when the withdraw side does not answer. */
+export const PAY_INFO_PATH = '/.well-known/lnurlp/_';
+
+/**
+ * What a mint advertisement yields once parsed.
+ *
+ * Everything is optional except the two limits and the tag, because that is genuinely
+ * what varies: a mint with no funding source omits its whole node section, and the
+ * response is still valid and still worth rendering.
+ */
+export interface LnurlAdvertisement {
+  minWithdrawableMsat: number;
+  maxWithdrawableMsat: number;
+  defaultDescription: string | null;
+  mintPubkey: string | null;
+  payLink: string | null;
+  nodeAlias: string | null;
+  nodeUri: string | null;
+  nodeCapacityMsat: number | null;
+  nodeChannels: number | null;
+  nodePeers: number | null;
+  /**
+   * Whether the mint's funding source answered.
+   *
+   * Derived, not read: `mintPubkey` is populated only when a funding source is both
+   * configured and reachable, and is dropped from the response otherwise. One bit, and
+   * it is the only HTTP-visible signal there is — see NOTES-LNURL.md for why it is not
+   * possible to separate "never configured" from "unreachable right now", and why the
+   * site does not try.
+   */
+  fundingAvailable: boolean;
+}
+
+function num(value: unknown): number | null {
+  return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+
+function str(value: unknown, max = 400): string | null {
+  if (typeof value !== 'string') return null;
+  const text = value.trim();
+  if (!text || text.length > max) return null;
+  return text;
+}
+
+/**
+ * Parse `/.well-known/lnurlw/_`.
+ *
+ * Returns null for anything that is not a withdrawRequest carrying both limits — which
+ * includes the mint's own `{"status":"ERROR"}` bodies, since those arrive with HTTP 200
+ * and would otherwise read as a successful probe. The caller turns null into the
+ * "responding but invalid" state, which is neither online nor offline.
+ */
+export function parseAdvertisement(body: unknown): LnurlAdvertisement | null {
+  if (!body || typeof body !== 'object' || Array.isArray(body)) return null;
+  const raw = body as Record<string, unknown>;
+
+  if (raw['tag'] !== 'withdrawRequest') return null;
+
+  const min = num(raw['minWithdrawable']);
+  const max = num(raw['maxWithdrawable']);
+  // Both bounds are required, and inverted bounds are not a mint advertisement.
+  if (min === null || max === null || min < 0 || max < 0 || min > max) return null;
+
+  const mintPubkey = isMintPubkey(raw['mintPubkey']) ? String(raw['mintPubkey']).toLowerCase() : null;
+
+  return {
+    minWithdrawableMsat: min,
+    maxWithdrawableMsat: max,
+    defaultDescription: str(raw['defaultDescription']),
+    mintPubkey,
+    payLink: str(raw['payLink']),
+    nodeAlias: sanitizeDisplayText(raw['nodeAlias'], 64) ?? null,
+    nodeUri: str(raw['nodeUri'], 200),
+    nodeCapacityMsat: num(raw['nodeCapacity']),
+    nodeChannels: num(raw['nodeNumChannels']),
+    nodePeers: num(raw['nodeNumPeers']),
+    fundingAvailable: mintPubkey !== null,
+  };
+}
+
+/** What the LUD-06 payRequest yields. Fetched for the fee, the address and the limits. */
+export interface LnurlPayInfo {
+  minSendableMsat: number;
+  maxSendableMsat: number;
+  /** The `text/plain` entry: the closest thing to an operator-written description. */
+  description: string | null;
+  /** The `text/identifier` entry, a LUD-16 lightning address. */
+  identifier: string | null;
+  /** `Mint fees: <base>,<ppm>`, absent when the mint is fee-free. */
+  feeBaseMsat: number | null;
+  feePpm: number | null;
+  /** The `withdrawLink` extension: lnurlcash's pointer back to the withdraw side. */
+  withdrawLink: string | null;
+}
+
+/**
+ * Parse `/.well-known/lnurlp/_`.
+ *
+ * `metadata` is a JSON *string* holding a JSON array of `[mime, value]` pairs, so it is
+ * parsed twice. A metadata blob that will not parse costs the description and the
+ * address and nothing else: the limits above it are still good.
+ */
+export function parsePayInfo(body: unknown): LnurlPayInfo | null {
+  if (!body || typeof body !== 'object' || Array.isArray(body)) return null;
+  const raw = body as Record<string, unknown>;
+
+  if (raw['tag'] !== 'payRequest') return null;
+
+  const min = num(raw['minSendable']);
+  const max = num(raw['maxSendable']);
+  if (min === null || max === null || min < 0 || max < 0 || min > max) return null;
+
+  let description: string | null = null;
+  let identifier: string | null = null;
+  let feeBaseMsat: number | null = null;
+  let feePpm: number | null = null;
+
+  try {
+    const entries: unknown = JSON.parse(typeof raw['metadata'] === 'string' ? raw['metadata'] : '[]');
+    if (Array.isArray(entries)) {
+      for (const entry of entries) {
+        if (!Array.isArray(entry) || typeof entry[0] !== 'string' || typeof entry[1] !== 'string') {
+          continue;
+        }
+        const [mime, value] = entry as [string, string];
+        // `Mint fees: <base_msat>,<ppm>` shares the `text/plain` mime with the
+        // description, so it is recognised by its prefix and taken out of the running
+        // for one — otherwise a fee-charging mint's description would be its fee line.
+        const fees = /^Mint fees:\s*(\d+)\s*,\s*(\d+)\s*$/i.exec(value);
+        if (mime === 'text/plain' && fees) {
+          feeBaseMsat = Number.parseInt(fees[1]!, 10);
+          feePpm = Number.parseInt(fees[2]!, 10);
+          continue;
+        }
+        if (mime === 'text/plain' && description === null) {
+          description = sanitizeDisplayText(value, 400) ?? null;
+        }
+        if (mime === 'text/identifier' && identifier === null) {
+          identifier = isLightningAddress(value) ? value.trim().toLowerCase() : null;
+        }
+      }
+    }
+  } catch {
+    // Unparseable metadata. The limits are still real, so this is not a failed probe.
+  }
+
+  return {
+    minSendableMsat: min,
+    maxSendableMsat: max,
+    description,
+    identifier,
+    feeBaseMsat,
+    feePpm,
+    withdrawLink: str(raw['withdrawLink']),
+  };
+}
+
+/** `name@domain`, and only that. Same shape rule the review cards apply to a NIP-05. */
+export function isLightningAddress(value: unknown): value is string {
+  if (typeof value !== 'string') return false;
+  const text = value.trim();
+  return text.length <= 128 && /^[a-z0-9._+-]+@[a-z0-9-]+(\.[a-z0-9-]+)+$/i.test(text);
+}
+
+/**
+ * The mint's lightning address, derived from `payLink`.
+ *
+ * Not read off the payRequest's own `text/identifier`, which echoes back whatever
+ * username was queried — probing `_` gets `_@host`, which is LUD-16's bare-domain form
+ * and not something to render at a reader. `payLink` is built from the operator's
+ * configured username unconditionally, so it is the one place the real name appears.
+ */
+export function addressFromPayLink(payLink: string | null | undefined): string | null {
+  if (!payLink) return null;
+  let url: URL;
+  try {
+    url = new URL(payLink);
+  } catch {
+    return null;
+  }
+  const username = /\/\.well-known\/lnurlp\/([^/?#]+)$/.exec(url.pathname)?.[1];
+  if (!username || username === '_') return null;
+  const address = `${decodeURIComponent(username)}@${url.hostname.toLowerCase()}`;
+  return isLightningAddress(address) ? address : null;
+}
+
+/**
+ * A `*.onion` host in the one-pager, or null.
+ *
+ * Deliberately looser than base32's alphabet. A v3 address is 56 characters of `a-z2-7`,
+ * but the mint software's own test fixture is not valid base32, and a real address that
+ * does not fit the expected shape is still the operator's address. Nothing is ever
+ * fetched over Tor by this site, so the cost of a wrong match is one displayed string.
+ */
+export function onionFromHtml(html: string): string | null {
+  const match = /\b([a-z0-9]{16,60}\.onion)\b/i.exec(html);
+  return match?.[1]?.toLowerCase() ?? null;
+}
+
+/**
+ * The software version, from `GET /openapi.json`.
+ *
+ * `0.0.0+unknown` is the package's own "I could not find my metadata" sentinel, not a
+ * release, so it is treated as no version at all rather than printed at a reader. The
+ * title is checked too: an arbitrary FastAPI app on the same host would otherwise
+ * contribute its version to a mint's page.
+ */
+export function parseSoftware(body: unknown): string | null {
+  if (!body || typeof body !== 'object') return null;
+  const info = (body as Record<string, unknown>)['info'];
+  if (!info || typeof info !== 'object') return null;
+
+  const record = info as Record<string, unknown>;
+  const title = str(record['title'], 64);
+  const version = str(record['version'], 64);
+  if (!title || !version) return null;
+  if (!/^[\w.+-]+$/.test(version) || version.startsWith('0.0.0+unknown')) return null;
+  if (!/^[\w.@/ -]+$/.test(title)) return null;
+
+  return `${title}/${version}`;
+}
+
+/* ---------- the announcement ---------- */
+
+export interface LnurlAnnouncement {
+  /** The `d` tag: a mint pubkey, or a normalized host. */
+  identifier: string;
+  /** The `d` tag when it was a pubkey, else null. Feeds the sticky identity rule. */
+  mintPubkey: string | null;
+  /** The canonical `u` tag, normalized. This is what rows are deduped by. */
+  baseUrl: string;
+  /** The routing slug the normalizer derived from that URL. */
+  slug: string;
+  /** The `features` tag, split. */
+  features: string[];
+  /** The `n` tag, normalized. */
+  network: string | null;
+  /** From `content`, which is kind-0-shaped metadata. */
+  name: string | null;
+  picture: string | null;
+  about: string | null;
+  announcerPubkey: string;
+  announcedAt: number;
+}
+
+/**
+ * Read a kind 38174 event, or return null if it is not one this site can use.
+ *
+ * `u` is required here where NIP-87 makes it a SHOULD for 38172, and the kind document
+ * says why: an LNURL mint's `d` may be a bare host with no scheme, which is not
+ * something to fetch, so an announcement with no usable `u` carries no address at all
+ * and there is nothing to probe, key a row by, or link to.
+ *
+ * The `d` tag is *not* required to match the `u` tag's host. A mint that has a pubkey
+ * announces under it, and checking the two against each other would reject exactly the
+ * events the identity rule exists to allow.
+ */
+export function parseLnurlAnnouncement(event: NostrEventLike): LnurlAnnouncement | null {
+  const d = tagValue(event.tags, 'd')?.trim().toLowerCase();
+  if (!d || d.length > 200) return null;
+
+  // A `d` that is neither a pubkey nor host-shaped is not an identifier this build can
+  // resolve a review against, so the announcement is not usable even if `u` is fine.
+  if (!isMintPubkey(d) && !/^[a-z0-9.-]+\.[a-z]{2,}(:\d+)?(\/[\w./~-]*)?$/.test(d)) return null;
+
+  let normalized: ReturnType<typeof normalizeMintUrl> = null;
+  for (const raw of tagValues(event.tags, 'u')) {
+    normalized = normalizeMintUrl(raw);
+    if (normalized) break;
+  }
+  if (!normalized) return null;
+
+  const meta = parseLnurlMetadata(event.content);
+
+  return {
+    identifier: d,
+    mintPubkey: isMintPubkey(d) ? d : null,
+    baseUrl: normalized.url,
+    slug: normalized.host,
+    features: parseFeatures(tagValue(event.tags, 'features')),
+    network: normalizeLnurlNetwork(tagValue(event.tags, 'n')),
+    name: meta.name,
+    picture: meta.picture,
+    about: meta.about,
+    announcerPubkey: event.pubkey,
+    announcedAt: event.created_at,
+  };
+}
+
+/**
+ * The `content` of a 38174, which the kind document defines as kind-0-style metadata.
+ *
+ * Same defensive posture as the Fedimint parser: this is arbitrary text written by
+ * anyone with a relay connection, so unparseable JSON, wrong types and junk fields all
+ * degrade to "no metadata" rather than throwing.
+ */
+export function parseLnurlMetadata(content: string): {
+  name: string | null;
+  picture: string | null;
+  about: string | null;
+} {
+  const empty = { name: null, picture: null, about: null };
+  if (!content.trim()) return empty;
+
+  let meta: Record<string, unknown>;
+  try {
+    const parsed: unknown = JSON.parse(content);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return empty;
+    meta = parsed as Record<string, unknown>;
+  } catch {
+    return empty;
+  }
+
+  const first = (...keys: string[]): unknown => {
+    for (const key of keys) if (meta[key] !== undefined && meta[key] !== null) return meta[key];
+    return undefined;
+  };
+
+  return {
+    name: sanitizeDisplayText(first('name', 'display_name', 'mint_name'), 64) ?? null,
+    picture: sanitizePictureUrl(first('picture', 'icon_url', 'image')) ?? null,
+    about: sanitizeDisplayText(first('about', 'description'), 400) ?? null,
+  };
+}
+
+/**
+ * Normalize an `n` tag.
+ *
+ * The same mapping the Fedimint side applies, and for the same reason: NIP-87 names the
+ * value `mainnet`, publishers copy each other, and `bitcoin` is what they write. Kept
+ * separate from `normalizeNetwork` only so the two ecosystems' rules can diverge later
+ * without one quietly changing the other; today they agree, and `check-lnurl.ts` asserts
+ * that they still do.
+ */
+export function normalizeLnurlNetwork(value: string | null | undefined): string | null {
+  const raw = value?.trim().toLowerCase();
+  if (!raw) return null;
+  if (raw === 'bitcoin' || raw === 'main' || raw === 'mainnet') return 'mainnet';
+  if (!/^[a-z0-9]{1,20}$/.test(raw)) return null;
+  return raw;
+}

shared/src/normalize.ts

@@ -28,6 +28,9 @@ function isDisallowedHost(hostname: string): boolean {
   if (hostname.endsWith('.local')) return true;
   if (PRIVATE_IPV4.test(hostname)) return true;
   if (isPrivateIpv6(hostname)) return true;
+  // Anything that parses as an IP literal is judged by the resolved-address rule too,
+  // so the two checks cannot disagree about, say, 100.64.0.1 or 224.0.0.1.
+  if (/^\d{1,3}(\.\d{1,3}){3}$/.test(hostname) && isPrivateIpAddress(hostname)) return true;
   // A bare label with no dot cannot be a public host.
   if (!hostname.includes('.') && !hostname.includes(':')) return true;
   return false;
@@ -50,6 +53,67 @@ function isPrivateIpv6(hostname: string): boolean {
   return false;
 }
 
+/**
+ * Is this literal IP address one the indexer must never connect to?
+ *
+ * Written against a *resolved* address rather than a hostname, which is the difference
+ * between this and `isDisallowedHost` above: `mint.example.com` looks like an ordinary
+ * public name and can resolve to `127.0.0.1`, and only the answer DNS gave can tell you
+ * so. `POST /api/index` fetches URLs a stranger typed, so it resolves first and checks
+ * every address here before a socket is opened.
+ *
+ * Broader than the hostname rule on purpose. Beyond loopback, link-local and the three
+ * RFC-1918 ranges it also refuses carrier-grade NAT (100.64/10), `0.0.0.0/8`, the
+ * benchmarking and documentation ranges, multicast and the broadcast address: none of
+ * them is a public mint, and each of them is somewhere on a network this server can see
+ * and a stranger should not be able to point it at.
+ */
+export function isPrivateIpAddress(value: string): boolean {
+  const ip = value.trim().toLowerCase().replace(/^\[|\]$/g, '');
+  if (!ip) return true;
+
+  const v4 = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(ip);
+  if (v4) {
+    const [a, b] = [Number(v4[1]), Number(v4[2])];
+    if (a === undefined || b === undefined || a > 255 || b > 255) return true;
+    if (a === 0 || a === 10 || a === 127) return true;              // this-network, RFC1918, loopback
+    if (a === 169 && b === 254) return true;                        // link-local
+    if (a === 172 && b >= 16 && b <= 31) return true;               // RFC1918
+    if (a === 192 && b === 168) return true;                        // RFC1918
+    if (a === 192 && b === 0) return true;                          // IETF protocol assignments / 192.0.2.0 docs
+    if (a === 198 && (b === 18 || b === 19)) return true;           // benchmarking
+    if (a === 198 && b === 51) return true;                         // documentation
+    if (a === 203 && b === 0) return true;                          // documentation
+    if (a === 100 && b >= 64 && b <= 127) return true;              // carrier-grade NAT
+    if (a >= 224) return true;                                      // multicast, reserved, broadcast
+    return false;
+  }
+
+  if (!ip.includes(':')) return true; // Not an address this function understands.
+
+  // An IPv4-mapped or IPv4-compatible address is judged on its IPv4 half.
+  const mapped = /:((?:\d{1,3}\.){3}\d{1,3})$/.exec(ip);
+  if (mapped?.[1]) return isPrivateIpAddress(mapped[1]);
+
+  if (ip === '::' || ip === '::1') return true;
+  if (/^f[cd]/.test(ip)) return true;   // unique local, fc00::/7
+  if (/^fe[89ab]/.test(ip)) return true; // link-local, fe80::/10
+  if (/^ff/.test(ip)) return true;       // multicast
+  return false;
+}
+
+/**
+ * Is this hostname one the indexer must never fetch, before DNS is consulted at all?
+ *
+ * The cheap half of the check: `localhost`, `.onion`, `.local`, a bare label with no
+ * dot, and an IP literal that is already disqualified by `isPrivateIpAddress`. Exported
+ * so the on-demand indexer can refuse the obvious cases without paying for a lookup,
+ * and so a redirect hop can be judged by the same rule its origin was.
+ */
+export function isBlockedHostname(hostname: string): boolean {
+  return isDisallowedHost(hostname.toLowerCase());
+}
+
 /**
  * May the indexer fetch this URL? http(s) only, and never a private or local host.
  *

shared/src/nostr.ts

@@ -13,6 +13,15 @@ export const KIND_REVIEW = 38000;
 export const KIND_MINT_ANNOUNCEMENT = 38172;
 /** NIP-87 Fedimint federation announcement. */
 export const KIND_FEDIMINT_ANNOUNCEMENT = 38173;
+/**
+ * LNURL mint announcement.
+ *
+ * Not in NIP-87: this site's own proposed extension to it, specified in
+ * `docs/KIND-LNURL-MINT.md` and intended for a PR to nostr-protocol/nips. 38174 is the
+ * next free slot in the family — checked against the kind index in the nips README and
+ * against every issue and PR in that repository before it was claimed.
+ */
+export const KIND_LNURL_ANNOUNCEMENT = 38174;
 /** Profile metadata. */
 export const KIND_PROFILE = 0;
 
@@ -30,6 +39,7 @@ export const KIND_PROFILE = 0;
 export const ANNOUNCEMENT_KINDS = {
   cashu: KIND_MINT_ANNOUNCEMENT,
   fedimint: KIND_FEDIMINT_ANNOUNCEMENT,
+  lnurl: KIND_LNURL_ANNOUNCEMENT,
 } as const;
 
 /**
@@ -224,6 +234,11 @@ export function isFedimintReview(event: NostrEventLike): boolean {
   return tagValue(event.tags, 'k') === String(KIND_FEDIMINT_ANNOUNCEMENT);
 }
 
+/** True when the event's `k` tag marks it as being about an LNURL mint. */
+export function isLnurlReview(event: NostrEventLike): boolean {
+  return tagValue(event.tags, 'k') === String(KIND_LNURL_ANNOUNCEMENT);
+}
+
 /**
  * The kind a review says it is about, from its `k` tag, as a number.
  *

shared/src/types.ts

@@ -1,5 +1,7 @@
 /** Shapes returned by the API. The web app builds against these. */
 
+import type { MintCapabilities } from './warnings.js';
+
 /**
  * Statuses a listed thing can be in.
  *
@@ -18,7 +20,7 @@ export type MintStatus = 'online' | 'degraded' | 'offline' | 'unknown' | 'announ
  * has to be able to hold a value it does not have a page for. Compare against
  * `ANNOUNCEMENT_KINDS` rather than switching exhaustively on this.
  */
-export type MintType = 'cashu' | 'fedimint' | (string & {});
+export type MintType = 'cashu' | 'fedimint' | 'lnurl' | (string & {});
 
 /** One item of `GET /api/mints`. */
 export interface MintListItem {
@@ -26,7 +28,7 @@ export interface MintListItem {
   host: string;
   name: string | null;
   icon: string | null;
-  /** 'cashu' or 'fedimint'. Rows written before the column existed read as 'cashu'. */
+  /** 'cashu', 'fedimint' or 'lnurl'. Rows written before the column existed read as 'cashu'. */
   type: MintType;
   status: MintStatus;
   last_online: number | null;
@@ -35,6 +37,40 @@ export interface MintListItem {
   score: number;
   last_review_at: number | null;
   version: string | null;
+
+  /* ---- card chips ----
+   *
+   * The three fields below exist so a card can be drawn from the list payload alone.
+   * Before them, /mints fetched `GET /api/mints/:host` once per mint at build time just
+   * to read two booleans off each one, which is fine for fifty-five mints on one build
+   * machine and is not fine for every visitor's browser once the list hydrates. They are
+   * facts, never rendered strings: the label a chip prints is decided by `mintChip` in
+   * the reader's own language, on whichever side is drawing the card.
+   *
+   * A federation has no counterpart and needs none — it publishes no capability list, so
+   * `mintChip` returns null for one and always will. See the Fedimint branch of
+   * `getMintWarnings`.
+   */
+
+  /**
+   * NUT numbers this mint publishes, as strings: `["4", "5", "17"]`. Cashu only; empty
+   * for the other ecosystems and for a mint whose `/v1/info` has never been read.
+   */
+  nuts: string[];
+  /**
+   * NUT-04 and NUT-05 switches, the Cashu chip's only input. null means nothing is
+   * cached for this mint, which is a different fact from "both are on" — see
+   * `readCapabilities`.
+   */
+  capabilities: MintCapabilities | null;
+  /**
+   * LNURL: the advertised withdraw ceiling, millisatoshi. Optional rather than
+   * `| null`, so this stays exactly what `Partial<LnurlFields>` declares on `MintDetail`
+   * and the two do not have to be kept identical by hand.
+   */
+  max_withdrawable_msat?: number | null;
+  /** LNURL: whether the last probe reached the mint's funding node. */
+  funding_available?: boolean | null;
 }
 
 export interface ProbeSample {
@@ -48,10 +84,14 @@ export type RatingDistribution = Record<'1' | '2' | '3' | '4' | '5', number>;
 /**
  * `GET /api/mints/:host`.
  *
- * The Fedimint keys are optional and absent on a Cashu mint, which is what keeps the
- * Cashu payload unchanged. Read them through `FedimintDetail` after checking `type`.
+ * The Fedimint and LNURL keys are optional and absent on a Cashu mint, which is what
+ * keeps the Cashu payload unchanged. Read them through `FedimintDetail` or
+ * `LnurlDetail` after checking `type`.
  */
-export interface MintDetail extends MintListItem, Partial<FedimintFields> {
+export interface MintDetail
+  extends MintListItem,
+    Partial<FedimintFields>,
+    Partial<LnurlFields> {
   description: string | null;
   pubkey: string | null;
   info: MintInfo | null;
@@ -100,6 +140,97 @@ export interface FedimintFields {
 /** `GET /api/mints/:host` for a Fedimint federation: the detail plus its own fields. */
 export type FedimintDetail = MintDetail & FedimintFields;
 
+/**
+ * What `ecosystem_json` holds for an LNURL row.
+ *
+ * Two sources, never mixed: `features` is what the operator *announced* on Nostr, and
+ * everything under "probed" is what the mint's own endpoints said when they were last
+ * reached. The kind document makes that separation normative — a prober never rewrites
+ * an operator's capability list — and keeping the two in different fields is what makes
+ * it impossible to do by accident.
+ *
+ * Every millisatoshi field is stored exactly as the wire gave it. Conversion to sats
+ * happens once, at render, through `msatToSat`.
+ */
+export interface LnurlFields {
+  /** The `d` tag: the mint pubkey when it has one, else the normalized host. */
+  lnurl_id: string;
+  /** The https base URL. `host` is the routing slug derived from it. */
+  base_url: string;
+  /** The `features` tag, split. The operator's claim, never edited by a probe. */
+  features: string[];
+  /**
+   * What the last probe actually observed this mint serving.
+   *
+   * Kept apart from `features` above rather than merged into it, because the two are
+   * different kinds of statement — a claim and an observation — and the kind document
+   * makes it normative that a prober never rewrites the first. The page renders their
+   * union through `displayFeatures`; the publisher signs only this one.
+   */
+  observed_features: string[];
+  /** The `n` tag, normalized — `bitcoin` and `mainnet` both arrive as `mainnet`. */
+  network: string | null;
+  /** `created_at` of the newest announcement seen. null for a seeded row. */
+  announced_at: number | null;
+  /** Who published that announcement. The `a` tag of a review points back at them. */
+  announcer_pubkey: string | null;
+
+  /* ---- probed: from the mint's own endpoints ---- */
+
+  /**
+   * The funding node's identity key, from the mint advertisement.
+   *
+   * Sticky once learned: a probe that finds none does not clear it, because a node
+   * being unreachable for one request is not a change of identity. Its *absence from
+   * the latest probe* is recorded separately, in `funding_available`.
+   */
+  mint_pubkey: string | null;
+  /**
+   * Whether the last probe found a reachable funding source.
+   *
+   * null before anything has probed. false is the degraded-but-online state: the mint
+   * answers, its limits are real, and `rotate`/`split`/`merge` still work, but nothing
+   * moves in or out over Lightning. See NOTES-LNURL.md for why this one bit cannot
+   * distinguish "never configured" from "unreachable right now", and why that is fine.
+   */
+  funding_available: boolean | null;
+  /** Which endpoint answered: the withdraw advertisement, or the payRequest fallback. */
+  probe_endpoint: string | null;
+  /**
+   * Set when the host answered but with something that is not a mint advertisement.
+   *
+   * A distinct outcome from both online and offline, and it has to be: these endpoints
+   * return HTTP 200 for their errors, so "responding" and "working" are different
+   * questions. Carries the short reason, for the banner.
+   */
+  invalid_reason: string | null;
+
+  /** Withdraw bounds, millisatoshi: what a note's value can actually be. */
+  min_withdrawable_msat: number | null;
+  max_withdrawable_msat: number | null;
+  /** Pay bounds, millisatoshi: what a minter can actually send. Not the same numbers. */
+  min_sendable_msat: number | null;
+  max_sendable_msat: number | null;
+  /** `Mint fees: <base>,<ppm>` from the payRequest metadata. Absent means fee-free. */
+  fee_base_msat: number | null;
+  fee_ppm: number | null;
+
+  /** The LUD-16 address, derived from `payLink` rather than the echoed identifier. */
+  lightning_address: string | null;
+  /** The Tor address from the one-pager, when one is advertised. */
+  onion_url: string | null;
+
+  /** The funding node, as the mint chooses to describe it. All optional, all msat. */
+  node_alias: string | null;
+  node_uri: string | null;
+  node_capacity_msat: number | null;
+  node_channels: number | null;
+  node_peers: number | null;
+}
+
+/** `GET /api/mints/:host` for an LNURL mint: the detail plus its own fields. */
+export type LnurlDetail = MintDetail & LnurlFields;
+
 /**
  * `GET /api/stats`.
  *
@@ -127,6 +258,41 @@ export interface Stats {
   fedimint_announced: number;
   /** Reviews of federations (`k` = 38173), included in `reviews_total`. */
   fedimint_reviews: number;
+  lnurl_total: number;
+  /** LNURL mints a probe reached. Online includes the degraded-funding ones. */
+  lnurl_online: number;
+  lnurl_offline: number;
+  /**
+   * Online mints whose funding source was unreachable at the last probe: up and
+   * serving, but nothing moves in or out over Lightning. A subset of `lnurl_online`,
+   * never added to it.
+   */
+  lnurl_degraded_funding: number;
+  /** Reviews of LNURL mints (`k` = 38174), included in `reviews_total`. */
+  lnurl_reviews: number;
+}
+
+/**
+ * How one configured relay answered during the last discovery cycle.
+ *
+ * The three facts are deliberately separate, because the failure this exists to catch
+ * had all three looking different from each other: the relays in `RELAYS` connected
+ * fine, reached EOSE fine, and simply did not carry the archive, so `events` was the
+ * only field that would have said anything. A relay that is down and a relay that is
+ * up and empty are different problems with different fixes.
+ */
+export interface RelayHealth {
+  url: string;
+  /** A socket was opened to it. false means the address is wrong or the relay is down. */
+  connected: boolean;
+  /**
+   * Events it sent, counted before cross-relay deduplication — so this is what *this*
+   * relay contributed, not what was new because of it. Zero on a connected relay is
+   * the interesting number.
+   */
+  events: number;
+  /** Every query it was asked ended in a real EOSE rather than in a timeout. */
+  eose: boolean;
 }
 
 /** `GET /api/health`. */
@@ -137,6 +303,26 @@ export interface Health {
   last_discovery_at: number | null;
   mints_tracked: number;
   updated_at: number;
+  /**
+   * Per-relay outcome of the last discovery cycle. Empty until one has run — including
+   * on a fresh database, which is why a brand new deployment reports degraded until its
+   * first backfill finishes.
+   */
+  discovery_relays: RelayHealth[];
+  /** Unique events the last discovery cycle received. null before the first one. */
+  last_discovery_events: number | null;
+  /** Which kind of cycle those numbers describe. */
+  last_discovery_mode: 'backfill' | 'incremental' | null;
+  /**
+   * The last backfill came back under `backfill_min_events`, or none has run yet.
+   *
+   * This is the flag that would have caught a year of ~31-event backfills against a
+   * relay list missing the archive. It forces `status` to degraded, and /api/health to
+   * 503, which is what the build gate and the site's own health checks read.
+   */
+  discovery_starved: boolean;
+  /** `BACKFILL_MIN_EVENTS`, echoed so a reader of this payload can see the threshold. */
+  backfill_min_events: number;
 }
 
 /**

shared/src/warnings.ts

@@ -88,7 +88,14 @@ export type MintWarningKind =
   | 'offline'       // offline under 7 days
   // Fedimint
   | 'fedimint-offline'  // a real check reported the guardians down
-  | 'never-confirmed';  // announced on Nostr, and nothing has ever confirmed it
+  | 'never-confirmed'   // announced on Nostr, and nothing has ever confirmed it
+  // LNURL. The offline tiers above are shared verbatim rather than twinned: `gone`,
+  // `offline-long` and `offline` are about reachability, which means exactly the same
+  // thing for an LNURL mint as for a Cashu one, and their copy already reads correctly
+  // for both. Only the states with no Cashu equivalent are new.
+  | 'lnurl-withdrawals-disabled' // maxWithdrawable is zero: nothing can be redeemed
+  | 'lnurl-invalid'              // the host answers, but not with a mint advertisement
+  | 'lnurl-no-funding';          // up and serving, but its Lightning node is unreachable
 
 export interface MintWarning {
   kind: MintWarningKind;
@@ -139,6 +146,19 @@ export interface MintWarningInput {
   capabilities?: Pick<MintCapabilities, 'mintDisabled' | 'meltDisabled'> | null;
   /** Only used to date "never answered a single check". */
   first_seen?: number;
+
+  /* ---- LNURL ---- */
+
+  /**
+   * The advertised withdraw ceiling, millisatoshi. Zero is the disabling value, and it
+   * is checked as `=== 0` rather than as falsy: `null` means nothing has probed, which
+   * is not the same claim at all.
+   */
+  max_withdrawable_msat?: number | null;
+  /** false when the last probe found the mint's Lightning node unreachable. */
+  funding_available?: boolean | null;
+  /** Set when the host answered with something that is not a mint advertisement. */
+  invalid_reason?: string | null;
 }
 
 export interface MintWarningOptions {
@@ -218,9 +238,28 @@ export const WARNING_COPY_EN: Record<string, string> = {
     'This federation was announced on Nostr on {date}, {days} ago, nothing has confirmed since then that it is running, and nobody has reviewed it recently. Everything below came from the announcement.',
   'neverConfirmed.meta': 'Announced {date}, never confirmed',
 
+  'lnurlWithdrawalsDisabled.lead': 'Withdrawals disabled.',
+  'lnurlWithdrawalsDisabled.body.online':
+    'This mint advertises a maximum withdrawal of zero, so no note it issues can be redeemed for anything. Do not mint here until that changes.',
+  'lnurlWithdrawalsDisabled.body.offline':
+    'This mint advertised a maximum withdrawal of zero when it was last reached, so no note it issued could be redeemed for anything. Do not mint here until that changes.',
+  'lnurlWithdrawalsDisabled.meta.online': 'Withdrawals currently disabled',
+  'lnurlWithdrawalsDisabled.meta.offline': 'Withdrawals were disabled when last seen',
+
+  'lnurlInvalid.lead': 'Endpoint responding but invalid.',
+  'lnurlInvalid.body':
+    'The host answers, but not with a mint advertisement this site can read, so withdrawals may not work. Anything below is the last state that did parse, and reviews still work.',
+  'lnurlInvalid.meta': 'Responding, but not with a valid mint advertisement',
+
+  'lnurlNoFunding.lead': 'Minting and melting unavailable.',
+  'lnurlNoFunding.body':
+    'Existing notes can still be rotated, split, or merged, but nothing moves in or out via Lightning right now. The mint itself is up and answering; the Lightning node behind it is not reachable from it.',
+  'lnurlNoFunding.meta': 'Minting and melting unavailable',
+
   'also.meltDisabled': 'Before going offline it had also disabled withdrawals.',
   'also.mintDisabled': 'Before going offline it had also disabled new minting.',
   'also.offline': 'It has also been offline since {date} ({days}).',
+  'also.noFunding': 'Its Lightning node was also unreachable, so nothing could be minted or melted.',
 };
 
 /**
@@ -247,12 +286,24 @@ const englishStrings: WarningStrings = (key, vars) => {
 
 /** Severity order, highest first. Index 0 of the returned list is the one to show. */
 const ORDER: MintWarningKind[] = [
-  'gone', 'melt-disabled', 'frozen', 'offline-long', 'melt-only', 'offline',
+  'gone',
+  'melt-disabled', 'frozen', 'lnurl-withdrawals-disabled',
+  'offline-long',
+  'melt-only', 'lnurl-invalid', 'lnurl-no-funding',
+  'offline',
   // Appended rather than interleaved. The Fedimint kinds never share a list with the
   // Cashu ones (the two branches are exclusive), so their position relative to those
   // is arbitrary — and appending leaves every existing rank exactly where it was.
   'fedimint-offline', 'never-confirmed',
 ];
+/*
+ * The LNURL kinds *are* interleaved, unlike the Fedimint ones, and they have to be:
+ * that branch reuses `gone`, `offline-long` and `offline`, so its warnings genuinely
+ * share a list with those ranks and appending would put a critical
+ * "withdrawals disabled" below a mild "offline since yesterday". The relative order of
+ * everything that existed before is unchanged, which is what `check-warnings.ts`
+ * asserts.
+ */
 
 /**
  * How stale an unconfirmed announcement has to be before it is worth saying so.
@@ -284,6 +335,7 @@ export function getMintWarnings(
   options: MintWarningOptions = {},
 ): MintWarning[] {
   if (mint.type === 'fedimint') return fedimintWarnings(mint, options);
+  if (mint.type === 'lnurl') return lnurlWarnings(mint, options);
   return cashuWarnings(mint, options);
 }
 
@@ -373,13 +425,7 @@ function cashuWarnings(
   const caps = mint.capabilities ?? readCapabilities(mint.info?.nuts);
   const { mintDisabled, meltDisabled } = caps;
 
-  const offline = mint.status === 'offline';
-  const since = mint.last_online;
-  const days = offline && since !== null ? Math.max(0, Math.floor((now - since) / 86400)) : null;
-
-  // Offline with no last_online means it has never once answered, which is at least
-  // as bad as a month of silence, so it lands in the top tier rather than the bottom.
-  const tier = !offline ? 0 : days === null ? 3 : days >= 30 ? 3 : days >= 7 ? 2 : 1;
+  const { offline, since, days, tier } = offlineTier(mint, now);
 
   /*
    * Cached flags describe the last configuration seen, not the current one, and the
@@ -468,6 +514,183 @@ function cashuWarnings(
   return out;
 }
 
+/**
+ * How long a listing has been unreachable, in the four bands the banners key on.
+ *
+ * Shared by the Cashu and LNURL branches, which apply exactly the same thresholds —
+ * being unreachable means the same thing whether the endpoint that stopped answering
+ * was `/v1/info` or a mint advertisement, and two copies of "is 7 days long?" is two
+ * places for it to become 8 in one of them.
+ *
+ * Tier 3 covers both a month of silence and never having answered at all: offline with
+ * no `last_online` means it has never once answered, which is at least as bad as a
+ * month of it, so it lands in the top tier rather than the bottom.
+ */
+function offlineTier(
+  mint: Pick<MintWarningInput, 'status' | 'last_online'>,
+  now: number,
+): { offline: boolean; since: number | null; days: number | null; tier: 0 | 1 | 2 | 3 } {
+  const offline = mint.status === 'offline';
+  const since = mint.last_online;
+  const days = offline && since !== null ? Math.max(0, Math.floor((now - since) / 86400)) : null;
+  const tier = !offline ? 0 : days === null ? 3 : days >= 30 ? 3 : days >= 7 ? 2 : 1;
+  return { offline, since, days, tier };
+}
+
+/**
+ * What can be said about an LNURL mint.
+ *
+ * Between the two extremes of the other ecosystems. A federation publishes no switches
+ * at all, so its page can only talk about reachability; a Cashu mint publishes NUT-04
+ * and NUT-05 flags, so its page can be specific about which direction is broken. An
+ * LNURL mint sits in between: two things about it are genuinely checkable over HTTP,
+ * and both get a banner.
+ *
+ *   - `maxWithdrawable` of zero. A mint advertising that no note can be redeemed for
+ *     anything is the closest analogue this ecosystem has to "withdrawals disabled",
+ *     and it is read from the advertisement rather than inferred, so it ranks with the
+ *     Cashu capability banners.
+ *   - A funding source the mint cannot reach. Distinctive to lnurlcash and worth its
+ *     own sentence, because it is *partial*: the mint is up, its notes still rotate,
+ *     split and merge, and only the two operations that need a Lightning node are
+ *     unavailable. Calling that "offline" would be wrong in both directions.
+ *
+ * The third, `lnurl-invalid`, is about this site's own reading rather than the mint's
+ * configuration: these endpoints answer their errors with HTTP 200, so a host that
+ * responds with something unparseable is a state that has to be named rather than
+ * silently counted as either up or down.
+ *
+ * Note what is deliberately missing: nothing here reads `features`. That tag is the
+ * operator's claim about what they built, and a banner derived from a claim rather than
+ * from an observation would be the same invention the Fedimint branch refuses to make.
+ */
+function lnurlWarnings(
+  mint: MintWarningInput,
+  options: MintWarningOptions = {},
+): MintWarning[] {
+  const now = options.now ?? Math.floor(Date.now() / 1000);
+  const date = options.formatDate ?? defaultDate;
+  const month = options.formatMonth ?? defaultMonth;
+  const s = options.strings ?? englishStrings;
+
+  const { offline, since, days, tier } = offlineTier(mint, now);
+  const tense = offline ? 'offline' : 'online';
+  const dayCount = s('dayCount', { n: days ?? 0 });
+
+  // `=== 0`, never falsy: null means nothing has probed this mint yet, and "we have not
+  // looked" must not render as "withdrawals are disabled".
+  const withdrawalsDisabled = mint.max_withdrawable_msat === 0;
+  const invalid = Boolean(mint.invalid_reason);
+  const noFunding = mint.funding_available === false;
+
+  const out: MintWarning[] = [];
+
+  // Pushed in ORDER, so the first one added is the one that wins.
+  if (tier === 3) {
+    out.push({
+      kind: 'gone',
+      severity: 'critical',
+      lead: s('gone.lead'),
+      body:
+        since !== null
+          ? s('gone.body.since', { date: date(since), days: dayCount })
+          : mint.first_seen
+            ? s('gone.body.neverDated', { month: month(mint.first_seen) })
+            : s('gone.body.never'),
+      meta: since !== null ? s('gone.meta.since', { date: date(since) }) : s('gone.meta.never'),
+    });
+  }
+
+  if (withdrawalsDisabled) {
+    out.push({
+      kind: 'lnurl-withdrawals-disabled',
+      severity: 'critical',
+      lead: s('lnurlWithdrawalsDisabled.lead'),
+      body: s(`lnurlWithdrawalsDisabled.body.${tense}`),
+      meta: s(`lnurlWithdrawalsDisabled.meta.${tense}`),
+    });
+  }
+
+  if (tier === 2 && since !== null) {
+    out.push({
+      kind: 'offline-long',
+      severity: 'critical',
+      lead: s('offlineLong.lead', { days: dayCount, date: date(since) }),
+      body: s('offlineLong.body'),
+      meta: s('offlineLong.meta', { date: date(since) }),
+    });
+  }
+
+  if (invalid) {
+    out.push({
+      kind: 'lnurl-invalid',
+      severity: 'warning',
+      lead: s('lnurlInvalid.lead'),
+      body: s('lnurlInvalid.body'),
+      meta: s('lnurlInvalid.meta'),
+    });
+  }
+
+  if (noFunding) {
+    out.push({
+      kind: 'lnurl-no-funding',
+      severity: 'warning',
+      lead: s('lnurlNoFunding.lead'),
+      body: s('lnurlNoFunding.body'),
+      meta: s('lnurlNoFunding.meta'),
+    });
+  }
+
+  if (tier === 1 && since !== null) {
+    out.push({
+      kind: 'offline',
+      severity: 'warning',
+      lead: s('offline.lead', { date: date(since) }),
+      body: s('offline.body'),
+      meta: s('offline.meta', { date: date(since) }),
+    });
+  }
+
+  const primary = out[0];
+  if (primary) {
+    const extra = lnurlCollapsed(primary.kind, { noFunding, offline, since, dayCount, date, s });
+    if (extra) primary.body += ` ${extra}`;
+  }
+
+  return out;
+}
+
+/**
+ * The one sentence a losing LNURL condition earns inside the winner's text.
+ *
+ * Same contract as `collapsed`, and separate from it because the conditions being
+ * folded in are different ones: there is no NUT-04 or NUT-05 here, and the fact worth
+ * rescuing from an offline banner is that the mint's Lightning node was down too.
+ */
+function lnurlCollapsed(
+  kind: MintWarningKind,
+  ctx: {
+    noFunding: boolean;
+    offline: boolean;
+    since: number | null;
+    dayCount: string;
+    date: (unix: number) => string;
+    s: WarningStrings;
+  },
+): string | null {
+  if (kind === 'gone' || kind === 'offline-long' || kind === 'offline') {
+    return ctx.noFunding ? ctx.s('also.noFunding') : null;
+  }
+
+  // A capability banner outranked an offline one: say the mint is also unreachable,
+  // otherwise the page reads as if it were up and merely misconfigured.
+  if (kind === 'lnurl-withdrawals-disabled' && ctx.offline && ctx.since !== null) {
+    return ctx.s('also.offline', { date: ctx.date(ctx.since), days: ctx.dayCount });
+  }
+
+  return null;
+}
+
 /**
  * The one sentence a losing condition earns inside the winner's text. Banners never
  * stack, but a mint that is both gone and had stopped paying out is a worse story
@@ -533,6 +756,8 @@ export const CHIP_COPY_EN: Record<string, string> = {
   frozen: 'Frozen',
   noWithdrawals: 'No withdrawals',
   meltOnly: 'Melt only',
+  /** LNURL: up and serving, but nothing moves in or out over Lightning. */
+  noFunding: 'No mint / melt',
 };
 
 export function mintChip(warnings: MintWarning[], strings?: WarningStrings): MintChip | null {
@@ -541,7 +766,13 @@ export function mintChip(warnings: MintWarning[], strings?: WarningStrings): Min
   if (kinds.has('frozen')) return { label: s('frozen'), severity: 'critical' };
   // "Melt only" is the other direction, so it cannot double as the label here.
   if (kinds.has('melt-disabled')) return { label: s('noWithdrawals'), severity: 'critical' };
+  // An LNURL mint advertising a zero withdraw ceiling is the same statement to a
+  // reader as a Cashu mint with melting off, so it earns the same two words.
+  if (kinds.has('lnurl-withdrawals-disabled')) {
+    return { label: s('noWithdrawals'), severity: 'critical' };
+  }
   if (kinds.has('melt-only')) return { label: s('meltOnly'), severity: 'warning' };
+  if (kinds.has('lnurl-no-funding')) return { label: s('noFunding'), severity: 'warning' };
   return null;
 }
 

web/astro.config.mjs

@@ -28,6 +28,12 @@ const apiUrl = process.env.API_URL ?? 'http://127.0.0.1:8787';
 // https://api.cashumints.space.
 const publicApiUrl = process.env.PUBLIC_API_URL ?? '';
 
+// Plausible-compatible analytics endpoint and site identifier. Empty values disable the
+// script, which is useful for local builds that should not report page views.
+const plausibleUrl =
+  process.env.PLAUSIBLE_URL ?? 'https://analytics.azzamo.net/js/script.js';
+const plausibleDomain = process.env.PLAUSIBLE_DOMAIN ?? 'cashumints.space';
+
 // Dev server and preview port. Set WEB_PORT in .env; a --port flag still overrides it.
 const port = Number.parseInt(process.env.WEB_PORT ?? '', 10) || 4321;
 
@@ -73,6 +79,8 @@ export default defineConfig({
   vite: {
     define: {
       'import.meta.env.PUBLIC_API_URL': JSON.stringify(publicApiUrl),
+      'import.meta.env.PLAUSIBLE_URL': JSON.stringify(plausibleUrl),
+      'import.meta.env.PLAUSIBLE_DOMAIN': JSON.stringify(plausibleDomain),
     },
     server: { proxy },
   },

web/package.json

@@ -8,11 +8,13 @@
     "og": "node scripts/og/build-og.mjs",
     "og:fixtures": "node scripts/og/build-og.mjs --fixtures",
     "build": "node scripts/og/build-og.mjs && astro build",
+    "start": "node server.mjs",
     "preview": "astro preview",
     "typecheck": "astro check",
     "bones": "node --env-file-if-exists=../.env scripts/bones.mjs",
     "check:links": "node scripts/check-links.mjs dist",
     "check:i18n": "node scripts/check-i18n.mjs",
+    "test": "node --test test/*.test.mjs",
     "check:hreflang": "node scripts/check-hreflang.mjs dist"
   },
   "dependencies": {

web/scripts/check-i18n.mjs

@@ -242,6 +242,8 @@ const DYNAMIC_PREFIXES = [
   'fedimint.network.',       // localNetworkName(network)
   'feed.ecosystem.',         // the /reviews filter, one option per ECOSYSTEMS entry
   'reviews.dialog.bodyPlaceholder.', // one prompt per ecosystem, keyed by subject.type
+  'reviews.dialog.lede.',    // the dialog's invitation, one per ecosystem
+  'reviews.rate.',           // the reviews panel's inline "Rate this mint" row
 ];
 
 const isDynamic = (key) => DYNAMIC_PREFIXES.some((prefix) => key.startsWith(prefix));
@@ -266,6 +268,20 @@ for (const file of files) {
   // A .ts file under lib/ or scripts/ is island code wholesale.
   const shipsToBrowser = /\/(lib|scripts)\//.test(relative) && relative.endsWith('.ts');
 
+  /*
+   * A page can inline one extra namespace for its own islands, through Base.astro's
+   * `clientNamespaces` prop. The home page does: its grids hydrate from the API and
+   * rewrite their own "All 56 mints" links, whose strings live under `home.` — a
+   * namespace not worth inlining on 1,300 mint pages that never read it.
+   *
+   * Read out of the page rather than listed here, so the prop and this check cannot
+   * disagree. A namespace a page does not actually pass is still a leak.
+   */
+  const extraNamespaces = new Set(
+    [...(/clientNamespaces=\{\[([^\]]*)\]\}/.exec(source)?.[1] ?? '').matchAll(/'([\w-]+)'/g)]
+      .map((m) => m[1]),
+  );
+
   for (const match of source.matchAll(T_CALL)) {
     const key = match[2];
     used.add(key);
@@ -278,7 +294,7 @@ for (const file of files) {
   for (const match of clientSource.matchAll(T_CALL)) {
     const key = match[2];
     const namespace = key.split('.')[0];
-    if (!clientNamespaces.has(namespace)) {
+    if (!clientNamespaces.has(namespace) && !extraNamespaces.has(namespace)) {
       clientLeaks.push({ key, file: relative, namespace });
     }
   }

web/scripts/make-assets.mjs

@@ -6,6 +6,7 @@
  * files change roughly never.
  *
  *   node scripts/make-assets.mjs
+ *   node scripts/make-assets.mjs --no-card   # icon set only, needs no browser
  *
  * Playwright and sharp are not dependencies of this workspace. Both arrive transitively
  * under `astro` (which ships sharp for its image pipeline) and are resolved through it,
@@ -14,10 +15,12 @@
  *
  * The card is drawn in a real browser rather than assembled by hand because it uses the
  * site's own fonts and tokens: a social card that does not look like the site is worth
- * less than no card. The moai is the same rect geometry as `components/Moai.astro`.
+ * less than no card. The moai on the card is the same rect geometry as
+ * `components/Moai.astro`. The icon set is a different mark: the pixel cashu nut carried
+ * over from the old site (`src/assets/cashu-logo.png`), composed with sharp alone.
  */
 import { createRequire } from 'node:module';
-import { mkdir, writeFile } from 'node:fs/promises';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
@@ -100,14 +103,8 @@ p { margin-top: 28px; font-size: 27px; line-height: 1.45; color: #9A927E; max-wi
   <div class="host">cashumints.space</div>
 </body></html>`;
 
-/* The icon master: the moai on the site's background, generous padding. */
-const iconHtml = `<!doctype html><html><head><meta charset="utf-8"><style>
-* { margin: 0; padding: 0; }
-body {
-  width: 512px; height: 512px; background: #0E0D0B;
-  display: flex; align-items: center; justify-content: center;
-}
-</style></head><body>${moaiSvg(320)}</body></html>`;
+/* The icon source: the old site's pixel cashu nut, 1000x1000 with transparent margins. */
+const logoPath = path.join(root, 'src', 'assets', 'cashu-logo.png');
 
 /**
  * A 32x32 ICO wrapping a PNG payload.
@@ -138,6 +135,52 @@ function icoFromPng(png) {
 
 await mkdir(publicDir, { recursive: true });
 
+/*
+ * The icon master: the nut trimmed and centred on the brand ground, at the footprint the
+ * moai used to occupy (glyph ≈ 380px tall in the 512 tile). Content this size also stays
+ * inside the circle a maskable icon is cropped to.
+ */
+const glyph = await sharp(logoPath).trim().resize(384, 384, { fit: 'inside' }).png().toBuffer();
+const master = await sharp({
+  create: { width: 512, height: 512, channels: 4, background: '#0E0D0B' },
+})
+  .composite([{ input: glyph, gravity: 'centre' }])
+  .png()
+  .toBuffer();
+
+for (const [name, size] of [
+  ['icon-512.png', 512],
+  ['icon-192.png', 192],
+  ['favicon-32.png', 32],
+]) {
+  await sharp(master).resize(size, size).png({ compressionLevel: 9 }).toFile(path.join(publicDir, name));
+  console.log(name);
+}
+
+// iOS ignores transparency and composites on white; the master's ground is already opaque.
+await sharp(master)
+  .resize(180, 180)
+  .png({ compressionLevel: 9 })
+  .toFile(path.join(publicDir, 'apple-touch-icon.png'));
+console.log('apple-touch-icon.png');
+
+const png32 = await sharp(master).resize(32, 32).png({ compressionLevel: 9 }).toBuffer();
+await writeFile(path.join(publicDir, 'favicon.ico'), icoFromPng(png32));
+console.log('favicon.ico');
+
+// The standalone SVG favicon: the nut itself, transparent like the old site served it.
+// The PNG rides inside the SVG so one source file covers every size; `pixelated` keeps
+// the pixel art crisp if anything scales it up.
+const logoB64 = (await readFile(logoPath)).toString('base64');
+await writeFile(
+  path.join(publicDir, 'favicon.svg'),
+  `<svg xmlns="http://www.w3.org/2000/svg" width="1000" height="1000" viewBox="0 0 1000 1000">` +
+    `<image width="1000" height="1000" style="image-rendering:pixelated" ` +
+    `href="data:image/png;base64,${logoB64}"/></svg>`,
+);
+console.log('favicon.svg');
+
+if (!process.argv.includes('--no-card')) {
   const browser = await chromium.launch();
   try {
     const page = await browser.newPage({
@@ -149,35 +192,7 @@ try {
     await page.evaluate(() => document.fonts.ready);
     await page.screenshot({ path: path.join(publicDir, 'og.png') });
     console.log('og.png');
-
-  await page.setViewportSize({ width: 512, height: 512 });
-  await page.setContent(iconHtml, { waitUntil: 'load' });
-  const master = await page.screenshot({ type: 'png' });
-
-  for (const [name, size] of [
-    ['icon-512.png', 512],
-    ['icon-192.png', 192],
-    ['favicon-32.png', 32],
-  ]) {
-    await sharp(master).resize(size, size).png({ compressionLevel: 9 }).toFile(path.join(publicDir, name));
-    console.log(name);
-  }
-
-  // iOS ignores transparency and composites on white, so flatten onto the brand ground.
-  await sharp(master)
-    .resize(180, 180)
-    .flatten({ background: '#0E0D0B' })
-    .png({ compressionLevel: 9 })
-    .toFile(path.join(publicDir, 'apple-touch-icon.png'));
-  console.log('apple-touch-icon.png');
-
-  const png32 = await sharp(master).resize(32, 32).png({ compressionLevel: 9 }).toBuffer();
-  await writeFile(path.join(publicDir, 'favicon.ico'), icoFromPng(png32));
-  console.log('favicon.ico');
-
-  // The standalone SVG favicon: the same mark, at any size, for browsers that take it.
-  await writeFile(path.join(publicDir, 'favicon.svg'), moaiSvg(11));
-  console.log('favicon.svg');
   } finally {
     await browser.close();
   }
+}

web/scripts/og/build-og.mjs

@@ -28,7 +28,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { Resvg } from '@resvg/resvg-js';
 import { renderSvg } from './card.mjs';
-import { cashuModel, defaultModel, fedimintModel } from './model.mjs';
+import { cashuModel, defaultModel, fedimintModel, lnurlModel } from './model.mjs';
 import { FIXTURES, NOW as FIXTURE_NOW } from './fixtures.mjs';
 
 const here = path.dirname(fileURLToPath(import.meta.url));
@@ -96,6 +96,8 @@ async function buildFixtures() {
     const model =
       raw.type === 'fedimint'
         ? fedimintModel(raw, { now: FIXTURE_NOW })
+        : raw.type === 'lnurl'
+          ? lnurlModel(raw, { now: FIXTURE_NOW })
           : cashuModel(raw, { now: FIXTURE_NOW });
     const png = await renderPng(model, null);
     const file = path.join(dir, `${raw.host}.png`);
@@ -114,9 +116,10 @@ async function build() {
   const previous = JSON.parse(await readFile(manifestFile, 'utf8').catch(() => '{}'));
   const previousImages = previous.images ?? {};
 
-  const [cashu, fedimint, stats] = await Promise.all([
+  const [cashu, fedimint, lnurl, stats] = await Promise.all([
     getJson('/api/mints?type=cashu'),
     getJson('/api/mints?type=fedimint'),
+    getJson('/api/mints?type=lnurl'),
     getJson('/api/stats'),
   ]);
 
@@ -135,6 +138,7 @@ async function build() {
   const listings = [
     ...cashu.map((m) => ({ listing: m, kind: 'cashu' })),
     ...fedimint.map((m) => ({ listing: m, kind: 'fedimint' })),
+    ...lnurl.map((m) => ({ listing: m, kind: 'lnurl' })),
   ];
 
   // A handful at a time: satori renders in milliseconds, the icon fetches are local,
@@ -158,6 +162,8 @@ async function build() {
       const model =
         kind === 'fedimint'
           ? fedimintModel(detail, { iconHash: icon?.hash ?? null, now })
+          : kind === 'lnurl'
+            ? lnurlModel(detail, { iconHash: icon?.hash ?? null, now })
             : cashuModel(detail, { iconHash: icon?.hash ?? null, now });
 
       const hash = hashModel(model);

web/scripts/og/card.mjs

@@ -29,6 +29,8 @@ const AMBER = '#F0A93B';
 const VIOLET = '#A78BFA';
 const MINT = '#5FD68F';
 const RED = '#E06450';
+/** The LNURL ecosystem label. The only cool blue here — see DESIGN.md. */
+const LNURL = '#4EA8DE';
 
 const GROTESK = 'Space Grotesk';
 const INTER = 'Inter';
@@ -137,22 +139,29 @@ function statusChip(model) {
   }
 }
 
-/** The type badge that makes a federation card unmistakable at thumbnail size. */
-function fedimintBadge() {
+/**
+ * The type badge that makes a non-Cashu card unmistakable at thumbnail size.
+ *
+ * Three things separate the three ecosystems at 300px wide, and the badge is only one
+ * of them: the word itself, the badge's colour, and the glow behind the whole card all
+ * change together. Cashu gets no badge at all, which is its own signal — it is the
+ * default and the majority of the index.
+ */
+function typeBadge(label, color, borderColor) {
   return h(
     'div',
     {
       display: 'flex',
       padding: '9px 14px',
       borderRadius: '9px',
-      border: `1.5px solid rgba(167,139,250,.5)`,
-      color: VIOLET,
+      border: `1.5px solid ${borderColor}`,
+      color,
       fontFamily: MONO,
       fontWeight: 500,
       fontSize: '18px',
       letterSpacing: '3px',
     },
-    'FEDIMINT',
+    label,
   );
 }
 
@@ -380,14 +389,85 @@ function thirdCellFedimint(model) {
   );
 }
 
-/** The background glow: amber for a healthy card, red-tinted for trouble, violet for Fedimint. */
+/**
+ * Third cell, LNURL: the withdraw range — never NUT limits, never a module list.
+ *
+ * This is the number that answers an LNURL reader's actual question: how much can one
+ * of this mint's notes be worth? It is shown in sats, converted from millisatoshi in
+ * the model, and it is a *range* rather than a pair of independent bounds, which is
+ * why the two rows read "min"/"max" the way the Cashu limits cell does.
+ *
+ * The lightning address takes the space the Fedimint cell gives its network badge: it
+ * is the one string on the whole card someone might copy out of a screenshot.
+ */
+function thirdCellLnurl(model) {
+  const base = {
+    display: 'flex',
+    flexDirection: 'column',
+    flex: 1.1,
+    padding: '30px 36px',
+    borderLeft: `1px solid ${LINE_SOFT}`,
+  };
+
+  if (model.warning) {
+    const color = model.warning.severity === 'critical' ? RED : AMBER;
+    return h(
+      'div',
+      { ...base, backgroundColor: model.warning.severity === 'critical' ? 'rgba(224,100,80,.06)' : 'rgba(240,169,59,.05)' },
+      cellLabel('WARNING', color),
+      h('div', { fontFamily: GROTESK, fontWeight: 700, fontSize: '34px', lineHeight: 1.05, color }, model.warning.label),
+      h('div', { fontFamily: INTER, fontWeight: 500, fontSize: '19px', color: MUTED, marginTop: '14px' }, model.warning.sub),
+    );
+  }
+
+  const lines = [];
+  if (model.withdraw) {
+    if (model.withdraw.min !== null) lines.push(['min', `${compact(model.withdraw.min)} sat`]);
+    if (model.withdraw.max !== null) lines.push(['max', `${compact(model.withdraw.max)} sat`]);
+  }
+
+  return h(
+    'div',
+    base,
+    cellLabel('WITHDRAW'),
+    lines.length === 0
+      ? h('div', { fontFamily: MONO, fontWeight: 400, fontSize: '24px', color: MUTED, marginTop: '8px' }, 'Not published')
+      : h(
+          'div',
+          { display: 'flex', flexDirection: 'column', gap: '10px', marginTop: '4px' },
+          ...lines.map(([k, v]) =>
+            h(
+              'div',
+              { display: 'flex', alignItems: 'baseline', gap: '14px' },
+              h('div', { fontFamily: MONO, fontWeight: 400, fontSize: '20px', color: FAINT }, k),
+              h('div', { fontFamily: MONO, fontWeight: 500, fontSize: '27px', color: TEXT }, v),
+            ),
+          ),
+        ),
+    model.address &&
+      h(
+        'div',
+        { fontFamily: MONO, fontWeight: 400, fontSize: '18px', color: FAINT, marginTop: '16px', maxWidth: '300px' },
+        fitMono(model.address, 30),
+      ),
+  );
+}
+
+/** The background glow: amber healthy, red for trouble, violet Fedimint, blue LNURL. */
 function glow(model) {
   const danger =
-    model.status === 'offline' || (model.type === 'cashu' && model.warning && model.warning.severity === 'critical');
+    model.status === 'offline' ||
+    (model.type !== 'fedimint' && model.warning && model.warning.severity === 'critical');
   const color = danger
     ? 'rgba(224,100,80,.13)'
     : model.type === 'fedimint'
       ? 'rgba(167,139,250,.11)'
+      : model.type === 'lnurl'
+        // Deliberately the strongest of the three. Amber and violet only have to
+        // separate a card from the site's own background; this one has to separate an
+        // LNURL card from a Fedimint card at 300px, where the badge text is a smudge
+        // and the tint is the first thing a reader actually resolves.
+        ? 'rgba(78,168,222,.20)'
         : 'rgba(240,169,59,.10)';
   return h('div', {
     position: 'absolute',
@@ -414,10 +494,12 @@ function brandRow(tagline) {
 /** One mint or federation card. `iconData` is a data: URI or null. */
 export function mintCard(model, iconData) {
   const isFed = model.type === 'fedimint';
+  const isLnurl = model.type === 'lnurl';
   const monoLine = isFed ? model.shortId : fitMono(model.domain, 46);
 
-  // Room beside the icon: canvas minus padding, icon, gaps and the chips.
-  const chipRoom = 240 + (isFed ? 180 : 0);
+  // Room beside the icon: canvas minus padding, icon, gaps and the chips. A badge is
+  // ~180px for FEDIMINT and ~120px for the shorter LNURL.
+  const chipRoom = 240 + (isFed ? 180 : isLnurl ? 120 : 0);
   const { size, clamp } = nameSize(model.name, 1200 - 128 - 148 - chipRoom);
 
   return h(
@@ -433,7 +515,7 @@ export function mintCard(model, iconData) {
       fontFamily: INTER,
     },
     glow(model),
-    brandRow(isFed ? 'Fedimint reviews' : 'Cashu mint reviews'),
+    brandRow(isFed ? 'Fedimint reviews' : isLnurl ? 'LNURL mint reviews' : 'Cashu mint reviews'),
     h(
       'div',
       { display: 'flex', alignItems: 'center', gap: '32px', marginTop: '52px', flexGrow: 1 },
@@ -459,7 +541,8 @@ export function mintCard(model, iconData) {
             model.name,
           ),
           statusChip(model),
-          isFed && fedimintBadge(),
+          isFed && typeBadge('FEDIMINT', VIOLET, 'rgba(167,139,250,.5)'),
+          isLnurl && typeBadge('LNURL', LNURL, 'rgba(78,168,222,.5)'),
         ),
         h('div', { fontFamily: MONO, fontWeight: 400, fontSize: '25px', color: MUTED, marginTop: '14px' }, monoLine),
         // The Fedimint soft warning is a muted line, deliberately not a red cell.
@@ -479,7 +562,7 @@ export function mintCard(model, iconData) {
       },
       ratingCell(model),
       reviewsCell(model),
-      isFed ? thirdCellFedimint(model) : thirdCellCashu(model),
+      isFed ? thirdCellFedimint(model) : isLnurl ? thirdCellLnurl(model) : thirdCellCashu(model),
     ),
   );
 }
@@ -525,13 +608,16 @@ export function defaultCard(model) {
     h(
       'div',
       { fontFamily: INTER, fontWeight: 500, fontSize: '28px', color: MUTED, marginTop: '14px' },
-      'Cashu mint and Fedimint reviews, signed on Nostr',
+      'Cashu, Fedimint and LNURL mint reviews, signed on Nostr',
     ),
     h(
       'div',
-      { display: 'flex', gap: '86px', marginTop: '64px' },
+      // Four stats where there were three, so the gap tightens rather than the row
+      // running past the card's own margins.
+      { display: 'flex', gap: '64px', marginTop: '64px' },
       stat(model.mints, 'Cashu mints'),
       stat(model.federations, 'federations'),
+      stat(model.lnurl, 'LNURL mints'),
       stat(model.reviews, 'signed reviews'),
     ),
   );

web/scripts/og/fixtures.mjs

@@ -1,7 +1,7 @@
 /**
  * The edge cases the template must survive, as synthetic API payloads.
  *
- * Run through the same cashuModel/fedimintModel derivation as real data — a fixture
+ * Run through the same cashuModel/fedimintModel/lnurlModel derivation as real data — a fixture
  * that bypassed the model would test a card no build can produce. `NOW` is pinned so
  * the rendered PNGs under og-fixtures/ are byte-stable and can live in the repo as
  * eyeball snapshots.
@@ -32,6 +32,31 @@ const base = {
   },
 };
 
+
+/**
+ * The shared shape of an LNURL row's detail payload, as `GET /api/mints/:host` returns
+ * it: the ecosystem fields flattened across the top level, millisatoshi on the wire.
+ */
+const lnurlBase = {
+  type: 'lnurl',
+  status: 'online',
+  last_online: NOW - 300,
+  last_probe: NOW - 300,
+  first_seen: NOW - 200 * 86400,
+  review_count: 9,
+  rating_avg: 4.4,
+  rating_distribution: dist(6, 2, 1),
+  last_review_at: NOW - 20 * 86400,
+  features: ['mint', 'melt', 'rotate', 'split', 'merge', 'lud06', 'lud03', 'lud16', 'signed-notes'],
+  network: 'mainnet',
+  mint_pubkey: '021ab89df9cbd28cdab8c71d228ca40deba1eaebd827f24849ec4f3e919c023555',
+  funding_available: true,
+  invalid_reason: null,
+  min_withdrawable_msat: 5_000,
+  max_withdrawable_msat: 999_899_000,
+  lightning_address: 'mint@lnurl.example',
+};
+
 export const FIXTURES = [
   {
     // A name at the 30-character mark: must step down, never clip.
@@ -109,4 +134,42 @@ export const FIXTURES = [
     network: 'mainnet',
     status_source: null,
   },
+  {
+    // The healthy LNURL card: blue glow, LNURL badge, a withdraw range in the third
+    // cell, and the lightning address under it.
+    ...lnurlBase,
+    host: 'fixture-lnurl-online',
+    url: 'lnurl:https://lnurl.example',
+    base_url: 'https://lnurl.example',
+    name: null,
+    icon: null,
+  },
+  {
+    // Offline 20 days: red glow beats the blue one, warning cell replaces the range.
+    // The blue badge stays, because which ecosystem it is has not changed.
+    ...lnurlBase,
+    host: 'fixture-lnurl-offline',
+    url: 'lnurl:https://lnurl.gone.example',
+    base_url: 'https://lnurl.gone.example',
+    name: 'Departed Notes',
+    icon: null,
+    status: 'offline',
+    last_online: NOW - 20 * 86400,
+    rating_avg: 2.1,
+    rating_distribution: dist(0, 1, 1, 3, 5),
+    review_count: 10,
+  },
+  {
+    // A withdraw ceiling of zero, while ONLINE: green status chip stays, and the
+    // critical warning cell appears anyway. The one card that must never print
+    // "max 0 sat" as though it were a limit.
+    ...lnurlBase,
+    host: 'fixture-lnurl-no-withdrawals',
+    url: 'lnurl:https://lnurl.locked.example',
+    base_url: 'https://lnurl.locked.example',
+    name: 'Locked Notes Mint',
+    icon: null,
+    min_withdrawable_msat: 0,
+    max_withdrawable_msat: 0,
+  },
 ];

web/scripts/og/model.mjs

@@ -14,10 +14,15 @@
  * The warning logic is imported from shared/, not restated: the image must never
  * disagree with the page it decorates about whether a mint is frozen or gone.
  */
-import { getMintWarnings, parseLimits, readCapabilities } from '@cashumints/shared';
+import { getMintWarnings, msatToSat, parseLimits, readCapabilities } from '@cashumints/shared';
 
-/** Bump when the template's layout or copy changes, to regenerate every image. */
-export const TEMPLATE_VERSION = 1;
+/**
+ * Bump when the template's layout or copy changes, to regenerate every image.
+ *
+ * 2: the LNURL variant. Its badge, glow and third cell are new, and the shared
+ * `warningCell` learned three LNURL warning kinds, so every card's hash input moved.
+ */
+export const TEMPLATE_VERSION = 2;
 
 const DAY = 86_400;
 
@@ -115,6 +120,11 @@ function warningCell(warning, mint, now) {
     'offline-long': 'Offline',
     'offline': 'Offline',
     'fedimint-offline': 'Reported offline',
+    // LNURL. `lnurl-withdrawals-disabled` gets the same two words as the Cashu
+    // melt-disabled cell, because it is the same statement to a reader.
+    'lnurl-withdrawals-disabled': 'No withdrawals',
+    'lnurl-no-funding': 'No mint / melt',
+    'lnurl-invalid': 'Not responding properly',
   }[warning.kind];
   if (!label) return null;
 
@@ -135,11 +145,26 @@ function warningCell(warning, mint, now) {
     case 'frozen':
       sub = 'Nothing moves in or out';
       break;
+    case 'lnurl-withdrawals-disabled':
+      sub = 'Notes cannot be redeemed';
+      break;
+    case 'lnurl-no-funding':
+      // The precise half of the story, and the half that stops a reader writing the
+      // mint off: its notes still work, only Lightning is shut.
+      sub = 'Notes still rotate and split';
+      break;
+    case 'lnurl-invalid':
+      sub = 'Endpoint answered with junk';
+      break;
   }
 
   // The mint is also offline while a capability warning outranks that fact: the cell
   // still has to say so, the way the page banner folds it into its last sentence.
-  if (['melt-only', 'melt-disabled', 'frozen'].includes(warning.kind) && mint.status === 'offline' && since !== null) {
+  if (
+    ['melt-only', 'melt-disabled', 'frozen', 'lnurl-withdrawals-disabled'].includes(warning.kind) &&
+    mint.status === 'offline' &&
+    since !== null
+  ) {
     sub = `Offline since ${shortDate(since)}`;
   }
 
@@ -227,6 +252,53 @@ export function fedimintModel(fed, { iconHash = null, now = Math.floor(Date.now(
   };
 }
 
+/**
+ * One LNURL mint's card model.
+ *
+ * The same skeleton as the other two, with the third cell answering this ecosystem's
+ * own question: how much can one of this mint's bearer notes be worth? That is the
+ * withdraw range, in sats, converted here once from the millisatoshi the wire carries.
+ *
+ * `withdraw` is null when the ceiling is zero, and deliberately: a card printing
+ * "max 0 sat" reads as a number rather than as a refusal, and the warning cell that
+ * outranks it says the true thing instead.
+ */
+export function lnurlModel(mint, { iconHash = null, now = Math.floor(Date.now() / 1000) } = {}) {
+  const baseUrl = mint.base_url ?? mint.url.replace(/^lnurl:/, '');
+  const domain = displayDomain(baseUrl);
+  const name = (mint.name ?? '').trim() || domain.split('/')[0] || domain;
+  const warning = getMintWarnings(mint, { now })[0] ?? null;
+  const offline = mint.status === 'offline';
+  const offlineDays =
+    offline && mint.last_online !== null
+      ? Math.max(0, Math.floor((now - mint.last_online) / DAY))
+      : null;
+
+  const min = msatToSat(mint.min_withdrawable_msat ?? null);
+  const max = msatToSat(mint.max_withdrawable_msat ?? null);
+
+  return {
+    v: TEMPLATE_VERSION,
+    type: 'lnurl',
+    slug: mint.host,
+    name,
+    domain,
+    status: mint.status,
+    offlineDays,
+    rating: mint.rating_avg,
+    reviewCount: mint.review_count,
+    sentiment: sentiment(mint.rating_distribution ?? {}),
+    lastReviewMonth: mint.last_review_at ? monthYear(mint.last_review_at) : null,
+    withdraw: max !== null && max > 0 ? { min, max } : null,
+    /** The LUD-16 address, which is the one string a reader might actually copy. */
+    address: mint.lightning_address ?? null,
+    warning: warningCell(warning, mint, now),
+    iconHash,
+    gradient: iconHash ? null : iconGradient(domain),
+    initials: iconHash ? null : initials(name),
+  };
+}
+
 /** The default card: brand, tagline, and the network's own numbers. */
 export function defaultModel(stats) {
   return {
@@ -235,6 +307,7 @@ export function defaultModel(stats) {
     slug: 'default',
     mints: stats.cashu_total,
     federations: stats.fedimint_total,
+    lnurl: stats.lnurl_total,
     reviews: stats.reviews_total,
   };
 }

web/scripts/og/thumbs.mjs

@@ -0,0 +1,46 @@
+/**
+ * A contact sheet of the three ecosystems' cards at thumbnail size.
+ *
+ * Not part of the build: run it by hand (`node scripts/og/thumbs.mjs`) to check the
+ * one thing a full-size render cannot show you — whether a reader scrolling a timeline
+ * can tell a Cashu card from a Fedimint one from an LNURL one before any text is
+ * legible. Writes og-fixtures/_thumbs.png.
+ */
+import { readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Resvg } from '@resvg/resvg-js';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const dir = path.resolve(here, '../../og-fixtures');
+
+/** 300px wide: roughly how a link preview renders in a feed. */
+const W = 300;
+const H = Math.round((630 / 1200) * W);
+const GAP = 16;
+const LABEL = 22;
+
+const cards = [
+  ['Cashu', 'fixture-no-icon.png'],
+  ['Fedimint', 'fixture-fed-announced.png'],
+  ['LNURL', 'fixture-lnurl-online.png'],
+];
+
+const parts = await Promise.all(
+  cards.map(async ([label, file], i) => {
+    const data = await readFile(path.join(dir, file));
+    const x = i * (W + GAP);
+    return (
+      `<image x="${x}" y="${LABEL}" width="${W}" height="${H}" ` +
+      `href="data:image/png;base64,${data.toString('base64')}"/>` +
+      `<text x="${x}" y="15" font-family="monospace" font-size="13" fill="#EDE8DC">${label}</text>`
+    );
+  }),
+);
+
+const svg =
+  `<svg xmlns="http://www.w3.org/2000/svg" width="${cards.length * (W + GAP) - GAP}" ` +
+  `height="${H + LABEL}"><rect width="100%" height="100%" fill="#0E0D0B"/>${parts.join('')}</svg>`;
+
+await writeFile(path.join(dir, '_thumbs.png'), new Resvg(svg).render().asPng());
+console.log(`og: og-fixtures/_thumbs.png (${cards.length} cards at ${W}px)`);

web/server.mjs

@@ -0,0 +1,386 @@
+/**
+ * The production web server.
+ *
+ * The site is `output: 'static'`: `pnpm build` prerenders every page and this process
+ * only hands the result out over HTTP. nginx sits in front of it and proxies, rather
+ * than pointing a `root` at the built tree, so that nothing outside this file decides
+ * what is readable. That is not a stylistic preference — it removes two whole classes
+ * of failure the file-serving arrangement kept producing:
+ *
+ *   traversal permissions   nginx runs as www-data and the build runs as cashumints,
+ *                           so every directory from / down to dist had to be traversable
+ *                           by a user with no other business in it. One 0700 home
+ *                           directory anywhere in the chain took the site down, and
+ *                           `try_files` reports a permission error as a plain miss, so
+ *                           the symptom was a blanket 404 or an internal-redirect loop
+ *                           ending in 500 — never the actual cause.
+ *
+ *   duplicated routing      the locale 404 rule lived in nginx as a hand-maintained
+ *                           alternation of 23 codes. Adding a language meant editing a
+ *                           file that is not in this repository, and forgetting to was
+ *                           silent. Locale 404s are resolved by looking in the built
+ *                           tree now, so the list cannot drift.
+ *
+ * Reading files is all it does. There is no template, no database handle and no route
+ * table: `/api/*` and `/icons/*` belong to the API on its own port and nginx forwards
+ * them there directly.
+ *
+ * Env:
+ *   SITE_PORT   8789         port to listen on
+ *   SITE_HOST   127.0.0.1    interface to bind; loopback because nginx terminates TLS
+ *   WEB_ROOT    ./dist       the tree to serve
+ */
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import http from 'node:http';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+
+function int(raw, fallback) {
+  const n = Number.parseInt(raw ?? '', 10);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+
+/**
+ * The tree to serve, absolute.
+ *
+ * Defaults to the build output next to this file, which is what `pnpm start` and the
+ * tests use. In production it points at a copy outside the checkout: `pnpm build`
+ * empties dist before it writes, so serving dist directly means a rebuild takes the
+ * whole site down for the length of the build. See cashumints-web.service.
+ */
+export const ROOT = path.resolve(process.env.WEB_ROOT ?? path.join(here, 'dist'));
+
+const PORT = int(process.env.SITE_PORT, 8789);
+const HOST = process.env.SITE_HOST ?? '127.0.0.1';
+
+/** One line per event, key=value after the message. Matches the API's log format. */
+function log(level, msg, fields = {}) {
+  const parts = [new Date().toISOString(), level.toUpperCase(), msg];
+  for (const [k, v] of Object.entries(fields)) {
+    if (v !== undefined && v !== null) parts.push(`${k}=${v}`);
+  }
+  const line = parts.join(' ');
+  if (level === 'error') console.error(line);
+  else console.log(line);
+}
+
+const TYPES = new Map(Object.entries({
+  '.html': 'text/html; charset=utf-8',
+  '.js': 'text/javascript; charset=utf-8',
+  '.mjs': 'text/javascript; charset=utf-8',
+  '.css': 'text/css; charset=utf-8',
+  '.json': 'application/json; charset=utf-8',
+  '.map': 'application/json; charset=utf-8',
+  '.webmanifest': 'application/manifest+json; charset=utf-8',
+  '.xml': 'application/xml; charset=utf-8',
+  '.txt': 'text/plain; charset=utf-8',
+  '.svg': 'image/svg+xml',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.webp': 'image/webp',
+  '.avif': 'image/avif',
+  '.gif': 'image/gif',
+  '.ico': 'image/x-icon',
+  '.woff2': 'font/woff2',
+  '.woff': 'font/woff',
+  '.ttf': 'font/ttf',
+  '.wasm': 'application/wasm',
+}));
+
+const IMMUTABLE = 'public, max-age=31536000, immutable';
+const WEEK = 'public, max-age=604800';
+const HOUR = 'public, max-age=3600';
+/** Zero lifetime but cacheable: the client keeps the body and revalidates into a 304. */
+const REVALIDATE = 'public, max-age=0, must-revalidate';
+
+/**
+ * How long a response may be reused.
+ *
+ * Everything Vite and the card builder emit carries a content hash in its filename, so
+ * those are immutable for a year — a changed file is a changed URL. Markup is the
+ * opposite: the URLs are permanent and the bytes change on every rebuild, so it
+ * revalidates every time and the ETag below turns that into a 304 in the usual case.
+ *
+ * `/og/default.png` is the one unhashed card, served for pages that have no mint of
+ * their own, so it gets an hour rather than a year.
+ */
+export function cacheControl(urlPath, ext) {
+  if (ext === '.html') return REVALIDATE;
+  if (urlPath === '/og/default.png') return HOUR;
+  if (urlPath.startsWith('/_astro/') || urlPath.startsWith('/og/')) return IMMUTABLE;
+  if (urlPath === '/robots.txt' || urlPath === '/sitemap.xml') return HOUR;
+  return WEEK;
+}
+
+/**
+ * Turn a request path into a path inside ROOT, or null if it escapes or is malformed.
+ *
+ * Returns the *relative* path so the caller can join it against ROOT; every segment is
+ * checked rather than trusting `path.join` to have swallowed the `..`. Dotfiles are
+ * refused outright: a static build emits none, so a request for one is either a probe
+ * or a mistake, and neither should be answered with bytes.
+ */
+export function safePath(urlPath) {
+  if (urlPath.includes('\0')) return null;
+
+  const normalized = path.posix.normalize(urlPath);
+  if (!normalized.startsWith('/')) return null;
+
+  const segments = normalized.split('/').filter(Boolean);
+  for (const segment of segments) {
+    if (segment === '..' || segment.startsWith('.')) return null;
+  }
+  return segments;
+}
+
+async function statFile(file) {
+  try {
+    const stats = await fsp.stat(file);
+    return stats.isFile() ? stats : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The candidates for one request path, in order.
+ *
+ * Astro emits directory-style routes — /mints is dist/mints/index.html — and
+ * `trailingSlash: 'ignore'` means /mints and /mints/ are both the page. Trying the
+ * literal path first keeps assets a single stat; the `.html` candidate covers the flat
+ * files at the root, /404.html among them.
+ */
+export function candidates(segments) {
+  const rel = segments.join('/');
+  if (rel === '') return ['index.html'];
+  return [rel, `${rel}/index.html`, `${rel}.html`];
+}
+
+/**
+ * The 404 body for a path, and it is not always the English one.
+ *
+ * A miss under /es keeps the visitor on the Spanish 404 rather than bouncing them into
+ * English, which is the same reason `redirectToDefaultLocale` is false in the Astro
+ * config. Which prefixes count is decided by what the build actually emitted: if
+ * <prefix>/404/index.html exists, the prefix is a locale. Nothing to keep in sync.
+ */
+async function notFoundBody(segments) {
+  const first = segments[0];
+  if (first) {
+    const localized = path.join(ROOT, first, '404', 'index.html');
+    const stats = await statFile(localized);
+    if (stats) return { file: localized, stats };
+  }
+  const fallback = path.join(ROOT, '404.html');
+  const stats = await statFile(fallback);
+  return stats ? { file: fallback, stats } : null;
+}
+
+/** nginx's ETag format: hex mtime and hex size, strong. Cheap, and changes on rebuild. */
+function etagFor(stats) {
+  return `"${Math.floor(stats.mtimeMs / 1000).toString(16)}-${stats.size.toString(16)}"`;
+}
+
+/** RFC 9110: a list of entity tags, or `*`. Weak comparison is right for GET. */
+function etagMatches(header, etag) {
+  if (!header) return false;
+  if (header.trim() === '*') return true;
+  const bare = etag.replace(/^W\//, '');
+  return header
+    .split(',')
+    .map((candidate) => candidate.trim().replace(/^W\//, ''))
+    .includes(bare);
+}
+
+function notModified(req, etag, lastModified) {
+  if (etagMatches(req.headers['if-none-match'], etag)) return true;
+
+  // Only consulted when the client sent no ETag, per RFC 9110 §13.1.3.
+  if (req.headers['if-none-match']) return false;
+  const since = Date.parse(req.headers['if-modified-since'] ?? '');
+  return Number.isFinite(since) && Math.floor(lastModified / 1000) * 1000 <= since;
+}
+
+/**
+ * Headers every response carries.
+ *
+ * No CSP here on purpose. The site loads an analytics script from another origin, the
+ * review islands open websockets to whatever relays are configured and the status
+ * islands fetch whatever mint URLs the index holds, so a policy tight enough to be
+ * worth having has to be derived from those lists rather than guessed at — and a wrong
+ * one fails as a silently broken island. HSTS belongs to nginx, which is what actually
+ * terminates TLS.
+ */
+function baseHeaders() {
+  return {
+    'X-Content-Type-Options': 'nosniff',
+    'Referrer-Policy': 'strict-origin-when-cross-origin',
+    'X-Frame-Options': 'DENY',
+  };
+}
+
+function send(res, status, headers, body) {
+  res.writeHead(status, { ...baseHeaders(), ...headers });
+  res.end(body);
+}
+
+/** Stream a file, or just its headers for HEAD. */
+function sendFile(req, res, status, file, stats, urlPath) {
+  const ext = path.extname(file).toLowerCase();
+  const etag = etagFor(stats);
+
+  const headers = {
+    'Content-Type': TYPES.get(ext) ?? 'application/octet-stream',
+    'Content-Length': stats.size,
+    'Last-Modified': new Date(stats.mtimeMs).toUTCString(),
+    ETag: etag,
+    'Cache-Control': cacheControl(urlPath, ext),
+    ...baseHeaders(),
+  };
+
+  // A 304 must not carry a body or a Content-Length describing one.
+  if (status === 200 && notModified(req, etag, stats.mtimeMs)) {
+    delete headers['Content-Length'];
+    delete headers['Content-Type'];
+    res.writeHead(304, headers);
+    res.end();
+    return;
+  }
+
+  res.writeHead(status, headers);
+  if (req.method === 'HEAD') {
+    res.end();
+    return;
+  }
+
+  const stream = fs.createReadStream(file);
+  stream.on('error', (err) => {
+    log('error', 'read failed', { file, err: err.message });
+    res.destroy();
+  });
+  // Kill the read when the client hangs up mid-transfer rather than draining the file.
+  res.on('close', () => stream.destroy());
+  stream.pipe(res);
+}
+
+async function handle(req, res) {
+  if (req.method !== 'GET' && req.method !== 'HEAD') {
+    send(res, 405, { Allow: 'GET, HEAD', 'Content-Type': 'text/plain; charset=utf-8' }, 'Method Not Allowed\n');
+    return;
+  }
+
+  let urlPath;
+  try {
+    urlPath = decodeURIComponent(new URL(req.url, 'http://localhost').pathname);
+  } catch {
+    send(res, 400, { 'Content-Type': 'text/plain; charset=utf-8' }, 'Bad Request\n');
+    return;
+  }
+
+  const segments = safePath(urlPath);
+  if (!segments) {
+    send(res, 400, { 'Content-Type': 'text/plain; charset=utf-8' }, 'Bad Request\n');
+    return;
+  }
+
+  for (const candidate of candidates(segments)) {
+    const file = path.join(ROOT, candidate);
+    // Belt and braces: safePath already refused `..`, this refuses anything that still
+    // resolved outside the tree, a symlink in the build output included.
+    if (file !== ROOT && !file.startsWith(ROOT + path.sep)) break;
+
+    const stats = await statFile(file);
+    if (stats) {
+      sendFile(req, res, 200, file, stats, urlPath);
+      return;
+    }
+  }
+
+  const miss = await notFoundBody(segments);
+  if (!miss) {
+    send(res, 404, { 'Content-Type': 'text/plain; charset=utf-8', 'Cache-Control': REVALIDATE }, 'Not Found\n');
+    return;
+  }
+  // Served as a 404, not a 200 with a 404-shaped body: a soft 404 gets every typo'd
+  // URL indexed as a real page.
+  sendFile(req, res, 404, miss.file, miss.stats, urlPath);
+}
+
+export function createServer() {
+  const server = http.createServer((req, res) => {
+    handle(req, res).catch((err) => {
+      log('error', 'request failed', { path: req.url, err: err.message });
+      if (!res.headersSent) {
+        send(res, 500, { 'Content-Type': 'text/plain; charset=utf-8', 'Cache-Control': 'no-store' }, 'Internal Server Error\n');
+      } else {
+        res.destroy();
+      }
+    });
+  });
+
+  /*
+   * Longer than nginx's upstream keepalive, and headersTimeout longer still.
+   *
+   * If this end closes an idle connection at the same moment nginx reuses it, nginx has
+   * nothing to retry and reports 502. Outlasting the proxy makes the proxy always the
+   * one to close, which is the race-free direction.
+   */
+  server.keepAliveTimeout = 65_000;
+  server.headersTimeout = 66_000;
+
+  // A malformed request line should not take the process with it.
+  server.on('clientError', (err, socket) => {
+    if (err.code === 'ECONNRESET' || !socket.writable) return;
+    socket.end('HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n');
+  });
+
+  return server;
+}
+
+/**
+ * Refuse to start on an empty or unreadable root.
+ *
+ * The failure this prevents is the one that is hardest to see: a process that starts
+ * cleanly, answers every request with a 404 and looks healthy to anything watching the
+ * port. Exiting non-zero puts the reason in `systemctl status` instead.
+ */
+async function checkRoot() {
+  const index = path.join(ROOT, 'index.html');
+  if (await statFile(index)) return;
+  log('error', 'web root has no index.html', {
+    root: ROOT,
+    hint: 'a manual `pnpm build` only writes web/dist; `systemctl start cashumints-web` builds and publishes to WEB_ROOT',
+  });
+  process.exit(1);
+}
+
+/** Only when run directly, so the tests can import the pieces above. */
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  await checkRoot();
+
+  const server = createServer();
+  server.listen(PORT, HOST, () => {
+    log('info', 'site listening', { host: HOST, port: PORT, root: ROOT });
+  });
+
+  let shuttingDown = false;
+  for (const signal of ['SIGTERM', 'SIGINT']) {
+    process.on(signal, () => {
+      if (shuttingDown) return;
+      shuttingDown = true;
+      log('info', 'shutting down', { signal });
+
+      server.close(() => process.exit(0));
+      // Idle keep-alive connections would otherwise hold the close open for a minute.
+      server.closeIdleConnections();
+      setTimeout(() => {
+        server.closeAllConnections();
+        process.exit(0);
+      }, 10_000).unref();
+    });
+  }
+}

web/src/bones/mint-page.bones.json

@@ -4,7 +4,7 @@
       "name": "mint-page",
       "viewportWidth": 324,
       "width": 324,
-      "height": 327,
+      "height": 407,
       "bones": [
         [
           0,
@@ -16,14 +16,14 @@
         [
           20.9877,
           0,
-          59.2593,
+          54.4078,
           43,
           8
         ],
         [
           20.9877,
           43,
-          59.2593,
+          54.4078,
           22,
           8
         ],
@@ -102,8 +102,15 @@
           0,
           265,
           100,
-          63,
+          84,
           8
+        ],
+        [
+          0,
+          366,
+          42.284,
+          41,
+          10
         ]
       ]
     },
@@ -111,7 +118,7 @@
       "name": "mint-page",
       "viewportWidth": 712,
       "width": 712,
-      "height": 193,
+      "height": 252,
       "bones": [
         [
           0,
@@ -123,19 +130,19 @@
         [
           9.5506,
           0,
-          26.9663,
+          24.7586,
           43,
           8
         ],
         [
           9.5506,
           43,
-          26.9663,
+          24.7586,
           22,
           8
         ],
         [
-          38.764,
+          36.5564,
           18,
           10.8146,
           29,
@@ -143,7 +150,7 @@
           true
         ],
         [
-          40.4494,
+          38.2417,
           29,
           0.9831,
           7,
@@ -211,6 +218,13 @@
           100,
           42,
           8
+        ],
+        [
+          0,
+          211,
+          19.2416,
+          41,
+          10
         ]
       ]
     },
@@ -218,7 +232,7 @@
       "name": "mint-page",
       "viewportWidth": 1184,
       "width": 1184,
-      "height": 172,
+      "height": 231,
       "bones": [
         [
           0,
@@ -230,19 +244,19 @@
         [
           5.7432,
           0,
-          16.2162,
+          14.8886,
           43,
           8
         ],
         [
           5.7432,
           43,
-          16.2162,
+          14.8886,
           22,
           8
         ],
         [
-          23.3108,
+          21.9832,
           18,
           6.5034,
           29,
@@ -250,7 +264,7 @@
           true
         ],
         [
-          24.3243,
+          22.9967,
           29,
           0.5912,
           7,
@@ -318,9 +332,16 @@
           100,
           21,
           8
+        ],
+        [
+          0,
+          190,
+          11.5709,
+          41,
+          10
         ]
       ]
     }
   },
-  "_hash": "f3f7f7e86a10ecca631b74af17fb0335"
+  "_hash": "e76f6212eab4b1517002712803fae94e"
 }

web/src/bones/reviews-panel.bones.json

@@ -4,132 +4,181 @@
       "name": "reviews-panel",
       "viewportWidth": 322,
       "width": 322,
-      "height": 727,
+      "height": 876,
       "bones": [
         [
           6.2112,
-          20,
+          18,
           11.8012,
           38,
           "50%"
         ],
         [
           22.9814,
-          19,
+          17,
           32.6087,
           22,
           8
         ],
         [
           22.9814,
-          41,
+          39,
           70.8075,
-          16,
+          17,
           5
         ],
         [
           22.9814,
-          70,
+          68,
           20.429,
           16,
           8
         ],
         [
-          46.5159,
-          68,
+          45.8948,
+          66,
+          0.9317,
+          20,
+          8
+        ],
+        [
+          49.3109,
+          66,
           11.8012,
-          19,
+          20,
           8
         ],
         [
           22.9814,
-          98,
+          96,
           70.8075,
-          116,
+          144,
+          8
+        ],
+        [
+          22.9814,
+          246,
+          70.8075,
+          27,
           8
         ],
         [
           6.2112,
-          255,
+          310,
           11.8012,
           38,
           "50%"
         ],
         [
           22.9814,
-          254,
+          309,
           23.6025,
           22,
           8
         ],
         [
           22.9814,
-          277,
+          331,
           70.8075,
-          16,
+          17,
           5
         ],
         [
           22.9814,
-          305,
+          360,
           20.429,
           16,
           8
         ],
         [
-          46.5159,
-          303,
+          45.8948,
+          358,
+          0.9317,
+          20,
+          8
+        ],
+        [
+          49.3109,
+          358,
           12.1118,
-          19,
+          20,
           8
         ],
         [
           22.9814,
-          333,
+          388,
           70.8075,
-          116,
+          120,
+          8
+        ],
+        [
+          22.9814,
+          514,
+          70.8075,
+          27,
           8
         ],
         [
           6.2112,
-          490,
+          578,
           11.8012,
           38,
           "50%"
         ],
         [
           22.9814,
-          489,
+          577,
           31.0559,
           22,
           8
         ],
         [
           22.9814,
-          512,
+          599,
           70.8075,
-          16,
+          17,
           5
         ],
         [
           22.9814,
-          540,
+          628,
           20.429,
           16,
           8
         ],
         [
-          46.5159,
-          538,
+          45.8948,
+          626,
+          0.9317,
+          20,
+          8
+        ],
+        [
+          49.3109,
+          626,
           12.7329,
-          19,
+          20,
           8
         ],
         [
           22.9814,
-          568,
+          656,
           70.8075,
-          139,
+          144,
+          8
+        ],
+        [
+          22.9814,
+          806,
+          20.8075,
+          17,
+          8
+        ],
+        [
+          22.9814,
+          831,
+          70.8075,
+          27,
           8
         ]
       ]
@@ -138,132 +187,174 @@
       "name": "reviews-panel",
       "viewportWidth": 710,
       "width": 710,
-      "height": 455,
+      "height": 533,
       "bones": [
         [
           2.8169,
-          20,
+          18,
           5.3521,
           38,
           "50%"
         ],
         [
           10.4225,
-          21,
+          17,
           14.7887,
           22,
           8
         ],
         [
           10.4225,
-          43,
-          75.2421,
-          16,
+          39,
+          67.7773,
+          17,
           5
         ],
         [
-          87.9181,
-          22,
+          80.4533,
+          21,
           9.265,
           16,
           8
         ],
         [
-          91.831,
-          42,
-          5.3521,
+          90.5634,
           19,
+          0.4225,
+          20,
+          8
+        ],
+        [
+          91.831,
+          19,
+          5.3521,
+          20,
           8
         ],
         [
           10.4225,
-          77,
+          68,
+          82.3944,
+          48,
+          8
+        ],
+        [
+          10.4225,
+          124,
           86.7606,
-          46,
+          27,
           8
         ],
         [
           2.8169,
-          164,
+          188,
           5.3521,
           38,
           "50%"
         ],
         [
           10.4225,
-          165,
+          187,
           10.7042,
           22,
           8
         ],
         [
           10.4225,
-          187,
-          75.2421,
-          16,
+          209,
+          67.6364,
+          17,
           5
         ],
         [
-          87.9181,
-          166,
+          80.3125,
+          191,
           9.265,
           16,
           8
         ],
+        [
+          90.4225,
+          189,
+          0.4225,
+          20,
+          8
+        ],
         [
           91.6901,
-          186,
+          189,
           5.493,
-          19,
+          20,
           8
         ],
         [
           10.4225,
-          221,
+          238,
+          82.3944,
+          48,
+          8
+        ],
+        [
+          10.4225,
+          294,
           86.7606,
-          46,
+          27,
           8
         ],
         [
           2.8169,
-          308,
+          358,
           5.3521,
           38,
           "50%"
         ],
         [
           10.4225,
-          309,
+          357,
           14.0845,
           22,
           8
         ],
         [
           10.4225,
-          331,
-          75.2421,
-          16,
+          379,
+          67.3548,
+          17,
           5
         ],
         [
-          87.9181,
-          310,
+          80.0308,
+          361,
           9.265,
           16,
           8
         ],
+        [
+          90.1408,
+          359,
+          0.4225,
+          20,
+          8
+        ],
         [
           91.4085,
-          330,
+          359,
           5.7746,
-          19,
+          20,
           8
         ],
         [
           10.4225,
-          365,
+          408,
+          82.3944,
+          72,
+          8
+        ],
+        [
+          10.4225,
+          488,
           86.7606,
-          70,
+          27,
           8
         ]
       ]
@@ -272,136 +363,178 @@
       "name": "reviews-panel",
       "viewportWidth": 784,
       "width": 784,
-      "height": 431,
+      "height": 533,
       "bones": [
         [
           2.551,
-          20,
+          18,
           4.8469,
           38,
           "50%"
         ],
         [
           9.4388,
-          21,
+          17,
           13.3929,
           22,
           8
         ],
         [
           9.4388,
-          43,
-          77.5789,
-          16,
+          39,
+          70.8187,
+          17,
           5
         ],
         [
-          89.0585,
-          22,
+          82.2983,
+          21,
           8.3905,
           16,
           8
         ],
         [
-          92.602,
-          42,
-          4.8469,
+          91.4541,
           19,
+          0.3827,
+          20,
+          8
+        ],
+        [
+          92.602,
+          19,
+          4.8469,
+          20,
           8
         ],
         [
           9.4388,
-          77,
+          68,
+          74.6173,
+          48,
+          8
+        ],
+        [
+          9.4388,
+          124,
           88.0102,
-          46,
+          27,
           8
         ],
         [
           2.551,
-          164,
+          188,
           4.8469,
           38,
           "50%"
         ],
         [
           9.4388,
-          165,
+          187,
           9.6939,
           22,
           8
         ],
         [
           9.4388,
-          187,
-          77.5789,
-          16,
+          209,
+          70.6912,
+          17,
           5
         ],
         [
-          89.0585,
-          166,
+          82.1708,
+          191,
           8.3905,
           16,
           8
         ],
+        [
+          91.3265,
+          189,
+          0.3827,
+          20,
+          8
+        ],
         [
           92.4745,
-          186,
+          189,
           4.9745,
-          19,
+          20,
           8
         ],
         [
           9.4388,
-          221,
+          238,
+          74.6173,
+          48,
+          8
+        ],
+        [
+          9.4388,
+          294,
           88.0102,
-          46,
+          27,
           8
         ],
         [
           2.551,
-          308,
+          358,
           4.8469,
           38,
           "50%"
         ],
         [
           9.4388,
-          309,
+          357,
           12.7551,
           22,
           8
         ],
         [
           9.4388,
-          331,
-          77.5789,
-          16,
+          379,
+          70.4361,
+          17,
           5
         ],
         [
-          89.0585,
-          310,
+          81.9157,
+          361,
           8.3905,
           16,
           8
         ],
+        [
+          91.0714,
+          359,
+          0.3827,
+          20,
+          8
+        ],
         [
           92.2194,
-          330,
+          359,
           5.2296,
-          19,
+          20,
           8
         ],
         [
           9.4388,
-          365,
+          408,
+          74.6173,
+          72,
+          8
+        ],
+        [
+          9.4388,
+          488,
           88.0102,
-          46,
+          27,
           8
         ]
       ]
     }
   },
-  "_hash": "788093c50463a4ad673ece50c6db52da"
+  "_hash": "d9fb0ac370be8e706ff4dfea00b0081b"
 }

web/src/components/CopyableId.astro

@@ -32,12 +32,14 @@ const t = useI18n(locale);
 const { value, label, kind = t('mint.kind.identifier'), class: className } = Astro.props;
 ---
 
+{/* The accessible name repeats the visible text: a voice-control user says what
+    they see, and a name that omits it cannot be spoken at. */}
 <button
   type="button"
   class:list={['cid', className]}
   data-copy-id={value}
   title={value}
-  aria-label={t('common.copyFull', { kind })}
+  aria-label={`${label ?? value}: ${t('common.copyFull', { kind })}`}
 >
   <span class="cid-text">{label ?? value}</span>
 </button>

web/src/components/Footer.astro

@@ -1,5 +1,23 @@
 ---
+/**
+ * The site footer: one component, every page, three zones.
+ *
+ * Zone one is four columns — who this is, then the two link groups people actually
+ * navigate to, then the language control. Zone two is a thin bar with the copyright
+ * and the credit, and nothing else: the moment anything else moves into that row it
+ * stops being a signature and starts being a fourth navigation surface.
+ *
+ * What used to be here was four flat rows, the last of which was ~20 raw language
+ * links wrapped over two lines. That wall is now the same switcher the header carries
+ * (see LanguageSwitcher.astro, `placement="footer"`), so there is one language control
+ * on the site in two places rather than two controls that happen to agree.
+ *
+ * Everything below is static per locale and prerenders. No hex, no npub, no counts,
+ * nothing fetched: the footer is the one region of every page that must be identical
+ * on the home page and on a mint page that failed to load.
+ */
 import LanguageSwitcher from './LanguageSwitcher.astro';
+import Moai from './Moai.astro';
 import { localePath, useI18n } from '../i18n';
 import { pageLocale } from '../i18n/paths';
 
@@ -9,23 +27,29 @@ const GITHUB = 'https://github.com/Azzamo-net/cashumints.space';
 const { locale } = pageLocale(Astro);
 const t = useI18n(locale);
 
-/**
- * Two rows: the pages people navigate to, then the ones they go looking for. The
- * disclaimer sits in the second row here and again at the bottom of every mint page,
- * which is where the decision it is about actually gets made.
+/*
+ * Route slugs stay English in every language and `localePath` adds the prefix, exactly
+ * as the header does. See src/i18n/routing.ts for why that trade was made.
  */
-const nav = [
-  { path: '/mints', label: t('footer.allMints') },
-  { path: '/fedimints', label: t('footer.allFedimints') },
-  { path: '/reviews', label: t('footer.allReviews') },
-  { path: '/wallets', label: t('footer.wallets') },
-  { path: '/about', label: t('footer.about') },
+const explore = [
+  { href: localePath('/mints', locale), label: t('footer.allMints') },
+  { href: localePath('/fedimints', locale), label: t('footer.allFedimints') },
+  { href: localePath('/lnurl-mints', locale), label: t('footer.allLnurlMints') },
+  { href: localePath('/reviews', locale), label: t('footer.allReviews') },
+  { href: localePath('/wallets', locale), label: t('footer.wallets') },
 ];
 
-const legal = [
-  { path: '/disclaimer', label: t('footer.disclaimer') },
-  { path: '/terms', label: t('footer.terms') },
-  { path: '/privacy', label: t('footer.privacy') },
+/*
+ * GitHub sits in this column rather than beside the credit line because it is a place
+ * to go, not a signature. It is the only external link in the columns, so it carries
+ * `rel="noopener"` and nothing else needs to.
+ */
+const site = [
+  { href: localePath('/about', locale), label: t('footer.about'), external: false },
+  { href: GITHUB, label: 'GitHub', external: true },
+  { href: localePath('/terms', locale), label: t('footer.terms'), external: false },
+  { href: localePath('/privacy', locale), label: t('footer.privacy'), external: false },
+  { href: localePath('/disclaimer', locale), label: t('footer.disclaimer'), external: false },
 ];
 
 /*
@@ -39,31 +63,65 @@ const madeBy = t('footer.madeBy', {
 });
 ---
 
-<footer>
-  <div class="foot-inner">
+<footer class="site-footer" role="contentinfo">
+  <div class="foot-cols">
+    {/*
+      The brand column. The custodial warning lives here, under the description,
+      because it is the most honest sentence on the site and it was previously an
+      orphan floating at the bottom right of the last row. It is set in `--muted`
+      rather than `--faint`: quiet, but a step louder than the link columns, which is
+      the only typographic claim this footer makes about relative importance.
+    */}
+    <div class="foot-brand">
+      <a class="foot-mark" href={localePath('/', locale)}>
+        <Moai size={20} />
+        <span>Cashumints.space</span>
+      </a>
+      <p class="foot-desc">{t('footer.tagline')}</p>
+      <p class="foot-warn">{t('footer.warning')}</p>
+    </div>
+
+    {/*
+      One nav landmark over both link columns, not one per column: a screen reader
+      listing landmarks should find "Footer", not "Footer" twice. The language control
+      carries its own nav, because it is a different kind of thing — it does not take
+      you to another page, it takes you to this page again.
+    */}
+    <nav class="foot-nav" aria-label={t('footer.nav')}>
+      <div class="foot-col">
+        <h2 class="foot-head">{t('footer.col.explore')}</h2>
+        <ul>
+          {explore.map((link) => (
+            <li><a href={link.href}>{link.label}</a></li>
+          ))}
+        </ul>
+      </div>
+
+      <div class="foot-col">
+        <h2 class="foot-head">{t('footer.col.site')}</h2>
+        <ul>
+          {site.map((link) => (
+            <li>
+              <a href={link.href} rel={link.external ? 'noopener' : undefined}>{link.label}</a>
+            </li>
+          ))}
+        </ul>
+      </div>
+    </nav>
+
+    <div class="foot-col foot-lang">
+      <h2 class="foot-head">{t('lang.label')}</h2>
+      <LanguageSwitcher placement="footer" />
+    </div>
+  </div>
+
+  {/*
+    The bottom bar. Two items, and the discipline is that it stays two items: the
+    copyright and who made it. Everything else that was ever tempted into this row now
+    has a column above it.
+  */}
+  <div class="foot-bar">
     <span>{t('footer.copyright', { year: String(year) })}</span>
-    <div class="links">
-      <a href={GITHUB} rel="noopener">GitHub</a>
-      {nav.map((link) => <a href={localePath(link.path, locale)}>{link.label}</a>)}
-    </div>
-    <span class="foot-right" set:html={madeBy} />
-  </div>
-  <div class="foot-inner foot-legal">
-    <div class="links">
-      {legal.map((link) => <a href={localePath(link.path, locale)}>{link.label}</a>)}
-    </div>
-    <LanguageSwitcher variant="inline" />
-    <span class="foot-right foot-warn">{t('footer.warning')}</span>
+    <span class="foot-credit" set:html={madeBy} />
   </div>
 </footer>
-
-<style>
-  /* The second row is quieter than the first and has no top border of its own: it
-     reads as a continuation of the footer, not a second footer. */
-  .foot-legal { padding-top: 0; border-top: none; font-size: 12.5px; }
-  .foot-warn { color: var(--faint); }
-
-  @media (max-width: 640px) {
-    .foot-legal { padding-top: 4px; }
-  }
-</style>

web/src/components/LanguageSwitcher.astro

@@ -1,12 +1,17 @@
 ---
 /**
- * The language switcher, in two shapes.
+ * The language switcher. One control, two placements.
  *
- * `menu` is the header control: a compact button showing the current language's code,
- * opening a list of the three. `inline` is the footer's plain row of three links. Both
- * are built from the same list and the same hrefs, because they are the same control
- * and a reader who finds one and then the other should not have to work out whether
- * they do the same thing.
+ * `bar` is the header's: a compact button showing the current language's code. `footer`
+ * is the Language column's: the same button, showing the language's full name, opening
+ * upward so the panel is never clipped off the bottom of the document. Same list, same
+ * hrefs, same markup, same script — the only differences are which label the trigger
+ * shows and which way the panel opens, because a reader who finds one and then the
+ * other should not have to work out whether they do the same thing.
+ *
+ * The footer used to carry a second, different control: every locale as a flat link,
+ * ~20 of them wrapped over two rows. That was not a switcher, it was a wall, and it
+ * grew by one row every time a language was added.
  *
  * Text, not flags, in both. A flag is a country: Spanish is not Spain, Dutch is not the
  * Netherlands, and English belongs to nobody in particular. Each language is written in
@@ -15,22 +20,24 @@
  * Every link points at this same page in that language, built from the unprefixed path,
  * so this works identically on a mint page: /mint/kashu.me and /es/mint/kashu.me are
  * the same mint. There is no "switch to Spanish and land on the home page" case, which
- * is the usual failure of a switcher that only knows about the site root.
+ * is the usual failure of a switcher that only knows about the site root. They are real
+ * `<a href>` elements, so a crawler follows them and a reader with no JavaScript uses
+ * them.
  *
- * The header shape is a `<details>` rather than a scripted dropdown. It opens, closes
- * and takes the keyboard with no JavaScript at all, which matters because the whole
- * point of this control is being able to leave a page you cannot read. The script below
- * only adds what `<details>` does not do by itself: closing on Escape and on a click
- * elsewhere.
+ * The control is a `<details>` rather than a scripted dropdown. It opens, closes and
+ * takes the keyboard with no JavaScript at all, which matters because the whole point
+ * of this control is being able to leave a page you cannot read. The script below only
+ * adds what `<details>` does not do by itself: closing on Escape and on a click
+ * elsewhere, and filtering the list as you type.
  */
-import { LOCALES, localePath, useI18n } from '../i18n';
+import { LOCALES, localePath, localeInfo, useI18n } from '../i18n';
 import { pageLocale } from '../i18n/paths';
 
 interface Props {
-  /** `menu` is the header control; `inline` is the footer row. */
-  variant?: 'menu' | 'inline';
+  /** `bar` is the header control; `footer` is the one in the Language column. */
+  placement?: 'bar' | 'footer';
 }
-const { variant = 'inline' } = Astro.props;
+const { placement = 'bar' } = Astro.props;
 
 const { locale, path } = pageLocale(Astro);
 const t = useI18n(locale);
@@ -43,40 +50,71 @@ const links = LOCALES.map((other) => ({
 }));
 
 /*
- * Two letters in the header, because the full name of the current language is a word
- * the reader already knows they are reading. The code is the locale's own, uppercased,
- * so a fourth language needs nothing added here.
+ * The header shows two letters, because the full name of the current language is a word
+ * the reader already knows they are reading, and the header row is full. The footer
+ * column has the width for the name and no adjacent nav to crowd, and a column headed
+ * "Language" reads better with "Nederlands" under it than with "NL".
  */
-const currentCode = locale.toUpperCase();
+const trigger = placement === 'footer' ? localeInfo(locale).label : locale.toUpperCase();
+
+/*
+ * The search field earns its place at 20-odd languages and is noise at three. It is
+ * the one part of this control that needs JavaScript, so it is also the one part that
+ * is allowed to be absent: every link is in the panel either way.
+ */
+const searchable = LOCALES.length > 8;
 ---
 
-{
-  variant === 'menu' ? (
-    <details class="lang-menu" data-lang-menu>
+<details class={`lang-menu lang-${placement}`} data-lang-menu>
   <summary aria-haspopup="true">
     <svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" aria-hidden="true">
       <circle cx="12" cy="12" r="9" />
       <path d="M3 12h18M12 3a15 15 0 0 1 4 9 15 15 0 0 1-4 9 15 15 0 0 1-4-9 15 15 0 0 1 4-9Z" />
     </svg>
-        {/* The code alone does not say what it is, so the label is in the tree for a
-            screen reader and out of the way for everyone else. */}
+    {/* The trigger label does not say what it is on its own, so the word is in the
+        accessibility tree and out of the way for everyone else. */}
     <span class="sr-only">{t('lang.label')}</span>
-        <span class="lang-code">{currentCode}</span>
+    <span class="lang-current">{trigger}</span>
     <svg class="lang-caret" width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" aria-hidden="true">
       <path d="m6 9 6 6 6-6" />
     </svg>
   </summary>
 
+  <div class="lang-panel">
+    {searchable && (
+      <div class="lang-search">
+        <svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" aria-hidden="true">
+          <circle cx="11" cy="11" r="7" />
+          <path d="m20 20-3.5-3.5" />
+        </svg>
+        <input
+          type="search"
+          placeholder={`${t('lang.label')}…`}
+          aria-label={t('lang.switcher')}
+          autocomplete="off"
+          spellcheck="false"
+          data-lang-search
+        />
+      </div>
+    )}
     <nav class="lang-list" aria-label={t('lang.switcher')}>
       {
+        /*
+         * The current language is still a link, and it goes where it says it goes.
+         * `aria-current` is what tells a screen reader it is where you already are; the
+         * weight and the tick are what tell everyone else.
+         */
         links.map((other) => (
           <a
             href={other.href}
             hreflang={other.code}
             lang={other.code}
             aria-current={other.current ? 'true' : undefined}
+            data-lang-option
+            data-search={`${other.label} ${other.code}`}
           >
             <span>{other.label}</span>
+            <span class="lang-option-code">{other.code.toUpperCase()}</span>
             {other.current && (
               <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" aria-hidden="true">
                 <path d="m5 13 4 4L19 7" />
@@ -86,33 +124,10 @@ const currentCode = locale.toUpperCase();
         ))
       }
     </nav>
+  </div>
 </details>
-  ) : (
-    <nav class="lang-switch" aria-label={t('lang.switcher')}>
-      {
-        /*
-         * The current language is still a link, and it goes where it says it goes.
-         * `aria-current` is what tells a screen reader it is where you already are, and
-         * the weight is what tells everyone else.
-         */
-        links.map((other) => (
-          <a
-            href={other.href}
-            hreflang={other.code}
-            lang={other.code}
-            aria-current={other.current ? 'true' : undefined}
-          >
-            {other.label}
-          </a>
-        ))
-      }
-    </nav>
-  )
-}
 
 <style>
-  /* ---------- the header control ---------- */
-
   .lang-menu { position: relative; flex-shrink: 0; }
 
   .lang-menu summary {
@@ -129,28 +144,62 @@ const currentCode = locale.toUpperCase();
   .lang-menu summary:hover { color: var(--text); background: var(--card2); }
   .lang-menu[open] summary { color: var(--text); background: var(--card2); }
 
-  .lang-code { font-family: var(--mono); font-size: 12.5px; letter-spacing: .04em; }
   .lang-caret { color: var(--faint); transition: transform var(--dur-quick) var(--ease-out); }
   .lang-menu[open] .lang-caret { transform: rotate(180deg); }
 
   /* The same panel the account menu uses, so the two controls beside each other in the
      header open into the same shape. */
-  .lang-list {
-    position: absolute; top: calc(100% + 8px); right: 0; z-index: 60;
-    min-width: 168px;
+  .lang-panel {
+    position: absolute; z-index: 60;
+    width: min(260px, calc(100vw - 24px));
     background: var(--card); border: 1px solid var(--line); border-radius: 12px;
-    padding: 6px; display: flex; flex-direction: column; gap: 2px;
+    padding: 6px;
     box-shadow: 0 18px 40px rgba(0, 0, 0, .45);
   }
+  .lang-search {
+    display: flex; align-items: center; gap: 8px;
+    min-height: 40px; padding: 0 10px;
+    color: var(--faint); background: var(--card2);
+    border: 1px solid var(--line); border-radius: 8px;
+  }
+  .lang-search:focus-within {
+    color: var(--text);
+    border-color: var(--amber);
+    box-shadow: 0 0 0 2px color-mix(in srgb, var(--amber) 18%, transparent);
+  }
+  .lang-search input {
+    width: 100%; min-width: 0; padding: 9px 0;
+    border: 0; outline: 0; background: transparent;
+    color: var(--text); font: inherit; font-size: 13.5px;
+  }
+  .lang-search input::placeholder { color: var(--faint); opacity: 1; }
+  .lang-search input::-webkit-search-cancel-button { cursor: pointer; }
+  .lang-list {
+    max-height: min(360px, calc(100dvh - 150px));
+    display: flex; flex-direction: column; gap: 2px;
+    overflow-y: auto; overscroll-behavior: contain;
+    scrollbar-width: thin; scrollbar-color: var(--line) transparent;
+  }
+  .lang-search + .lang-list { margin-top: 6px; padding-right: 2px; }
   .lang-list a {
     display: flex; align-items: center; gap: 8px;
     padding: 8px 10px; border-radius: 8px;
     font-size: 13.5px; color: var(--muted);
     transition: color .15s, background .15s;
   }
+  .lang-list a[hidden] { display: none; }
   .lang-list a:hover { color: var(--text); background: var(--card2); }
   .lang-list a[aria-current] { color: var(--text); font-weight: 600; }
-  .lang-list a svg { margin-left: auto; color: var(--amber); flex-shrink: 0; }
+  .lang-option-code {
+    margin-left: auto; color: var(--faint);
+    font-family: var(--mono); font-size: 10.5px; letter-spacing: .04em;
+  }
+  .lang-list a svg { color: var(--amber); flex-shrink: 0; }
+
+  /* ---------- the header placement ---------- */
+
+  .lang-bar .lang-current { font-family: var(--mono); font-size: 12.5px; letter-spacing: .04em; }
+  .lang-bar .lang-panel { top: calc(100% + 8px); right: 0; }
 
   /*
    * Narrow: the globe alone.
@@ -162,40 +211,63 @@ const currentCode = locale.toUpperCase();
    * accessible name stays either way, because it was never the visible text.
    */
   @media (max-width: 760px) {
-    .lang-menu summary { padding: 7px 8px; gap: 0; }
-    .lang-code,
-    .lang-caret { display: none; }
+    .lang-bar summary { padding: 7px 8px; gap: 0; }
+    .lang-bar .lang-current,
+    .lang-bar .lang-caret { display: none; }
   }
   @media (max-width: 420px) {
-    .lang-menu summary { padding: 6px 6px; }
+    .lang-bar summary { padding: 6px 6px; }
   }
 
-  /* ---------- the footer row ---------- */
+  /* ---------- the footer placement ---------- */
 
-  .lang-switch { display: flex; align-items: center; gap: 12px; flex-wrap: wrap; }
-  .lang-switch a {
-    font-size: 12.5px; color: var(--faint);
-    transition: color var(--dur-quick);
-  }
-  .lang-switch a:hover { color: var(--text); }
-  .lang-switch a[aria-current] { color: var(--text); font-weight: 600; }
+  /*
+   * Aligned with the column's other text rather than inset by the trigger's padding,
+   * so the globe sits on the same vertical line as the "Language" heading above it and
+   * the links in the columns beside it.
+   */
+  .lang-footer { display: inline-block; margin-inline-start: -10px; }
+  .lang-footer summary { font-size: 13.5px; }
+  .lang-footer .lang-current { font-weight: 500; }
+
+  /*
+   * Opens upward. The control is a few hundred pixels from the bottom of the document,
+   * so a panel hanging below it would be a scroll into empty space at best and clipped
+   * at worst. `inset-inline-start: 0` rather than `left`, because two of the shipped
+   * locales are right-to-left and the panel should hang from the trigger's leading
+   * edge in both directions.
+   */
+  .lang-footer .lang-panel { bottom: calc(100% + 8px); inset-inline-start: 0; }
+  .lang-footer .lang-list { max-height: min(300px, calc(100dvh - 200px)); }
 </style>
 
 <script>
   import { onReady } from '../scripts/reveal';
 
   /**
-   * The two things `<details>` does not do on its own.
+   * The three things `<details>` does not do on its own.
    *
    * Everything else about this control (open, close, keyboard, focus) is the element's
    * own behaviour and works with this script blocked, which is the point of using one.
    *
    * Attached to the document once rather than to the element, because the view
-   * transition router replaces the header on every navigation and a per-element
-   * listener would be re-bound, and leak, once per page visited.
+   * transition router replaces the header and the footer on every navigation and a
+   * per-element listener would be re-bound, and leak, once per page visited. One
+   * listener set serves both placements.
    */
   let wired = false;
 
+  const normalise = (value: string): string =>
+    value.normalize('NFKD').replace(/\p{Diacritic}/gu, '').toLocaleLowerCase().trim();
+
+  const resetSearch = (menu: HTMLDetailsElement): void => {
+    const input = menu.querySelector<HTMLInputElement>('[data-lang-search]');
+    if (input) input.value = '';
+    for (const option of menu.querySelectorAll<HTMLElement>('[data-lang-option]')) {
+      option.hidden = false;
+    }
+  };
+
   const closeAll = (except?: Element | null): void => {
     for (const menu of document.querySelectorAll<HTMLDetailsElement>('[data-lang-menu][open]')) {
       if (menu !== except) menu.open = false;
@@ -221,5 +293,28 @@ const currentCode = locale.toUpperCase();
       // Back to the control that opened it, not to the top of the document.
       open.querySelector('summary')?.focus();
     });
+
+    document.addEventListener('input', (event) => {
+      const input = (event.target as Element | null)?.closest<HTMLInputElement>('[data-lang-search]');
+      if (!input) return;
+      const menu = input.closest<HTMLDetailsElement>('[data-lang-menu]');
+      if (!menu) return;
+      const query = normalise(input.value);
+      for (const option of menu.querySelectorAll<HTMLElement>('[data-lang-option]')) {
+        option.hidden = !normalise(option.dataset.search ?? '').includes(query);
+      }
+    });
+
+    // `toggle` does not bubble, so capture it. Starting in the search field makes a
+    // long language list keyboard-friendly; clearing on close keeps every reopen useful.
+    document.addEventListener('toggle', (event) => {
+      const menu = event.target as HTMLDetailsElement;
+      if (!menu.matches?.('[data-lang-menu]')) return;
+      if (menu.open) {
+        requestAnimationFrame(() => menu.querySelector<HTMLInputElement>('[data-lang-search]')?.focus());
+      } else {
+        resetSearch(menu);
+      }
+    }, true);
   });
 </script>

web/src/components/LoginDialog.astro

@@ -103,6 +103,14 @@ const t = useI18n(locale);
 
       <div class="login-qr" data-connect-qr></div>
 
+      {/*
+        The same pairing link the QR carries, as something to tap. A reader whose
+        signer app is on the device they are reading on cannot scan their own screen;
+        this hands the link straight to the app instead. The href is set when the
+        pairing starts: nostrconnect:// for any signer, primalconnect:// for Primal.
+      */}
+      <a class="btn login-open-app" data-connect-open hidden></a>
+
       <div class="login-uri">
         <span class="mono" data-connect-uri></span>
         <button type="button" class="copy-btn" data-connect-copy data-copy="" aria-label={t('login.copyLink')} hidden>

web/src/components/MintCard.astro

@@ -1,9 +1,10 @@
 ---
 import {
-  federationIdFromSlug, getMintWarnings, mintChip,
-  type MintCapabilities, type MintListItem,
+  baseUrlFromKey, federationIdFromSlug, getMintWarnings, mintChip,
+  type LnurlDetail, type MintCapabilities, type MintListItem,
 } from '@cashumints/shared';
 import { iconUrl } from '../lib/api';
+import { targetPath } from '../lib/feed-resolve';
 import { displayDomain, iconGradient, initials, transitionName } from '../lib/format';
 import { localePath, useI18n } from '../i18n';
 import { formatters, starString } from '../i18n/format';
@@ -28,28 +29,43 @@ interface Props {
    * from the detail it already has. Left off, the card simply has no chip.
    */
   capabilities?: MintCapabilities | null;
+  /**
+   * The LNURL states a chip can be drawn from, for a caller that already has the
+   * detail. The Cashu counterpart is `capabilities` above, and this is separate rather
+   * than merged with it because the two ecosystems' chips are read from entirely
+   * different facts: NUT switches there, an advertised withdraw ceiling and a reachable
+   * Lightning node here. Left off, an LNURL card simply has no chip.
+   */
+  lnurl?: Pick<LnurlDetail, 'max_withdrawable_msat' | 'funding_available'> | null;
 }
 
-const { mint, rank, sentiment, revealDelay, capabilities } = Astro.props;
+const { mint, rank, sentiment, revealDelay, capabilities, lnurl } = Astro.props;
 
 const { locale } = pageLocale(Astro);
 const t = useI18n(locale);
 const f = formatters(t);
 
 /*
- * One card, both ecosystems.
+ * One card, all three ecosystems.
  *
  * A federation has no URL, so the second line cannot be a domain: `fedimint:aeca6c…`
  * is a database key and means nothing to a reader. It shows the federation id instead,
  * shortened, which is the thing that actually identifies it — and which is what the
  * search box below matches on, so pasting an id finds its federation.
  *
+ * An LNURL mint does have a URL, but its row key carries an `lnurl:` scheme in front of
+ * it, so the domain comes out of the key rather than off it directly. A reader should
+ * see `lnurl.21mint.me`, not `lnurl:https://lnurl.21mint.me`.
+ *
  * Everything else on the card is identical, and deliberately: rating, review count,
- * sentiment bar and status all mean the same thing for both, and a reader moving
- * between /mints and /fedimints should not have to re-learn a card.
+ * sentiment bar and status all mean the same thing for all three, and a reader moving
+ * between the three indexes should not have to re-learn a card.
  */
 const fedimint = mint.type === 'fedimint';
-const domain = fedimint ? federationIdFromSlug(mint.host) : displayDomain(mint.url);
+const lnurlBase = baseUrlFromKey(mint.url);
+const domain = fedimint
+  ? federationIdFromSlug(mint.host)
+  : displayDomain(lnurlBase ?? mint.url);
 const name = fedimint
   ? mint.name ?? t('card.unnamedFederation')
   : mint.name ?? domain.split('/')[0] ?? domain;
@@ -57,7 +73,9 @@ const icon = iconUrl(mint.icon);
 const offline = mint.status === 'offline';
 /** Announced on Nostr and never confirmed by any check. Federations only. */
 const announced = mint.status === 'announced';
-const href = localePath(`${fedimint ? '/fedimint' : '/mint'}/${mint.host}`, locale);
+// One route per ecosystem, from the same table the review feed's links use, so a card
+// and a feed row can never disagree about where a listing lives.
+const href = localePath(targetPath(mint), locale);
 
 /*
   Two words at most. Offline already has its own card styling, so only the states a
@@ -65,14 +83,18 @@ const href = localePath(`${fedimint ? '/fedimint' : '/mint'}/${mint.host}`, loca
   cannot pay back out, or one that has stopped moving sats in either direction. The
   mint page carries the explanation.
 */
-const chip = capabilities
-  ? mintChip(
-      getMintWarnings(
-        { status: mint.status, last_online: mint.last_online, capabilities },
-        warningOptions(f),
-      ),
-      chipStrings(t),
-    )
+const chipSource = capabilities || lnurl
+  ? {
+      type: mint.type,
+      status: mint.status,
+      last_online: mint.last_online,
+      capabilities: capabilities ?? null,
+      ...(lnurl ?? {}),
+    }
+  : null;
+
+const chip = chipSource
+  ? mintChip(getMintWarnings(chipSource, warningOptions(f)), chipStrings(t))
   : null;
 
 const status = statusLabel(mint.status, t);

web/src/components/MintLive.astro

@@ -11,11 +11,12 @@
  * the same code that prerendered them, so a live upgrade can never leave the three
  * disagreeing with each other.
  *
- * Both a mint page and a federation page mount this, unchanged. It fetches the same
- * endpoint for both and updates whichever of the four regions the page actually has:
- * a federation has no limits cell and no NUT rows, and a mint has no modules panel, so
- * each lookup simply misses. `getMintWarnings` branches on the `type` in the payload,
- * so a fresh read can never put a Cashu banner on a federation.
+ * All three ecosystems' pages mount this, unchanged. It fetches the same endpoint for
+ * every one of them and updates whichever regions the page actually has: a federation
+ * has no limits cell and no NUT rows, an LNURL mint has features rather than NUTs and
+ * withdraw bounds rather than mint limits, and a Cashu mint has neither of the other
+ * two panels — so each lookup simply misses. `getMintWarnings` branches on the `type` in
+ * the payload, so a fresh read can never put one ecosystem's banner on another's page.
  */
 interface Props {
   host: string;
@@ -26,15 +27,18 @@ const { host } = Astro.props;
 <span data-mint-live={host} hidden></span>
 
 <script>
-  import { getMintWarnings, readCapabilities, type MintWarning } from '@cashumints/shared';
+  import {
+    displayFeatures, getMintWarnings, readCapabilities, type MintWarning,
+  } from '@cashumints/shared';
   import { apiBase } from '../lib/client';
   import { bannerHtml, limitsHtml, nutRowsHtml } from '../lib/mint-state';
   import { moduleRowsHtml } from '../lib/fedimint-ui';
+  import { featureRowsHtml, withdrawLimitsHtml } from '../lib/lnurl-ui';
   import { useI18n } from '../i18n/client';
   import { formatters, type Formatters } from '../i18n/format';
   import { statusLabel, warningOptions } from '../i18n/mint';
   import { onReady, prefersReducedMotion } from '../scripts/reveal';
-  import type { MintDetail } from '@cashumints/shared';
+  import type { LnurlDetail, MintDetail } from '@cashumints/shared';
 
   function remove(el: Element): void {
     el.classList.add('leaving');
@@ -85,7 +89,7 @@ const { host } = Astro.props;
   }
 
   /** Keep the places that repeat the banner's facts in step with it. */
-  function renderCapabilities(mint: MintDetail, f: Formatters): void {
+  function renderCapabilities(mint: MintDetail & Partial<LnurlDetail>, f: Formatters): void {
     /*
      * A federation's modules panel, rebuilt from a fresh announcement. Handled before
      * the NUT work rather than after it because the two are mutually exclusive: the
@@ -98,6 +102,35 @@ const { host } = Astro.props;
       return;
     }
 
+    /*
+     * An LNURL mint's features and withdraw bounds, from a fresh probe. Handled here
+     * for the same reason the modules panel is, and with the same early return: these
+     * elements only exist on an LNURL page, and falling through to `readCapabilities`
+     * on a payload with no `info` would be reading NUT switches this ecosystem has none
+     * of.
+     *
+     * The limits cell is rebuilt inside this branch rather than left to the shared code
+     * below, because the two cells hold different numbers — withdraw bounds here, NUT-04
+     * mint limits there — and the selector is the same.
+     */
+    const featureRows = document.querySelector<HTMLElement>('[data-live-features]');
+    if (featureRows) {
+      featureRows.innerHTML = featureRowsHtml(
+        displayFeatures(mint.features, mint.observed_features),
+        mint.funding_available ?? null,
+        f,
+      );
+      const lnurlLimits = document.querySelector<HTMLElement>('[data-live-limits]');
+      if (lnurlLimits) {
+        lnurlLimits.innerHTML = withdrawLimitsHtml(
+          mint.min_withdrawable_msat,
+          mint.max_withdrawable_msat,
+          f,
+        );
+      }
+      return;
+    }
+
     const caps = readCapabilities(mint.info?.nuts);
 
     const limits = document.querySelector<HTMLElement>('[data-live-limits]');
@@ -155,8 +188,20 @@ const { host } = Astro.props;
          */
         const checked = document.querySelector<HTMLElement>('[data-live-checked]');
         if (checked && mint.type !== 'fedimint') {
+          /*
+           * The "up" wording differs by whether a version was discoverable, and only
+           * LNURL routinely has none: its version comes solely from `/openapi.json`,
+           * which an operator can turn off, so that cell falls back to "last confirmed"
+           * rather than printing "unknown" above a date. A Cashu mint has `version` set
+           * from `/v1/info` in every real case and takes the same branch it always did.
+           */
+          const up =
+            mint.version
+              ? t('mint.checked', { when: f.relative(mint.last_probe) })
+              : t('lnurl.confirmed.when', { when: f.relative(mint.last_probe) });
+
           checked.textContent =
-            mint.status !== 'offline' ? t('mint.checked', { when: f.relative(mint.last_probe) })
+            mint.status !== 'offline' ? up
             : mint.last_online ? t('mint.lastSeen', { when: f.relative(mint.last_online) })
             : t('mint.neverReached');
         }

web/src/components/NotFound.astro

@@ -0,0 +1,455 @@
+---
+import Base from '../layouts/Base.astro';
+import Moai from './Moai.astro';
+import Reviews from './Reviews.astro';
+import ReviewByUrl from './ReviewByUrl.astro';
+import { localePath, useI18n, type Locale } from '../i18n';
+
+/**
+ * The 404, as a component rather than a page, because it is reached two ways.
+ *
+ * `pages/404.astro` emits the English one at `/404`, which is also the route Astro's
+ * dev server and a static host look for by name; `pages/[...locale]/404.astro` emits
+ * the prefixed ones. Neither can import the other's template, so the page itself
+ * lives here and both are three lines.
+ *
+ * Also the resolver for a mint this build has never heard of, which is most of what
+ * the file now does.
+ *
+ * It began as a fallback for a mint discovered *between builds*: a GET against the API
+ * for the host in the URL, and a summary rendered from whatever came back. That covered
+ * the gap between discovery and the next rebuild and nothing else — a mint nobody had
+ * announced on Nostr was not in the index either, so the lookup missed and the reader
+ * got a 404 for a mint that was live and answering. `/lnurl-mint/mint.600.wtf` was the
+ * case that made it obvious.
+ *
+ * So the lookup became a resolver, for all three route shapes:
+ *
+ *   1. the API is asked whether it knows the host (unchanged, and the common case);
+ *   2. on a miss, the address is derived from the path and `POST /api/index` checks it
+ *      live — one probe, and a Nostr lookup if nothing answers;
+ *   3. whatever comes back renders the page shell *and* the reviews panel, so a mint
+ *      indexed a second ago is readable and reviewable immediately;
+ *   4. and every way that can fail says what happened in plain words, with the
+ *      review-by-URL dialog offered so a mistyped address can be corrected on the spot.
+ *
+ * A federation is the one shape that cannot be resolved from its own URL: `/fedimint/`
+ * carries a shortened federation id, and an invite code cannot be derived from one. That
+ * link goes straight to step 4's not-found state, with the dialog offered for the code.
+ */
+interface Props {
+  locale: Locale;
+}
+const { locale } = Astro.props;
+
+const t = useI18n(locale);
+---
+
+<Base
+  title={t('notfound.title')}
+  description={t('notfound.description')}
+  current="mints"
+  offGraph
+>
+  <div class="page">
+    <div class="notfound" data-notfound>
+      {/* 44px, not a hero graphic: DESIGN.md says the moai is never scaled large. */}
+      <span class="nf-moai"><Moai size={44} /></span>
+      <h1>{t('notfound.heading')}</h1>
+      <p class="lede">{t('notfound.lede')}</p>
+
+      <form class="search nf-search" action={localePath('/mints', locale)} method="get" role="search">
+        <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" aria-hidden="true">
+          <circle cx="11" cy="11" r="7" /><path d="m20 20-3.5-3.5" />
+        </svg>
+        <label class="sr-only" for="nf-search">{t('home.search.label')}</label>
+        <input
+          id="nf-search"
+          name="q"
+          type="text"
+          autocomplete="off"
+          placeholder={t('home.search.placeholder')}
+          data-search-input
+        />
+        <kbd aria-hidden="true">/</kbd>
+      </form>
+
+      <div class="nf-actions">
+        <a class="btn primary" href={localePath('/mints', locale)}>{t('notfound.browse')}</a>
+        <a class="btn" href={localePath('/', locale)}>{t('notfound.home')}</a>
+      </div>
+    </div>
+
+    {/*
+      Filled in by the resolver below when the URL looks like a mint page. Nothing
+      here is prerendered, so this is the one place on the site that gets a page
+      level skeleton. `data-boneyard` marks the capture target for `pnpm bones`.
+    */}
+    <div class="mint-fallback" data-mint-fallback hidden>
+      {/*
+        One line, in words, above the skeleton: this page is doing something unusual —
+        checking a stranger's mint over the network — and a screenful of bones with no
+        explanation reads as a page that is merely slow. Outside the capture target on
+        purpose, so it is not measured into the skeleton it introduces.
+      */}
+      <p class="fb-checking" data-nf-status hidden></p>
+      <div data-boneyard="mint-page" data-boneyard-config='{"excludeSelectors":[".sr-only"]}'><div data-mint-fallback-body></div></div>
+
+      {/*
+        The real reviews panel, with no subject until one is resolved.
+
+        It is the same island every mint page runs, so a mint resolved here gets the
+        same list, the same filters and the same write dialog rather than a lesser
+        version of them — which is the difference between "this mint is reachable" and
+        "this mint is reviewable", and the second is the point of the whole feature.
+        The island sits out its first run with no subject and starts when the resolver
+        dispatches `cashumints:subject`.
+      */}
+      <div class="nf-reviews" data-nf-reviews hidden>
+        <Reviews subject={null} reviewCount={0} distribution={{ '1': 0, '2': 0, '3': 0, '4': 0, '5': 0 }} name="" />
+      </div>
+    </div>
+  </div>
+
+  {/*
+    The same dialog the index pages carry. Here it is the way out of every dead end:
+    a wrong ecosystem, an address with a typo in it, or a federation link whose invite
+    code only the reader has. Its trigger names which ecosystem to ask about.
+  */}
+  <ReviewByUrl type="cashu" />
+</Base>
+
+<style>
+  .notfound { padding: 54px 0 20px; max-width: 620px; }
+  .nf-moai { display: block; margin-bottom: 18px; }
+  .notfound h1 { font-family: var(--display); font-size: 34px; font-weight: 700; letter-spacing: -.02em; }
+  .nf-actions { display: flex; gap: 12px; margin-top: 22px; flex-wrap: wrap; }
+
+  /* Same search control as the home page hero, so a miss lands somewhere useful. */
+  .nf-search {
+    display: flex; align-items: center; gap: 12px; margin-top: 24px;
+    background: var(--card); border: 1px solid var(--line);
+    border-radius: 14px; padding: 14px 16px;
+    transition: border-color .15s, box-shadow .15s;
+  }
+  .nf-search:focus-within { border-color: var(--amber-dim); box-shadow: 0 0 0 3px rgba(240, 169, 59, .08); }
+  .nf-search > svg { color: var(--faint); flex-shrink: 0; }
+  .nf-search input {
+    flex: 1; background: none; border: none; outline: none; min-width: 0;
+    color: var(--text); font-family: var(--body); font-size: 15.5px;
+  }
+  .nf-search input::placeholder { color: var(--faint); }
+  .nf-search kbd {
+    font-family: var(--mono); font-size: 11.5px; color: var(--faint);
+    border: 1px solid var(--line); border-radius: 6px; padding: 2px 7px; flex-shrink: 0;
+  }
+
+  /* The .fb-* rules live in global.css: this page builds that markup with
+     innerHTML, and Astro's scoped selectors do not reach injected elements. */
+  .mint-fallback { padding: 20px 0 40px; }
+  /* The one line above the skeleton while a mint is being checked. */
+  .fb-checking {
+    font-size: 13.5px; color: var(--muted); margin-bottom: 16px;
+    display: flex; align-items: center; gap: 9px;
+  }
+  /* `display: flex` beats the user agent's `[hidden] { display: none }`, so an author
+     rule has to take it back or the line (and its pulsing dot) never goes away. */
+  .fb-checking[hidden] { display: none; }
+  .fb-checking::before {
+    content: ''; width: 7px; height: 7px; border-radius: 50%;
+    background: var(--amber); flex-shrink: 0;
+    animation: soft-pulse 1.4s var(--ease-in-out) infinite;
+  }
+</style>
+
+<script>
+  import { apiBase, escapeHtml, iconGradient } from '../lib/client';
+  import { armBuildSnapshot, clearBones, isBuildMode, showBones, swapBones } from '../lib/skeleton';
+  import { useI18n } from '../i18n/client';
+  import { formatters, starString, type Formatters } from '../i18n/format';
+  import { statusLabel, warningOptions } from '../i18n/mint';
+  import { bannerHtml } from '../lib/mint-state';
+  import { splitLocale } from '../i18n/routing';
+  import { onReady } from '../scripts/reveal';
+  import { indexErrorMessage, mintDisplayName, requestIndex, subjectFor } from '../lib/index-client';
+  import mintPageBones from '../bones/mint-page.bones.json';
+  import {
+    addressFromSlug, getMintWarnings, typeForPath,
+    type IndexFailure, type IndexType, type MintDetail,
+  } from '@cashumints/shared';
+
+  /**
+   * The summary this page can build from the API alone. `pnpm bones` measures the
+   * output of this same function, so the bones are the shape of what actually
+   * arrives rather than of a fuller page that never does.
+   */
+  function fallbackHtml(mint: MintDetail, f: Formatters): string {
+    const domain = mint.url.replace(/^lnurl:/, '').replace(/^https?:\/\//, '');
+    const name = mint.name ?? domain.split('/')[0] ?? domain;
+
+    /*
+     * The one warning the mint has earned, drawn by the same function the mint pages
+     * use. It matters most on exactly the mint this resolver exists for: one indexed
+     * from a Nostr announcement because nothing answered at its address is, by
+     * definition, a mint whose page opens with "likely gone" — and a status chip alone
+     * does not say that.
+     */
+    const warning = bannerHtml(getMintWarnings(mint, warningOptions(f))[0] ?? null);
+
+    return `
+      ${warning}
+      <div class="fb-head">
+        <span class="mc-icon" style="background:${iconGradient(domain)};width:52px;height:52px;border-radius:13px;font-size:21px">${escapeHtml(
+          (name[0] ?? '?').toUpperCase(),
+        )}</span>
+        <span>
+          <span class="fb-name">${escapeHtml(name)}</span>
+          <span class="fb-domain">${escapeHtml(domain)}</span>
+        </span>
+        <span class="status-chip ${escapeHtml(mint.status)}"><span class="status-dot"></span>${escapeHtml(
+          statusLabel(mint.status, f.t),
+        )}</span>
+      </div>
+      <div class="fb-stats">
+        <span class="fb-stat"><span class="k">${escapeHtml(
+          f.t('notfound.fb.rating'),
+        )}</span><span class="v">${
+          mint.rating_avg === null ? f.t('time.none') : f.decimal(mint.rating_avg)
+        } <span class="stars" style="font-size:14px">${starString(mint.rating_avg)}</span></span></span>
+        <span class="fb-stat"><span class="k">${escapeHtml(
+          f.t('notfound.fb.reviews'),
+        )}</span><span class="v">${f.number(mint.review_count)}</span></span>
+        <span class="fb-stat"><span class="k">${escapeHtml(
+          f.t('notfound.fb.software'),
+        )}</span><span class="v" style="font-family:var(--mono);font-size:16px">${escapeHtml(
+          mint.version ?? f.t('mint.software.unknown'),
+        )}</span></span>
+        <span class="fb-stat"><span class="k">${escapeHtml(
+          f.t('notfound.fb.lastOnline'),
+        )}</span><span class="v" style="font-size:16px">${escapeHtml(
+          f.relative(mint.last_online),
+        )}</span></span>
+      </div>
+      <p class="fb-note">${escapeHtml(f.t('notfound.fb.note'))}</p>
+      <div class="fb-actions">
+        <button type="button" class="btn primary" data-write-open>${escapeHtml(
+          f.t('reviews.byUrl.open'),
+        )}</button>
+      </div>`;
+  }
+
+  const setup = (): void => {
+  const f = formatters(useI18n());
+  const t = f.t;
+
+  /*
+   * The miss could be at /mint/x or at /es/mint/x, and both resolve to the same mint.
+   * The prefix comes off with the same helper the build routes with, so the two can
+   * never disagree about what counts as a locale segment.
+   */
+  const { path } = splitLocale(window.location.pathname);
+  const target = typeForPath(path);
+
+  const box = document.querySelector<HTMLElement>('[data-mint-fallback]');
+  const body = document.querySelector<HTMLElement>('[data-mint-fallback-body]');
+  const status = document.querySelector<HTMLElement>('[data-nf-status]');
+  const notfound = document.querySelector<HTMLElement>('[data-notfound]');
+  const reviewsBox = document.querySelector<HTMLElement>('[data-nf-reviews]');
+  const panel = document.querySelector<HTMLElement>('[data-reviews-panel]');
+
+  if (!box || !body) return;
+
+  if (isBuildMode()) {
+    // `pnpm bones` is measuring this page. Show a representative mint so the capture
+    // has a real summary to measure instead of an empty box. Imported dynamically so
+    // the fixture never reaches a real visitor.
+    void armBuildSnapshot()
+      .then(() => import('../lib/skeleton-fixtures'))
+      .then(({ FIXTURE_MINT }) => {
+        if (notfound) notfound.hidden = true;
+        box.hidden = false;
+        body.innerHTML = fallbackHtml(FIXTURE_MINT, f);
+      });
+    return;
+  }
+
+  if (!target) return; // An ordinary 404. The page above is the whole answer.
+
+  /**
+   * Hand the resolved mint to the reviews panel and let it run.
+   *
+   * The panel is the same island a mint page uses and it reads its subject off its own
+   * root, so "starting" it is writing the subject there and telling it to look again.
+   * Nothing about the panel is special-cased for this page.
+   */
+  function startReviews(mint: MintDetail): void {
+    const subject = subjectFor(mint);
+    if (!panel || !subject || !reviewsBox) return;
+
+    panel.dataset['subject'] = JSON.stringify(subject);
+    const list = panel.querySelector<HTMLElement>('[data-review-list]');
+    if (list) list.dataset['reviewCount'] = String(mint.review_count);
+
+    // The write dialog's heading names the mint, and until now there was no mint to
+    // name. Same sentence the prerendered pages carry.
+    const title = document.querySelector<HTMLElement>('#write-title');
+    if (title) title.textContent = t('reviews.dialog.title', { name: mintDisplayName(mint) });
+
+    /*
+     * And the prompt in the box, which is the one line in that dialog that cannot be
+     * ecosystem-neutral: "how did minting and melting work out" means nothing about a
+     * federation. The panel picks it at build time from its subject, and this page had
+     * none, so it defaulted to the Cashu wording. Same key, same fallback rule.
+     */
+    const prompt = document.querySelector<HTMLTextAreaElement>('[data-write-dialog] textarea');
+    if (prompt) {
+      const key = `reviews.dialog.bodyPlaceholder.${mint.type}`;
+      prompt.placeholder = t.has(key) ? t(key) : t('reviews.dialog.bodyPlaceholder.cashu');
+    }
+
+    reviewsBox.hidden = false;
+    document.dispatchEvent(new CustomEvent('cashumints:subject'));
+  }
+
+  /**
+   * The tab title for a resolved mint.
+   *
+   * One key per ecosystem rather than the Cashu one for all three: a federation's tab
+   * reading "Cashu mint reviews" is a small, flatly wrong sentence in the one place a
+   * reader keeps a page open under.
+   */
+  function titleFor(mint: MintDetail): string {
+    const name = mintDisplayName(mint);
+    if (mint.type === 'fedimint') return t('mint.titleFedimint', { name });
+    if (mint.type === 'lnurl') return t('mint.titleLnurl', { name });
+    return t('mint.title', { name });
+  }
+
+  /** Render the page shell for a mint the site now has. */
+  function renderMint(mint: MintDetail): void {
+    if (status) status.hidden = true;
+    swapBones(body!, (slot) => {
+      slot.innerHTML = fallbackHtml(mint, f);
+    });
+    document.title = titleFor(mint);
+    startReviews(mint);
+  }
+
+  /**
+   * The honest dead end.
+   *
+   * Not the plain 404: the reader asked about a specific address and this says what
+   * happened to it, in the words the failure deserves, with the two ways forward that
+   * actually exist — correct the address, or open it as the ecosystem it turned out to
+   * belong to.
+   */
+  function renderFailure(message: string, options: { detected?: IndexType; prefill?: string } = {}): void {
+    if (status) status.hidden = true;
+    clearBones(body!);
+    box!.hidden = true;
+    if (reviewsBox) reviewsBox.hidden = true;
+    if (!notfound) return;
+
+    notfound.hidden = false;
+    const lede = notfound.querySelector<HTMLElement>('.lede');
+    if (lede) lede.textContent = message;
+    const heading = notfound.querySelector<HTMLElement>('h1');
+    if (heading) {
+      // A federation is not a mint, and this heading is the one line that names it.
+      heading.textContent =
+        target!.type === 'fedimint'
+          ? t('notfound.resolve.failedFedimint')
+          : t('notfound.resolve.failed');
+    }
+
+    const actions = notfound.querySelector<HTMLElement>('.nf-actions');
+    if (!actions || actions.querySelector('[data-review-url-open]')) return;
+
+    /*
+     * The way out, as the first action. A reader who typed one character wrong is one
+     * dialog away from their mint's page; a reader whose address belongs to another
+     * ecosystem is one button away from the right one.
+     */
+    const kind = options.detected ?? target!.type;
+    const label = options.detected
+      ? t('notfound.resolve.switch', { kind: t(`feed.ecosystem.${options.detected}`) })
+      : t('notfound.resolve.retry');
+
+    const button = document.createElement('button');
+    button.type = 'button';
+    button.className = 'btn primary';
+    button.dataset['reviewUrlOpen'] = kind;
+    if (options.prefill) button.dataset['reviewUrlValue'] = options.prefill;
+    button.textContent = label;
+    actions.prepend(button);
+
+    // The dialog's own island bound its triggers when the page loaded, and this button
+    // did not exist then.
+    button.addEventListener('click', () => {
+      document.querySelector<HTMLElement>('[data-review-url-dialog]')?.dispatchEvent(
+        new CustomEvent('cashumints:open', { detail: { type: kind, value: options.prefill ?? '' } }),
+      );
+    });
+  }
+
+  // The "page not found" copy would be wrong if this mint turns out to exist, so hold
+  // it back while we find out rather than flashing it and taking it away again.
+  if (notfound) notfound.hidden = true;
+  box.hidden = false;
+  if (status) {
+    status.textContent = t('notfound.resolve.checking');
+    status.hidden = false;
+  }
+  // The same sentence goes to `showBones` as its screen reader status line, so both
+  // kinds of reader are told the same thing at the same moment.
+  showBones(body, mintPageBones, { label: t('notfound.resolve.checking') });
+
+  void (async () => {
+    // 1. Does the index already know it? Much the commonest case: a mint discovered
+    //    since the last build, whose row exists and whose page does not.
+    try {
+      const res = await fetch(`${apiBase}/api/mints/${encodeURIComponent(target.host)}`);
+      if (res.ok) {
+        renderMint((await res.json()) as MintDetail);
+        return;
+      }
+    } catch {
+      // The API is unreachable. Indexing would fail for the same reason; fall through
+      // to the failure state, which says so.
+    }
+
+    /*
+     * 2. Two shapes cannot be turned back into an address.
+     *
+     * A federation's page address carries a shortened id, and an invite code cannot be
+     * derived from one. A slug with a path in it (`mint.example.com-bitcoin`) is
+     * ambiguous by construction — the hyphen may be a path separator or part of a
+     * hostname — and guessing would mean fetching, and possibly indexing, the wrong
+     * host. Both say so and offer the dialog, which is where an address the reader
+     * actually has can go.
+     */
+    const address = target.type === 'fedimint' ? null : addressFromSlug(target.host);
+    if (!address) {
+      renderFailure(
+        target.type === 'fedimint' ? t('notfound.resolve.fedimint') : t('notfound.resolve.ambiguous'),
+      );
+      return;
+    }
+
+    // 3. Check it live and index it if it is real.
+    const result = await requestIndex(target.type, address);
+    if (result.ok) {
+      renderMint(result.mint);
+      return;
+    }
+
+    const failure: IndexFailure = result.failure;
+    renderFailure(indexErrorMessage(result, t), {
+      ...(failure.detected_type ? { detected: failure.detected_type } : {}),
+      prefill: address,
+    });
+  })();
+  };
+
+  onReady(setup);
+</script>

web/src/components/ReviewByUrl.astro

@@ -0,0 +1,492 @@
+---
+/**
+ * Island: review a mint by pasting its address.
+ *
+ * The index pages list what this site knows. Until now, reviewing something it did not
+ * know was impossible from here — the only way in was a mint page, and a mint with no
+ * page could not be reached. This is the way in: one dialog, two steps, on /mints,
+ * /fedimints and /lnurl-mints alike.
+ *
+ *   1. **Identify.** One field, labelled for this page's ecosystem, with a format check
+ *      that runs before any request. Submitting it calls `POST /api/index`, which either
+ *      finds the mint already indexed, checks it live and indexes it, tells us it is a
+ *      *different* ecosystem's mint (with a one-click switch), or explains why not.
+ *   2. **Review.** The site's ordinary write form — same stars, same identity row, same
+ *      publisher — pointed at whatever step 1 resolved.
+ *
+ * One `<dialog>` for both, because it is one intention: the reader came here to write a
+ * review and the address is the first question, not a separate errand. The steps
+ * cross-fade in place rather than the dialog closing and reopening.
+ *
+ * The trigger lives on the page rather than in here: it belongs in the index head row,
+ * beside the heading, and the dialog belongs at the end of the document. Anything with
+ * `data-review-url-open` opens this.
+ */
+import WriteForm from './WriteForm.astro';
+import { useI18n, type Locale } from '../i18n';
+import { pageLocale } from '../i18n/paths';
+import type { IndexType } from '@cashumints/shared';
+
+interface Props {
+  /** Which ecosystem this page lists, and therefore what the dialog opens asking for. */
+  type: IndexType;
+}
+const { type } = Astro.props;
+
+const { locale } = pageLocale(Astro) as { locale: Locale };
+const t = useI18n(locale);
+
+/*
+ * The label, the invitation and the two review prompts all differ per ecosystem, and
+ * all of them fall back to the Cashu wording for a type whose own string has not been
+ * written — the same rule the reviews panel already applies to its placeholder.
+ */
+const wordsFor = (
+  kind: IndexType,
+): { label: string; placeholder: string; lede: string; body: string } => {
+  const key = (base: string): string =>
+    t.has(`${base}.${kind}`) ? `${base}.${kind}` : `${base}.cashu`;
+  return {
+    label: t(key('reviews.byUrl.label')),
+    placeholder: t(key('reviews.byUrl.placeholder')),
+    lede: t(key('reviews.dialog.lede')),
+    body: t(key('reviews.dialog.bodyPlaceholder')),
+  };
+};
+
+/*
+ * All three ecosystems' wording travels with the dialog, not just this page's.
+ *
+ * An index page only ever asks about its own, but the 404 page carries one of these for
+ * whichever deep link missed — and a wrong-type answer can move a submission from one
+ * ecosystem to another mid-dialog, at which point "Mint URL" is the wrong label for the
+ * box the reader is looking at. Three short strings in an attribute is a smaller price
+ * than a dialog per ecosystem or a second request for a label.
+ */
+const words = {
+  cashu: wordsFor('cashu'),
+  fedimint: wordsFor('fedimint'),
+  lnurl: wordsFor('lnurl'),
+};
+const initial = words[type] ?? words.cashu;
+---
+
+<dialog
+  class="modal rbu-dialog"
+  data-review-url-dialog
+  data-rbu-type={type}
+  data-rbu-words={JSON.stringify(words)}
+  aria-labelledby="rbu-title"
+>
+  {/*
+    Both steps live in the same box and only one is ever in the flow, so the dialog is
+    the height of whichever step is showing and the backdrop never jumps around a
+    half-rendered second step.
+  */}
+  <div class="rbu-steps" data-rbu-steps>
+    <form class="modal-body rbu-step" data-rbu-identify novalidate>
+      <div class="modal-head">
+        <h2 id="rbu-title">{t('reviews.byUrl.title')}</h2>
+        <button type="button" class="copy-btn" data-rbu-close aria-label={t('common.close')}>
+          <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" aria-hidden="true">
+            <path d="M18 6 6 18M6 6l12 12" />
+          </svg>
+        </button>
+      </div>
+
+      <p class="modal-note">{t('reviews.byUrl.lede')}</p>
+
+      <label class="write-label" for="rbu-input" data-rbu-label>{initial.label}</label>
+      <input
+        id="rbu-input"
+        class="rbu-input"
+        data-rbu-input
+        type="text"
+        autocomplete="off"
+        autocapitalize="off"
+        spellcheck="false"
+        placeholder={initial.placeholder}
+        aria-describedby="rbu-error"
+      />
+
+      <p class="write-error" id="rbu-error" data-rbu-error hidden role="alert"></p>
+      {/* Filled by the island when the API says "that is the other ecosystem's mint". */}
+      <p class="rbu-switch" data-rbu-switch hidden></p>
+
+      <div class="write-actions">
+        <button type="button" class="btn" data-rbu-close>{t('common.cancel')}</button>
+        <button type="submit" class="btn primary" data-rbu-check>
+          <span class="write-spinner" aria-hidden="true"></span>
+          <span data-rbu-check-label>{t('reviews.byUrl.check')}</span>
+        </button>
+      </div>
+    </form>
+
+    <div class="rbu-step" data-rbu-review hidden>
+      <WriteForm locale={locale} lede={initial.lede} placeholder={initial.body} idPrefix="rbu">
+        <div class="modal-head" slot="head">
+          <h2 data-rbu-review-title>{t('reviews.byUrl.title')}</h2>
+          <button type="button" class="copy-btn" data-write-close aria-label={t('common.close')}>
+            <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" aria-hidden="true">
+              <path d="M18 6 6 18M6 6l12 12" />
+            </svg>
+          </button>
+        </div>
+        <button type="button" class="rbu-back" slot="head" data-rbu-back>
+          <svg width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" aria-hidden="true">
+            <path d="m15 18-6-6 6-6" />
+          </svg>
+          {t('reviews.byUrl.back')}
+        </button>
+        {/*
+          The mint the reader is about to review, drawn from the payload the API just
+          returned. It is the confirmation that the right thing was found — a domain and
+          a status chip say more than a name alone — and it is why the second step does
+          not need to repeat the address in its heading.
+        */}
+        <div class="rbu-preview" slot="head" data-rbu-preview></div>
+      </WriteForm>
+    </div>
+  </div>
+</dialog>
+
+<style>
+  /* The two steps share one box; only the one in the flow is measured. */
+  .rbu-steps { position: relative; }
+  /*
+   * `hidden` alone is not enough on the first step: it carries `.modal-body`, whose
+   * `display: flex` beats the user agent's `[hidden] { display: none }` and left both
+   * steps stacked in the dialog at once. An author rule has to take it back.
+   */
+  .rbu-step[hidden] { display: none; }
+  .rbu-step { transition: opacity 140ms var(--ease-out), transform 140ms var(--ease-out); }
+  /* Leaving to the left, arriving from the right: the reader is moving forwards. */
+  .rbu-step.is-leaving { opacity: 0; transform: translateX(-10px); }
+  .rbu-step.is-entering { opacity: 0; transform: translateX(10px); }
+  /* Going back reverses it, so the motion always matches the direction of travel. */
+  .rbu-step.is-leaving-back { opacity: 0; transform: translateX(10px); }
+  .rbu-step.is-entering-back { opacity: 0; transform: translateX(-10px); }
+
+  @media (prefers-reduced-motion: reduce) {
+    .rbu-step { transition: none; }
+    .rbu-step.is-leaving, .rbu-step.is-entering,
+    .rbu-step.is-leaving-back, .rbu-step.is-entering-back { opacity: 1; transform: none; }
+  }
+</style>
+
+<script>
+  import { escapeHtml, iconGradient } from '../lib/client';
+  import { useI18n } from '../i18n/client';
+  import { statusLabel } from '../i18n/mint';
+  import { localePath, splitLocale } from '../i18n/routing';
+  import { onReady, prefersReducedMotion } from '../scripts/reveal';
+  import { closeModal, openModal } from '../lib/modal';
+  import { indexErrorMessage, mintDisplayName, displayAddress, requestIndex, subjectFor } from '../lib/index-client';
+  import { rememberFreshReview, wireWriteForm } from '../lib/write-review';
+  import { checkIndexInput, mintPath, type IndexSuccess, type IndexType } from '@cashumints/shared';
+  import type { ReviewSubject } from '../lib/review-subject';
+
+  const setup = (): void => {
+    const dialog = document.querySelector<HTMLDialogElement>('[data-review-url-dialog]');
+    if (!dialog) return;
+
+    const t = useI18n();
+    const identify = dialog.querySelector<HTMLFormElement>('[data-rbu-identify]')!;
+    const reviewStep = dialog.querySelector<HTMLElement>('[data-rbu-review]')!;
+    const input = dialog.querySelector<HTMLInputElement>('[data-rbu-input]')!;
+    const errorBox = dialog.querySelector<HTMLElement>('[data-rbu-error]')!;
+    const switchBox = dialog.querySelector<HTMLElement>('[data-rbu-switch]')!;
+    const checkButton = dialog.querySelector<HTMLButtonElement>('[data-rbu-check]')!;
+    const checkLabel = dialog.querySelector<HTMLElement>('[data-rbu-check-label]')!;
+    const preview = dialog.querySelector<HTMLElement>('[data-rbu-preview]')!;
+    const reviewTitle = dialog.querySelector<HTMLElement>('[data-rbu-review-title]')!;
+
+    const label = dialog.querySelector<HTMLElement>('[data-rbu-label]')!;
+    const ledeBox = dialog.querySelector<HTMLElement>('[data-write-lede]')!;
+    const bodyBox = dialog.querySelector<HTMLTextAreaElement>('textarea[name="content"]')!;
+
+    /**
+     * The wording for each ecosystem, carried in the markup.
+     *
+     * Read defensively: a payload that will not parse is a build bug, and a dialog that
+     * threw here would take the whole review flow down rather than showing a slightly
+     * generic label.
+     */
+    const words = ((): Record<
+      string,
+      { label: string; placeholder: string; lede: string; body: string }
+    > => {
+      try {
+        return JSON.parse(dialog.dataset['rbuWords'] ?? '{}') as Record<
+          string,
+          { label: string; placeholder: string; lede: string; body: string }
+        >;
+      } catch {
+        return {};
+      }
+    })();
+
+    /**
+     * What is being asked for right now.
+     *
+     * Starts as the page's own ecosystem, and changes in two places: a trigger that
+     * names one (the 404 page, whose dialog serves whichever deep link missed), and the
+     * one-click switch after a wrong-type answer.
+     */
+    let pageType = (dialog.dataset['rbuType'] ?? 'cashu') as IndexType;
+
+    function setType(next: IndexType): void {
+      pageType = next;
+      const wording = words[next];
+      if (!wording) return;
+      label.textContent = wording.label;
+      input.placeholder = wording.placeholder;
+      ledeBox.textContent = wording.lede;
+      bodyBox.placeholder = wording.body;
+    }
+
+    /** What step 1 resolved, and what step 2 publishes against. */
+    let resolved: { mint: IndexSuccess; subject: ReviewSubject } | null = null;
+    /** True while a submission is in flight, so nothing runs over it. */
+    let checking = false;
+
+    /* ---------- step 2: the ordinary write form ---------- */
+
+    const writer = wireWriteForm({
+      dialog,
+      subject: () => resolved?.subject ?? null,
+      onBackdrop: () => input.value.trim() === '' || window.confirm(t('reviews.byUrl.confirmClose')),
+      onPublished: (published) => {
+        const mint = resolved?.mint;
+        if (!mint) return;
+
+        /*
+         * The review is on the relays; the page that shows it is somewhere else. Hand it
+         * forward through sessionStorage and go there: the reviews panel picks it up on
+         * arrival and renders it at the top, exactly as it would have if the review had
+         * been written on that page. Without this, an author would land on their own
+         * mint's page and not see what they just wrote until the relays echoed it back.
+         */
+        rememberFreshReview(published);
+
+        const { locale } = splitLocale(window.location.pathname);
+        window.location.href = localePath(mintPath(mint.type, mint.host), locale);
+      },
+    });
+
+    /* ---------- moving between the steps ---------- */
+
+    /**
+     * Cross-fade to the other step, and hand back the moment it is in the flow.
+     *
+     * `onShown` is where anything that focuses belongs: a hidden element cannot take
+     * focus, so setting up the incoming step before this callback runs would put the
+     * cursor on the document body and leave the reader pressing Tab to find the form.
+     * It runs before the pane is painted, so the step is never seen half-arranged.
+     */
+    function showStep(next: 'identify' | 'review', onShown?: () => void): void {
+      const from = next === 'review' ? identify : reviewStep;
+      const to = next === 'review' ? reviewStep : identify;
+      const back = next === 'identify';
+
+      if (prefersReducedMotion()) {
+        from.hidden = true;
+        to.hidden = false;
+        onShown?.();
+        return;
+      }
+
+      from.classList.add(back ? 'is-leaving-back' : 'is-leaving');
+      window.setTimeout(() => {
+        from.hidden = true;
+        from.classList.remove('is-leaving', 'is-leaving-back');
+
+        to.hidden = false;
+        to.classList.add(back ? 'is-entering-back' : 'is-entering');
+        onShown?.();
+        // Two frames: one for the browser to lay the pane out hidden-to-shown, one for
+        // the transition to have a starting value to move from.
+        requestAnimationFrame(() =>
+          requestAnimationFrame(() => to.classList.remove('is-entering', 'is-entering-back')),
+        );
+      }, 140);
+    }
+
+    /* ---------- the preview card ---------- */
+
+    function drawPreview(mint: IndexSuccess): void {
+      const name = mintDisplayName(mint);
+      const address = displayAddress(mint);
+      const note = mint.existing ? t('reviews.byUrl.existing') : t('reviews.byUrl.indexed');
+
+      preview.innerHTML =
+        `<span class="rbu-icon" style="background:${iconGradient(address)}">${escapeHtml(
+          (name[0] ?? '?').toUpperCase(),
+        )}</span>` +
+        `<span class="rbu-who">` +
+        `<span class="rbu-name">${escapeHtml(name)}</span>` +
+        // A federation submitted as a bare invite code has no name but its own id, and
+        // printing that id twice says nothing the first line did not.
+        (address === name ? '' : `<span class="rbu-domain">${escapeHtml(address)}</span>`) +
+        `</span>` +
+        `<span class="rbu-chips">` +
+        `<span class="status-chip ${escapeHtml(mint.status)}"><span class="status-dot"></span>${escapeHtml(
+          statusLabel(mint.status, t),
+        )}</span>` +
+        `<span class="rbu-note">${escapeHtml(note)}</span></span>`;
+
+      reviewTitle.textContent = t('reviews.dialog.title', { name });
+    }
+
+    /* ---------- step 1: identify ---------- */
+
+    function showError(message: string): void {
+      errorBox.textContent = message;
+      errorBox.hidden = message === '';
+    }
+
+    function setChecking(busy: boolean): void {
+      checking = busy;
+      input.disabled = busy;
+      checkButton.disabled = busy;
+      checkButton.classList.toggle('is-busy', busy);
+      checkLabel.textContent = busy ? t('reviews.byUrl.checking') : t('reviews.byUrl.check');
+    }
+
+    /** Offer the other ecosystem, with a button that re-submits under it. */
+    function offerSwitch(detected: IndexType): void {
+      switchBox.hidden = false;
+      switchBox.innerHTML =
+        `${escapeHtml(t('reviews.byUrl.detected', { kind: t(`feed.ecosystem.${detected}`) }))} ` +
+        `<button type="button" class="rev-retry" data-rbu-switch-to="${escapeHtml(detected)}">${escapeHtml(
+          t('reviews.byUrl.switchTo', { kind: t(`feed.ecosystem.${detected}`) }),
+        )}</button>`;
+    }
+
+    async function submitAddress(type: IndexType, raw: string): Promise<void> {
+      if (checking) return;
+
+      showError('');
+      switchBox.hidden = true;
+
+      // The format check runs first and costs nothing: an empty box, a sentence, or an
+      // invite code in a URL field are all answerable without asking the server.
+      const precheck = checkIndexInput(type, raw);
+      if (!precheck.ok) {
+        showError(
+          precheck.reason === 'empty' ? t('reviews.byUrl.error.empty')
+          : precheck.reason === 'bad_invite' ? t('reviews.byUrl.error.badInvite')
+          : t('reviews.byUrl.error.badUrl'),
+        );
+        input.focus();
+        return;
+      }
+
+      setChecking(true);
+      const result = await requestIndex(type, precheck.value);
+      setChecking(false);
+
+      if (!result.ok) {
+        const detected = result.failure.detected_type;
+        showError(indexErrorMessage(result, t));
+        if (detected && detected !== type) offerSwitch(detected);
+        input.focus();
+        input.select();
+        return;
+      }
+
+      const subject = subjectFor(result.mint);
+      if (!subject) {
+        // Indexed, but this build has no review kind for its ecosystem. Publishing an
+        // event nothing could resolve would be worse than saying so.
+        showError(t('reviews.byUrl.error.notAMint'));
+        return;
+      }
+
+      resolved = { mint: result.mint, subject };
+      drawPreview(result.mint);
+      writer.reset();
+      showStep('review', () => writer.open());
+    }
+
+    identify.addEventListener('submit', (event) => {
+      event.preventDefault();
+      void submitAddress(pageType, input.value);
+    });
+
+    // The one-click switch: re-submit the same address under the ecosystem the API
+    // recognised, and carry straight on into the review.
+    switchBox.addEventListener('click', (event) => {
+      const button = (event.target as HTMLElement).closest<HTMLElement>('[data-rbu-switch-to]');
+      const detected = button?.dataset['rbuSwitchTo'] as IndexType | undefined;
+      if (!detected) return;
+      // The box is about to be asked about a different ecosystem, so it says so before
+      // the request goes out rather than after it comes back.
+      setType(detected);
+      void submitAddress(detected, input.value);
+    });
+
+    input.addEventListener('input', () => {
+      showError('');
+      switchBox.hidden = true;
+    });
+
+    dialog.querySelector('[data-rbu-back]')?.addEventListener('click', () => {
+      showStep('identify');
+      window.setTimeout(() => input.focus(), 160);
+    });
+
+    for (const button of dialog.querySelectorAll('[data-rbu-close], [data-write-close]')) {
+      button.addEventListener('click', () => closeModal(dialog));
+    }
+
+    /* ---------- opening ---------- */
+
+    /**
+     * Open the dialog on step 1, asking about `type`, with `prefill` in the box.
+     *
+     * Always back to the address, even if a previous visit got as far as the form: the
+     * reader pressed "write a review", not "carry on with the last one".
+     */
+    function openWith(type: IndexType, prefill?: string): void {
+      setType(type in words ? type : ((dialog!.dataset['rbuType'] ?? 'cashu') as IndexType));
+      resolved = null;
+      identify.hidden = false;
+      reviewStep.hidden = true;
+      showError('');
+      switchBox.hidden = true;
+      setChecking(false);
+      if (prefill) input.value = prefill;
+      openModal(dialog!);
+      input.focus();
+      input.select();
+    }
+
+    for (const trigger of document.querySelectorAll<HTMLElement>('[data-review-url-open]')) {
+      trigger.addEventListener('click', () => {
+        /*
+         * A trigger may name the ecosystem it is asking about, and hand over the address
+         * the reader was already looking for. The index pages need neither — their
+         * dialog is already theirs and there is nothing to prefill — but the 404 page's
+         * trigger serves all three and knows exactly which address just failed.
+         */
+        const asked = trigger.dataset['reviewUrlOpen'] as IndexType | undefined;
+        openWith(asked ?? ((dialog.dataset['rbuType'] ?? 'cashu') as IndexType), trigger.dataset['reviewUrlValue']);
+      });
+    }
+
+    /*
+     * The same thing, for a trigger that did not exist when this ran.
+     *
+     * The 404 page builds its button only once a resolution has failed, which is long
+     * after the loop above. Rather than have that page reach into this island's
+     * internals, it dispatches an event at the dialog and this answers it.
+     */
+    dialog.addEventListener('cashumints:open', (event) => {
+      const detail = (event as CustomEvent<{ type?: string; value?: string }>).detail ?? {};
+      openWith((detail.type ?? 'cashu') as IndexType, detail.value);
+    });
+  };
+
+  onReady(setup);
+</script>

web/src/components/Topbar.astro

@@ -5,7 +5,7 @@ import { localePath, useI18n } from '../i18n';
 import { pageLocale } from '../i18n/paths';
 
 interface Props {
-  current?: 'mints' | 'fedimints' | 'reviews' | 'wallets' | 'about';
+  current?: 'mints' | 'fedimints' | 'lnurl-mints' | 'reviews' | 'wallets' | 'about';
   /** Shows the compact search affordance next to the brand (mint pages, /mints). */
   mintCount?: number;
 }
@@ -21,15 +21,23 @@ const t = useI18n(locale);
 /*
  * "Cashu mints", not "Mints".
  *
- * Two ecosystems are listed now, so a bare "Mints" beside "Fedimints" reads as though
- * federations were something other than mints — or as though the first link covered
- * both. The extra word costs ~45px in the widest nav row and buys a label that is
- * unambiguous at a glance. It is the same wording on /mints' own heading, in the
- * breadcrumb and in the footer, so nothing calls the same page two things.
+ * Three ecosystems are listed now, so a bare "Mints" beside "Fedimints" and "LNURL
+ * mints" reads as though the others were something other than mints — or as though the
+ * first link covered all of them. The extra word costs ~45px in the widest nav row and
+ * buys a label that is unambiguous at a glance. It is the same wording on /mints' own
+ * heading, in the breadcrumb and in the footer, so nothing calls the same page two
+ * things.
+ *
+ * Six items is where this row stops fitting on one line. It still does at 1280px in
+ * every locale; below that the nav drops to a row of its own rather than collapsing
+ * behind a hamburger, which is the `@media (max-width: 1180px)` block in global.css and
+ * the comment there explains how that number was arrived at. A fourth ecosystem would
+ * need a real menu instead — this row is full.
  */
 const links = [
   { path: '/mints', label: t('nav.mints'), key: 'mints' },
   { path: '/fedimints', label: t('nav.fedimints'), key: 'fedimints' },
+  { path: '/lnurl-mints', label: t('nav.lnurlMints'), key: 'lnurl-mints' },
   { path: '/reviews', label: t('nav.reviews'), key: 'reviews' },
   { path: '/wallets', label: t('nav.wallets'), key: 'wallets' },
   { path: '/about', label: t('nav.about'), key: 'about' },
@@ -79,7 +87,7 @@ const links = [
       of it to get out. The footer keeps its own copy, where someone deliberately looking
       for site settings expects to find one.
     */}
-    <LanguageSwitcher variant="menu" />
+    <LanguageSwitcher placement="bar" />
 
     {/*
       The account control. Prerendered logged out, because a static build cannot know

web/src/components/WriteForm.astro

@@ -0,0 +1,122 @@
+---
+/**
+ * The write-a-review form: a login gate, stars, body, identity row, actions.
+ *
+ * One markup, two dialogs. The reviews panel on a mint page opens it directly; the
+ * review-by-URL dialog on an index page opens it as its second step, once the reader's
+ * pasted address has been indexed. Its behaviour lives in `lib/write-review.ts`, and
+ * every hook below (`data-write-*`) is what that module binds to.
+ *
+ * Three states, only one of which is ever on screen:
+ *
+ *   1. **Gate.** No session and no NIP-07 extension: there is nothing to sign with, so
+ *      the dialog asks for a login before it asks for anything else. Writing a review
+ *      into a form that cannot publish it is the one outcome worth designing away.
+ *   2. **Stars.** The rating is the whole first step. It is the one thing every review
+ *      must carry, it takes one tap, and it is what the rest of the form is *for*.
+ *   3. **The rest.** Body, identity and publish, revealed once a rating is chosen.
+ *
+ * Nothing here knows which ecosystem is being reviewed. The heading is a slot because
+ * the two dialogs have genuinely different heads — one names the mint, the other has a
+ * step back to the address field — and the lede and placeholder are props for the same
+ * reason: "how did minting and melting work out" means nothing about a federation.
+ */
+import { useI18n, type Locale } from '../i18n';
+
+interface Props {
+  locale: Locale;
+  /** The one line under the heading, chosen per ecosystem by the caller. */
+  lede: string;
+  /** The body placeholder, chosen per ecosystem by the caller. */
+  placeholder: string;
+  /**
+   * Prefix for the two element ids in here.
+   *
+   * A mint page carries both dialogs at once — the panel's, and the one the header
+   * button opens — so the ids cannot be constants. `for`/`aria-describedby` are the
+   * whole reason they exist; nothing styles by id.
+   */
+  idPrefix?: string;
+}
+
+const { locale, lede, placeholder, idPrefix = 'review' } = Astro.props;
+const t = useI18n(locale);
+
+const bodyId = `${idPrefix}-body`;
+const countId = `${idPrefix}-count`;
+---
+
+<form method="dialog" class="modal-body write-form" data-write-form novalidate>
+  <slot name="head" />
+
+  <p class="modal-note" data-write-lede>{lede}</p>
+
+  {/*
+    The gate. Shown in place of everything below it when there is no signer at all, and
+    never on a page load: whether a reader has one is a browser fact the island checks
+    as the dialog opens. Its button is an ordinary `data-login-open`, so the same popup
+    the header opens is the one that opens here.
+  */}
+  <div class="write-gate" data-write-gate hidden>
+    <p class="write-gate-title">{t('reviews.dialog.gate.title')}</p>
+    <p class="write-gate-lead">{t('reviews.dialog.gate.lead')}</p>
+    <div class="write-actions">
+      <button type="button" class="btn" data-write-close>{t('common.cancel')}</button>
+      <button type="button" class="btn primary" data-login-open>{t('login.open')}</button>
+    </div>
+  </div>
+
+  <div class="write-steps" data-write-steps>
+    <fieldset class="star-picker" data-star-picker>
+      <legend class="sr-only">{t('reviews.dialog.ratingLegend')}</legend>
+      {
+        [1, 2, 3, 4, 5].map((value) => (
+          <label class="star-option">
+            <input type="radio" name="rating" value={value} required />
+            <span aria-hidden="true">★</span>
+            <span class="sr-only">{t('reviews.dialog.starsSr', { n: value })}</span>
+          </label>
+        ))
+      }
+      {/*
+        The only "Choose a rating" on screen. It used to be said here and again beside
+        the publish button, which is one prompt too many for one decision.
+      */}
+      <span class="star-label" data-star-label aria-live="polite">
+        {t('reviews.dialog.chooseRating')}
+      </span>
+    </fieldset>
+
+    <div class="write-rest" data-write-rest hidden>
+      <div class="write-id" data-write-identity></div>
+
+      <label class="write-label" for={bodyId}>{t('reviews.dialog.bodyLabel')}</label>
+      <div class="write-box">
+        <textarea id={bodyId} name="content" rows="5" aria-describedby={countId} placeholder={placeholder}
+        ></textarea>
+        <span class="write-count" id={countId} data-char-count>
+          {t('reviews.dialog.charCount', { n: 0, max: 2000 })}
+        </span>
+      </div>
+
+      <p class="write-status" data-write-status hidden role="status"></p>
+      <p class="write-error" data-write-error hidden role="alert"></p>
+
+      <div class="write-actions">
+        <span class="write-why" data-write-why></span>
+        <button type="button" class="btn" data-write-close>{t('common.cancel')}</button>
+        <button type="submit" class="btn primary" data-write-submit disabled>
+          <span class="write-spinner" aria-hidden="true"></span>
+          <span data-write-submit-label>{t('reviews.dialog.submit')}</span>
+        </button>
+      </div>
+
+      {/*
+        What pressing that button actually does, beside the button rather than in the
+        heading: it is a consequence, and a consequence belongs next to the thing that
+        causes it, not above a form nobody has filled in yet.
+      */}
+      <p class="write-permanent">{t('reviews.dialog.permanent')}</p>
+    </div>
+  </div>
+</form>

web/src/i18n/GLOSSARY.md

@@ -4,8 +4,17 @@ The terms this site keeps consistent across every language. Decide a term once h
 then use it everywhere: a reader who meets "reseña" on the home page and "opinión" on a
 mint page has to work out whether they are the same thing.
 
-Adding a fourth language starts here, not in the catalog. Fill in the column, then
-translate `en.json` with it beside you.
+Adding a language starts here, not in the catalog. Fill in the column, then translate
+`en.json` with it beside you.
+
+The table has columns for the three hand-written languages. The other twenty-one catalogs
+were machine-translated in bulk, and only six of them (de, da, sv, id, vi, tr) have since
+had the first row of this table applied throughout: in those, a mint is a `mint`. The
+remaining fifteen keep the machine's word for it below the chrome, which is usually the
+local term for a coin factory. A native pass on one of them means adding its column here
+first, then working through `xx.json` against it. The house rules below hold in every
+language, translated column or not, and the first row of the table is the one the machine
+got wrong most often.
 
 ## House rules, in every language
 
@@ -61,6 +70,20 @@ translate `en.json` with it beside you.
 | announced (a federation) | anunciada | aangekondigd | Its own status. NOT a synonym for unknown: see the note below. |
 | confirmed (a federation) | confirmada | bevestigd | Something outside this site checked and it answered. |
 | network (mainnet, signet) | la red | het netwerk | The network names themselves stay English. |
+| LNURL | LNURL | LNURL | Always capitals, never inflected, never translated. |
+| lnurlcash | lnurlcash | lnurlcash | Lowercase, always. The protocol's own spelling (LUD-25), like `ecash`. |
+| LNURL mint | el mint LNURL | de LNURL mint | The thing, not "LNURL-acuñadora". Same noun as a Cashu mint, so it takes the same article and the same word. |
+| bearer note | la nota al portador | het toonderbriefje | What an LNURL mint issues. Spanish uses the financial term; Dutch uses the everyday compound. Never "billete" / "biljet" alone, which loses the point that whoever holds it owns it. |
+| to rotate (a note) | rotar | roteren | Replacing a note's secret without changing its value. Not "girar" / "draaien". |
+| to split (a note) | dividir | splitsen | One note becomes two. |
+| to merge (notes) | fusionar | samenvoegen | Several notes become one. |
+| LUD-03, LUD-06, LUD-16, LUD-21, LUD-25 | unchanged | unchanged | Same rule as NUT-04: the number is the name. The plain-language label beside it IS translated. |
+| withdraw (an LNURL mint) | la retirada | de opname | The LNURL side of melting. Deliberately the same word the Cashu warnings already use for "withdrawals disabled", so one reader meets one concept. |
+| mint pubkey | la clave pública del mint | de publieke sleutel van de mint | The funding node's identity key. Its own thing, distinct from a Cashu mint's `/v1/info` pubkey. |
+| lightning address | la dirección Lightning | het Lightning-adres | The `name@host` form (LUD-16). Never translate the `@`. |
+| Tor / onion address | la dirección Tor | het Tor-adres | Tor keeps its capital T. "Onion" is never translated. |
+| funding source | el nodo Lightning | de Lightning-node | Deliberately NOT a literal "fuente de financiación" / "financieringsbron", which reads as an investor. The copy names the thing a reader can picture: the mint's Lightning node. |
+| Anon (a reviewer) | Anón | Anon | The label for a reviewer with no kind-0 profile. Site copy, so it IS translated: Spanish shortens "anónimo" to match the label's width, Dutch keeps "anon" because that is what NL Nostr users write. Decided 2026-08; used by the label and the "hide anon" filter alike. |
 
 ## Two decisions worth knowing
 
@@ -74,6 +97,14 @@ not need this: `minten` and `melten` are what NL and BE Nostr users actually wri
 review, "portemonnee", "ondertekenaar") reads as stiff or, worse, as a different concept.
 Spanish translates more, because Spanish tech writing does.
 
+**"Unavailable" is not "not supported", on an LNURL mint.** The Features panel has three
+states where the Cashu NUTs panel has three and the Fedimint Modules panel has two. A
+feature the operator never announced is *not announced* (`lnurl.features.notListed`); one
+they did announce but that cannot work right now, because the mint's Lightning node is
+unreachable, is *unavailable* (`lnurl.features.unavailable`). Those are different facts —
+"they never built it" against "it is built and broken today" — and a language that uses
+one word for both loses the distinction the panel exists to draw.
+
 **"Announced" is not "unknown", in any language.** A Cashu mint that has not been probed
 yet is `status.unknown`: we have not looked. A federation that is `status.announced` is
 one nobody *can* look at — there is no check to run, and there may never be. Translating

web/src/i18n/ar-eg.json

@@ -0,0 +1,794 @@
+{
+  "site.name": "Cashumints.space",
+  "common.close": "اقفل",
+  "common.cancel": "إلغاء",
+  "common.done": "تم",
+  "common.back": "العودة",
+  "common.retry": "جرّب تاني",
+  "common.connect": "اتصل",
+  "common.copied": "اتنسخ",
+  "common.copyFull": "انسخ {kind} بالكامل",
+  "common.previousPage": "الصفحة السابقة",
+  "common.nextPage": "الصفحة التالية",
+  "common.reviewPages": "صفحات الاستعراض",
+  "time.never": "أبداً",
+  "time.justNow": "دلوقتي",
+  "time.none": "-",
+  "time.unknownDate": "تاريخ مش معروف",
+  "time.ago.minute": "منذ {n}",
+  "time.ago.hour": "منذ {n}",
+  "time.ago.day": "قبل {n}",
+  "time.ago.week": "منذ {n}",
+  "time.ago.month": "منذ {n}",
+  "time.ago.year": "منذ {n}",
+  "time.short.minute": "{n}m",
+  "time.short.hour": "{n}h",
+  "time.short.day": "{n}d",
+  "time.short.week": "{n}w",
+  "time.short.month": "{n}mo",
+  "time.short.year": "{n}",
+  "status.online": "أونلاين",
+  "status.offline": "أوفلاين",
+  "status.degraded": "مينفعش الوصول إليها",
+  "status.unknown": "لم يتم فحصها بعد",
+  "nav.skip": "روح للمحتوى",
+  "nav.main": "الرئيسية",
+  "nav.mints": "دور سكّ Cashu",
+  "nav.reviews": "التقييمات",
+  "nav.wallets": "المحافظ",
+  "nav.about": "بشأن",
+  "nav.searchMints": "دوّر في {n} دار سكّ",
+  "lang.label": "اللغة",
+  "lang.switcher": "اختار لغة",
+  "footer.copyright": "© {year} Cashumints.space",
+  "footer.allMints": "كل دور سكّ Cashu",
+  "footer.allReviews": "كل التقييمات",
+  "footer.wallets": "المحافظ",
+  "footer.about": "بشأن",
+  "footer.disclaimer": "إخلاء المسؤولية",
+  "footer.terms": "الشروط",
+  "footer.privacy": "الخصوصية",
+  "footer.madeBy": "اتعمل بـ ❤️ بواسطة {azzamo} · بدعم Cashu وNIP-87",
+  "footer.warning": "دور السكّ بتحفظ فلوسك عندها. أي دار سكّ ممكن تختفي بفلوسك.",
+  "footer.tagline": "تقييمات المجتمع لدور سكّ ecash، موقّعة على Nostr.",
+  "footer.col.explore": "استكشف",
+  "footer.col.site": "الموقع",
+  "footer.nav": "تذييل الصفحة",
+  "home.title": "Cashumints.space · لاقي دار سكّ Cashu تقدر تثق فيها",
+  "home.description": "لاقي دار سكّ Cashu تقدر تثق فيها. عندنا {mints} دار سكّ مفهرسة و{reviews} مراجعة من المجتمع ومتوقعة على Nostr، مع حالة التشغيل المباشرة وNUTs المدعومة وبرنامج دار السكّ.",
+  "home.hero.title": "لاقي دار سكّ Cashu",
+  "home.hero.titleEm": "تقدر الثقة",
+  "home.hero.lede": "كل دار سكّ على شبكة Nostr مع استعراضات حقيقية للمجتمع لا بوّابات، بس وقّعَ الاستعراضاتَ إنت يُمْكِنُ أَنْ تَتأكّدَ نفسك.",
+  "home.search.label": "فتش الدار سكّ بالاسم أو النطاق أو URL",
+  "home.search.placeholder": "البحث بالاسم أو المجال أو المعاكرونة",
+  "home.filters.mostReviewed": "معظم الاستعراضات",
+  "home.filters.highestRated": "أعلى معدل",
+  "home.filters.recentlyActive": "نشط مؤخرا",
+  "home.filters.websockets": "خدمات الدعم على الشبكة العالمية",
+  "home.top.title": "الدار سكّ اليكاشف",
+  "home.top.sub": "مصنفة حسب الاستعراضات والتقييم",
+  "home.top.all": "كل دور السكّ وعددها {n} ←",
+  "home.latest.title": "آخر استعراضات",
+  "home.latest.sub": "مباشرة من شبكة Nostr",
+  "home.latest.prev": "الاستعراضات السابقة",
+  "home.latest.next": "المزيد من الاستعراضات",
+  "home.latest.all": "جميع الاستعراضات",
+  "home.latest.empty": "مينفعش قراءة أي استعراضات من عمليات النقل دلوقتي افتح أي صفحة نعن لقراءة وكتابة الاستعراضات مباشرة.",
+  "home.why.title": "لماذا تثق بدي الاستعراضات؟",
+  "home.why.signed.title": "توقيع، لم يقدم",
+  "home.why.signed.body": "كل استعراض هو {link} حدث وقع من قبل مفتاح كاتبه Nostr مفيش حاجة هنا يتم تحريره أو ترتيبه أو نقله من قبلنا",
+  "home.why.signed.link": "NIP-87",
+  "home.why.verify.title": "تحقق بنفسك",
+  "home.why.verify.body": "الاستعراضات تَعِيشُ على عملياتِ نوتستر العامةِ، لَيسَ قاعدةَ بياناتنا. نوجه أي زبون في نفس المسارات وسترى نفس البيانات",
+  "home.why.checked.title": "تم التحقق منها باستمرار",
+  "home.why.checked.body": "إحنا نفحص كل دار سكّ للوقت الاضافي ونسخة البرمجيات والحدود و ندعم نوتس لذا المواصفات التي تراها موجودة ولا تُبلغ عن نفسها",
+  "home.cta.title": "أتفكرين في الدار سكّ؟ إقرأه أولاً",
+  "home.cta.body": "الدار سكّ يمسك كشائك اقرأوا ما وجده الآخرون قبل ما تضعوا جلساتكم و تتركوا مراجعة لما استخدمتم واحدة بنفسكم",
+  "home.cta.explore": "استكشاف كل الدار سكّ",
+  "home.cta.learn": "تعلم بشأن (كاش)",
+  "pulse.mintsIndexed": "دار سكّ مفهرسة",
+  "pulse.reviewsOnNostr": "عمليات استعراض نوتستر",
+  "pulse.lastReview": "الاستعراض الأخير",
+  "pulse.mintsOnline": "الدار سكّ على الإنترنت",
+  "pulse.indexer": "الرقم القياسي",
+  "pulse.connected": "متصل",
+  "pulse.stale": "قديم",
+  "mints.title": "كل دور سكّ Cashu · Cashumints.space",
+  "mints.description": "كل دور سكّ Cashu وعددها {total} والمفهرسة من Nostr: ‏{online} أونلاين و{offline} أوفلاين، مع تقييمات المجتمع ووقت التشغيل وبرنامج دار السكّ. دوّر ورتّب القائمة كاملة.",
+  "mints.heading": "كل دور سكّ Cashu",
+  "mints.lede": "كل دار سكّ اكتشفت على شبكة Nostr بما في ذليك التي اختفت الدار سكّ الخارجي يبقى في القائمة حتى تقدر العثور عليها واستعراضها",
+  "mints.search.label": "دار سكّ البحث بالاسم أو المجال",
+  "mints.search.placeholder": "البحث بالاسم أو المجال...",
+  "mints.sort.label": "الدار سكّ",
+  "mints.sort.score": "أفضل عام",
+  "mints.sort.rating": "أعلى معدل",
+  "mints.sort.reviews": "معظم الاستعراضات",
+  "mints.sort.recent": "جرى استعراضها مؤخرا",
+  "mints.sort.seen": "شوهد مؤخرا على الإنترنت",
+  "mints.hideOffline": "إخفاء خارج الخط",
+  "mints.showing": "بنعرض {total} دار سكّ ({online} أونلاين، {offline} أوفلاين)",
+  "mints.showingFiltered": "بنعرض {shown} من {total} دار سكّ ({online} أونلاين، {offline} أوفلاين)",
+  "mints.noResults": "مفيش دور سكّ مطابقة. جرّب دومين أو الصق URL لدار سكّ.",
+  "mints.clearSearch": "أخلوا البحث",
+  "card.noRatings": "لا تقديرات بعد",
+  "card.reviews.one": "{n}",
+  "card.reviews.other": "{n}",
+  "card.lastSeen": "{when} شوهد آخر مرة",
+  "card.neverSeen": "لم أره على الإنترنت",
+  "card.reviewed": "اتراجعت {when}",
+  "card.noReviews": "لم تجر أي استعراضات بعد",
+  "mint.title": "مراجعات دار سكّ Cashu ‏{name}",
+  "mint.titleFedimint": "{name} · مراجعات اتحاد Fedimint",
+  "mint.titleLnurl": "{name} · مراجعات mint من نوع LNURL",
+  "mint.breadcrumb": "مسار الصفحة",
+  "mint.crumbMints": "النقدية الدار سكّ",
+  "mint.copyUrl": "نسخ دار سكّ URL",
+  "mint.qrButton": "QR لدار السكّ",
+  "mint.writeReview": "كتابة استعراض",
+  "mint.rankByScore": "# {rank} بالنتيجة",
+  "mint.tagLightning": "Lightning",
+  "mint.summary": "موجز مصغر",
+  "mint.rating.label": "التقييم المجتمعي",
+  "mint.rating.none": "لا تقديرات بعد",
+  "mint.rating.reviews.one": "{n}",
+  "mint.rating.reviews.other": "{n}",
+  "mint.rating.unrated.one": "{n} لم يترك أي تقدير",
+  "mint.rating.unrated.other": "{n} لم يترك أي تقدير",
+  "mint.activity.label": "النشاط",
+  "mint.activity.since": "منذ الاستعراض الأخير",
+  "mint.activity.noReviews": "لم تجر أي استعراضات بعد",
+  "mint.activity.recent.one": "{n} استعراض أجري في التسعين يوما الماضية",
+  "mint.activity.recent.other": "{n} استعراضات في التسعين يوما الماضية",
+  "mint.limits.label": "الحدود",
+  "mint.limits.notPublished": "غير منشورة",
+  "mint.limits.min": "الحد الأدنى",
+  "mint.limits.max": "الحد الأقصى",
+  "mint.limits.mintRow": "السكّ",
+  "mint.limits.meltRow": "الذوبان",
+  "mint.limits.disabled": "المعوقين",
+  "mint.limits.range": "{min} إلى {max} {unit}",
+  "mint.limits.upTo": "حتى {max} {unit}",
+  "mint.limits.from": "من {min} {unit}",
+  "mint.software.label": "برمجيات متنقلة",
+  "mint.software.unknown": "مجهول",
+  "mint.checked": "{when}",
+  "mint.lastSeen": "{when} شوهد آخر مرة",
+  "mint.neverReached": "لم تصل أبداً",
+  "mint.uptime.checks": "{ok} من آخر {total} شيكات يمكن الوصول إليها",
+  "mint.uptime.percent": "{percent} في المائة يمكن الوصول إليها على مدى 30 يوما",
+  "mint.uptime.description": "{ok} من آخر {total} شيك",
+  "mint.operator.title": "من المشغل",
+  "mint.operator.motd": "رسالة اليوم",
+  "mint.operator.beta": "ده الدار سكّ يصف نفسه بأنه تجريبي أو في بيتا اقرأ كلمات المشغل تحت قبل تخزين أي شيء مش هتقدر أن تخسره",
+  "mint.nuts.title": "وحدات غير حكومية مدعومة",
+  "mint.nuts.noneOffline": "مفيش قائمة بـ (ن.ت) مخبأة لده الدار سكّ، إنقطعت عن اعشانظار قبل تسجيل واحد.",
+  "mint.nuts.noneYet": "مفيش قائمة بـ (ن.ت) مجهزة لده الدار سكّ بعد",
+  "mint.nuts.supported": "بتدعم {n} من أصل {total} من NUTs المعروفة",
+  "mint.nuts.whatAre": "ما هي NUTs؟",
+  "mint.nutRow.disabled": "المعوقين",
+  "mint.nutRow.notSupported": "غير مدعوم",
+  "mint.details.title": "تفاصيل دقيقة",
+  "mint.details.pubkey": "المفتاح العام",
+  "mint.details.nostr": "Nostr",
+  "mint.details.email": "الإيميل",
+  "mint.details.serverTime": "وقت الخدمة",
+  "mint.details.firstSeen": "شوهدت أول مرة",
+  "mint.details.terms": "المصطلحات",
+  "mint.kind.identifier": "محدد الهوية",
+  "mint.kind.mintPubkey": "لحم الدار سكّ",
+  "mint.kind.nostrAddress": "عنوان Nostr",
+  "mint.kind.emailAddress": "عنوان البريد الإليكتروني",
+  "mint.kind.npub": "npub",
+  "mint.disclaimer": "ده الدار سكّ متحفظ، إنه يحمل ماليك، ويمكنه التوقف عن فعل ذليك في أي وقت. فالرات هي آراء مجتمعية ووسائل على الإنترنت يمكن الوصول إليها ومش جديرة بالثقة.",
+  "mint.disclaimerLink": "اقرأ المصل اليكامل",
+  "mint.qr.title": "إضافة {name} إلى محفظتك",
+  "mint.qr.note": "امسح ده بمحفظة (Cashu) لإضافة الدار سكّ، أو انسخ الـ (يور إل) و اربطه",
+  "mint.qr.warn": "إضافة الدار سكّ يعني ثقته بأمواليك",
+  "mint.qr.whatMeans": "ماذا يعني ذليك؟",
+  "mint.qr.wallets": "الجدران التي تدعم Cashu",
+  "mint.chip.frozen": "متجمّدة",
+  "mint.chip.noWithdrawals": "لا انسحابات",
+  "mint.chip.meltOnly": "ميلت بس",
+  "mint.warnings.dayCount.one": "{n} يوما",
+  "mint.warnings.dayCount.other": "{n} يوما",
+  "mint.warnings.gone.lead": "من المحتمل أنه ذهب",
+  "mint.warnings.gone.body.since": "دار السكّ دي مش متاحة من {date} ({days}). اعتبر الفلوس اللي فيها معرّضة للخطر، وماتبعتش فلوس جديدة. التفاصيل تحت بتعرض آخر حالة معروفة ليها.",
+  "mint.warnings.gone.body.neverDated": "ده الدار سكّ لم يجيب على شيك واحد منذ أن بدأنا مشاهدته في {month} معالجة الأموال المحتفظ بها هناك على أنها معرضة للخطر، ولا ترسل أموالا جديدة. أي شيء أسفل جاء من إعلان Nostr، ومش من الدار سكّ.",
+  "mint.warnings.gone.body.never": "ده الدار سكّ لم يجيب على شيك واحد منذ أن بدأنا مشاهدته معالجة الأموال المحتفظ بها هناك على أنها معرضة للخطر، ولا ترسل أموالا جديدة. أي شيء أسفل جاء من إعلان Nostr، ومش من الدار سكّ.",
+  "mint.warnings.gone.meta.since": "المبلغ النهائي منذ {date}",
+  "mint.warnings.gone.meta.never": "مينفعش الوصول إليها منذ أن تم اكتشافها",
+  "mint.warnings.meltDisabled.lead": "سحب معوق.",
+  "mint.warnings.meltDisabled.body.online": "ده الدار سكّ يذوب Lightning (نوت 05) ويُمكنُكَ أن تُجلس، ليكن لا يُمكنكَ سحبهم عبر Lightning. لا تُودع حتى يعود الإنصهار",
+  "mint.warnings.meltDisabled.body.offline": "ده الدار سكِّ كَانَ عِنْدَهُ الإنصهارُ Lightningِ (NUT-05) انطفأْ: إنت يُمْكِنُ أَنْ تَضِعَ في، لَكنَّك لا تَستطيعُ سحبهم عبر Lightningِ. لا تُودع حتى يعود الإنصهار",
+  "mint.warnings.meltDisabled.meta.online": "معوقات حاليا",
+  "mint.warnings.meltDisabled.meta.offline": "تم تعطيل السحب لما شوهد آخر مرة",
+  "mint.warnings.frozen.lead": "مجمدة",
+  "mint.warnings.frozen.body.online": "النسيج والذوبان معاقان مينفعش للجلسات أن تنتقل أو تخرج عبر Lightning",
+  "mint.warnings.frozen.body.offline": "تم تعطيل كل من التنين والذوبان. مينفعش للجلسات أن تنتقل أو تخرج عبر Lightning",
+  "mint.warnings.frozen.meta.online": "مفيش حاجة يتحرك أو يخرج",
+  "mint.warnings.frozen.meta.offline": "تجمد لما شوهد آخر مرة",
+  "mint.warnings.offlineLong.lead": "أوفلاين بقالها {days}، من {date}.",
+  "mint.warnings.offlineLong.body": "قد يختفي الدار سكّ كل شيء تحتها هو آخر حالة معروفة، والاستعراضات لا تزال تعمل.",
+  "mint.warnings.offlineLong.meta": "المبلغ النهائي منذ {date}",
+  "mint.warnings.meltOnly.lead": "ملطخة بس",
+  "mint.warnings.meltOnly.body.online": "النسيج الجديد معوق: مش هتقدر الإيداع، ليكن اليكشب الحالي يمكن سحبه. ده غالباً ما يعني أن الدار سكّ ينخفض لذا إن أمسكت به، فكّر في الإنصهار",
+  "mint.warnings.meltOnly.body.offline": "تم تعطيل النسيج الجديد (NUT-04): مش هتقدر الإيداع، بس اليكشب الحالي لسه يمكن سحبه. ده غالباً ما يعني أن الدار سكّ ينخفض لذا إن أمسكت به، فكّر في الإنصهار",
+  "mint.warnings.meltOnly.meta.online": "دلوقتي يذوب بس",
+  "mint.warnings.meltOnly.meta.offline": "(ميلت) بس لما شوهد آخر مرة",
+  "mint.warnings.offline.lead": "مسافر منذ {date}",
+  "mint.warnings.offline.body": "تم تأكيد آخر التفاصيل ما زال بإمكانك كتابة مراجعة",
+  "mint.warnings.offline.meta": "المبلغ النهائي منذ {date}",
+  "mint.warnings.also.meltDisabled": "قبل ما تنفجر كان لديها أيضاً سحبات معاقه",
+  "mint.warnings.also.mintDisabled": "قبل ما تنفجر، كان أيضاً قد عطّل نغمة جديدة.",
+  "mint.warnings.also.offline": "وكمان أوفلاين من {date} ({days}).",
+  "nut.0": "الإخطار والنماذج",
+  "nut.1": "مقايضة المفاتيح العامة",
+  "nut.2": "المقايض والرسوم",
+  "nut.3": "مبادلات",
+  "nut.4": "التعدين عن طريق Lightning",
+  "nut.5": "الميل عن طريق Lightning",
+  "nut.6": "معلومات دقيقة",
+  "nut.7": "تفتيش الدولة الطرف",
+  "nut.8": "رسوم Lightning الزائدة المدفوعة",
+  "nut.9": "التوقيعات التقييدية",
+  "nut.10": "شروط الإنفاق",
+  "nut.11": "الدفع للمفتاح العام",
+  "nut.12": "براهين DLEQ",
+  "nut.13": "أسرار محددة",
+  "nut.14": "العقود المتعلقة بالوقت المحدد",
+  "nut.15": "المدفوعات المتعددة الجنسيات",
+  "nut.16": "رموز كمية متحركة",
+  "nut.17": "اشتراكات الشبكة",
+  "nut.18": "طلبات الدفع",
+  "nut.19": "الردود المفصَّلة",
+  "nut.20": "اقتباسات موقعة من الدار سكّ",
+  "nut.21": "التوثيق",
+  "nut.22": "التوثيق الأعمى",
+  "nut.23": "طريقة الدفع BOLT11",
+  "nut.24": "المبلغ المطلوب",
+  "nut.25": "طريقة الدفع BOLT12",
+  "reviews.title": "الاستعراضات",
+  "reviews.anon": "مجهول",
+  "reviews.anonTitle": "لم يعثر على أي ملف عام لده المفتاح",
+  "reviews.nip05Title": "مُحدِّد هوية NIP-05 (لم يتحقق من ذليك في الموقع ده)",
+  "reviews.filter.group": "استعراضات الملفات",
+  "reviews.filter.all": "كل شيء",
+  "reviews.filter.five": "5★",
+  "reviews.filter.critical": "حرجة",
+  "reviews.filter.recent": "حديثة",
+  "reviews.filter.hideAnon": "اختبئ",
+  "reviews.anonHidden.other": "عرض {n} من {total} استعراضات: آنون مخبأ.",
+  "reviews.allAnon.one": "الاستعراض الوحيد هنا هو (آن)",
+  "reviews.allAnon.other": "جميع استعراضات الـ {n} هنا هي آن",
+  "reviews.allAnonShow.one": "أريه",
+  "reviews.allAnonShow.other": "أرهم",
+  "reviews.loading.one": "بنحمّل {n} مراجعة من مرحّلات Nostr",
+  "reviews.loading.other": "بنحمّل {n} مراجعات من مرحّلات Nostr",
+  "reviews.empty": "لا استعراضات بعد سيكون الأول ليكتابة واحدة.",
+  "reviews.emptyWritten": "لا استعراضات مكتوبة هنا بعد. سيكون الأول ليكتابة واحدة.",
+  "reviews.emptyFilter": "لا استعراضات تطابق ده المرشح",
+  "reviews.rate.cashu": "قيّم جهة الإصدار دي",
+  "reviews.rate.fedimint": "قيّم الاتحاد ده",
+  "reviews.rate.lnurl": "قيّم جهة الإصدار دي",
+  "reviews.noscript": "(الاستعراضات موقعة على (Nostr وتحمّل في مركبك لذا دي القائمة تحتاج (جافاسكريت فالتقديرات والعدادات الواردة أعلاه تأتي من الموقع نفسه.",
+  "reviews.relayError": "مينفعش أن تصل إلى النفقة. وقد تكون الاستعراضات غير كاملة.",
+  "reviews.srRating": "{rating} من 5",
+  "reviews.srNoRating": "مفيش تقييم",
+  "reviews.readMore": "اقرأ المزيد",
+  "reviews.readLess": "عرض أقل",
+  "reviews.actions.copyNpub": "نسخة رقم npub",
+  "reviews.actions.openNostr": "مشاهدة ده الحدث في Nostr",
+  "reviews.actions.copyLink": "وصلة نسخ بده الاستعراض",
+  "reviews.anonNote": "دي أول مراجعة من الـnpub ده، ومفيش نشاط تاني ليه",
+  "reviews.published": "نُشرت",
+  "reviews.publishedPartial": "نُشرت إلى {accepted} من {total} إعادة شحن.",
+  "reviews.propagating": "بننشر على موزّعات Nostr",
+  "reviews.summary.line.one": "{count} تصنيف دون تعليق: {breakdown}",
+  "reviews.summary.line.other": "{count} تصنيف دون تعليق: {breakdown}",
+  "reviews.summary.lineDay.one": "{count} تصنيف دون تعليق على {when}: {breakdown}",
+  "reviews.summary.lineDay.other": "{count} تصنيف دون تعليق على {when}: {breakdown}",
+  "reviews.summary.showOne": "أريه",
+  "reviews.summary.showMany": "أرهم",
+  "reviews.breakdown.5": "{n} 5 نجم",
+  "reviews.breakdown.4": "{n} نجم",
+  "reviews.breakdown.3": "{n} 3",
+  "reviews.breakdown.2": "{n} نجمان",
+  "reviews.breakdown.1": "{n} نجم واحد",
+  "reviews.breakdown.none": "{n} بدون تصنيف",
+  "reviews.dialog.title": "راجع {name}",
+  "reviews.dialog.lede.cashu": "احكيلنا تجربتك مع جهة الإصدار دي.",
+  "reviews.dialog.lede.fedimint": "احكيلنا تجربتك مع الاتحاد ده.",
+  "reviews.dialog.lede.lnurl": "احكيلنا تجربتك مع جهة الإصدار دي.",
+  "reviews.dialog.permanent": "بيتنشر بشكل دائم على موزّعات Nostr العامة.",
+  "reviews.dialog.gate.title": "سجّل الدخول عشان تكتب تقييم",
+  "reviews.dialog.gate.lead": "التقييمات بتتوقّع بمفتاح Nostr بتاعك. المفتاح بيفضل في المُوقِّع، والموقع ده عمره ما بيشوفه.",
+  "reviews.dialog.ratingLegend": "تقديرك",
+  "reviews.dialog.starsSr.one": "{n}",
+  "reviews.dialog.starsSr.other": "{n} نجوم",
+  "reviews.dialog.chooseRating": "اختيار تقدير",
+  "reviews.dialog.starLabel": "{n}: {phrase}",
+  "reviews.dialog.stars.1": "تجنب ذليك",
+  "reviews.dialog.stars.2": "مشاكل",
+  "reviews.dialog.stars.3": "عملت مع كهوف",
+  "reviews.dialog.stars.4": "جيد",
+  "reviews.dialog.stars.5": "عمل رائع",
+  "reviews.dialog.bodyLabel": "ماذا لازم يعرف الآخرون؟",
+  "reviews.dialog.charCount": "{n} / {max}",
+  "reviews.dialog.submit": "التوقيع والنشر",
+  "reviews.dialog.signing": "التوقيع...",
+  "reviews.dialog.publishing": "النشر...",
+  "reviews.dialog.publishingTo": "النشر للتأخيرات ({accepted}/{total})",
+  "reviews.dialog.waitingExtension": "في انتظار التمديد",
+  "reviews.dialog.waitingSigner": "في انتظار توقيعك",
+  "reviews.dialog.confirmClose": "إغلاق ده الاستعراض؟ مشروعك محتفظ به حتى تغادر الموقع",
+  "reviews.dialog.why.login": "تسجيل في النشر",
+  "reviews.dialog.why.words": "أكتب بضع كلمات",
+  "reviews.dialog.why.more.one": "{n} شخصية أخرى",
+  "reviews.dialog.why.more.other": "{n} المزيد من الشخصيات",
+  "reviews.dialog.why.over.one": "{n} شخصية على الحد الأقصى",
+  "reviews.dialog.why.over.other": "{n} شخصيات فوق الحد",
+  "reviews.dialog.identity.needSigner": "تحتاج لتوقيع Nostr للنشر مفتاحك يبقى فيه الموقع ده لا يراه",
+  "reviews.dialog.identity.loginToPublish": "تسجيل في النشر",
+  "reviews.dialog.identity.switch": "غيّر",
+  "reviews.dialog.identity.extension": "التوقيع على التمديد الخاص بك",
+  "reviews.dialog.identity.readingKey": "قراءة مفتاحك العام",
+  "reviews.dialog.identity.willAsk": "طلب منك أن توقع",
+  "reviews.dialog.error.noRelay": "ولم يقبل أي تأخير الاستعراض. تحقق من اتصاليك، ثم حاول تاني.",
+  "reviews.validate.rating": "اختار تقدير من 1 إلى 5 نجوم",
+  "reviews.validate.short": "أكتب ما لا يقل عن {n} شخصية ليكي يكون الاستعراض مفيداً.",
+  "reviews.validate.long": "وتقتصر عمليات الاستعراض على {n} شخصية.",
+  "feed.title": "أحدث تقييمات دور السكّ والاتحادات · Cashumints.space",
+  "feed.description": "كل مراجعة لمنّاتة أو اتحاد أو منّاتة LNURL فور نشرها: {reviews} مراجعة تغطي {mints} منّاتة Cashu و{federations} اتحاد Fedimint و{lnurl} منّاتة LNURL، موقّعة على Nostr ومقروءة هنا من الأحدث. صفِّ حسب المنظومة أو التقييم أو الاسم.",
+  "feed.heading": "آخر استعراضات",
+  "feed.lede": "كل استعراض ليكل اتحاد من اتحادات الدار سكّ والFedimint، أولها، يقرأ مباشرة من نوتستر. ويوقع كل واحد منهم من جانب مؤلفه ويعيش في المناورات، ومش في قاعدة بياناتنا.",
+  "feed.label": "الاستعراضات",
+  "feed.showingBuild.one": "عرض أحدث استعراض من آخر بناء",
+  "feed.showingBuild.other": "{n} عرض آخر استعراضات من المبنى الأخير",
+  "feed.noscript": "المراجعات متوقعة على Nostr وبتتحمّل في متصفحك، عشان كده التصفية والقائمة الكاملة محتاجين JavaScript. المراجعات الـ{n} اللي تحت اتقرت من المرحّلات وقت بناء الصفحة.",
+  "feed.emptyBuild": "مقدرناش نقرا مراجعات من المرحّلات وقت بناء الصفحة. القائمة هتتحمّل تاني من المرحّلات في متصفحك.",
+  "feed.foot": "فالاستعراضات هي آراء مجتمعية، ومش مطالبات متحقق منها. اقرأي الرقم {link} قبل ما تثقي بالدار سكّ بالمال",
+  "feed.footLink": "الملتمس",
+  "feed.showing": "عرض {shown} من {total}",
+  "feed.showingMatching": "عرض {shown} من {matching} استعراضات مطابقة ({total} في المجموع)",
+  "feed.emptyRelays": "لم تعد أي استعراضات من المؤخرات افتح أي صفحة نعن لقراءة وكتابة الاستعراضات هناك",
+  "feed.emptyFilter": "لا استعراضات تطابق ده المرشح أخلوا صندوق الدار سكّ أو حاولوا جميعاً",
+  "feed.relayError": "لم أستطع الوصول إلى التوابيت عرض الاستعراضات من المبنى الأخير.",
+  "feed.relayEmpty": "لم تعد أي استعراضات من المؤخرات عرض الاستعراضات من المبنى الأخير.",
+  "feed.reading": "اقرأ التوابيت",
+  "login.open": "تسجيل الدخول",
+  "login.title": "اركب مع (Nostr)",
+  "login.note": "مفتاحك يبقى في موقّعك الموقع ده لا يستطيع رؤيته",
+  "login.extension.name": "التمديد",
+  "login.extension.desc": "وقع مع (ألبي) أو (نوكس) أو (ن.ب) آخر",
+  "login.extension.none": "مفيش إضافة متصفح",
+  "login.extension.getOne": "الحصول على واحد:",
+  "login.remote.name": "الإشارة عن بعد",
+  "login.remote.desc": "مسح رمز مع تطبيق لافتة، أو رعاة الرابط",
+  "login.primal.name": "Primal",
+  "login.primal.desc": "الموافقة على تسجيل الدخول في التطبيق الرئيسي على هاتفك",
+  "login.paste.label": "أَو يَعْبرُ الرابطَ اللاصقةَ التي أعطاها ليك",
+  "login.copyLink": "عُلم الصلة",
+  "login.whatIsNostr": "ما هو (Nostr)؟",
+  "login.connect.remote.title": "اتصل بعلامة نائية",
+  "login.connect.remote.lead": "افحص ده مع تطبيقك للتوقيع او انسخ الرابط واقطعه هناك",
+  "login.connect.remote.hint": "بيشتغل مع أي موقّع NIP-46: ‏nsec.app أو Amber أو Nostrify أو bunker بتاعك.",
+  "login.connect.remote.open": "افتح في تطبيقك",
+  "login.connect.primal.title": "اتصل بـPrimal",
+  "login.connect.primal.lead": "افتحي الجائزة على هاتفكِ، ابحثي عن توقيع بعيد في أماكنها، ومسحي ده الرمز.",
+  "login.connect.primal.hint": "Primal بيمضي للتطبيقات التانية عبر NIP-46، يعني ده نفس الاتصال اللي بيستخدمه أي موقّع، ومفتاحك بيفضل جوه Primal. ‏{link}",
+  "login.connect.primal.open": "مفتوحة في القطاع الخاص",
+  "login.status.buildingLink": "بناء وصلة وصل",
+  "login.status.waitingExtension": "في انتظار التمديد",
+  "login.status.waitingSigner": "في انتظار توقيعك",
+  "login.status.connecting": "الاتصال بعلامتك",
+  "login.status.connected": "متصل",
+  "login.toast.loggedIn": "تم تسجيل الدخول",
+  "login.toast.fetchingProfile": "بنجيب بروفايلك على Nostr من المرحّلات…",
+  "login.toast.profile": "البروفايل: {name}",
+  "login.toast.noProfile": "مفيش بروفايل اتلاقى على المرحّلات",
+  "login.method.extension": "التمديد",
+  "login.method.remote": "عن بُعد",
+  "login.method.primal": "Primal",
+  "login.account": "حساب Nostr",
+  "login.copyNpub": "عُلم",
+  "login.logout": "أخرج",
+  "signer.status.waitingExtension": "في انتظار التمديد",
+  "signer.status.signed": "توقيع",
+  "signer.status.reconnecting": "إعادة الاتصال بعلامتك",
+  "signer.status.approveWindow": "موقّعكَ يَحتاجُك لإقرار ده في نافذتِه الخاصةِ",
+  "signer.status.waitingSigner": "في انتظار توقيعك",
+  "signer.status.stillWaiting": "ما زالَ يَنتظرُ موقّعَكَ للإجابة",
+  "signer.status.connected": "متصل",
+  "signer.error.noExtension": "لم يتم العثور على تمديد للتوقيع اثبتي (ألبي) أو (نوس2كس) ثم أعيدي تحميل الصفحة دي",
+  "signer.error.privateKey": "ده يبدو كمفتاح خاص ومش وصلة الموقع ده لا يأخذ مفتاح عُذر المخبأ رقم الرابط الذي أعطاه ليك موقّعك",
+  "signer.error.badLink": "دي مش وصلة وصل يفهمها الموقع ده استلموا المخبأ من موقّعكم",
+  "signer.error.noAnswer": "موقّعك لم يجيب قد يكون مغلقاً، أو قد يكون نقله منخفضاً افتحه وحاول ثانية",
+  "signer.error.timeout": "موقّعك لم يجيب في الوقت المناسب افتحه، تأكد أنه لسه متصلاً ثم حاول تاني",
+  "signer.error.cancelled": "تم إلغاء الإتصال",
+  "signer.error.declined": "رفض طلب التوقيع",
+  "notfound.title": "الصفحة مش موجودة · Cashumints.space",
+  "notfound.description": "الصفحة دي مش موجودة على Cashumints.space.",
+  "notfound.heading": "الصفحة دي غير موجودة",
+  "notfound.lede": "قد يكون قد تحرك، أو قد لا يتم فهرسة الدار سكّ بعد. ابحث عن دار سكّ بالاسم أو المجال، أو عجينة الدار سكّ.",
+  "notfound.browse": "فجر كل الدار سكّ",
+  "notfound.home": "عودي للمنزل",
+  "notfound.loading": "الموقع {host}",
+  "notfound.fb.rating": "التقييم",
+  "notfound.fb.reviews": "الاستعراضات",
+  "notfound.fb.software": "البرمجيات",
+  "notfound.fb.lastOnline": "آخر الإنترنت",
+  "notfound.fb.note": "فُهرس هذا الـ mint بعد آخر بناء للموقع، لذا هذا ملخّص من الواجهة الحية، ومراجعاته أدناه. تظهر الصفحة الكاملة عند البناء التالي.",
+  "notfound.resolve.checking": "أول زيارة: بنفحص الـ mint ده دلوقتي.",
+  "notfound.resolve.failed": "تعذّرت إضافة هذا الـ mint",
+  "notfound.resolve.failedFedimint": "تعذّرت إضافة الاتحاد ده",
+  "notfound.resolve.retry": "جرّب عنوان تاني",
+  "notfound.resolve.switch": "افتحه بوصفه mint من نوع {kind}",
+  "notfound.resolve.fedimint": "عنوان صفحة الاتحاد لا يحمل رمز الدعوة الخاص به، لذا لا يمكن العثور عليه من الرابط وحده. ألصق رمز الدعوة وسيُضاف.",
+  "notfound.resolve.ambiguous": "لا يمكن استنتاج هذا العنوان من الرابط وحده. ألصق رابط الـ mint كاملًا وسيُضاف.",
+  "wallets.title": "محافظ Cashu · Cashumints.space",
+  "wallets.description": "محفظات (Cashu) التي تعمل مع الدار سكّ المدرجة هنا عبر الهواتف المحمولة والشبكات والبروزر وخط القيادة",
+  "wallets.heading": "الجدار",
+  "wallets.lede": "تحتاج إلى محفظة لحجز أي من دي الدار سكّ معظم المحافظ تتحدث مع العديد من الدار سكّ في آن واحد، لذليك إنت لا ترتبط مع أول واحد تحاول.",
+  "wallets.note": "القائمة دي مش كاملة ومش توصية. مشروع Cashu عنده فهرس أوسع على {link}. المحفظة بتمسك المفاتيح ودار السكّ بتمسك الفلوس؛ اقرا مراجعات دار السكّ قبل ما تختار تحط sats فين.",
+  "wallets.platform.android": "أندرو",
+  "wallets.platform.ios": "iOS",
+  "wallets.platform.web": "الويب",
+  "wallets.platform.extension": "التمديد",
+  "wallets.platform.cli": "CLI",
+  "wallets.platform.python": "Python",
+  "wallets.item.minibits": "محفظة اليكش المتحركة مع نعنتها الخاصة، دعم عنوان Lightning و اتصالات Nostr.",
+  "wallets.item.nutstash": "محفظة بروزر التي تتعامل مع دار سكّ متعددة في آن واحد، وواردات وصادرات الخنازير الخام.",
+  "wallets.item.enuts": "وركّزت محفظة متنقلة على أرصدة متعددة وأرسلت كاش على Nostr.",
+  "wallets.item.cashume": "محفظة ويب مرجعية من مشروع Cashu. بتشتغل بالكامل في المتصفح وممكن تثبّتها كتطبيق PWA.",
+  "wallets.item.boardwalk": "محفظة الإنترنت مبنية حول عناوين Lightning وإرسال اليكاش عن طريق الرابط",
+  "wallets.item.coinos": "محفظة Lightning ونقطة البيع التي تدير أيضاً محفظتها الخاصة",
+  "wallets.item.oxchat": "رسول Nostr مع محفظة كاش مبنية في، لإرسال جلس داخل الدردشة.",
+  "wallets.item.nutshell": "التنفيذ المرجعي. يعمل كمحفظة على خط القيادة و كبرمجيات الدار سكّ",
+  "about.title": "عن (Cashumints.space) الفضاء",
+  "about.description": "ما هو Cashu، ما هو الدار سكّ في الواقع، ما هو NIP-87 هو، وكيف الموقع ده يفهرس الدار سكّ ويقرأ استعراضات من توابع Nostr.",
+  "about.heading": "بشأن",
+  "about.lede": "(Cashumints.space)، يُذكر الفضاء كلّ دار سكّ كشوتو) يمكننا إيجادها على شبكة (Nostr) ويُريك ما يقوله الناس عنهم إنها مصنوعة من (أزامو)",
+  "about.cashu.title": "ما Cashu",
+  "about.cashu.p1": "(Cashu) هو بروتوكول كاش لـ(بيتكوين) مشاكل الدار سكّ المُعمى التي تُدعم بالجلسات التي تُمسك بها، ودي اليكسور تتحرك بين الناس بدون تعلم الدار سكّ الذي أرسل ما إلى من. إن الخصوصية حقيقية وها هي النقطة: إن اليكسور مش حسابات، ومينفعش للدار سكّ أن يربط الحبر الذي وقعه إلى القرد الذي يعود.",
+  "about.cashu.p2": "تقدر قراءة البروتوكول ومواصفاته في {link} المواصفات نفسها تُدعى (نوتس)، حيث تأتي أرقام (نوت) في كل صفحة نعنت.",
+  "about.mints.title": "ما هو الدار سكّ، والمقايضة",
+  "about.mints.p1": "الدار سكّ هو السجن لما تَخْدعُ تَدْفعُ جلسَاتَ إلى الذي يَرْكضُ ذليك الخادمِ، وإنت تَئتمنُهم لتَشْريف الملوكِ لما تَذوبُهم. مفيش دليل احتيالي، ولا تجسس ولا نقض. مشغل الدار سكّ ممكن يختفي مع التوازن، والدار سكّ قد.",
+  "about.mints.p2": "وده هو بالضبط سبب وجود عمليات استعراض هنا. الموقع ده لا يخبرك أن الدار سكّ آمن الحالة على صفحة الدار سكّ تقول {code}، ومش \"مئتمنة\"، وده يعني بس أن الخادم أجاب لما سألنا آخر مرة. معالجة الأرصدة النقدية مثل النقدية في جيب معطف: غرامة للنفقة، خطأ للوفورات.",
+  "about.nip87.title": "ما هو NIP-87",
+  "about.nip87.p1": "NIP-87 هو معيار Nostr للإعلان عن دور سكّ ecash والتوصية بيها. فيه نوعين أحداث مهمين هنا:",
+  "about.nip87.li1": "‏{code} بيعلن عن دار سكّ. عنوان URL بتاعها موجود في وسم {tag}. كده الموقع بيكتشف دور سكّ ماشافهاش قبل كده.",
+  "about.nip87.li2": "‏{code} عبارة عن مراجعة فيها التقييم والنص، وبتشير لدار السكّ بوسم {utag} (عنوان URL) ووسم {dtag} (المفتاح العام بتاع دار السكّ).",
+  "about.nip87.p2": "كل مراجعة تم توقيعها من قبل مفتاح (Nostr) الخاص بمؤلفها إحنا لا نَدْعو مراجعةَ \"مُحقّقَ\" عشان لا أحد يَتأكّدُ منه: هو موقّعُ، الذي a مطالبة مختلفة وأكثر فائدة. يعني أنه تقدر التحقق من من كتبها و أنه لم يتم تغييرها وده لا يعني أن صاحب البلاغ صادق أو أبداً يستخدم الدار سكّ.",
+  "about.how.title": "كيف يعمل الموقع ده",
+  "about.how.p1": "هناك حلقتان وقاعدة واحدة القاعدة هي أن الدار سكّ يمدي بياناته الوصفية و (Nostr) يمليك الاستعراضات لذا الموقع ده لا يخزن كسلطة",
+  "about.how.li1": "{strong} يسأل كل دار سكّ معروفة عن {code} كل عشر دقائق ويسجل ما يقوله: الاسم، الوصف، النسخة، دعم NUTs، الحدود، تفاصيل الاتصال. ويسجل أيضا ما لو كان الدار سكّ قد أجاب على الإطلاق، وهو المكان الذي يأتي منه الوقت الإضافي.",
+  "about.how.li1Label": "حلقة المسبار",
+  "about.how.li2": "{strong} يربط بنفقات Nostr كل ساعة، ويقرأ الإعلانات والاستعراضات الدار سكّ، ويضيف أي دار سكّ لم يشاهدها من قبل.",
+  "about.how.li2Label": "حلقة الاكتشاف",
+  "about.how.p2": "الجزء المهم هو ما يحدث لما يتوقف الدار سكّ عن الإجابة بياناتها المخبأة لا تُخطّى أبداً من قبل مسبار فاشل، لذا فإن الدار سكّ الميت يبقي صفحته اليكاملة: مواصفاته وتاريخه واستعراضاته، وأظهرت النسخة السابقة من الموقع ده صفحة خاطئة بدلا من ذليك، مما يعني أن الدار سكّ هم أكثر الناس احتياجا لتحذير بعضهم البعض من دي التي مينفعش استعراضها. كان ذليك السبب الرئيسي لإعادة البناء",
+  "about.how.p3": "النص الاستعراضي لا يُخزن أبداً على جانبنا. لما تفتح صفحتك الدار سكّه الخاصه بك تتحدث الى المصاريف مباشرة وتقرأ الاستعراضات نفسها ولما تكتب واحدة يتم توقيعها من قبل التمديد الخاص بك Nostr وترسل مباشرة الى دي المصاريف إحنا نحتفظ بالعد حتى يمكن ترتيب الصفحات وفرزها، مفيش حاجة أكثر. مفيش حاجة هنا يمكن تحريره أو حذفه من قبلنا، بما في ذليك الاستعراضات التي لا نفضل أن نجريها.",
+  "about.relays.title": "نفقات نقرأها",
+  "about.relays.p1": "دي هي الملصقات التي تستخدمها",
+  "about.relays.p2": "نوجه أيّ زبون من (Nostr) في نفس المسارات وسترى نفس الأحداث ده هو الوعد: مفيش حاجة هنا صحيح بس عشاننا نقول ذليك.",
+  "about.nuts.title": "ما هي NUTs؟",
+  "about.nuts.p1": "NUTs هي مواصفات Cashu المرقمة، زي BIPs في Bitcoin. دار السكّ بتعلن هي مطبّقة أنهي مواصفات، وده بيوضح تقدر تعمل إيه: ‏NUT-04 وNUT-05 للسكّ والصرف عبر Lightning، وNUT-07 بيسمح للمحفظة تتأكد لو التوكن اتصرف، وNUT-17 بيدي تحديثات مباشرة عبر WebSockets، وNUT-20 بيسمح للمحفظة تثبت إن عرض السكّ اتصدر ليها فعلًا. القائمة كاملة على {link}.",
+  "about.numbers.title": "دلوقتي",
+  "about.numbers.p1": "عندنا {mints} دار سكّ مفهرسة، {online} منها بيرد، و{reviews} مراجعة محسوبة من المرحّلات اللي فوق.",
+  "about.source.title": "المصدر والائتمان",
+  "about.source.p1": "الموقع مفتوح المصدر على {github}، وبناه وبيشغله {azzamo}. لو فيه حاجة غلط في صفحة دار سكّ، صلّحها عند المصدر: بيانات دار السكّ جاية من {code} بتاعها، والمراجعات جاية من Nostr.",
+  "terms.title": "شروط الاستخدام · Cashumints.space",
+  "terms.description": "شروط استخدام Cashumints.space: الموقع ده إيه، وبيعمل إيه ومش بيعمل إيه، ومين المسؤول عن إيه. مفيش حسابات، مفيش ضمانات، ومفيش أي ارتباط بأي دار سكّ.",
+  "terms.heading": "مدة الاستخدام",
+  "terms.lede": "{date} شروط دنيئة للموقع الذي يفهرس البيانات العامة بس آخر تحديث",
+  "terms.what.title": "ما الموقع ده",
+  "terms.what.p1": "(Cashumints.space) الفضاء هو مؤشر للبيانات المتاحة للجمهور عن الدار سكّ نوعان من البيانات، من مكان آخر:",
+  "terms.what.li1": "\"البيانات الفوقية المصغرة، مُقروءة من نقطة نهاية كل دار سكّ \"{code} اسم، وصف، نسخة برمجية، مُدعمة بـ \"نوتز\" وتفاصيل الاتصال و ما لو كان الدار سكّ قد أجاب لما سألنا آخر مرة",
+  "terms.what.li2": "المراجعات بتتقري من مرحّلات Nostr العامة. دي أحداث NIP-87 نشرها أصحابها على مرحّلات أي حد يقدر يستعلم منها.",
+  "terms.what.p2": "نجمع دي البيانات، نطبيعها، نرتبها ونريها إحنا لا نخلقه",
+  "terms.noAccounts.title": "لا حسابات، لا أوامر",
+  "terms.noAccounts.p1": "مفيش تسجيل. الموقع متاح زي ما هو من غير أي ضمان: لا إن البيانات دقيقة أو حديثة، ولا إن الموقع هيفضل متاح. بيانات دار السكّ ممكن تكون قديمة بدقايق أو ساعات، ودار السكّ ممكن تتغير بعد آخر فحص، والمرحّل ممكن مايردش، وساعتها هتشوف بيانات أقل من الموجود.",
+  "terms.noAccounts.p2": "استخدمه على مسؤوليتك. إحنا مش مسؤولين عن أي خسارة بسبب استخدام الموقع أو الاعتماد على حاجة قريتها هنا. شوف {link} عشان مخاطر استخدام دار سكّ Cashu بالتحديد.",
+  "terms.noAccounts.link": "الملتمس",
+  "terms.noCustody.title": "إحنا لا نحمل ماليك",
+  "terms.noCustody.p1": "الموقع دهِ لا يَأْخذُ حضانةَ الأموالِ. مش لديه محفظة ولا يلمس (كاش) ومينفعشه تحريك أو تجميد أو استعادة أي شيء لو كان عندك مشكلة مع الدار سكّ، مشغّل الدار سكّ هو الطرف الوحيد الذي ممكن يساعدك، وإحنا مينفعش الاتصال بهم نيابة عنك.",
+  "terms.noCustody.p2": "إحنا لا ننتسب إلى أي دار سكّ مدرجة هنا، ولا نعنت يدفع لقائمة أو رتبتها أو تصنيفها. وتكتشف المعادن من إعلانات نوست العامة وتصنفها خوارزمية على بيانات الاستعراض العام.",
+  "terms.reviews.title": "الاستعراضات هي كلمات الآخرين",
+  "terms.reviews.p1": "أما الاستعراضات فهي محتواها الذي ينشره المستعملون على عمليات نقل نوتر العلنية التي يقوم بها مؤلفوهم. إحنا نعرضهم إحنا لا نتحكم بهم ولم نكتبها، ومينفعشنا تحريرها، ومينفعشنا حذفها من المناورات التي تحملها: فهي أحداث موقعة على شبكة لا نمليكها.",
+  "terms.reviews.p2": "{link} الاستعراض هو تجربة شخص واحد ومش حقيقة مؤكدة لو نشرت واحدة، إنت مسؤول عن ما يقول. لا تنشر أي شيء غير قانوني، وتدرك أن ما تنشره عام ودائم (انظر 91827361).",
+  "terms.reviews.link": "الخصوصية",
+  "terms.reviews.p3": "ويمكننا أن نتوقف عن عرض استعراض محدد في الموقع ده، وسنفعل ذليك من أجل المحتوى غير القانوني. ده يزيله من دي الصفحات بس ده الحدث يبقى على المؤخرات وأي عميل آخر من (Nostr) يستطيع قراءته",
+  "terms.links.title": "الصلات بالمواقع الأخرى",
+  "terms.links.p1": "ووصلات المحافظ واتصالات المشغلين وكل شيء آخر يشير إلى الموقع ده هو هناك عشانها جزء من البيانات الرابط مش مصادقة وإحنا لا نعرف ما هو في النهاية الأخرى",
+  "terms.changes.title": "التغييرات",
+  "terms.changes.p1": "وممكن تتغير دي المصطلحات. التاريخ في القمة يقول لما فعلوا الموقع هو مصدر مفتوح، لذليك كل تغيير في الصفحة دي هو في تاريخ الالتزام.",
+  "terms.contact.title": "الاتصال",
+  "terms.contact.p1": "ومن الأفضل تقديم القضايا وطلبات التصفية في {github}. ويدير الموقع {azzamo}.",
+  "privacy.title": "الخصوصية · Cashumints.space",
+  "privacy.description": "الخصوصية على Cashumints.space: مفيش حسابات، مفيش كوكيز تتبّع، مفيش تحليلات. الـ localStorage بيتستخدم لتخزين البروفايلات مؤقتًا ومفيش أي حاجة بتتبعت لأي مكان. التقييمات بتتوقّع في المتصفح بتاعك.",
+  "privacy.heading": "الخصوصية",
+  "privacy.lede": "{date} نجمع القليل كما يمكن للموقع آخر تحديث",
+  "privacy.noAccounts.title": "مفيش حسابات",
+  "privacy.noAccounts.p1": "مش هناك إشارة، لا سجل ولا ملف مفيش حاجة في الموقع ده يسأليك من إنت ومفيش سجل للمستعملين للتسرب عشانه مفيش مستعملين",
+  "privacy.noTracking.title": "لا تتبع كوكيز، لا محللين",
+  "privacy.noTracking.p1": "الموقع لا يجهز اليكعك للتعقب ومفيش نص تحليلي، ولا مدير للعلامات، ولا بيكسيل، ولا تسجيل للجلسات ولا شبكة إعلانية. مفيش حاجة في الصفحة يُبلغ عن سلوكك لنا أو لأي شخص آخر",
+  "privacy.logs.title": "سجلات السيرفر",
+  "privacy.logs.p1": "الخادم على الشبكة يحتفظ بسجلات الدخول القياسية وده ما يفعله أي خادم على الشبكة سجل خط تسجيل عنوانك، الوقت، الصفحة التي طلبتها، حالة الرد، ووكيل المستعمل والمرجع الذي أرسلته وتوجد سجلات ليكشف الأخطاء وإساءة استعمال الأماكن. ولا ينضمون إلى أي شيء آخر ولا يتم بيعهم أو تقاسمهم.",
+  "privacy.logs.operatorLabel": "ملاحظة:",
+  "privacy.logs.operator": "لو كنت تدير الموقع ده، تذكر الاحتفاظ الحقيقي هنا. ويستخدم الوزع في نظام README (Migginx) مع سجل دخوله غير الافتراضي وأي تناوب في سفن التوزيع الخاصة بك (بشأن شركة Debian وUbuntu التي تعمل باللوغاريت، يوميا، مع الاحتفاظ بـ 14 يوما). تأكد ما يفعله خادمك ويستبدل دي الفقرة بالرقم",
+  "privacy.storage.title": "ما الذي يخزن في جهازك",
+  "privacy.storage.p1": "الموقع يستخدم تخزيناً محلياً لشيئين بالضبط، كلاهما يبقى على جهازك ولا يرسل إلى أي مكان",
+  "privacy.storage.li1": "نسخة مؤقتة من بيانات ملفات Nostr (أحداث kind 0: الأسماء والصور وعناوين NIP-05) للمراجعين اللي شوفت مراجعاتهم. ده بيوفّر الاستعلام من المرحّلات في كل صفحة. البيانات بتنتهي، والذاكرة المؤقتة ليها حد وبتشيل الأقدم الأول.",
+  "privacy.storage.li2": "الأفضليات المتقاطعة لذليك الموقع يتصرف بنفس الطريقة المرة القادمة",
+  "privacy.storage.p2": "تصفية بيانات موقعك تزيل كلاهما مفيش حاجة ينكسر، مظهر الملف يركض تاني",
+  "privacy.thirdParties.title": "ما الذي تتحدث عنه",
+  "privacy.thirdParties.p1": "وضع صفحة تربط منظفك ببعض الأماكن بجانب الموقع ده وده هو كيف أن الموقع الذي لا تتبع جانب الخادم لسه يقرأ البيانات الحية:",
+  "privacy.thirdParties.li1Label": "النشرات العامة",
+  "privacy.thirdParties.li1": "‏{strong} عبر WebSocket، لقراية المراجعات وملفات أصحابها. المرحّل بيشوف IP بتاعك والطلب، زي أي خادم بتتصل بيه. المرحّلات موجودة في {link}.",
+  "privacy.thirdParties.li1Link": "حول الصفحة",
+  "privacy.thirdParties.li2Label": "صور الأفاتار",
+  "privacy.thirdParties.li2": "{strong}، محشوة من أي مكان نقاط المستعرض. دي تُرسل بسياسة عدم الإحالات لذا لا يتعلم المضيف أي صفحة كنت عليها",
+  "privacy.publishing.title": "نشر استعراض",
+  "privacy.publishing.p1": "كتابة المراجعة بتحصل في متصفحك، مش على خادمنا. الحدث بيمضيه امتداد NIP-07 عندك (Alby أو nos2x أو شبيه) وبيتذاع من متصفحك للمرحّلات مباشرة. مفتاحك الخاص عمره ما بيسيب الامتداد والموقع مش بيشوفه. إحنا مابنبنيش إدارة مفاتيح خاصة ومابنطلبش مفتاح أو عبارة استرداد.",
+  "privacy.permanent.title": "أي شيء تنشره لـ(Nostr) عام ودائم",
+  "privacy.permanent.p1": "الجزء ده يستاهل تقراه مرتين. المراجعة حدث متوقّع على مرحّلات عامة. أول ما تتنشر، خلاص بقت عامة:",
+  "privacy.permanent.li1": "أي حد يقدر يقراها، دلوقتي وبعدين، بأي عميل Nostr. مش ”عامة على Cashumints.space“، دي عامة على الشبكة.",
+  "privacy.permanent.li2": "إنه مرتبط بشكل دائم بمفتاحك العام (Nostr) إلى جانب كل ما نشره المفتاح",
+  "privacy.permanent.li3": "حذفها طلب ومش أمر تقدر أن تنشري حدثاً للحذف وبعض البطاقات ستفي به ليكن النفقة حرّة في تجاهله وأي شخص قد نسخ الحدث معالجة استعراض منشور بصفة دائمة.",
+  "privacy.permanent.li4": "مينفعشنا حذفها ليك يمكننا أن نتوقف عن عرضه هنا، ذليك لا يغير شيئاً على البطولات.",
+  "privacy.permanent.p2": "لو كنت تريد مراجعة الدار سكّ دون أن يكون مرتبطا بهويتك الرئيسية، استخدام مفتاح نوتستر منفصل. ملاحظة أن المفتاح الذي مفيش فيه أي نشاط آخر يظهر على ده النحو في الاستعراضات القاسية، عشان اليكتابة الرئيسية الجديدة لعلامة تجارية هي استعراض نجم واحد هي نمط من القراء يستحقون رؤيته.",
+  "privacy.contact.title": "المسائل",
+  "privacy.contact.p1": "الموقع هو المصدر المفتوح: لو كنت تريد التحقق من أي من ما سبق، قراءة الرمز في {github}. الأسئلة والتصويبات ممكن تدخل في مشكلة هناك",
+  "disclaimer.title": "(Cashumints.space) الفضاء",
+  "disclaimer.description": "ما لازم تعرفه قبل ما تستخدم الدار سكّ اليكشاوي: الدار سكّ محجوز، الدار سكّ ممكن يختفي بأمواليك،",
+  "disclaimer.heading": "إخلاء المسؤولية",
+  "disclaimer.lede": "{date} إقرأ ده قبل ما تضع المال في الدار سكّ آخر تحديث",
+  "disclaimer.callout": "(Cashu نينت) يحتجز ماليك من أجليك لو اختفت، خندقك قد اختفى، ومش هناك من يناشد. احتفظ بس بما تستطيع أن تخسره",
+  "disclaimer.custodial.title": "النزلاء يحتجزون",
+  "disclaimer.custodial.p1": "لما تَدْعنُ كاش، تَدْعمُ قليلاً إلى مشغلِ الدار سكِّ ويُصبحُ توكرزَ ظهراً. دي الشارات هي مطالبة على ذليك المشغل. هم لَمْ يَعْضوكَ، والمشغل هو الذي يُقرّرُ أَنْ يَحترمَهم.",
+  "disclaimer.custodial.p2": "وده يعني أن كل دار سكّ تحمل نفس المخاطر: إذ يمكن للمشغل أن يختفي، ويمكن إجباره على التوقف، أو أن يفقد الأموال من خلال حشرة أو قرصنة، أو يمكن ببساطة أن يطفئ الخادم. ومفيش تأمين للودائع، ولا تحميل، ولا خط دعم، ومفيش أي سبيل انتصاف قانوني يستحق الاعتماد عليه. ده صحيح من أعلى الدار سكّ في الموقع ده",
+  "disclaimer.custodial.p3": "(Cashu) مصمم للمبالغ الصغيرة تتحرك بسرعة إستخدمه بدي الطريقة، أمسك ما إنت على وشك أن تنفقه، ومش مدخراتك، وتنشر عبر الدار سكّ بدلاً من وقوف كل شيء في واحد.",
+  "disclaimer.reviews.title": "الاستعراضات هي آراء، غير متحقق منها",
+  "disclaimer.reviews.p1": "كُلّ مراجعة هنا كَتبتْ مِن قِبل شخص ما على Nostr ووقعَ بمفتاحِهم. \"التوقيع\" يعني أننا نستطيع أن نخبرك أي مفتاح كتبها ولا يعني الاستعراض أن صاحب البلاغ استخدم الدار سكّ، أو أن صاحب البلاغ مش المشغل، أو المنافس، أو شخص واحد بعشرة مفاتيح.",
+  "disclaimer.reviews.p2": "إحنا لا نتحقق من المستعرضين، وإحنا لا نحرر أو نلغي الاستعراضات التي نختلف معها. اقرأ القليل، انظر إلى ما يقولونه في الواقع، ويزن دار سكّ مع ثلاثة استعراضات مختلفة عن واحد مع ثلاثمائة.",
+  "disclaimer.status.title": "أونلاين معناها متاحة، مش موثوقة",
+  "disclaimer.status.p1": "نتفقد كل دار سكّ بشكل منتظم ونظهر ما لو كانت الإجابة. وده كل ما يعنيه الوضع الأخضر: فقد رد الخادم. لا تقول شيئاً عما لو كان المشغّل مُذيباً، صادقاً، أو ما زال ينوي أن يُكرّم مُخلّفاتك غداً.",
+  "disclaimer.status.p2": "الدار سكّ ممكن يكون على الإنترنت حتى اللحظة التي لا يكون. التأريخ في وقت متأخر، دعم NUTs ونسخة البرمجيات أقول ليكم شيئا عن كيفية تشغيل الدار سكّ، بس لا أحد منهم وعد عن أمواليك.",
+  "disclaimer.ranking.title": "كيف يعمل الترتيب وما لا يعنيه",
+  "disclaimer.ranking.p1": "ويُصدر أمر عن القُصَّر خوارزمية بشأن بيانات الاستعراض العام: التقييم، وعدد الاستعراضات، والنشاط الأخير، مع اقتراب الدار سكّ على الإنترنت من الدار سكّ الخارجي عن طريق التقصير. التفاصيل في رمز المصدر المفتوح",
+  "disclaimer.ranking.p2": "لا أحد يدفع ثمن التنسيب مش هناك مكان مشرف، ولا قائمة معززة، ولا ترتيب مع أي دار سكّ في الموقع ده. درجة عالية تعني أن الخوارزمية كانت تحب البيانات العامة ومفيش حاجة أكثر وهي مش توصية ومش تقييما للسلامة.",
+  "disclaimer.notAdvice.title": "دي مش نصيحة مالية",
+  "disclaimer.notAdvice.p1": "ومفيش في الموقع ده أي نصائح مالية أو استثمارية أو قانونية أو ضريبية. إحنا لا نعرف موقفك وإحنا لا ننصحك استخدام الدار سكّ، واختيار أي واحد، هو قرارك.",
+  "disclaimer.dyor.title": "قم ببحثك الخاص",
+  "disclaimer.dyor.li1": "ابحث عن المشغل الدار سكّ الذي يديره شخص له سمعة عامة ليخسره هو عرض مختلف من URL مجهول.",
+  "disclaimer.dyor.li2": "اقرأي شروط الدار سكّ و داء الاغراض الدار سكّ الذي يسمي نفسه اختبار أو بيتا يعني ذليك.",
+  "disclaimer.dyor.li3": "ابدأي بالصغر قليلًا، أنفقه، أذيبه، وأرى ما سيحدث قبل ما تثق به أكثر.",
+  "disclaimer.dyor.li4": "راقب الحدود فغالبا ما يكون الحد الأقصى المنخفض علامة على وجود مشغِّل حريص، ولا يكون ارتفاعه علامة على وجود عامل آمن.",
+  "disclaimer.dyor.li5": "وتذكروا أن (توكن) هو من يمليكه",
+  "disclaimer.site.title": "حول الموقع نفسه",
+  "disclaimer.site.p1": "البيانات هنا ممكن تكون غلط أو قديمة. دور السكّ بتتفحص في مواعيد محددة، والمرحّلات ساعات مابتردش، والصفحة اللي بتقراها اتبنت في وقت سابق. الموقع متاح زي ما هو من غير ضمان. شوف {link}.",
+  "disclaimer.site.link": "المصطلحات المستخدمة",
+  "disclaimer.updated": "2026 آب/أغسطس",
+  "login.getPrimal": "الحصول على Primal",
+  "reviews.dialog.identity.extensionGone": "تمديدك لم يجيب اركب مرة اخرى او استخدم لافتة نائية",
+  "seo.orgDescription": "دليل لدور سكّ Cashu، بحالتها المباشرة ومراجعات المجتمع المتوقعة على Nostr.",
+  "seo.ogImageAlt": "(Cashumints.space)، الفضاء، ابحث عن (Cashu نين) تقدر الوثوق به.",
+  "seo.mint.title.one": "مراجعات {name}: تقييم {rating} من {n} مراجعة | Cashumints.space",
+  "seo.mint.title.other": "مراجعات {name}: تقييم {rating} من {n} مراجعات | Cashumints.space",
+  "seo.mint.titleOffline.one": "{name}: أوفلاين بقالها {n} يوم | Cashumints.space",
+  "seo.mint.titleOffline.other": "{name}: أوفلاين بقالها {n} يوم | Cashumints.space",
+  "seo.mint.titleNoReviews": "{name}: معلومات ومراجعات دار سكّ Cashu | Cashumints.space",
+  "seo.fedimint.titleNoReviews": "{name}: معلومات ومراجعات اتحاد Fedimint | Cashumints.space",
+  "seo.desc.fallback": "مراجعات المجتمع لـ{name} ‏({domain}).",
+  "seo.desc.fallbackDomain": "مراجعات المجتمع لدار سكّ Cashu على {domain}.",
+  "seo.desc.rated.one": "تقييم {rating}/5 من {n} مراجعة Nostr متوقعة.",
+  "seo.desc.rated.other": "تقييم {rating}/5 من {n} مراجعات Nostr متوقعة.",
+  "seo.desc.noReviews": "لا استعراضات بعد",
+  "seo.desc.status": "{status}.",
+  "seo.desc.statusLimits": "{status}، الحدود {limits}.",
+  "seo.desc.fedModules": "{status}. الوحدات: {modules}.",
+  "seo.desc.fedModulesNetwork": "{status}. الوحدات: {modules} على {network}.",
+  "seo.mint.ogAlt.one": "{name}: {rating} نجمة من {n} تقييم على Cashumints.space",
+  "seo.mint.ogAlt.other": "{name}: {rating} نجمة من {n} تقييمات على Cashumints.space",
+  "seo.mint.ogAltNoReviews": "{name} على Cashumints.space",
+  "nav.home": "البيت",
+  "mint.more.title": "المزيد من الدار سكّ",
+  "mint.more.all": "انظر كل الدار سكّ",
+  "nav.fedimints": "اتحادات Fedimint",
+  "status.announced": "بس",
+  "card.unnamedFederation": "الاتحاد غير المسمى",
+  "card.notChecked": "لم يتم فحصها",
+  "fedimints.title": "كل اتحادات Fedimint · Cashumints.space",
+  "fedimints.description": "كل اتحادات Fedimint وعددها {total} والمعلنة على Nostr: ‏{online} اتأكد إنها شغالة بفحص خارجي، و{announced} اتعلن عنها من غير تأكيد. تقييمات المجتمع والوحدات وأكواد الدعوة لكل اتحاد.",
+  "fedimints.heading": "جميع الاتحادات",
+  "fedimints.lede": "كل اتحاد Fedimint أعلن على شبكة Nostr ومفيش في الاتحاد نقطة نهاية خاصة بالمركز العام، لذا تأكد أن بعضها يجري من خلال شيك خارجي، والبقية مدرجة بالضبط كما أعلن عنها.",
+  "fedimints.search.label": "الاتحادات البحثية بالاسم أو العاطلة",
+  "fedimints.search.placeholder": "البحث بالاسم أو الاتحاد",
+  "fedimints.sort.label": "الاتحادات الترفيهية",
+  "fedimints.hideOffline": "إخفاء خارج الخط",
+  "fedimints.showing": "بنعرض {total} اتحاد ({online} اتأكد إنه شغال، و{announced} مُعلن بس)",
+  "fedimints.showingFiltered": "بنعرض {shown} من {total} اتحاد ({online} اتأكد إنه شغال، و{announced} مُعلن بس)",
+  "fedimints.announcedNote.one": "واحدة من دي تم الإعلان عنها في (Nostr) ولم يتأكد منها شيء منذ تشغيلها وهي مدرجة على النحو المعلن عنه بدلا من أن تكون على شبكة الإنترنت أو خارجها، عشان أيا منها لن يكون صحيحا.",
+  "fedimints.announcedNote.other": "أُعلن عن {n} من هؤلاء في Nostr ولم يتأكد أي شيء منذ تشغيلهم. وهي مدرجة على النحو المعلن عنه لا على أنها على شبكة الإنترنت أو خارجها، عشان أيا منها لن يكون صحيحا.",
+  "fedimints.noResults": "مفيش تطابق بين الاتحادات جربي اسماً، أو عانقي الاتحاد",
+  "fedimints.emptyIndex": "لم يتم الإعلان عن أي اتحادات في إعادة الموقع ده وتملأ القائمة نفسها لما تصل الإعلانات.",
+  "fedimint.crumb": "اتحادات Fedimint",
+  "fedimint.breadcrumb": "مسار الصفحة",
+  "fedimint.unnamed": "الاتحاد غير المسمى",
+  "fedimint.idLabel": "الاتحاد",
+  "fedimint.kind.federationId": "الاتحاد",
+  "fedimint.moduleCount.one": "{n}",
+  "fedimint.moduleCount.other": "{n} وحدة",
+  "fedimint.copyInvite": "رمز الدعوة",
+  "fedimint.confirmed.label": "تم تأكيدها",
+  "fedimint.confirmed.never": "أبداً",
+  "fedimint.confirmed.by": "بحلول عام {source}",
+  "fedimint.confirmed.unattributed": "الشيك الأخير",
+  "fedimint.announcedOn": "المعلنة {when}",
+  "fedimint.announcedUnknown": "تاريخ الإعلان",
+  "fedimint.modules.title": "الوحدات",
+  "fedimint.modules.none": "إعلان ده الاتحاد لا يورد أي وحدات",
+  "fedimint.modules.note": "الوحدات هي الأجزاء التي يديرها الاتحاد الإعلان يقول أيهما موجود، ومفيش حاجة حول ما لو كان أي منهما يقبل الودائع.",
+  "fedimint.modules.notListed": "غير مدرجة",
+  "fedimint.invite.title": "رمز دعوة",
+  "fedimint.invite.count.one": "{n} الرمز",
+  "fedimint.invite.count.other": "{n}رمز",
+  "fedimint.invite.note": "استرح ده في محفظة Fedimint للإنضمام إنها تحمل عناوين الإتحاد و الأوصياء عليها ومن المفترض أن يتم تقاسمها",
+  "fedimint.invite.kind": "رمز دعوة",
+  "fedimint.invite.qr": "QR",
+  "fedimint.invite.qrCaption": "امسح عشان تنضم لـ{name}",
+  "fedimint.details.federationId": "الاتحاد",
+  "fedimint.details.network": "الشبكة",
+  "fedimint.details.announcedBy": "أعلن",
+  "fedimint.details.announced": "إعلانات",
+  "fedimint.more.title": "المزيد من الاتحادات",
+  "fedimint.more.all": "انظر جميع الاتحادات",
+  "fedimint.disclaimer": "الإنضمام إلى الاتحاد يعني الثقة بأوليائه بأمواليك فالرات هي آراء مجتمعية، وتؤكد أن الركض وسيلة يمكن الوصول إليها ومش جديرة بالثقة.",
+  "fedimint.module.lightning": "Lightning",
+  "fedimint.module.mint": "دار سكّ ecash",
+  "fedimint.module.wallet": "محفظة الشاين",
+  "fedimint.module.meta": "البيانات الوصفية",
+  "fedimint.module.stability_pool": "مجمع الاستقرار",
+  "fedimint.module.multi_sig_stability_pool": "مجمع الاستقرار (مولتيسج)",
+  "fedimint.module.fedi-social": "التعافي الاجتماعي",
+  "fedimint.network.mainnet": "Btcoin",
+  "fedimint.network.signet": "Signet",
+  "fedimint.network.testnet": "Testnet",
+  "fedimint.network.testnet4": "Testnet4",
+  "fedimint.network.regtest": "الحكم",
+  "feed.ecosystem.group": "النظام الإيكولوجي",
+  "feed.ecosystem.all": "كل شيء",
+  "feed.ecosystem.cashu": "النقدية",
+  "feed.ecosystem.fedimint": "Fedimint",
+  "feed.filterBySubject": "ملء بواسطة الدار سكّ أو الاتحاد",
+  "feed.anySubject": "أي دار سكّ أو اتحاد",
+  "feed.clearSubject": "نظف الاسم",
+  "home.topFedimints.title": "Fedimints",
+  "home.topFedimints.sub": "مصنفة حسب الاستعراضات والتقييم",
+  "home.topFedimints.all": "{n} جميع الاتحادات",
+  "reviews.validate.subject": "مش هناك ما يشير إلى ده الاستعراض.",
+  "mint.warnings.fedimintOffline.lead": "أُبلغ عنه خارج الإنترنت",
+  "mint.warnings.fedimintOffline.body.since": "آخر فحص وصل للاتحاد ده كان يوم {date} (من {days}). الحراس ماردوش من وقتها. اعتبر الفلوس اللي هناك معرّضة للخطر، وماتنضمش بفلوس جديدة.",
+  "mint.warnings.fedimintOffline.body.never": "مفيش شيك لده الاتحاد قد وصل إليه، وآخر واحد فشل. معالجة الأموال المحتفظ بها هناك على أنها معرضة للخطر، ولا تنضم إليها بأموال جديدة.",
+  "mint.warnings.fedimintOffline.meta.since": "المبلغ عنها منذ {date}",
+  "mint.warnings.fedimintOffline.meta.never": "مُبلغ عنه خارج الإنترنت، لم يتم الوصول إليه من قبل",
+  "mint.warnings.neverConfirmed.lead": "لم يتم تأكيده",
+  "mint.warnings.neverConfirmed.body.reviewed": "الاتحاد ده اتعلن عنه على Nostr يوم {date}، من {days}، ومفيش حاجة أكدت من وقتها إنه شغال. المراجعات تحت هي علامة النشاط الوحيدة في الصفحة؛ وكل حاجة تانية جاية من الإعلان.",
+  "mint.warnings.neverConfirmed.body.quiet": "الاتحاد ده اتعلن عنه على Nostr يوم {date}، من {days}، ومفيش حاجة أكدت من وقتها إنه شغال، ومحدش راجعه قريب. كل اللي تحت جاي من الإعلان.",
+  "mint.warnings.neverConfirmed.meta": "اتعلن عنه {date}، وماتأكدش أبدًا",
+  "footer.allFedimints": "جميع الاتحادات",
+  "reviews.dialog.bodyPlaceholder.cashu": "كيف كان القذف والذوبان ودعم العمل؟ كن محدداً",
+  "reviews.dialog.bodyPlaceholder.fedimint": "كيف تم الإنضمام، ودفعات Lightning ودعم العمل؟ كن محدداً",
+  "fedimint.details.title": "تفاصيل الاتحاد",
+  "nav.lnurlMints": "دور سكّ LNURL",
+  "footer.allLnurlMints": "كل دور سكّ LNURL",
+  "lnurlMints.title": "منّاتات LNURL: منّاتات سندات lnurlcash لحاملها، مع المراجعات | Cashumints.space",
+  "lnurlMints.description": "كل منّاتات LNURL البالغ عددها {total} والمفهرسة من شبكة Nostr: {online} متصلة، {offline} غير متصلة. تقييمات المجتمع وحدود السحب والميزات لكل واحدة.",
+  "lnurlMints.heading": "منّاتات LNURL",
+  "lnurlMints.lede": "كل منّاتة LNURL يعرفها هذا الموقع. منّاتة LNURL تُصدر سندات lnurlcash لحاملها: سندات Lightning تحتفظ بها كسرّ، ويمكن تدويرها أو تقسيمها أو دمجها أو صهرها مجددًا إلى دفعة Lightning. تُفحص كل واحدة عبر HTTPS كل بضع دقائق.",
+  "lnurlMints.search.label": "ابحث في منّاتات LNURL",
+  "lnurlMints.search.placeholder": "ابحث بالاسم أو العنوان…",
+  "lnurlMints.sort.label": "ترتيب منّاتات LNURL حسب",
+  "lnurlMints.hideOffline": "إخفاء غير المتصلة",
+  "lnurlMints.showing": "عرض {total} منّاتة LNURL ({online} متصلة، {offline} غير متصلة)",
+  "lnurlMints.showingFiltered": "عرض {shown} من {total} منّاتة LNURL ({online} متصلة، {offline} غير متصلة)",
+  "lnurlMints.noResults": "لا توجد منّاتة LNURL مطابقة.",
+  "lnurlMints.emptyIndex": "لم تُفهرس أي منّاتة LNURL بعد.",
+  "lnurl.crumb": "منّاتات LNURL",
+  "lnurl.breadcrumb": "مسار التنقل",
+  "lnurl.copyAddress": "نسخ العنوان",
+  "lnurl.more.title": "المزيد من منّاتات LNURL",
+  "lnurl.more.all": "كل منّاتات LNURL ←",
+  "lnurl.disclaimer": "منّاتة LNURL تحتفظ بالساتوشي الخاص بك بينما تحتفظ أنت بسنداتها، فاستخدامها يعني الوثوق بمشغّلها. التقييمات آراء من المجتمع، و«متصلة» تعني يمكن الوصول إليها، لا أنها جديرة بالثقة.",
+  "lnurl.features.title": "الميزات",
+  "lnurl.features.none": "لم تُعلن هذه المنّاتة عمّا تدعمه.",
+  "lnurl.features.note": "الميزات هي ما أعلنه مشغّل المنّاتة على Nostr. وحيثما أمكن لهذا الموقع التحقق من إحداها عبر HTTPS فإنه يفعل، ويُنبّه عندما يكون شيء مُعلن غير متاح حاليًا.",
+  "lnurl.features.notListed": "غير مُعلن",
+  "lnurl.features.unavailable": "غير متاح",
+  "lnurl.feature.mint": "السكّ عبر Lightning (LUD-06)",
+  "lnurl.feature.melt": "الصهر إلى Lightning",
+  "lnurl.feature.notes": "تدوير / تقسيم / دمج السندات",
+  "lnurl.feature.lud16": "عنوان Lightning",
+  "lnurl.feature.lud21": "التحقق من الدفع (LUD-21)",
+  "lnurl.feature.signed-notes": "سندات موقّعة (تحقق دون اتصال)",
+  "lnurl.feature.onion": "عنوان Tor",
+  "lnurl.feature.rotate": "تدوير سند",
+  "lnurl.feature.split": "تقسيم سند",
+  "lnurl.feature.merge": "دمج السندات",
+  "lnurl.feature.lud06": "LUD-06 payRequest",
+  "lnurl.feature.lud03": "LUD-03 withdrawRequest",
+  "lnurl.limits.label": "حدود السحب",
+  "lnurl.limits.notPublished": "غير منشور",
+  "lnurl.limits.withdrawRow": "السحب",
+  "lnurl.limits.disabled": "معطّل",
+  "lnurl.limits.sats.one": "{n} ساتوشي",
+  "lnurl.limits.sats.two": "{n} ساتوشي",
+  "lnurl.limits.sats.few": "{n} ساتوشي",
+  "lnurl.limits.sats.many": "{n} ساتوشي",
+  "lnurl.limits.sats.other": "{n} ساتوشي",
+  "lnurl.details.title": "تفاصيل المنّاتة",
+  "lnurl.details.address": "عنوان Lightning",
+  "lnurl.details.mintPubkey": "المفتاح العام للمنّاتة",
+  "lnurl.details.onion": "عنوان Tor",
+  "lnurl.details.fee": "رسوم السكّ",
+  "lnurl.details.node": "العقدة",
+  "lnurl.details.capacity": "السعة المُعلنة",
+  "lnurl.kind.lightningAddress": "عنوان Lightning",
+  "lnurl.kind.mintPubkey": "المفتاح العام للمنّاتة",
+  "lnurl.kind.onionAddress": "عنوان Tor",
+  "lnurl.confirmed.label": "آخر تأكيد",
+  "lnurl.confirmed.when": "تم التأكيد {when}",
+  "lnurl.fee.base.one": "{n} ساتوشي",
+  "lnurl.fee.base.two": "{n} ساتوشي",
+  "lnurl.fee.base.few": "{n} ساتوشي",
+  "lnurl.fee.base.many": "{n} ساتوشي",
+  "lnurl.fee.base.other": "{n} ساتوشي",
+  "lnurl.fee.percent": "{percent}٪",
+  "home.topLnurl.title": "أفضل منّاتات LNURL",
+  "home.topLnurl.sub": "مرتّبة حسب المراجعات والتقييم",
+  "home.topLnurl.all": "كل منّاتات LNURL البالغة {n} ←",
+  "feed.ecosystem.lnurl": "LNURL",
+  "reviews.dialog.bodyPlaceholder.lnurl": "كيف كان السكّ والصهر وتدوير السندات؟ كن محددًا.",
+  "reviews.byUrl.open": "اكتب مراجعة",
+  "reviews.byUrl.title": "اكتب مراجعة",
+  "reviews.byUrl.lede": "الصق العنوان. لو الموقع لسه ما يعرفوش، هيتفحص ويتضاف دلوقتي.",
+  "reviews.byUrl.label.cashu": "رابط الـ mint",
+  "reviews.byUrl.label.fedimint": "رمز دعوة الاتحاد",
+  "reviews.byUrl.label.lnurl": "رابط mint من نوع LNURL",
+  "reviews.byUrl.placeholder.cashu": "mint.example.com",
+  "reviews.byUrl.placeholder.fedimint": "fed11…",
+  "reviews.byUrl.placeholder.lnurl": "mint.example.com",
+  "reviews.byUrl.check": "افحص هذا العنوان",
+  "reviews.byUrl.checking": "بنفحص…",
+  "reviews.byUrl.back": "استخدم عنوان تاني",
+  "reviews.byUrl.existing": "مدرج بالفعل",
+  "reviews.byUrl.indexed": "اتضاف دلوقتي",
+  "reviews.byUrl.confirmClose": "نقفل؟ العنوان اللي كتبته مش هيتحفظ.",
+  "reviews.byUrl.detected": "استجاب هذا العنوان بوصفه mint من نوع {kind}.",
+  "reviews.byUrl.switchTo": "راجعه بوصفه mint من نوع {kind}",
+  "reviews.byUrl.error.empty": "اكتب عنوان الأول.",
+  "reviews.byUrl.error.badUrl": "ده مش شكله رابط mint.",
+  "reviews.byUrl.error.badInvite": "هذا ليس رمز دعوة Fedimint. الرموز تبدأ بـ fed11.",
+  "reviews.byUrl.error.badInput": "لا يستطيع هذا الموقع فحص ذلك العنوان.",
+  "reviews.byUrl.error.blocked": "هذا ليس عنوانًا عامًا، لذا لا يمكن فحصه.",
+  "reviews.byUrl.error.notAMint": "استجاب هذا العنوان، لكن ليس بوصفه mint من هذا النوع.",
+  "reviews.byUrl.error.wrongType": "استجاب هذا العنوان، لكن بوصفه mint من نوع آخر.",
+  "reviews.byUrl.error.unverifiable": "لم يستجب شيء على ذلك العنوان، ولا أثر له على Nostr حتى الآن.",
+  "reviews.byUrl.error.rateLimited.one": "ده فحص كتير من نفس الاتصال. جرّب تاني بعد حوالي {n} دقيقة.",
+  "reviews.byUrl.error.rateLimited.other": "ده فحص كتير من نفس الاتصال. جرّب تاني بعد حوالي {n} دقيقة.",
+  "reviews.byUrl.error.network": "تعذّر الوصول إلى الفهرس. تحقّق من اتصالك ثم حاول مجددًا.",
+  "seo.lnurl.titleNoReviews": "{name}: معلومات ومراجعات منّاتة LNURL | Cashumints.space",
+  "seo.desc.statusWithdraw": "{status}، السحب {min}–{max} ساتوشي.",
+  "mint.chip.noFunding": "لا سكّ ولا صهر",
+  "mint.warnings.lnurlWithdrawalsDisabled.lead": "السحب معطّل.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.online": "تُعلن هذه المنّاتة حدًّا أقصى للسحب يساوي صفرًا، فلا يمكن استبدال أي سند تُصدره بأي شيء. لا تسكّ هنا حتى يتغير ذلك.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.offline": "عند آخر اتصال بها كانت هذه المنّاتة تُعلن حدًّا أقصى للسحب يساوي صفرًا، فلم يكن ممكنًا استبدال أي سند تُصدره بأي شيء. لا تسكّ هنا حتى يتغير ذلك.",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.online": "السحب معطّل حاليًا",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.offline": "كان السحب معطّلًا عند آخر ظهور",
+  "mint.warnings.lnurlInvalid.lead": "نقطة النهاية تستجيب لكنها غير صالحة.",
+  "mint.warnings.lnurlInvalid.body": "المضيف يستجيب، لكن ليس بإعلان منّاتة يستطيع هذا الموقع قراءته، لذا قد لا يعمل السحب. كل ما في الأسفل هو آخر حالة أمكن قراءتها، والمراجعات لا تزال تعمل.",
+  "mint.warnings.lnurlInvalid.meta": "يستجيب، لكن ليس بإعلان منّاتة صالح",
+  "mint.warnings.lnurlNoFunding.lead": "السكّ والصهر غير متاحين.",
+  "mint.warnings.lnurlNoFunding.body": "لا تزال السندات الموجودة قابلة للتدوير أو التقسيم أو الدمج، لكن لا شيء يدخل أو يخرج عبر Lightning حاليًا. المنّاتة نفسها تعمل وتستجيب؛ لكن عقدة Lightning خلفها غير قابلة للوصول منها.",
+  "mint.warnings.lnurlNoFunding.meta": "السكّ والصهر غير متاحين",
+  "mint.warnings.also.noFunding": "كانت عقدة Lightning الخاصة بها غير قابلة للوصول أيضًا، فلم يكن ممكنًا سكّ أو صهر أي شيء."
+}

web/src/i18n/ar.json

@@ -0,0 +1,794 @@
+{
+  "site.name": "Cashumints.space",
+  "common.close": "إغلاق",
+  "common.cancel": "إلغاء",
+  "common.done": "تم",
+  "common.back": "العودة",
+  "common.retry": "إعادة المحاولة",
+  "common.connect": "اتصل",
+  "common.copied": "تم نسخه",
+  "common.copyFull": "نسخ {kind} بالكامل",
+  "common.previousPage": "الصفحة السابقة",
+  "common.nextPage": "الصفحة التالية",
+  "common.reviewPages": "صفحات المراجعة",
+  "time.never": "أبدًا",
+  "time.justNow": "قبل قليل",
+  "time.none": "-",
+  "time.unknownDate": "تاريخ غير معروف",
+  "time.ago.minute": "منذ {n} د",
+  "time.ago.hour": "منذ {n} س",
+  "time.ago.day": "منذ {n} ي",
+  "time.ago.week": "منذ {n} أ",
+  "time.ago.month": "منذ {n} ش",
+  "time.ago.year": "منذ {n} سنة",
+  "time.short.minute": "{n} د",
+  "time.short.hour": "{n} س",
+  "time.short.day": "{n} ي",
+  "time.short.week": "{n} أ",
+  "time.short.month": "{n} ش",
+  "time.short.year": "{n} سنة",
+  "status.online": "عبر الإنترنت",
+  "status.offline": "غير متصل",
+  "status.degraded": "غير قابل للاتصال",
+  "status.unknown": "لم يتم التحقق منه بعد",
+  "nav.skip": "الانتقال إلى المحتوى",
+  "nav.main": "الرئيسية",
+  "nav.mints": "جهات إصدار Cashu",
+  "nav.reviews": "التقييمات",
+  "nav.wallets": "المحافظ",
+  "nav.about": "نبذة عن",
+  "nav.searchMints": "البحث في {n} جهة إصدار",
+  "lang.label": "اللغة",
+  "lang.switcher": "اختر لغة",
+  "footer.copyright": "© {year} Cashumints.space",
+  "footer.allMints": "كل جهات إصدار Cashu",
+  "footer.allReviews": "جميع التقييمات",
+  "footer.wallets": "المحافظ",
+  "footer.about": "نبذة عن",
+  "footer.disclaimer": "إخلاء المسؤولية",
+  "footer.terms": "الشروط",
+  "footer.privacy": "الخصوصية",
+  "footer.madeBy": "صُمم بحب ❤️ بواسطة {azzamo} · مدعوم بواسطة Cashu وNIP-87",
+  "footer.warning": "جهات الإصدار ائتمانية. يمكن لجهة إصدار أن تختفي بأموالك.",
+  "footer.tagline": "تقييمات المجتمع لجهات إصدار ecash، موقَّعة على Nostr.",
+  "footer.col.explore": "استكشاف",
+  "footer.col.site": "الموقع",
+  "footer.nav": "تذييل الصفحة",
+  "home.title": "Cashumints.space · ابحث عن جهة إصدار Cashu يمكنك الوثوق بها",
+  "home.description": "ابحث عن جهة إصدار Cashu يمكنك الوثوق بها. تمت فهرسة {mints} جهة إصدار مع {reviews} مراجعة مجتمعية موقعة على Nostr، إلى جانب حالة التشغيل المباشرة وNUTs المدعومة وبرمجيات جهة الإصدار.",
+  "home.hero.title": "ابحث عن جهة إصدار Cashu",
+  "home.hero.titleEm": "يمكنك الوثوق به",
+  "home.hero.lede": "كل جهة إصدار على شبكة Nostr، مع مراجعات حقيقية من المجتمع. لا حراس بوابة، بل مراجعات موقعة يمكنك التحقق منها بنفسك.",
+  "home.search.label": "ابحث عن جهات إصدار حسب الاسم أو النطاق أو عنوان URL",
+  "home.search.placeholder": "ابحث حسب الاسم أو النطاق، أو الصق رابطًا جهة إصدار…",
+  "home.filters.mostReviewed": "الأكثر تقييمًا",
+  "home.filters.highestRated": "الأعلى تقييمًا",
+  "home.filters.recentlyActive": "نشط مؤخرًا",
+  "home.filters.websockets": "يدعم WebSockets",
+  "home.top.title": "الأعلى جهات إصدار Cashu",
+  "home.top.sub": "مرتبة حسب التعليقات والتقييمات",
+  "home.top.all": "الكل {n} جهات إصدار →",
+  "home.latest.title": "أحدث التقييمات",
+  "home.latest.sub": "بث مباشر من شبكة Nostr",
+  "home.latest.prev": "التعليقات السابقة",
+  "home.latest.next": "المزيد من التقييمات",
+  "home.latest.all": "جميع التقييمات →",
+  "home.latest.empty": "لم يتمكن النظام من قراءة أي تعليقات من المرحلات في الوقت الحالي. افتح أي صفحة تحمل جهة إصدار لقراءة التعليقات وكتابتها مباشرةً.",
+  "home.why.title": "لماذا يمكن الوثوق بهذه التقييمات؟",
+  "home.why.signed.title": "تم التوقيع عليه، ولم يتم تقديمه",
+  "home.why.signed.body": "كل تقييم هو حدث يحمل {link} وموقع بمفتاح Nostr الخاص بمؤلفه. ولا نقوم نحن بتعديل أي شيء هنا أو تصنيفه أو حذفه.",
+  "home.why.signed.link": "NIP-87",
+  "home.why.verify.title": "تحقق من ذلك بنفسك",
+  "home.why.verify.body": "يتم تخزين التعليقات على خوادم الترحيل العامة Nostr، وليس في قاعدة بياناتنا. ما عليك سوى توجيه أي عميل إلى نفس خوادم الترحيل هذه وسترى نفس البيانات.",
+  "home.why.checked.title": "يتم فحصه باستمرار",
+  "home.why.checked.body": "نقوم بفحص كل جهة إصدار للتحقق من وقت التشغيل وإصدار البرنامج والحدود وNUTs المدعوم، لذا فإن المواصفات التي تراها حديثة وليست مستمدة من تقارير ذاتية.",
+  "home.cta.title": "هل تفكر في جهة إصدار؟ اقرأ هذا أولاً.",
+  "home.cta.body": "جهة إصدار يحتوي على ecash. اقرأ ما وجده الآخرون قبل أن تدخل sats، واترك تعليقًا بعد أن تستخدمه بنفسك.",
+  "home.cta.explore": "استكشف جميع التي تبدأ بـ جهات إصدار",
+  "home.cta.learn": "تعرف على Cashu",
+  "pulse.mintsIndexed": "جهات إصدار مُفهرس",
+  "pulse.reviewsOnNostr": "التعليقات على Nostr",
+  "pulse.lastReview": "آخر مراجعة",
+  "pulse.mintsOnline": "جهات إصدار متصل بالإنترنت",
+  "pulse.indexer": "المفهرس",
+  "pulse.connected": "متصل",
+  "pulse.stale": "قديم",
+  "mints.title": "الكل جهات إصدار Cashu · Cashumints.space",
+  "mints.description": "جميع {total} وجهات إصدار Cashu المُفهرسة من شبكة Nostr، {online} متصل بالإنترنت و{offline} غير متصل بالإنترنت، مع تقييمات المجتمع ووقت التشغيل وجهة إصدار البرامج. ابحث في القائمة الكاملة وقم بفرزها.",
+  "mints.heading": "كل جهات إصدار Cashu",
+  "mints.lede": "جميع العناوين جهة إصدار التي تم اكتشافها على شبكة Nostr، بما في ذلك تلك التي لم تعد موجودة. أما العناوين جهات إصدار غير المتصلة بالإنترنت، فستظل مدرجة في القائمة حتى تتمكن من العثور عليها ومراجعتها.",
+  "mints.search.label": "ابحث عن جهات إصدار حسب الاسم أو النطاق",
+  "mints.search.placeholder": "البحث حسب الاسم أو النطاق…",
+  "mints.sort.label": "جهات إصدار",
+  "mints.sort.score": "الأفضل بشكل عام",
+  "mints.sort.rating": "الأعلى تقييمًا",
+  "mints.sort.reviews": "الأكثر تقييمًا",
+  "mints.sort.recent": "تمت مراجعتها مؤخرًا",
+  "mints.sort.seen": "تمت مشاهدتها مؤخرًا على الإنترنت",
+  "mints.hideOffline": "إخفاء الحالة \"غير متصل\"",
+  "mints.showing": "يتم عرض {total} وجهات إصدار ({online} متصل، {offline} غير متصل)",
+  "mints.showingFiltered": "يتم عرض {shown} من أصل {total} جهات إصدار ({online} متصلون، {offline} غير متصلين)",
+  "mints.noResults": "لا توجد نتائج مطابقة لـ جهات إصدار. جرب إدخال اسم نطاق، أو الصق رابطًا يحتوي على جهة إصدار.",
+  "mints.clearSearch": "مسح البحث",
+  "card.noRatings": "لا توجد تقييمات حتى الآن",
+  "card.reviews.one": "{n} تقييم",
+  "card.reviews.other": "{n} تقييم",
+  "card.lastSeen": "شوهد آخر مرة {when}",
+  "card.neverSeen": "لم يُشاهد على الإنترنت من قبل",
+  "card.reviewed": "تمت مراجعة {when}",
+  "card.noReviews": "لا توجد تعليقات حتى الآن",
+  "mint.title": "{name} · جهة إصدار Cashu تقييمات",
+  "mint.titleFedimint": "{name} · مراجعات اتحاد Fedimint",
+  "mint.titleLnurl": "{name} · مراجعات mint من نوع LNURL",
+  "mint.breadcrumb": "مسار التنقل",
+  "mint.crumbMints": "جهات إصدار Cashu",
+  "mint.copyUrl": "نسخ رابط جهة إصدار",
+  "mint.qrButton": "جهة إصدار ريال قطري",
+  "mint.writeReview": "اكتب تقييمًا",
+  "mint.rankByScore": "#{rank} حسب النتيجة",
+  "mint.tagLightning": "Lightning",
+  "mint.summary": "جهة إصدار ملخص",
+  "mint.rating.label": "التصنيف المجتمعي",
+  "mint.rating.none": "لا توجد تقييمات حتى الآن",
+  "mint.rating.reviews.one": "{n} - تقييم",
+  "mint.rating.reviews.other": "{n} تقييم",
+  "mint.rating.unrated.one": "{n} لم يقدم أي تقييم",
+  "mint.rating.unrated.other": "{n} لم يقدم أي تقييم",
+  "mint.activity.label": "النشاط",
+  "mint.activity.since": "منذ المراجعة الأخيرة",
+  "mint.activity.noReviews": "لا توجد تعليقات حتى الآن",
+  "mint.activity.recent.one": "{n} تقييم خلال الـ 90 يوماً الماضية",
+  "mint.activity.recent.other": "{n} تقييم خلال الـ 90 يوماً الماضية",
+  "mint.limits.label": "الحدود",
+  "mint.limits.notPublished": "لم يُنشر",
+  "mint.limits.min": "دقيقة",
+  "mint.limits.max": "الحد الأقصى",
+  "mint.limits.mintRow": "جهة إصدار",
+  "mint.limits.meltRow": "يذوب",
+  "mint.limits.disabled": "معاق",
+  "mint.limits.range": "{min} إلى {max} {unit}",
+  "mint.limits.upTo": "حتى {max} {unit}",
+  "mint.limits.from": "من {min} إلى {unit}",
+  "mint.software.label": "برنامج جهة إصدار",
+  "mint.software.unknown": "غير معروف",
+  "mint.checked": "تم التحقق من {when}",
+  "mint.lastSeen": "شوهد آخر مرة {when}",
+  "mint.neverReached": "لم يتم الوصول إليها قط",
+  "mint.uptime.checks": "{ok} من أصل {total} شيك يمكن الوصول إليها",
+  "mint.uptime.percent": "{percent}% يمكن الوصول إليهم خلال 30 يومًا",
+  "mint.uptime.description": "نجحت {ok} عملية فحص من أصل {total} عملية فحص",
+  "mint.operator.title": "من المشغل",
+  "mint.operator.motd": "رسالة اليوم",
+  "mint.operator.beta": "يصف هذا جهة إصدار نفسه بأنه تجريبي أو في مرحلة بيتا. اقرأ ما جاء في تصريحات المشغل نفسه أدناه قبل تخزين أي شيء لا يمكنك تحمل فقدانه.",
+  "mint.nuts.title": "المدعوم: NUTs",
+  "mint.nuts.noneOffline": "لا توجد قائمة مخزنة مؤقتًا برقم NUT لهذا جهة إصدار، فقد انقطع اتصاله بالإنترنت قبل أن يتم تسجيل أي قائمة له.",
+  "mint.nuts.noneYet": "لم يتم تخزين القائمة NUT مؤقتًا لهذا جهة إصدار حتى الآن.",
+  "mint.nuts.supported": "{n} من أصل {total} معروف NUTs مدعوم",
+  "mint.nuts.whatAre": "ما هو NUTs؟",
+  "mint.nutRow.disabled": "معاق",
+  "mint.nutRow.notSupported": "غير مدعوم",
+  "mint.details.title": "جهة إصدار تفاصيل",
+  "mint.details.pubkey": "Pubkey",
+  "mint.details.nostr": "Nostr",
+  "mint.details.email": "البريد الإلكتروني",
+  "mint.details.serverTime": "توقيت الخادم",
+  "mint.details.firstSeen": "شوهد لأول مرة",
+  "mint.details.terms": "الشروط",
+  "mint.kind.identifier": "المعرّف",
+  "mint.kind.mintPubkey": "جهة إصدار pubkey",
+  "mint.kind.nostrAddress": "العنوان Nostr",
+  "mint.kind.emailAddress": "عنوان البريد الإلكتروني",
+  "mint.kind.npub": "npub",
+  "mint.disclaimer": "هذا حساب جهة إصدار هو حساب أمانة: فهو يحتفظ بأموالك، ويمكنه التوقف عن ذلك في أي وقت. التصنيفات هي آراء المجتمع، والوسائل المتاحة عبر الإنترنت يمكن الوصول إليها، لكنها غير موثوقة.",
+  "mint.disclaimerLink": "اقرأ إخلاء المسؤولية بالكامل",
+  "mint.qr.title": "أضف {name} إلى محفظتك",
+  "mint.qr.note": "امسح هذا الرمز ضوئيًّا باستخدام محفظة Cashu لإضافة جهة إصدار، أو انسخ عنوان URL والصقه هنا.",
+  "mint.qr.warn": "إضافة جهة إصدار يعني أن تثق به وتوكل إليه أموالك.",
+  "mint.qr.whatMeans": "ما يعنيه ذلك",
+  "mint.qr.wallets": "المحافظ التي تدعم Cashu",
+  "mint.chip.frozen": "فروزن",
+  "mint.chip.noWithdrawals": "لا توجد عمليات سحب",
+  "mint.chip.meltOnly": "للذوبان فقط",
+  "mint.warnings.dayCount.one": "{n} يوم",
+  "mint.warnings.dayCount.other": "{n} يومًا",
+  "mint.warnings.gone.lead": "من المرجح أنه اختفى.",
+  "mint.warnings.gone.body.since": "لم يعد بالإمكان الوصول إلى هذا جهة إصدار منذ {date} ({days}). يرجى اعتبار الأموال المودعة فيه معرضة للخطر، وعدم إرسال أي أموال جديدة إليه. توضح التفاصيل أدناه آخر حالة معروفة له.",
+  "mint.warnings.gone.body.neverDated": "لم يرد هذا الحساب جهة إصدار على أي طلب تحقق منذ أن بدأنا مراقبته في {month}. تعاملوا مع الأموال المودعة فيه على أنها معرضة للخطر، ولا ترسلوا أموالاً جديدة. كل ما يلي مأخوذ من الإعلان Nostr، وليس من الإعلان جهة إصدار.",
+  "mint.warnings.gone.body.never": "لم يرد جهة إصدار على أي استفسار منذ أن بدأنا مراقبته. اعتبروا الأموال المودعة هناك معرضة للخطر، ولا ترسلوا أي أموال جديدة. كل ما يلي مأخوذ من إعلان Nostr، وليس من جهة إصدار.",
+  "mint.warnings.gone.meta.since": "غير متصل منذ {date}",
+  "mint.warnings.gone.meta.never": "لم يتم الوصول إليه مطلقًا منذ اكتشافه",
+  "mint.warnings.meltDisabled.lead": "تم تعطيل عمليات السحب.",
+  "mint.warnings.meltDisabled.body.online": "هذا جهة إصدار يحتوي على Lightning والاسترداد (NUT-05) المعطلة: يمكنك إدخال sats، لكن لا يمكنك سحبها عبر Lightning. لا تقم بالإيداع حتى يعود الاسترداد.",
+  "mint.warnings.meltDisabled.body.offline": "تم تعطيل جهة إصدار من قبل Lightning والاسترداد (NUT-05): يمكنك إيداع المبلغ عبر sats، لكن لا يمكنك سحبها عبر Lightning. لا تقم بالإيداع حتى يعود الاسترداد.",
+  "mint.warnings.meltDisabled.meta.online": "عمليات السحب معطلة حاليًا",
+  "mint.warnings.meltDisabled.meta.offline": "تم تعطيل عمليات السحب عند آخر ظهور",
+  "mint.warnings.frozen.lead": "جهة إصدار متجمد.",
+  "mint.warnings.frozen.body.online": "كل من الإصدار والاسترداد معطلان. ولا يمكن لـ sats الدخول أو الخروج عبر Lightning.",
+  "mint.warnings.frozen.body.offline": "تم تعطيل كل من الإصدار والاسترداد. ولا يمكن لـ sats الدخول أو الخروج عبر Lightning.",
+  "mint.warnings.frozen.meta.online": "مُجمَّد حاليًا، ولا يدخل أو يخرج منه أي شيء",
+  "mint.warnings.frozen.meta.offline": "كان في حالة جمود عند رؤيته آخر مرة",
+  "mint.warnings.offlineLong.lead": "غير متصل منذ {days}، منذ {date}.",
+  "mint.warnings.offlineLong.body": "ربما يكون جهة إصدار قد اختفى. كل ما يلي يمثل آخر حالة معروفة له، ولا تزال التعليقات تعمل.",
+  "mint.warnings.offlineLong.meta": "غير متصل منذ {date}",
+  "mint.warnings.meltOnly.lead": "للتذويب فقط.",
+  "mint.warnings.meltOnly.body.online": "الإصدار الجديد (NUT-04) معطل: لا يمكنك الإيداع، لكن لا يزال بالإمكان السحب من الحالي ecash. وغالبًا ما يعني هذا أن جهة إصدار في طريقه إلى الانتهاء، لذا إذا كنت تمتلك ecash، ففكر في استبعاد الاسترداد.",
+  "mint.warnings.meltOnly.body.offline": "تم تعطيل الإصدار الجديد (NUT-04): لا يمكنك الإيداع، لكن لا يزال بالإمكان السحب من الحالي ecash. وغالبًا ما يعني هذا أن جهة إصدار في طريقه إلى الانتهاء، لذا إذا كنت تمتلك ecash، ففكر في استبعاد الاسترداد.",
+  "mint.warnings.meltOnly.meta.online": "حاليًا، يقتصر الأمر على الذوبان فقط",
+  "mint.warnings.meltOnly.meta.offline": "تذوب فقط عند آخر مرة شوهدت فيها",
+  "mint.warnings.offline.lead": "غير متصل منذ {date}.",
+  "mint.warnings.offline.body": "تم تأكيد التفاصيل في ذلك الوقت. لا يزال بإمكانك كتابة تقييم.",
+  "mint.warnings.offline.meta": "غير متصل منذ {date}",
+  "mint.warnings.also.meltDisabled": "وقبل أن تتوقف عن العمل، كانت قد أوقفت أيضًا عمليات السحب.",
+  "mint.warnings.also.mintDisabled": "وقبل أن ينقطع الاتصال بالإنترنت، كان قد عطل أيضًا الإصدار الجديد.",
+  "mint.warnings.also.offline": "كما أنها غير متصلة بالإنترنت منذ {date} ({days}).",
+  "nut.0": "الرموز والنماذج",
+  "nut.1": "جهة إصدار تبادل المفاتيح العامة",
+  "nut.2": "مجموعات المفاتيح والرسوم",
+  "nut.3": "مبادلة الرموز الرقمية",
+  "nut.4": "الإصدار عبر Lightning",
+  "nut.5": "الاسترداد عبر Lightning",
+  "nut.6": "جهة إصدار معلومات",
+  "nut.7": "التحقق من حالة الرمز الرمزي",
+  "nut.8": "رسوم زائدة قدرها Lightning",
+  "nut.9": "استعادة التوقيعات",
+  "nut.10": "شروط الإنفاق",
+  "nut.11": "الدفع إلى المفتاح العام",
+  "nut.12": "DLEQ نسخة تجريبية",
+  "nut.13": "الأسرار الحتمية",
+  "nut.14": "عقود القفل الزمني المُجزَّأة",
+  "nut.15": "المدفوعات متعددة المسارات",
+  "nut.16": "رموز QR المتحركة",
+  "nut.17": "WebSocket اشتراك",
+  "nut.18": "طلبات الدفع",
+  "nut.19": "الردود المخزنة مؤقتًا",
+  "nut.20": "تم التوقيع على جهة إصدار اقتباس",
+  "nut.21": "المصادقة الواضحة",
+  "nut.22": "المصادقة العمياء",
+  "nut.23": "BOLT11 طريقة الدفع",
+  "nut.24": "HTTP 402 مطلوب الدفع",
+  "nut.25": "BOLT12 طريقة الدفع",
+  "reviews.title": "التعليقات",
+  "reviews.anon": "مجهول",
+  "reviews.anonTitle": "لم يتم العثور على ملف تعريف عام برقم Nostr لهذا المفتاح",
+  "reviews.nip05Title": "المعرّف NIP-05 (لم يتم التحقق منه من قِبل هذا الموقع)",
+  "reviews.filter.group": "تصفية التقييمات",
+  "reviews.filter.all": "الكل",
+  "reviews.filter.five": "5★",
+  "reviews.filter.critical": "حرجة",
+  "reviews.filter.recent": "الأخبار الأخيرة",
+  "reviews.filter.hideAnon": "إخفاء الهوية",
+  "reviews.anonHidden.other": "يُعرض {n} من أصل {total} تقييمًا: مجهول، مخفي.",
+  "reviews.allAnon.one": "التعليق الوحيد هنا هو تعليق مجهول.",
+  "reviews.allAnon.other": "جميع التقييمات البالغ عددها {n} الموجودة هنا مجهولة المصدر.",
+  "reviews.allAnonShow.one": "اعرضه",
+  "reviews.allAnonShow.other": "أرهم",
+  "reviews.loading.one": "جاري تحميل التقييم {n} من Nostr مرحل",
+  "reviews.loading.other": "جاري تحميل {n} تقييم من Nostr مرحل",
+  "reviews.empty": "لا توجد تعليقات حتى الآن. كن أول من يكتب تعليقًا.",
+  "reviews.emptyWritten": "لا توجد تعليقات مكتوبة هنا حتى الآن. كن أول من يكتب تعليقًا.",
+  "reviews.emptyFilter": "لا توجد تقييمات تتطابق مع هذا الفلتر.",
+  "reviews.rate.cashu": "قيّم جهة الإصدار هذه",
+  "reviews.rate.fedimint": "قيّم هذا الاتحاد",
+  "reviews.rate.lnurl": "قيّم جهة الإصدار هذه",
+  "reviews.noscript": "يتم تسجيل التعليقات على Nostr ويتم تحميلها في متصفحك، لذا تحتاج هذه القائمة إلى JavaScript. أما التقييمات وأعداد التعليقات المذكورة أعلاه فهي مستمدة من الموقع نفسه.",
+  "reviews.relayError": "تعذر الوصول إلى جهاز الترحيل. قد تكون المراجعات غير مكتملة.",
+  "reviews.srRating": "{rating} من أصل 5",
+  "reviews.srNoRating": "لم يتم إعطاء تقييم",
+  "reviews.readMore": "اقرأ المزيد",
+  "reviews.readLess": "إظهار أقل",
+  "reviews.actions.copyNpub": "نسخة npub",
+  "reviews.actions.openNostr": "شاهد هذا الحدث على Nostr",
+  "reviews.actions.copyLink": "نسخ رابط هذه المراجعة",
+  "reviews.anonNote": "أول تقييم من هذا npub، لم يتم العثور على أي نشاط آخر",
+  "reviews.published": "تم النشر.",
+  "reviews.publishedPartial": "تم النشر إلى {accepted} من أصل {total} مرحل.",
+  "reviews.propagating": "جارٍ النشر إلى مرحلات Nostr",
+  "reviews.summary.line.one": "{count} تقييم بدون تعليق: {breakdown}",
+  "reviews.summary.line.other": "{count} تقييمًا بدون تعليق: {breakdown}",
+  "reviews.summary.lineDay.one": "تقييم {count} بدون تعليق على {when}: {breakdown}",
+  "reviews.summary.lineDay.other": "{count} تقييمًا بدون تعليق على {when}: {breakdown}",
+  "reviews.summary.showOne": "اعرضه",
+  "reviews.summary.showMany": "أرهم",
+  "reviews.breakdown.5": "{n} خمس نجوم",
+  "reviews.breakdown.4": "{n} أربع نجوم",
+  "reviews.breakdown.3": "{n} ثلاث نجوم",
+  "reviews.breakdown.2": "{n} نجمتان",
+  "reviews.breakdown.1": "{n} نجمة واحدة",
+  "reviews.breakdown.none": "{n} بدون تقييم",
+  "reviews.dialog.title": "التقييم {name}",
+  "reviews.dialog.lede.cashu": "شارك تجربتك مع جهة الإصدار هذه.",
+  "reviews.dialog.lede.fedimint": "شارك تجربتك مع هذا الاتحاد.",
+  "reviews.dialog.lede.lnurl": "شارك تجربتك مع جهة الإصدار هذه.",
+  "reviews.dialog.permanent": "يُنشر بشكل دائم على موزّعات Nostr العامة.",
+  "reviews.dialog.gate.title": "سجّل الدخول لكتابة تقييم",
+  "reviews.dialog.gate.lead": "تُوقَّع التقييمات بمفتاح Nostr الخاص بك. يبقى المفتاح في المُوقِّع، ولا يطّلع عليه هذا الموقع أبدًا.",
+  "reviews.dialog.ratingLegend": "تقييمك",
+  "reviews.dialog.starsSr.one": "{n} نجمة",
+  "reviews.dialog.starsSr.other": "{n} نجمة",
+  "reviews.dialog.chooseRating": "اختر تقييمًا",
+  "reviews.dialog.starLabel": "{n}: {phrase}",
+  "reviews.dialog.stars.1": "تجنبه",
+  "reviews.dialog.stars.2": "واجهت مشاكل",
+  "reviews.dialog.stars.3": "نجحت، مع بعض التحفظات",
+  "reviews.dialog.stars.4": "جيد",
+  "reviews.dialog.stars.5": "يعمل بشكل رائع",
+  "reviews.dialog.bodyLabel": "ما الذي ينبغي أن يعرفه الآخرون؟",
+  "reviews.dialog.charCount": "{n} / {max}",
+  "reviews.dialog.submit": "التوقيع والنشر",
+  "reviews.dialog.signing": "التوقيع…",
+  "reviews.dialog.publishing": "جاري النشر…",
+  "reviews.dialog.publishingTo": "النشر إلى الموزعات ({accepted}/{total})",
+  "reviews.dialog.waitingExtension": "في انتظار تمديدك",
+  "reviews.dialog.waitingSigner": "في انتظار الموقّع",
+  "reviews.dialog.confirmClose": "هل تريد إغلاق هذه المراجعة؟ سيتم الاحتفاظ بمسودتك حتى تغادر الموقع.",
+  "reviews.dialog.why.login": "تسجيل الدخول للنشر",
+  "reviews.dialog.why.words": "اكتب بضع كلمات",
+  "reviews.dialog.why.more.one": "{n} حرف إضافي",
+  "reviews.dialog.why.more.other": "{n} حرف إضافي",
+  "reviews.dialog.why.over.one": "{n} حرفًا فوق الحد الأقصى",
+  "reviews.dialog.why.over.other": "{n} حرفًا زائدة عن الحد المسموح به",
+  "reviews.dialog.identity.needSigner": "تحتاج إلى مُوقِّع برقم Nostr للنشر. سيبقى مفتاحك محفوظًا فيه، ولن يطلع عليه هذا الموقع أبدًا.",
+  "reviews.dialog.identity.loginToPublish": "تسجيل الدخول للنشر",
+  "reviews.dialog.identity.switch": "مفتاح",
+  "reviews.dialog.identity.extension": "تسجيل الدخول باستخدام ملحق المتصفح",
+  "reviews.dialog.identity.readingKey": "جاري قراءة مفتاحك العام…",
+  "reviews.dialog.identity.willAsk": "سيُطلب من الملحق الخاص بك التوقيع",
+  "reviews.dialog.error.noRelay": "لم يقبل أي وسيط طلب المراجعة. يرجى التحقق من اتصالك، ثم حاول مرة أخرى.",
+  "reviews.validate.rating": "اختر تقييمًا من 1 إلى 5 نجوم.",
+  "reviews.validate.short": "اكتب ما لا يقل عن {n} حرفًا حتى تكون المراجعة مفيدة.",
+  "reviews.validate.long": "يقتصر عدد أحرف التعليقات على {n} حرفًا.",
+  "feed.title": "أحدث التقييمات لـ جهة إصدار و«الفيدرالية» · Cashumints.space",
+  "feed.description": "كل مراجعة لمنّاتة أو اتحاد أو منّاتة LNURL فور نشرها: {reviews} مراجعة تغطي {mints} منّاتة Cashu و{federations} اتحاد Fedimint و{lnurl} منّاتة LNURL، موقّعة على Nostr ومقروءة هنا من الأحدث. صفِّ حسب المنظومة أو التقييم أو الاسم.",
+  "feed.heading": "أحدث التقييمات",
+  "feed.lede": "كل تقييم لكل اتحاد من الاتحادات جهة إصدار Cashu وFedimint، مع عرض الأحدث أولاً، يُقرأ مباشرةً من محطات الترحيل Nostr. كل تقييم موقَّع من قبل مؤلفه ويُحفظ على محطات الترحيل، وليس في قاعدة بياناتنا.",
+  "feed.label": "التعليقات",
+  "feed.showingBuild.one": "عرض أحدث تقييم من الإصدار الأخير",
+  "feed.showingBuild.other": "عرض آخر {n} تقييم من الإصدار الأخير",
+  "feed.noscript": "يتم توقيع التعليقات على Nostr ويتم تحميلها في متصفحك، لذا فإن عملية التصفية والقائمة الكاملة تتطلبان JavaScript. أما التعليقات الـ {n} الواردة أدناه فقد تمت قراءتها من المرحلات عند إنشاء هذه الصفحة.",
+  "feed.emptyBuild": "لم يتمكن الموقع من قراءة أي تقييمات من أجهزة الترحيل عند إنشاء هذه الصفحة. يتم تحديث القائمة من أجهزة الترحيل في متصفحك.",
+  "feed.foot": "التعليقات هي آراء المجتمع، وليست ادعاءات تم التحقق منها. اقرأ {link} قبل أن تثق في جهة إصدار وتدفع له المال.",
+  "feed.footLink": "إخلاء المسؤولية",
+  "feed.showing": "يُعرض {shown} من أصل {total} تقييمًا",
+  "feed.showingMatching": "يتم عرض {shown} من أصل {matching} تقييمًا مطابقًا (إجمالي {total})",
+  "feed.emptyRelays": "لم ترد أي تعليقات من الموزعات. افتح أي صفحة تحمل جهة إصدار لتقرأ التعليقات وتكتب تعليقاتك هناك.",
+  "feed.emptyFilter": "لا توجد تقييمات تتطابق مع هذا الفلتر. قم بإلغاء تحديد المربع جهة إصدار، أو جرب خيار «الكل».",
+  "feed.relayError": "تعذر الوصول إلى المرحلات. يتم عرض التقييمات من الإصدار الأخير.",
+  "feed.relayEmpty": "لم ترد أي مراجعات من الوسيطات. يتم عرض المراجعات من الإصدار الأخير.",
+  "feed.reading": "قراءة المرحلات…",
+  "login.open": "تسجيل الدخول",
+  "login.title": "تسجيل الدخول باستخدام Nostr",
+  "login.note": "يظل مفتاحك محفوظًا في جهاز التوقيع الخاص بك. ولا يمكن لهذا الموقع رؤيته أبدًا.",
+  "login.extension.name": "ملحق المتصفح",
+  "login.extension.desc": "قم بالتسجيل باستخدام Alby أو nos2x أو أي رقم آخر من سلسلة NIP-07",
+  "login.extension.none": "لم يتم العثور على امتداد",
+  "login.extension.getOne": "احصل على واحدة:",
+  "login.remote.name": "الموقّع عن بُعد",
+  "login.remote.desc": "امسح الرمز ضوئيًّا باستخدام تطبيق التوقيع، أو الصق رابط «بونكر»",
+  "login.primal.name": "Primal",
+  "login.primal.desc": "قم بالموافقة على تسجيل الدخول في تطبيق Primal على هاتفك",
+  "login.paste.label": "أو الصق رابط الاتصال الذي قدمه لك الموقّع",
+  "login.copyLink": "انسخ رابط الاتصال",
+  "login.whatIsNostr": "ما هو Nostr؟",
+  "login.connect.remote.title": "ربط مُوقِّع عن بُعد",
+  "login.connect.remote.lead": "امسح هذا ضوئيًا باستخدام تطبيق التوقيع الخاص بك، أو انسخ الرابط والصقه هناك.",
+  "login.connect.remote.hint": "يعمل مع أي موقّع يحمل NIP-46: nsec.app، Amber، Nostrify، أو المخبأ الخاص بك.",
+  "login.connect.remote.open": "افتح في تطبيق التوقيع الخاص بك",
+  "login.connect.primal.title": "تواصل مع Primal",
+  "login.connect.primal.lead": "افتح Primal على هاتفك، وابحث عن خيار «التسجيل عن بُعد» في الإعدادات، ثم امسح هذا الرمز ضوئيًّا.",
+  "login.connect.primal.hint": "Primal يُستخدم للتوقيع على تطبيقات أخرى عبر NIP-46، لذا فإن هذا هو نفس الاتصال الذي يستخدمه أي مُوقِّع، ويبقى مفتاحك في Primal. {link}",
+  "login.connect.primal.open": "افتتح في Primal",
+  "login.status.buildingLink": "إنشاء رابط اتصال",
+  "login.status.waitingExtension": "في انتظار تمديدك",
+  "login.status.waitingSigner": "في انتظار الموقّع",
+  "login.status.connecting": "الاتصال بالموقّع",
+  "login.status.connected": "متصل",
+  "login.toast.loggedIn": "تم تسجيل الدخول",
+  "login.toast.fetchingProfile": "جارٍ جلب ملفك الشخصي على Nostr من خوادم الترحيل…",
+  "login.toast.profile": "الملف الشخصي: {name}",
+  "login.toast.noProfile": "لم يُعثر على ملف شخصي على خوادم الترحيل",
+  "login.method.extension": "التمديد",
+  "login.method.remote": "عن بُعد",
+  "login.method.primal": "Primal",
+  "login.account": "حسابك Nostr",
+  "login.copyNpub": "انسخ الكامل npub",
+  "login.logout": "تسجيل الخروج",
+  "signer.status.waitingExtension": "في انتظار تمديدك",
+  "signer.status.signed": "موقّع",
+  "signer.status.reconnecting": "إعادة الاتصال بالموقّع",
+  "signer.status.approveWindow": "يحتاج الموقّع منك إلى الموافقة على هذا الأمر في نافذة منفصلة",
+  "signer.status.waitingSigner": "في انتظار الموقّع",
+  "signer.status.stillWaiting": "ما زلنا ننتظر رد الموقّع",
+  "signer.status.connected": "متصل",
+  "signer.error.noExtension": "لم يتم العثور على تمديد التوقيع. قم بتثبيت Alby أو nos2x، ثم أعد تحميل هذه الصفحة.",
+  "signer.error.privateKey": "يبدو أن هذا مفتاح خاص، وليس رابط اتصال. هذا الموقع لا يطلب أبدًا إدخال مفتاح. الصق الرابط bunker:// الذي أعطاك إياه المُوقِّع.",
+  "signer.error.badLink": "هذا الرابط غير مدعوم في هذا الموقع. قم بلصق الرابط bunker:// من الموقّع الخاص بك.",
+  "signer.error.noAnswer": "لم يرد المُوقِّع الخاص بك. ربما يكون الحساب مغلقًا، أو ربما يكون خادم الترحيل الخاص به معطلاً. افتحه وحاول مرة أخرى.",
+  "signer.error.timeout": "لم يرد الموقّع في الوقت المحدد. افتح الجهاز، وتأكد من أنه لا يزال متصلاً، ثم حاول مرة أخرى.",
+  "signer.error.cancelled": "تم إلغاء الاتصال.",
+  "signer.error.declined": "تم رفض طلب التوقيع",
+  "notfound.title": "الصفحة غير موجودة · Cashumints.space",
+  "notfound.description": "هذه الصفحة غير موجودة على Cashumints.space.",
+  "notfound.heading": "هذه الصفحة غير موجودة",
+  "notfound.lede": "ربما تم نقله، أو ربما لم يتم فهرسة جهة إصدار بعد. ابحث عن جهة إصدار بالاسم أو النطاق، أو الصق عنوان URL الخاص بجهة إصدار.",
+  "notfound.browse": "تصفح جميع جهات إصدار",
+  "notfound.home": "اذهب إلى المنزل",
+  "notfound.loading": "جاري التحميل {host}",
+  "notfound.fb.rating": "التقييم",
+  "notfound.fb.reviews": "التعليقات",
+  "notfound.fb.software": "البرامج",
+  "notfound.fb.lastOnline": "آخر مرة كان متصلاً بالإنترنت",
+  "notfound.fb.note": "فُهرس هذا الـ mint بعد آخر بناء للموقع، لذا هذا ملخّص من الواجهة الحية، ومراجعاته أدناه. تظهر الصفحة الكاملة عند البناء التالي.",
+  "notfound.resolve.checking": "أول زيارة: يجري فحص هذا الـ mint الآن.",
+  "notfound.resolve.failed": "تعذّرت إضافة هذا الـ mint",
+  "notfound.resolve.failedFedimint": "تعذّرت إضافة هذا الاتحاد",
+  "notfound.resolve.retry": "جرّب عنوانًا آخر",
+  "notfound.resolve.switch": "افتحه بوصفه mint من نوع {kind}",
+  "notfound.resolve.fedimint": "عنوان صفحة الاتحاد لا يحمل رمز الدعوة الخاص به، لذا لا يمكن العثور عليه من الرابط وحده. ألصق رمز الدعوة وسيُضاف.",
+  "notfound.resolve.ambiguous": "لا يمكن استنتاج هذا العنوان من الرابط وحده. ألصق رابط الـ mint كاملًا وسيُضاف.",
+  "wallets.title": "Cashu محفظة · Cashumints.space",
+  "wallets.description": "Cashu محفظة تعمل مع جهات إصدار المذكور هنا، عبر الهاتف المحمول والويب والمتصفح وخط الأوامر، مع الاستفادة من المزايا التي تتميز بها كل واحدة منها.",
+  "wallets.heading": "المحافظ",
+  "wallets.lede": "تحتاج إلى محفظة لتخزين ecash من أي من هذه جهات إصدار. تتواصل معظم المحافظ مع عدة أرقام من جهات إصدار في آن واحد، لذا فأنت لست ملزماً باستخدام أول رقم تجربه.",
+  "wallets.note": "هذه القائمة ليست شاملة ولا تمثل توصية. يحتفظ مشروع Cashu بفهرس أوسع نطاقًا على الرابط {link}. المحفظة تحتوي على المفاتيح، أما جهة إصدار فيحتوي على الأموال: اقرأ تقييمات جهة إصدار قبل أن تختار المكان الذي ستضع فيه sats.",
+  "wallets.platform.android": "Android",
+  "wallets.platform.ios": "iOS",
+  "wallets.platform.web": "الويب",
+  "wallets.platform.extension": "ملحق المتصفح",
+  "wallets.platform.cli": "CLI",
+  "wallets.platform.python": "Python",
+  "wallets.item.minibits": "محفظة الهاتف المحمول ecash مع دعم عناوينها الخاصة جهة إصدار وLightning وجهات الاتصال Nostr.",
+  "wallets.item.nutstash": "محفظة متصفح تدعم التعامل مع عدة جهات إصدار في آن واحد، وتقوم باستيراد وتصدير الرموز الأولية.",
+  "wallets.item.enuts": "محفظة جوال تركز على أرصدة العملات المتعددة وإرسال ecash إلى Nostr.",
+  "wallets.item.cashume": "محفظة ويب مرجعية من مشروع Cashu. تعمل بالكامل داخل المتصفح، ويمكن تثبيتها كملف PWA.",
+  "wallets.item.boardwalk": "محفظة إلكترونية مبنية على Lightning عنوان، وإرسال ecash عبر الرابط.",
+  "wallets.item.coinos": "Lightning: محفظة ونقطة بيع تدير أيضًا جهة إصدار Cashu.",
+  "wallets.item.oxchat": "تطبيق المراسلة Nostr المزود بمحفظة ecash مدمجة، لإرسال sats داخل المحادثات.",
+  "wallets.item.nutshell": "التنفيذ المرجعي. يعمل كمحفظة عبر سطر الأوامر وكبرنامج جهة إصدار.",
+  "about.title": "حوالي Cashumints.space",
+  "about.description": "ما هو Cashu، وما الذي يحتويه جهة إصدار فعليًّا، وما هو NIP-87، وكيف يقوم هذا الموقع بفهرسة جهات إصدار وقراءة التقييمات الواردة من محطات الترحيل Nostr.",
+  "about.heading": "نبذة عن",
+  "about.lede": "يضم Cashumints.space كل رقم من أرقام جهة إصدار Cashu التي يمكننا العثور عليها على الشبكة Nostr، ويعرض لك ما يقوله الناس عنها. وقد صممه Azzamo.",
+  "about.cashu.title": "ما هو Cashu؟",
+  "about.cashu.p1": "Cashu هو بروتوكول ecash الخاص بـ Bitcoin. يقوم جهة إصدار بإصدار رموز مميزة مجهولة المصدر مدعومة بـ sats التي يمتلكها، وتنتقل هذه الرموز بين الأشخاص دون أن يعرف جهة إصدار من أرسل ماذا إلى من. الخصوصية حقيقية وهذا هو بيت القصيد: الرموز ليست حسابات، ولا يمكن لـ جهة إصدار ربط الرمز الذي وقّعه بالرمز الذي يعود إليه.",
+  "about.cashu.p2": "يمكنك الاطلاع على البروتوكول ومواصفاته في {link}. وتُسمى المواصفات نفسها NUTs، ومن هنا تأتي NUT الموجودة في كل صفحة من صفحات جهة إصدار.",
+  "about.mints.title": "ما هو جهة إصدار، والمفاضلة",
+  "about.mints.p1": "جهة إصدار هو رقم حراسة. عندما تقوم بـ جهة إصدار ecash، فإنك تسلم sats إلى من يدير ذلك الخادم، وتثق في أنه سيحترم الرموز عند سحبها مرة أخرى. لا توجد ضمانات ضد الاحتيال، ولا حساب ضمان، ولا حق في الرجوع. يمكن لمشغل جهة إصدار أن يختفي بالرصيد، وقد حدث ذلك بالفعل مع جهات إصدار.",
+  "about.mints.p2": "وهذا بالضبط هو سبب وجود التقييمات هنا. فهذا الموقع لا يخبرك أبدًا أن جهة إصدار آمن. الحالة الموضحة على صفحة جهة إصدار تشير إلى {code}، وليس «موثوق»، وهذا يعني فقط أن الخادم استجاب عندما سألنا آخر مرة. تعامل مع أرصدة ecash كما لو كانت نقودًا في جيب معطفك: لا بأس بإنفاقها، لكنها غير مناسبة للادخار.",
+  "about.nip87.title": "ما هو NIP-87؟",
+  "about.nip87.p1": "NIP-87 هو الأسلوب المتبع في Nostr للإعلان عن ecash وجهات إصدار والتوصية بهما. وهناك نوعان من الأحداث مهمان هنا:",
+  "about.nip87.li1": "يُعلن {code} عن جهة إصدار. ويوجد عنوان URL الخاص بـ جهة إصدار داخل العلامة {tag}. وهذه هي الطريقة التي يكتشف بها الموقع جهات إصدار الذي لم يسبق له رؤيته من قبل.",
+  "about.nip87.li2": "{code} هو تعليق. ويحتوي على التقييم ونص التعليق، ويشير إلى جهة إصدار الذي يتعلق به باستخدام علامة {utag} (عنوان URL جهة إصدار) وعلامة {dtag} (المفتاح العام الخاص بـ جهة إصدار).",
+  "about.nip87.p2": "يتم توقيع كل تقييم بمفتاح Nostr الخاص بمؤلفه. نحن لا نصف أي تقييم أبدًا بـ«المُثبت»، لأن لا أحد قام بالتحقق منه: إنه موقَّع، وهو ادعاء مختلف وأكثر فائدة. وهذا يعني أنه يمكنك التحقق من هوية كاتبه ومن أنه لم يتم التلاعب به. ولا يعني ذلك أن المؤلف صادق أو أنه استخدم مفتاح جهة إصدار من قبل.",
+  "about.how.title": "كيف يعمل هذا الموقع",
+  "about.how.p1": "هناك حلقتان وقاعدة واحدة. القاعدة هي أن جهة إصدار يمتلك بياناته الوصفية، بينما يمتلك Nostr التقييمات؛ لذا لا يخزن هذا الموقع أيًّا منهما باعتباره مصدرًا موثوقًا.",
+  "about.how.li1": "يقوم {strong} بالاستعلام عن {code} من كل رقم معروف من جهة إصدار كل عشر دقائق، ويسجل ما يرد عليه: الاسم، والوصف، والإصدار، وأرقام NUTs المدعومة، والحدود، وتفاصيل الاتصال. كما يسجل أيضًا ما إذا كان جهة إصدار قد أجاب أم لا، ومن هنا تأتي معلومات وقت التشغيل.",
+  "about.how.li1Label": "حلقة الاستشعار",
+  "about.how.li2": "يتصل {strong} بNostr كل ساعة، ويقرأ إعلانات جهة إصدار ومراجعاته، ويضيف أي إعلانات من جهة إصدار لم يرها من قبل.",
+  "about.how.li2Label": "حلقة الاكتشاف",
+  "about.how.p2": "الجزء المهم هو ما يحدث عندما يتوقف جهة إصدار عن الرد. لا يتم أبدًا استبدال بياناته الوصفية المخزنة مؤقتًا بنتيجة فحص فاشلة، لذا فإن جهة إصدار المعطل يحتفظ بصفحته الكاملة: مواصفاته، وتاريخه، وتقييماته، مع لافتة توضح تاريخ توقفه عن العمل. أما الإصدار السابق من هذا الموقع، فقد كان يعرض صفحة خطأ بدلاً من ذلك، مما يعني أن التي كان الناس في أمس الحاجة إلى تحذير بعضهم البعض منها، وهي التي لا يمكن مراجعتها، هي التي لم يتم عرضها. وكان ذلك السبب الرئيسي وراء إعادة بناء الموقع.",
+  "about.how.p3": "لا يتم تخزين نص التعليقات أبدًا على خوادمنا. عندما تفتح صفحة جهة إصدار، يتواصل متصفحك مباشرةً مع محطات الترحيل ويقرأ التعليقات بنفسه، وعندما تكتب تعليقًا، يتم توقيعه بواسطة ملحقك الخاص Nostr وإرساله مباشرةً إلى تلك المحطات. نحن نحتفظ بعدد التعليقات فقط حتى يمكن ترتيب الصفحات وتصنيفها، ولا شيء أكثر من ذلك. لا يمكننا تعديل أو حذف أي شيء هنا، بما في ذلك التعليقات التي نفضل عدم وجودها.",
+  "about.relays.title": "المرحلات التي قرأنا عنها",
+  "about.relays.p1": "هذه هي خوادم الترحيل التي يستخدمها كل من أداة الفهرسة ومتصفحك:",
+  "about.relays.p2": "قم بتوجيه أي عميل يحمل Nostr إلى نفس نقاط الترحيل وسترى نفس الأحداث. هذا هو جوهر الوعد: لا يوجد هنا شيء يُعتبر صحيحًا لمجرد أننا نقول ذلك.",
+  "about.nuts.title": "ما هو NUTs؟",
+  "about.nuts.p1": "NUTs هي المواصفات المرقمة Cashu، مثل BIPs لـ Bitcoin. ويُعلن جهة إصدار عن المواصفات التي ينفذها، وهذا يوضح لك ما يمكنه فعله فعليًّا: NUT-04 وNUT-05 هما الإصدار والاسترداد على Lightning (بدونهما، لا يكون لـ جهة إصدار فائدة تذكر)، يسمح NUT-07 للمحفظة بالتحقق مما إذا كان الرمز المميز قد تم إنفاقه بالفعل، ويوفر NUT-17 للمحافظ تحديثات فورية عبر WebSockets بدلاً من الاستقصاء، ويسمح NUT-20 للمحفظة بإثبات أن عرض الأسعار جهة إصدار قد صدر لها بالفعل. توجد القائمة الكاملة في {link}.",
+  "about.numbers.title": "في الوقت الحالي",
+  "about.numbers.p1": "{mints} جهات إصدار تم فهرستها، {online} منها استجابت، {reviews} تقييمات تم احتسابها من المرحلات المذكورة أعلاه.",
+  "about.source.title": "المصدر والائتمان",
+  "about.source.p1": "الموقع مفتوح المصدر على العنوان {github}. تم إنشاؤه وتشغيله بواسطة {azzamo}. إذا كانت هناك مشكلة في إحدى صفحات جهة إصدار، فقم بإصلاحها من المصدر: تأتي البيانات الوصفية لـ جهة إصدار من {code} الخاص بـ جهة إصدار، وتأتي التعليقات من Nostr.",
+  "terms.title": "شروط الاستخدام · Cashumints.space",
+  "terms.description": "شروط استخدام Cashumints.space: ماهية الموقع، وما لا يقوم به، ومن المسؤول عن ماذا. لا توجد حسابات، ولا ضمانات، ولا علاقة بأي جهة إصدار.",
+  "terms.heading": "شروط الاستخدام",
+  "terms.lede": "شروط بسيطة لموقع يقتصر على فهرسة البيانات العامة. آخر تحديث: {date}.",
+  "terms.what.title": "ما هو هذا الموقع؟",
+  "terms.what.p1": "Cashumints.space هو فهرس للبيانات المتاحة للجمهور حول جهات إصدار Cashu. وهناك نوعان من البيانات، وكلاهما مستمدان من مصدر آخر:",
+  "terms.what.li1": "جهة إصدار من البيانات الوصفية، التي تمت قراءتها من نقطة النهاية {code} الخاصة بكل جهة إصدار: الاسم، والوصف، وإصدار البرنامج، وNUTs المدعوم، وتفاصيل الاتصال، وما إذا كان جهة إصدار قد رد عند آخر استفسار لنا.",
+  "terms.what.li2": "التعليقات، التي تمت قراءتها من Nostr منصة توزيع عامة. وهذه هي NIP-87 حدثًا نشرها مؤلفوها على منصات توزيع يمكن لأي شخص الاستعلام عنها.",
+  "terms.what.p2": "نقوم بجمع تلك البيانات وتوحيدها وترتيبها وعرضها. لكننا لا نقوم بإنشائها.",
+  "terms.noAccounts.title": "لا توجد حسابات، ولا توجد ضمانات",
+  "terms.noAccounts.p1": "لا يوجد ما يتعين عليك التسجيل فيه. يُقدم الموقع كما هو، دون أي ضمان من أي نوع: لا ضمان بدقة البيانات، ولا ضمان بأنها حديثة، ولا ضمان بأن الموقع سيكون متاحًا. قد تكون بيانات جهة إصدار قديمة بمقدار دقائق أو ساعات، وقد يتغير جهة إصدار بعد آخر مرة قمنا فيها بالتحقق منه، وقد يفشل أحد أجهزة الترحيل في الرد، وفي هذه الحالة سترى أقل مما هو موجود بالفعل.",
+  "terms.noAccounts.p2": "استخدمه على مسؤوليتك الخاصة. نحن لا نتحمل أي مسؤولية عن أي خسارة تنجم عن استخدام هذا الموقع أو الاعتماد على أي شيء تقرأه هنا. راجع {link} للاطلاع على المخاطر المحددة المرتبطة باستخدام جهة إصدار Cashu.",
+  "terms.noAccounts.link": "إخلاء المسؤولية",
+  "terms.noCustody.title": "نحن لا نحتفظ بأموالك",
+  "terms.noCustody.p1": "لا يتولى هذا الموقع أبدًا حفظ الأموال. فهو لا يمتلك محفظة، ولا يتعامل مع ecash، ولا يمكنه تحويل أو تجميد أو استرداد أي شيء. إذا واجهتك مشكلة تتعلق بجهة إصدار، فإن مشغل جهة إصدار هو الطرف الوحيد الذي يمكنه مساعدتك، ولا يمكننا الاتصال به نيابة عنك.",
+  "terms.noCustody.p2": "نحن لا نرتبط بأي من جهة إصدار المدرجة هنا، ولا يدفع أي رقم من جهة إصدار مقابل إدراجه أو ترتيبه أو تقييمه. يتم العثور على جهات إصدار من خلال الإعلانات العامة Nostr، ويتم ترتيبها بواسطة خوارزمية تستند إلى بيانات التقييمات العامة.",
+  "terms.reviews.title": "التعليقات هي كلمات الآخرين",
+  "terms.reviews.p1": "التعليقات هي محتوى ينشئه المستخدمون ويتم نشره على محطات الترحيل العامة Nostr بواسطة مؤلفيها. نحن نعرضها، لكننا لا نتحكم فيها. لم نكتبها، ولا يمكننا تعديلها، ولا يمكننا حذفها من محطات الترحيل التي تحتوي عليها: فهي أحداث موقعة على شبكة لا نملكها.",
+  "terms.reviews.p2": "التعليق هو تجربة شخصية، وليس حقيقة مؤكدة. إذا قمت بنشر تعليق، فأنت مسؤول عما ورد فيه. لا تنشر أي شيء مخالف للقانون، واعلم أن ما تنشره يكون متاحًا للجمهور ودائمًا (انظر {link}).",
+  "terms.reviews.link": "صفحة الخصوصية",
+  "terms.reviews.p3": "يمكننا إيقاف عرض تعليق معين على هذا الموقع، وسنقوم بذلك في حالة وجود محتوى غير قانوني. ويؤدي ذلك إلى إزالته من هذه الصفحات فقط. أما الحدث نفسه فيظل موجودًا على قنوات البث، ويمكن لأي عميل آخر يحمل Nostr قراءته.",
+  "terms.links.title": "روابط لمواقع أخرى",
+  "terms.links.p1": "يوجد جهة إصدار رابطًا إلكترونيًّا ورابطًا لمحفظة رقمية وبيانات اتصال بمشغلي شبكات الهاتف وكل ما يشير إلى مواقع خارج هذا الموقع، وذلك لأنها تشكل جزءًا من البيانات. ولا يُعد وجود الرابط بمثابة تأييد، كما أننا لا نتحقق من محتوى المواقع التي تؤدي إليها هذه الروابط.",
+  "terms.changes.title": "التغييرات",
+  "terms.changes.p1": "قد تتغير هذه الشروط. ويشير التاريخ المذكور في أعلى الصفحة إلى تاريخ آخر تعديل لها. والموقع مفتوح المصدر، لذا فإن كل تغيير يُجرى على هذه الصفحة يُسجل في سجل التعديلات.",
+  "terms.contact.title": "الاتصال",
+  "terms.contact.p1": "من الأفضل الإبلاغ عن المشكلات وطلبات إزالة المحتوى عبر {github}. ويتم إدارة الموقع بواسطة {azzamo}.",
+  "privacy.title": "الخصوصية · Cashumints.space",
+  "privacy.description": "الخصوصية في Cashumints.space: لا توجد حسابات، ولا ملفات تعريف ارتباط للتتبع، ولا أدوات تحليل. يُستخدم localStorage لتخزين ملف التعريف مؤقتًا ولا يتم إرسال أي شيء إلى أي مكان. يتم توقيع التعليقات في متصفحك الخاص.",
+  "privacy.heading": "الخصوصية",
+  "privacy.lede": "نحن نجمع أقل قدر ممكن من البيانات، بقدر ما يسمح به موقع الويب. آخر تحديث: {date}.",
+  "privacy.noAccounts.title": "لا توجد حسابات",
+  "privacy.noAccounts.p1": "لا يوجد تسجيل، ولا تسجيل دخول، ولا ملف شخصي. لا يطلب منك أي شيء في هذا الموقع أن تذكر هويتك، ولا يوجد سجل للمستخدمين يمكن أن يتسرب لأنه لا يوجد مستخدمون أصلاً.",
+  "privacy.noTracking.title": "لا ملفات تعريف ارتباط للتتبع، ولا تحليلات",
+  "privacy.noTracking.p1": "لا يقوم الموقع بوضع أي ملفات تعريف ارتباط لأغراض التتبع. ولا يوجد أي برنامج نصي للتحليلات، ولا مدير علامات، ولا بكسل، ولا تسجيل للجلسات، ولا شبكة إعلانية. ولا يوجد أي شيء في الصفحة يُبلغنا أو يُبلغ أي جهة أخرى بسلوكك.",
+  "privacy.logs.title": "سجلات الخادم",
+  "privacy.logs.p1": "يحتفظ خادم الويب بسجلات وصول قياسية، وهو ما يقوم به أي خادم ويب بشكل افتراضي. تسجل كل سطر في السجل عنوان IP الخاص بك، والوقت، والصفحة التي طلبتها، وحالة الاستجابة، ووكيل المستخدم والمصدر الذي أرسله متصفحك. وتُستخدم هذه السجلات لتصحيح الأخطاء وكشف حالات إساءة الاستخدام. ولا يتم ربطها بأي شيء آخر، كما لا يتم بيعها أو مشاركتها.",
+  "privacy.logs.operatorLabel": "ملاحظة للمشغل:",
+  "privacy.logs.operator": "إذا كنت تدير هذا الموقع، فاذكر مدة الاحتفاظ الفعلية هنا. يستخدم النشر في README الملف nginx مع سجل الوصول الافتراضي الخاص به وأي نظام تدوير يقدمه توزيعك (في Debian وUbuntu، وهو logrotate، يوميًا، مع الاحتفاظ بالسجلات لمدة 14 يومًا). تأكد من طريقة عمل الخادم الخاص بك واستبدل هذه الفقرة بالرقم.",
+  "privacy.storage.title": "ما الذي يتم تخزينه في متصفحك",
+  "privacy.storage.p1": "يستخدم الموقع localStorage لغرضين محددين فقط، وكلاهما يبقى على جهازك ولا يتم إرسالهما إلى أي مكان أبدًا:",
+  "privacy.storage.li1": "مخزن مؤقت يحتوي على Nostr من بيانات التعريف (أحداث من النوع 0: الأسماء، الصور الرمزية، NIP-05 العناوين) الخاصة بالمراجعين الذين اطلعت على تقييماتهم. وهذا يوفر إعادة الاستعلام عن المرحلات في كل صفحة. تنتهي صلاحية الإدخالات، ويتم تحديد سعة المخزن المؤقت وإزالة أقدم الإدخالات أولاً.",
+  "privacy.storage.li2": "تفضيلات الواجهة، حتى يعمل الموقع بنفس الطريقة في المرة القادمة.",
+  "privacy.storage.p2": "يؤدي مسح بيانات المواقع من متصفحك إلى إزالة كليهما. لن يحدث أي خلل، بل ستُجرى عمليات البحث عن الملفات الشخصية من جديد فحسب.",
+  "privacy.thirdParties.title": "ما الذي يتواصل معه متصفحك",
+  "privacy.thirdParties.p1": "يؤدي تحميل الصفحة إلى توصيل متصفحك بعدة مواقع أخرى بخلاف هذا الموقع. وهذه هي الطريقة التي يستقبل بها موقع لا يستخدم التتبع من جانب الخادم البيانات المباشرة:",
+  "privacy.thirdParties.li1Label": "Nostr مرحلات عامة",
+  "privacy.thirdParties.li1": "{strong}، عبر WebSocket، لقراءة التقييمات وملفات تعريف المُقيِّمين. يرى خادم الترحيل عنوان IP الخاص بك وما طلبته، كما يفعل أي خادم تتصل به. وترد قائمة بخوادم الترحيل على {link}.",
+  "privacy.thirdParties.li1Link": "صفحة «نبذة عنا»",
+  "privacy.thirdParties.li2Label": "صور الأفاتار الخاصة بالمراجعين",
+  "privacy.thirdParties.li2": "{strong}، يتم تحميلها من المكان الذي يشير إليه ملف تعريف المُراجع. ويتم إرسالها وفقًا لسياسة «عدم الإحالة»، بحيث لا يتمكن المضيف من معرفة الصفحة التي كنتَ تتصفحها.",
+  "privacy.publishing.title": "نشر مراجعة",
+  "privacy.publishing.p1": "تتم عملية كتابة التعليق في متصفحك، وليس على خادمنا. يتم توقيع هذه العملية بواسطة ملحقك NIP-07 (أو Alby، أو nos2x، أو ما شابه)، ويتم بثها من متصفحك مباشرةً إلى محطات الترحيل. لا يغادر مفتاحك الخاص الملحق أبدًا، ولا يراه هذا الموقع أبدًا. نحن لا ننشئ نظامًا مخصصًا لإدارة المفاتيح، ولا نطلب أبدًا مفتاحًا أو عبارة البذرة.",
+  "privacy.permanent.title": "أي شيء تنشره على Nostr يكون عامًا ودائمًا",
+  "privacy.permanent.p1": "هذا هو الجزء الذي يستحق القراءة مرتين. المراجعة هي حدث مُوقَّع عليه في شبكات الترحيل العامة. وبمجرد نشرها، تصبح متاحة للجميع:",
+  "privacy.permanent.li1": "يمكن لأي شخص قراءتها، الآن أو لاحقًا، باستخدام أي عميل Nostr. فهي ليست «عامة على Cashumints.space»، بل هي عامة على الشبكة.",
+  "privacy.permanent.li2": "وهو مرتبط بشكل دائم بمفتاحك العام Nostr، إلى جانب كل ما نشره هذا المفتاح على الإطلاق.",
+  "privacy.permanent.li3": "حذفها هو طلب وليس أمرًا. يمكنك نشر حدث حذف، وستلتزم بعض الوسيطات بتنفيذه، لكن للوسيطة الحرية في تجاهله، وسيظل الحدث محفوظًا لدى أي شخص قام بنسخه مسبقًا. تعامل مع المراجعة المنشورة على أنها دائمة.",
+  "privacy.permanent.li4": "لا يمكننا حذفه نيابة عنك. يمكننا إيقاف عرضه هنا؛ لكن ذلك لا يغير شيئًا في أجهزة الترحيل.",
+  "privacy.permanent.p2": "إذا كنت ترغب في كتابة تقييم لـ جهة إصدار دون ربطه بهويتك الرئيسية، فاستخدم مفتاحًا منفصلاً هو Nostr. لاحظ أن المفتاح الذي لا يوجد له أي نشاط آخر يظهر على هذا النحو في التقييمات القاسية، لأن قيام مفتاح جديد تمامًا بكتابة تقييم بنجمة واحدة يُعد نمطًا يستحق القراء رؤيته.",
+  "privacy.contact.title": "أسئلة",
+  "privacy.contact.p1": "الموقع مفتوح المصدر: إذا كنت ترغب في التحقق من أي مما سبق، فاقرأ الكود على {github}. يمكن إرسال الأسئلة والتصحيحات عبر إنشاء «قضية» هناك.",
+  "disclaimer.title": "إخلاء المسؤولية · Cashumints.space",
+  "disclaimer.description": "ما يجب معرفته قبل استخدام جهة إصدار جهات إصدار Cashu: هذه تابعة لجهات حفظ، أما جهة إصدار فقد يختفي مع أموالك، والتقييمات هي آراء، والمعلومات المتوفرة عبر الإنترنت يمكن الوصول إليها ولكنها غير موثوقة.",
+  "disclaimer.heading": "إخلاء المسؤولية",
+  "disclaimer.lede": "اقرأ هذا قبل أن تودع أموالاً في حساب جهة إصدار. آخر تحديث: {date}.",
+  "disclaimer.callout": "جهة إصدار Cashu يحتفظ بأموالك نيابة عنك. إذا اختفى، فسيضيع رقمك ecash، ولن يكون هناك من تلجأ إليه. احتفظ فقط بما يمكنك تحمل خسارته.",
+  "disclaimer.custodial.title": "جهات إصدار هي حسابات أمانة",
+  "disclaimer.custodial.p1": "عندما تقوم بـ جهة إصدار ecash، فإنك تسلم bitcoin إلى المشغل جهة إصدار وتحصل على الرموز في المقابل. هذه الرموز تمثل مطالبة تجاه ذلك المشغل. فهي ليست bitcoin في حوزتك، والمشغل هو الذي يقرر ما إذا كان سيقبلها أم لا.",
+  "disclaimer.custodial.p2": "وهذا يعني أن كل موقع يحمل جهة إصدار ينطوي على نفس المخاطر: فقد يختفي المشغل، أو يُجبر على التوقف، أو يفقد الأموال بسبب خلل تقني أو اختراق، أو قد يقوم ببساطة بإيقاف تشغيل الخادم. ولا يوجد تأمين على الودائع، ولا إمكانية لاسترداد الأموال، ولا خط دعم، ولا سبل انتصاف قانونية يمكن الاعتماد عليها. وينطبق هذا حتى على الموقع الذي يحمل جهة إصدار الأعلى تقييمًا على هذا الموقع.",
+  "disclaimer.custodial.p3": "تم تصميم حساب Cashu للمبالغ الصغيرة التي تتحرك بسرعة. استخدمه على النحو التالي: احتفظ فيه بالمبلغ الذي تنوي إنفاقه، وليس مدخراتك، ووزع المبلغ على حساب جهات إصدار بدلاً من إيداع كل المبلغ في حساب واحد.",
+  "disclaimer.reviews.title": "التعليقات هي آراء، وليست ادعاءات تم التحقق منها",
+  "disclaimer.reviews.p1": "كل تعليق هنا كتب بواسطة شخص يحمل Nostr وتم توقيعه بمفتاحه. يعني التوقيع أنه يمكننا تحديد المفتاح الذي كتب التعليق. ولا يعني ذلك أن التعليق صحيح، أو أن كاتبه استخدم جهة إصدار، أو أن كاتبه ليس المشغل، أو منافسًا، أو شخصًا واحدًا يمتلك عشرة مفاتيح.",
+  "disclaimer.reviews.p2": "نحن لا نتحقق من هوية المُقيِّمين، ولا نقوم بتعديل أو حذف التقييمات التي نختلف معها. اقرأ بعض التقييمات، وانظر إلى ما تقوله فعليًّا، وقيِّم التقييم الذي يحمل جهة إصدار مع ثلاث تقييمات بشكل مختلف عن التقييم الذي يحمل ثلاثمائة تقييم.",
+  "disclaimer.status.title": "\"عبر الإنترنت\" تعني \"يمكن الوصول إليه\"، لا \"موثوق به\"",
+  "disclaimer.status.p1": "نقوم بفحص كل جهة إصدار بانتظام ونوضح ما إذا كان قد استجاب أم لا. هذا هو كل ما تعنيه الحالة الخضراء: أن الخادم قد استجاب. وهي لا تشير بأي شكل إلى ما إذا كان المشغل ميسورًا ماليًا، أو أمينًا، أو لا يزال ينوي الوفاء برموزك الرقمية غدًا.",
+  "disclaimer.status.p2": "قد يظل جهة إصدار متصلاً بالإنترنت حتى اللحظة التي ينقطع فيها الاتصال. ويقدم لك سجل وقت التشغيل، وNUTs المدعوم، وإصدار البرنامج بعض المعلومات حول كيفية تشغيل جهة إصدار، لكن لا شيء من ذلك يمثل وعداً فيما يتعلق بأموالك.",
+  "disclaimer.ranking.title": "كيف يعمل نظام التصنيف، وما الذي لا يعنيه",
+  "disclaimer.ranking.p1": "يتم ترتيب جهات إصدار وفقًا لخوارزمية تستند إلى بيانات التقييمات العامة: التقييم، وعدد التقييمات، والنشاط الأخير، مع إعطاء الأولوية افتراضيًّا لـ جهات إصدار عبر الإنترنت على تلك التي تتم خارج الإنترنت. وترد التفاصيل في الكود مفتوح المصدر.",
+  "disclaimer.ranking.p2": "لا يدفع أحد مقابل تحديد ترتيب العروض. لا توجد أي خانات مدعومة، ولا قوائم مُروَّجة، ولا أي ترتيبات مع أي جهة تحمل جهة إصدار على هذا الموقع. ويعني الترتيب المتقدم أن الخوارزمية قد أعجبت بالبيانات العامة، ولا شيء أكثر من ذلك. وهذا لا يُعد توصيةً ولا تصنيفًا للأمان.",
+  "disclaimer.notAdvice.title": "هذه ليست نصيحة مالية",
+  "disclaimer.notAdvice.p1": "لا يُعد أي شيء وارد في هذا الموقع بمثابة مشورة مالية أو استثمارية أو قانونية أو ضريبية. نحن لا نعرف وضعك ولا نقدم لك أي مشورة. إن استخدام جهة إصدار واختيار المناسب هو قرارك أنت.",
+  "disclaimer.dyor.title": "قم بإجراء بحثك الخاص",
+  "disclaimer.dyor.li1": "ابحث عن صاحب الرقم. فجهة إصدار الذي يديره شخص لديه سمعة عامة قد يتضرر من ذلك يختلف تمامًا عن رابط ويب مجهول.",
+  "disclaimer.dyor.li2": "اقرأ الشروط الخاصة بـ جهة إصدار وMOTD. أما جهة إصدار الذي يصف نفسه بأنه «اختبار» أو «نسخة تجريبية»، فهو يعني ذلك فعلاً.",
+  "disclaimer.dyor.li3": "ابدأ بخطوات صغيرة. جهة إصدار، استخدم القليل منه، ثم استرجعه، وانظر ماذا سيحدث قبل أن تثق به بمبالغ أكبر.",
+  "disclaimer.dyor.li4": "انتبه إلى الحدود. غالبًا ما يكون الحد الأقصى المنخفض دلالة على حرص المشغل، في حين أن الحد الأقصى المرتفع لا يعني بالضرورة أنه آمن.",
+  "disclaimer.dyor.li5": "احرص على عمل نسخة احتياطية من توكناتك، وتذكر أن التوكن هو أصل لحامله: فمن يحمله يمكنه إنفاقه.",
+  "disclaimer.site.title": "حول الموقع نفسه",
+  "disclaimer.site.p1": "قد تكون البيانات الواردة هنا خاطئة أو قديمة. يتم فحص جهات إصدار وفقًا لجدول زمني محدد، وقد تفشل المرحلات أحيانًا في الرد، كما أن الصفحة التي تقرأها الآن تم إنشاؤها في وقت ما في الماضي. يُقدَّم الموقع «كما هو»، دون أي ضمان. انظر {link}.",
+  "disclaimer.site.link": "شروط الاستخدام",
+  "disclaimer.updated": "20 أغسطس 2026",
+  "login.getPrimal": "احصل على Primal",
+  "reviews.dialog.identity.extensionGone": "ملحق المتصفح الخاص بك لا يستجيب. يرجى تسجيل الدخول مرة أخرى، أو استخدام أداة التوقيع عن بُعد.",
+  "seo.orgDescription": "دليل يحتوي على جهات إصدار Cashu، مع حالة محدثة من كل جهة إصدار وتقييمات المجتمع الموقعة على Nostr.",
+  "seo.ogImageAlt": "Cashumints.space: ابحث عن جهة إصدار Cashu يمكنك الوثوق بهما.",
+  "seo.mint.title.one": "{name} تقييم: حصل على تقييم {rating} من أصل {n} تقييم | Cashumints.space",
+  "seo.mint.title.other": "{name} تقييم: حصل على تقييم {rating} من أصل {n} تقييم | Cashumints.space",
+  "seo.mint.titleOffline.one": "{name}: غير متصل منذ {n} يومًا | Cashumints.space",
+  "seo.mint.titleOffline.other": "{name}: غير متصل منذ {n} يومًا | Cashumints.space",
+  "seo.mint.titleNoReviews": "{name}: جهة إصدار Cashu معلومات وتقييمات | Cashumints.space",
+  "seo.fedimint.titleNoReviews": "{name}: Fedimint معلومات عن الاتحاد وتقييمات | Cashumints.space",
+  "seo.desc.fallback": "تقييمات المستخدمين لرقم {name} ({domain}).",
+  "seo.desc.fallbackDomain": "تقييمات المستخدمين لـ جهة إصدار Cashu و{domain}.",
+  "seo.desc.rated.one": "حصلت على تقييم {rating}/5 بناءً على تقييم {n}، الذي وقّعه Nostr.",
+  "seo.desc.rated.other": "حصل على تقييم {rating}/5 بناءً على {n} تقييمًا موقّعًا من Nostr.",
+  "seo.desc.noReviews": "لا توجد تعليقات حتى الآن.",
+  "seo.desc.status": "{status}.",
+  "seo.desc.statusLimits": "{status}، الحدود {limits}.",
+  "seo.desc.fedModules": "{status}. الوحدات: {modules}.",
+  "seo.desc.fedModulesNetwork": "{status}. الوحدات: {modules} و{network}.",
+  "seo.mint.ogAlt.one": "{name}: {rating} نجمة من تقييم {n} في Cashumints.space",
+  "seo.mint.ogAlt.other": "{name}: {rating} نجمة من {n} تقييمًا على Cashumints.space",
+  "seo.mint.ogAltNoReviews": "{name} على Cashumints.space",
+  "nav.home": "الصفحة الرئيسية",
+  "mint.more.title": "المزيد جهات إصدار",
+  "mint.more.all": "عرض الكل جهات إصدار",
+  "nav.fedimints": "Fedimints",
+  "status.announced": "تم الإعلان عنها فقط",
+  "card.unnamedFederation": "اتحاد لم يُذكر اسمه",
+  "card.notChecked": "لم يتم التحقق منه مطلقًا",
+  "fedimints.title": "جميع الاتحادات Fedimint · Cashumints.space",
+  "fedimints.description": "جميع الاتحادات البالغ عددها {total} وFedimint التي تم الإعلان عنها على الشبكة Nostr: {online} تم تأكيد تشغيلها من خلال فحص خارجي، و{announced} تم الإعلان عنها ولم يتم تأكيدها قط. تقييمات المجتمع والوحدات النمطية ورموز الدعوة لكل منها.",
+  "fedimints.heading": "جميع الاتحادات",
+  "fedimints.lede": "يتم الإعلان عن كل اتحاد Fedimint على شبكة Nostr. ولا يمتلك الاتحاد نقطة نهاية حالة عامة خاصة به، لذا يتم التأكد من تشغيل بعضها من خلال فحص خارجي، بينما يتم إدراج الباقي تمامًا كما تم الإعلان عنها.",
+  "fedimints.search.label": "البحث عن الاتحادات حسب الاسم أو المعرّف",
+  "fedimints.search.placeholder": "البحث حسب الاسم أو رقم التعريف الخاص بالاتحاد…",
+  "fedimints.sort.label": "فرز الاتحادات",
+  "fedimints.hideOffline": "إخفاء الحالة \"غير متصل\"",
+  "fedimints.showing": "يُعرض {total} اتحاد ({online} تم تأكيد انضمامها، {announced} تم الإعلان عنها فقط)",
+  "fedimints.showingFiltered": "يتم عرض {shown} من أصل {total} اتحادًا ({online} تم تأكيد انضمامها، و{announced} تم الإعلان عنها فقط)",
+  "fedimints.announcedNote.one": "تم الإعلان عن أحد هذه الخدمات على Nostr، ولم يتأكد منذ ذلك الحين ما إذا كانت تعمل أم لا. وقد تم إدراجها على أنها «تم الإعلان عنها» بدلاً من «متصلة» أو «غير متصلة»، لأن كلا الحالتين غير صحيحتين.",
+  "fedimints.announcedNote.other": "تم الإعلان عن {n} منها في Nostr، ولم يتأكد منذ ذلك الحين أنها قيد التشغيل. وقد أُدرجت في القائمة على أنها «مُعلنة» وليس «متصلة» أو «غير متصلة»، لأن كلا الحالتين غير صحيحتين.",
+  "fedimints.noResults": "لا توجد مباراة تابعة لأي اتحاد. جرب إدخال اسم، أو الصق معرّف الاتحاد.",
+  "fedimints.emptyIndex": "لم يتم الإعلان عن أي اتحادات في سباقات التتابع، حسبما يرد في هذا الموقع. وتُملأ القائمة تلقائيًا فور وصول الإعلانات.",
+  "fedimint.crumb": "Fedimints",
+  "fedimint.breadcrumb": "مسار التنقل",
+  "fedimint.unnamed": "اتحاد لم يُذكر اسمه",
+  "fedimint.idLabel": "الاتحاد",
+  "fedimint.kind.federationId": "معرّف الاتحاد",
+  "fedimint.moduleCount.one": "الوحدة {n}",
+  "fedimint.moduleCount.other": "{n} وحدة",
+  "fedimint.copyInvite": "نسخ رمز الدعوة",
+  "fedimint.confirmed.label": "تم التأكيد",
+  "fedimint.confirmed.never": "أبدًا",
+  "fedimint.confirmed.by": "بواسطة {source}",
+  "fedimint.confirmed.unattributed": "آخر فحص",
+  "fedimint.announcedOn": "أُعلن عن {when}",
+  "fedimint.announcedUnknown": "لم يتم تحديد موعد للإعلان",
+  "fedimint.modules.title": "الوحدات",
+  "fedimint.modules.none": "لا يتضمن إعلان هذا الاتحاد أي وحدات دراسية.",
+  "fedimint.modules.note": "الوحدات هي الأجزاء التي يديرها الاتحاد. ويشير الإعلان إلى الوحدات الموجودة، دون أن يذكر ما إذا كانت أي منها تقبل الإيداعات أم لا.",
+  "fedimint.modules.notListed": "غير مدرج",
+  "fedimint.invite.title": "رمز الدعوة",
+  "fedimint.invite.count.one": "الرمز {n}",
+  "fedimint.invite.count.other": "{n} رمزًا",
+  "fedimint.invite.note": "الصق هذا في محفظة Fedimint للانضمام. تحتوي هذه المحفظة على معرّف الاتحاد وعناوين أمنائه، وهي مخصصة للمشاركة.",
+  "fedimint.invite.kind": "رمز الدعوة",
+  "fedimint.invite.qr": "QR",
+  "fedimint.invite.qrCaption": "امسح الرمز ضوئيًا للانضمام إلى {name}",
+  "fedimint.details.federationId": "معرّف الاتحاد",
+  "fedimint.details.network": "الشبكة",
+  "fedimint.details.announcedBy": "أعلن عن ذلك",
+  "fedimint.details.announced": "تم الإعلان عن",
+  "fedimint.more.title": "المزيد من الاتحادات",
+  "fedimint.more.all": "عرض جميع الاتحادات",
+  "fedimint.disclaimer": "الانضمام إلى اتحاد ما يعني أن توكل أموالك إلى القائمين عليه. التصنيفات هي آراء المجتمع، و«التشغيل المؤكد» يعني أن الخدمة متاحة، لا أنها جديرة بالثقة.",
+  "fedimint.module.lightning": "Lightning",
+  "fedimint.module.mint": "Ecash جهة إصدار",
+  "fedimint.module.wallet": "محفظة على السلسلة",
+  "fedimint.module.meta": "البيانات الوصفية",
+  "fedimint.module.stability_pool": "صندوق الاستقرار",
+  "fedimint.module.multi_sig_stability_pool": "مجمع الاستقرار (متعدد التوقيعات)",
+  "fedimint.module.fedi-social": "التعافي الاجتماعي",
+  "fedimint.network.mainnet": "Bitcoin mainnet",
+  "fedimint.network.signet": "Signet",
+  "fedimint.network.testnet": "Testnet",
+  "fedimint.network.testnet4": "Testnet4",
+  "fedimint.network.regtest": "Regtest",
+  "feed.ecosystem.group": "النظام البيئي",
+  "feed.ecosystem.all": "الكل",
+  "feed.ecosystem.cashu": "Cashu",
+  "feed.ecosystem.fedimint": "Fedimint",
+  "feed.filterBySubject": "التصفية حسب جهة إصدار أو الاتحاد",
+  "feed.anySubject": "أي رقم من جهة إصدار أو الاتحاد",
+  "feed.clearSubject": "مسح فلتر الاسم",
+  "home.topFedimints.title": "أفضل عملات «فيديمينتس»",
+  "home.topFedimints.sub": "مرتبة حسب التعليقات والتقييمات",
+  "home.topFedimints.all": "جميع الاتحادات البالغ عددها {n} →",
+  "reviews.validate.subject": "لا يوجد ما يمكن توجيه هذه المراجعة إليه.",
+  "mint.warnings.fedimintOffline.lead": "تم الإبلاغ عنه في وضع عدم الاتصال.",
+  "mint.warnings.fedimintOffline.body.since": "آخر شيك وصل إلى هذا الاتحاد كان برقم {date} (قبل {days}). ولم يرد القائمون عليه منذ ذلك الحين. تعاملوا مع الأموال المودعة هناك على أنها معرضة للخطر، ولا تضيفوا إليها أموالاً جديدة.",
+  "mint.warnings.fedimintOffline.body.never": "لم تصل إلى هذا الاتحاد أي شيكات على الإطلاق، وقد فشل آخر شيك تم إرساله. تعاملوا مع الأموال المودعة هناك على أنها معرضة للخطر، ولا تودعوا فيها أموالاً جديدة.",
+  "mint.warnings.fedimintOffline.meta.since": "تم الإبلاغ عن انقطاع الاتصال منذ {date}",
+  "mint.warnings.fedimintOffline.meta.never": "تم الإبلاغ عنه في وضع عدم الاتصال، ولم يتم الوصول إليه مطلقًا",
+  "mint.warnings.neverConfirmed.lead": "تم الإعلان عنه، لكن لم يتم تأكيده قط.",
+  "mint.warnings.neverConfirmed.body.reviewed": "تم الإعلان عن هذا الاتحاد في Nostr منذ {date} و{days}، ولم يتأكد منذ ذلك الحين أنه لا يزال نشطًا. التعليقات الواردة أدناه هي العلامة الوحيدة على وجود نشاط في هذه الصفحة؛ أما كل ما عدا ذلك فقد ورد في الإعلان.",
+  "mint.warnings.neverConfirmed.body.quiet": "تم الإعلان عن هذا الاتحاد في Nostr منذ {date} و{days}، ولم يتم تأكيد أي شيء منذ ذلك الحين يفيد بأنه لا يزال نشطًا، ولم يقم أحد بمراجعته مؤخرًا. كل ما يلي مأخوذ من الإعلان.",
+  "mint.warnings.neverConfirmed.meta": "تم الإعلان عن {date}، ولم يتم تأكيده قط",
+  "footer.allFedimints": "جميع الاتحادات",
+  "reviews.dialog.bodyPlaceholder.cashu": "كيف تم حساب الإصدار والاسترداد و\"support\"؟ كن محددًا.",
+  "reviews.dialog.bodyPlaceholder.fedimint": "كيف سارت الأمور فيما يتعلق بالانضمام، وLightning عملية دفع، والدعم؟ يرجى التحديد.",
+  "fedimint.details.title": "تفاصيل الاتحاد",
+  "nav.lnurlMints": "جهات إصدار LNURL",
+  "footer.allLnurlMints": "كل جهات إصدار LNURL",
+  "lnurlMints.title": "منّاتات LNURL: منّاتات سندات lnurlcash لحاملها، مع المراجعات | Cashumints.space",
+  "lnurlMints.description": "كل منّاتات LNURL البالغ عددها {total} والمفهرسة من شبكة Nostr: {online} متصلة، {offline} غير متصلة. تقييمات المجتمع وحدود السحب والميزات لكل واحدة.",
+  "lnurlMints.heading": "منّاتات LNURL",
+  "lnurlMints.lede": "كل منّاتة LNURL يعرفها هذا الموقع. منّاتة LNURL تُصدر سندات lnurlcash لحاملها: سندات Lightning تحتفظ بها كسرّ، ويمكن تدويرها أو تقسيمها أو دمجها أو صهرها مجددًا إلى دفعة Lightning. تُفحص كل واحدة عبر HTTPS كل بضع دقائق.",
+  "lnurlMints.search.label": "ابحث في منّاتات LNURL",
+  "lnurlMints.search.placeholder": "ابحث بالاسم أو العنوان…",
+  "lnurlMints.sort.label": "ترتيب منّاتات LNURL حسب",
+  "lnurlMints.hideOffline": "إخفاء غير المتصلة",
+  "lnurlMints.showing": "عرض {total} منّاتة LNURL ({online} متصلة، {offline} غير متصلة)",
+  "lnurlMints.showingFiltered": "عرض {shown} من {total} منّاتة LNURL ({online} متصلة، {offline} غير متصلة)",
+  "lnurlMints.noResults": "لا توجد منّاتة LNURL مطابقة.",
+  "lnurlMints.emptyIndex": "لم تُفهرس أي منّاتة LNURL بعد.",
+  "lnurl.crumb": "منّاتات LNURL",
+  "lnurl.breadcrumb": "مسار التنقل",
+  "lnurl.copyAddress": "نسخ العنوان",
+  "lnurl.more.title": "المزيد من منّاتات LNURL",
+  "lnurl.more.all": "كل منّاتات LNURL ←",
+  "lnurl.disclaimer": "منّاتة LNURL تحتفظ بالساتوشي الخاص بك بينما تحتفظ أنت بسنداتها، فاستخدامها يعني الوثوق بمشغّلها. التقييمات آراء من المجتمع، و«متصلة» تعني يمكن الوصول إليها، لا أنها جديرة بالثقة.",
+  "lnurl.features.title": "الميزات",
+  "lnurl.features.none": "لم تُعلن هذه المنّاتة عمّا تدعمه.",
+  "lnurl.features.note": "الميزات هي ما أعلنه مشغّل المنّاتة على Nostr. وحيثما أمكن لهذا الموقع التحقق من إحداها عبر HTTPS فإنه يفعل، ويُنبّه عندما يكون شيء مُعلن غير متاح حاليًا.",
+  "lnurl.features.notListed": "غير مُعلن",
+  "lnurl.features.unavailable": "غير متاح",
+  "lnurl.feature.mint": "السكّ عبر Lightning (LUD-06)",
+  "lnurl.feature.melt": "الصهر إلى Lightning",
+  "lnurl.feature.notes": "تدوير / تقسيم / دمج السندات",
+  "lnurl.feature.lud16": "عنوان Lightning",
+  "lnurl.feature.lud21": "التحقق من الدفع (LUD-21)",
+  "lnurl.feature.signed-notes": "سندات موقّعة (تحقق دون اتصال)",
+  "lnurl.feature.onion": "عنوان Tor",
+  "lnurl.feature.rotate": "تدوير سند",
+  "lnurl.feature.split": "تقسيم سند",
+  "lnurl.feature.merge": "دمج السندات",
+  "lnurl.feature.lud06": "LUD-06 payRequest",
+  "lnurl.feature.lud03": "LUD-03 withdrawRequest",
+  "lnurl.limits.label": "حدود السحب",
+  "lnurl.limits.notPublished": "غير منشور",
+  "lnurl.limits.withdrawRow": "السحب",
+  "lnurl.limits.disabled": "معطّل",
+  "lnurl.limits.sats.one": "{n} ساتوشي",
+  "lnurl.limits.sats.two": "{n} ساتوشي",
+  "lnurl.limits.sats.few": "{n} ساتوشي",
+  "lnurl.limits.sats.many": "{n} ساتوشي",
+  "lnurl.limits.sats.other": "{n} ساتوشي",
+  "lnurl.details.title": "تفاصيل المنّاتة",
+  "lnurl.details.address": "عنوان Lightning",
+  "lnurl.details.mintPubkey": "المفتاح العام للمنّاتة",
+  "lnurl.details.onion": "عنوان Tor",
+  "lnurl.details.fee": "رسوم السكّ",
+  "lnurl.details.node": "العقدة",
+  "lnurl.details.capacity": "السعة المُعلنة",
+  "lnurl.kind.lightningAddress": "عنوان Lightning",
+  "lnurl.kind.mintPubkey": "المفتاح العام للمنّاتة",
+  "lnurl.kind.onionAddress": "عنوان Tor",
+  "lnurl.confirmed.label": "آخر تأكيد",
+  "lnurl.confirmed.when": "تم التأكيد {when}",
+  "lnurl.fee.base.one": "{n} ساتوشي",
+  "lnurl.fee.base.two": "{n} ساتوشي",
+  "lnurl.fee.base.few": "{n} ساتوشي",
+  "lnurl.fee.base.many": "{n} ساتوشي",
+  "lnurl.fee.base.other": "{n} ساتوشي",
+  "lnurl.fee.percent": "{percent}٪",
+  "home.topLnurl.title": "أفضل منّاتات LNURL",
+  "home.topLnurl.sub": "مرتّبة حسب المراجعات والتقييم",
+  "home.topLnurl.all": "كل منّاتات LNURL البالغة {n} ←",
+  "feed.ecosystem.lnurl": "LNURL",
+  "reviews.dialog.bodyPlaceholder.lnurl": "كيف كان السكّ والصهر وتدوير السندات؟ كن محددًا.",
+  "reviews.byUrl.open": "اكتب مراجعة",
+  "reviews.byUrl.title": "اكتب مراجعة",
+  "reviews.byUrl.lede": "ألصق العنوان. إن كان هذا الموقع لا يعرفه بعد، فسيفحصه ويضيفه الآن.",
+  "reviews.byUrl.label.cashu": "رابط الـ mint",
+  "reviews.byUrl.label.fedimint": "رمز دعوة الاتحاد",
+  "reviews.byUrl.label.lnurl": "رابط mint من نوع LNURL",
+  "reviews.byUrl.placeholder.cashu": "mint.example.com",
+  "reviews.byUrl.placeholder.fedimint": "fed11…",
+  "reviews.byUrl.placeholder.lnurl": "mint.example.com",
+  "reviews.byUrl.check": "افحص هذا العنوان",
+  "reviews.byUrl.checking": "جارٍ الفحص…",
+  "reviews.byUrl.back": "استخدم عنوانًا آخر",
+  "reviews.byUrl.existing": "مدرج بالفعل",
+  "reviews.byUrl.indexed": "أُضيف للتو",
+  "reviews.byUrl.confirmClose": "إغلاق؟ العنوان الذي كتبته لن يُحفظ.",
+  "reviews.byUrl.detected": "استجاب هذا العنوان بوصفه mint من نوع {kind}.",
+  "reviews.byUrl.switchTo": "راجعه بوصفه mint من نوع {kind}",
+  "reviews.byUrl.error.empty": "اكتب عنوانًا أولًا.",
+  "reviews.byUrl.error.badUrl": "هذا لا يبدو رابط mint.",
+  "reviews.byUrl.error.badInvite": "هذا ليس رمز دعوة Fedimint. الرموز تبدأ بـ fed11.",
+  "reviews.byUrl.error.badInput": "لا يستطيع هذا الموقع فحص ذلك العنوان.",
+  "reviews.byUrl.error.blocked": "هذا ليس عنوانًا عامًا، لذا لا يمكن فحصه.",
+  "reviews.byUrl.error.notAMint": "استجاب هذا العنوان، لكن ليس بوصفه mint من هذا النوع.",
+  "reviews.byUrl.error.wrongType": "استجاب هذا العنوان، لكن بوصفه mint من نوع آخر.",
+  "reviews.byUrl.error.unverifiable": "لم يستجب شيء على ذلك العنوان، ولا أثر له على Nostr حتى الآن.",
+  "reviews.byUrl.error.rateLimited.one": "عدد كبير من الفحوص من اتصال واحد. حاول مجددًا بعد نحو {n} دقيقة.",
+  "reviews.byUrl.error.rateLimited.other": "عدد كبير من الفحوص من اتصال واحد. حاول مجددًا بعد نحو {n} دقيقة.",
+  "reviews.byUrl.error.network": "تعذّر الوصول إلى الفهرس. تحقّق من اتصالك ثم حاول مجددًا.",
+  "seo.lnurl.titleNoReviews": "{name}: معلومات ومراجعات منّاتة LNURL | Cashumints.space",
+  "seo.desc.statusWithdraw": "{status}، السحب {min}–{max} ساتوشي.",
+  "mint.chip.noFunding": "لا سكّ ولا صهر",
+  "mint.warnings.lnurlWithdrawalsDisabled.lead": "السحب معطّل.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.online": "تُعلن هذه المنّاتة حدًّا أقصى للسحب يساوي صفرًا، فلا يمكن استبدال أي سند تُصدره بأي شيء. لا تسكّ هنا حتى يتغير ذلك.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.offline": "عند آخر اتصال بها كانت هذه المنّاتة تُعلن حدًّا أقصى للسحب يساوي صفرًا، فلم يكن ممكنًا استبدال أي سند تُصدره بأي شيء. لا تسكّ هنا حتى يتغير ذلك.",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.online": "السحب معطّل حاليًا",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.offline": "كان السحب معطّلًا عند آخر ظهور",
+  "mint.warnings.lnurlInvalid.lead": "نقطة النهاية تستجيب لكنها غير صالحة.",
+  "mint.warnings.lnurlInvalid.body": "المضيف يستجيب، لكن ليس بإعلان منّاتة يستطيع هذا الموقع قراءته، لذا قد لا يعمل السحب. كل ما في الأسفل هو آخر حالة أمكن قراءتها، والمراجعات لا تزال تعمل.",
+  "mint.warnings.lnurlInvalid.meta": "يستجيب، لكن ليس بإعلان منّاتة صالح",
+  "mint.warnings.lnurlNoFunding.lead": "السكّ والصهر غير متاحين.",
+  "mint.warnings.lnurlNoFunding.body": "لا تزال السندات الموجودة قابلة للتدوير أو التقسيم أو الدمج، لكن لا شيء يدخل أو يخرج عبر Lightning حاليًا. المنّاتة نفسها تعمل وتستجيب؛ لكن عقدة Lightning خلفها غير قابلة للوصول منها.",
+  "mint.warnings.lnurlNoFunding.meta": "السكّ والصهر غير متاحين",
+  "mint.warnings.also.noFunding": "كانت عقدة Lightning الخاصة بها غير قابلة للوصول أيضًا، فلم يكن ممكنًا سكّ أو صهر أي شيء."
+}

web/src/i18n/config.ts

@@ -23,6 +23,8 @@ export interface LocaleInfo {
   intl: string;
   /** `og:locale`. Underscored, region required by the OpenGraph spec. */
   og: string;
+  /** Writing direction for the document. */
+  dir?: 'rtl';
 }
 
 /**
@@ -33,8 +35,63 @@ export const LOCALES: LocaleInfo[] = [
   { code: 'en', label: 'English', intl: 'en-GB', og: 'en_US' },
   { code: 'es', label: 'Español', intl: 'es-ES', og: 'es_ES' },
   { code: 'nl', label: 'Nederlands', intl: 'nl-NL', og: 'nl_NL' },
+  { code: 'zh', label: '简体中文', intl: 'zh-CN', og: 'zh_CN' },
+  { code: 'hi', label: 'हिन्दी', intl: 'hi-IN', og: 'hi_IN' },
+  { code: 'ar', label: 'العربية الفصحى', intl: 'ar-SA', og: 'ar_SA', dir: 'rtl' },
+  { code: 'fr', label: 'Français', intl: 'fr-FR', og: 'fr_FR' },
+  { code: 'pt', label: 'Português', intl: 'pt-BR', og: 'pt_BR' },
+  { code: 'it', label: 'Italiano', intl: 'it-IT', og: 'it_IT' },
+  { code: 'tr', label: 'Türkçe', intl: 'tr-TR', og: 'tr_TR' },
+  { code: 'pl', label: 'Polski', intl: 'pl-PL', og: 'pl_PL' },
+  { code: 'uk', label: 'Українська', intl: 'uk-UA', og: 'uk_UA' },
+  { code: 'ro', label: 'Română', intl: 'ro-RO', og: 'ro_RO' },
+  { code: 'el', label: 'Ελληνικά', intl: 'el-GR', og: 'el_GR' },
+  { code: 'cs', label: 'Čeština', intl: 'cs-CZ', og: 'cs_CZ' },
+  { code: 'sv', label: 'Svenska', intl: 'sv-SE', og: 'sv_SE' },
+  { code: 'da', label: 'Dansk', intl: 'da-DK', og: 'da_DK' },
+  { code: 'id', label: 'Bahasa Indonesia', intl: 'id-ID', og: 'id_ID' },
+  { code: 'ur', label: 'اردو', intl: 'ur-PK', og: 'ur_PK', dir: 'rtl' },
+  { code: 'ru', label: 'Русский', intl: 'ru-RU', og: 'ru_RU' },
+  { code: 'de', label: 'Deutsch', intl: 'de-DE', og: 'de_DE' },
+  { code: 'ja', label: '日本語', intl: 'ja-JP', og: 'ja_JP' },
+  { code: 'ar-eg', label: 'العربية المصرية', intl: 'ar-EG', og: 'ar_EG', dir: 'rtl' },
+  { code: 'vi', label: 'Tiếng Việt', intl: 'vi-VN', og: 'vi_VN' },
 ];
 
+/*
+ * All twenty-four, and what "shipping" one actually required.
+ *
+ * These locales spent a while listed here while `index.ts` imported only en, es and nl.
+ * That is the failure worth remembering, because it does not look like one: every other
+ * locale rendered the *English* catalog under its own `<html lang>`, its own URL prefix
+ * and a full reciprocal hreflang set. Not a half-translated page — twenty-one complete
+ * duplicates of the English site, each telling a crawler it was a different language.
+ * They were removed from this table rather than wired up, which fixed the SEO claim and
+ * left twenty-one finished catalogs on disk reaching nobody.
+ *
+ * They are back, and this time the catalog is imported and in `CATALOGS` alongside the
+ * entry here. Those two edits are one change; either alone is the bug above. The build
+ * cannot tell you when you make it — `catalogFor()` falls back to English by design —
+ * so the guard is `test/i18n-wiring.test.mjs`, which fails when a locale in this table
+ * has no catalog of its own behind it.
+ *
+ * Adding a language is therefore four things: the entry here, the code in `locales.mjs`,
+ * the import and `CATALOGS` line in `index.ts`, and `xx.json` itself.
+ *
+ * On translation quality: these catalogs were machine-translated in bulk and then
+ * repaired by hand across the strings that appear on every page — the brand name, the
+ * footer, the nav, the language switcher, the custody warning. The brand in particular
+ * was being translated as a phrase ("Καταιγίδες. Διάστημα", "ログイン スペース"), which is
+ * why `site.name` is now asserted identical to English in every catalog by the same
+ * test. Below the chrome, the body copy is still machine output: understandable, not
+ * idiomatic, and worth a native pass per language before anyone calls it finished.
+ *
+ * `ar` (Modern Standard) and `ar-eg` (Egyptian) are both here and both real catalogs
+ * rather than duplicates. Two RTL page sets do compete for a mostly-overlapping
+ * audience; that is a content decision to revisit with traffic in hand, not a reason to
+ * leave a finished catalog unreachable.
+ */
+
 export type Locale = string;
 
 /** Just the codes, for the Astro config and for validating a URL segment. */
@@ -79,6 +136,10 @@ export const CLIENT_NAMESPACES = [
   // redraws when a fresh announcement disagrees with the build.
   'fedimints',
   'fedimint',
+  // The LNURL index's count line, and the feature rows and withdraw-limits cell the
+  // live island redraws when a fresh probe disagrees with the build.
+  'lnurlMints',
+  'lnurl',
   'card',
   'reviews',
   'feed',

web/src/i18n/cs.json

@@ -0,0 +1,834 @@
+{
+  "site.name": "Cashumints.space",
+  "common.close": "Zavřít",
+  "common.cancel": "Zrušit",
+  "common.done": "Hotovo",
+  "common.back": "Zpět",
+  "common.retry": "Zkusit znovu",
+  "common.connect": "Připojit",
+  "common.copied": "Zkopírováno",
+  "common.copyFull": "Kopírovat plně{kind}",
+  "common.previousPage": "Předchozí stránka",
+  "common.nextPage": "Další strana",
+  "common.reviewPages": "Přezkum stránky",
+  "time.never": "nikdy",
+  "time.justNow": "právě teď",
+  "time.none": "-",
+  "time.unknownDate": "neznámé datum",
+  "time.ago.minute": "{n}m před",
+  "time.ago.hour": "{n}h před",
+  "time.ago.day": "{n}d před",
+  "time.ago.week": "{n}Před",
+  "time.ago.month": "{n}mo před",
+  "time.ago.year": "{n}Ano.",
+  "time.short.minute": "{n}m",
+  "time.short.hour": "{n}h",
+  "time.short.day": "{n}d",
+  "time.short.week": "{n}s",
+  "time.short.month": "{n}mo",
+  "time.short.year": "{n}y",
+  "status.online": "Online",
+  "status.offline": "Offline",
+  "status.degraded": "Nedosažitelné",
+  "status.unknown": "Ještě není zkontrolováno",
+  "nav.skip": "Přeskočit na obsah",
+  "nav.main": "Hlavní",
+  "nav.mints": "Cashu minty",
+  "nav.reviews": "Recenze",
+  "nav.wallets": "Peněženky",
+  "nav.about": "O",
+  "nav.searchMints": "Hledat mezi {n} minty",
+  "lang.label": "Jazyk",
+  "lang.switcher": "Vyberte si jazyk",
+  "footer.copyright": "© {year} Cashumints.space",
+  "footer.allMints": "Všechny Cashu minty",
+  "footer.allReviews": "Všechny recenze",
+  "footer.wallets": "Peněženky",
+  "footer.about": "O",
+  "footer.disclaimer": "Právní upozornění",
+  "footer.terms": "Podmínky",
+  "footer.privacy": "Ochrana soukromí",
+  "footer.madeBy": "Vytvořeno s ❤️ od {azzamo} · Poháněno Cashu a NIP-87",
+  "footer.warning": "Minty jsou custodiální. Mint může zmizet s vašimi penězi.",
+  "footer.tagline": "Recenze komunity na ecash minty, podepsané na Nostru.",
+  "footer.col.explore": "Prozkoumat",
+  "footer.col.site": "Web",
+  "footer.nav": "Zápatí",
+  "home.title": "Cashumints.space · Najdi Cashu mint, kterému můžeš věřit",
+  "home.description": "Najdi Cashu mint, kterému můžeš věřit. {mints} mintů v indexu, {reviews} komunitních recenzí podepsaných na Nostru, k tomu živá dostupnost, podporované NUTy a software mintu.",
+  "home.hero.title": "Najdi Cashu mint",
+  "home.hero.titleEm": "Můžeš věřit.",
+  "home.hero.lede": "Každá mincovna na síti Nostr, s opravdovými komunitními recenzemi. Žádné brány, jen podepsal recenze si můžete ověřit sami.",
+  "home.search.label": "Hledat mincovny podle jména, domain, nebo URL",
+  "home.search.placeholder": "Hledat podle jména, domain, nebo vložit mincovna URLD",
+  "home.filters.mostReviewed": "Nejpřezkoumávanější",
+  "home.filters.highestRated": "Nejvyšší hodnocení",
+  "home.filters.recentlyActive": "Nedávno aktivní",
+  "home.filters.websockets": "Podporuje webové Sockets",
+  "home.top.title": "Top Cashu mincovny",
+  "home.top.sub": "hodnocené podle hodnocení a hodnocení",
+  "home.top.all": "Všechny{n}mincovny →",
+  "home.latest.title": "Poslední recenze",
+  "home.latest.sub": "živě ze sítě Nostr",
+  "home.latest.prev": "Předchozí recenze",
+  "home.latest.next": "Další recenze",
+  "home.latest.all": "Všechny recenze →",
+  "home.latest.empty": "Žádné recenze by mohly být čteny z relé právě teď. Otevřete jakékoli mincovna stránky číst a psát recenze přímo.",
+  "home.why.title": "Proč věřit těmto recenzím?",
+  "home.why.signed.title": "Podepsáno, nepředloženo",
+  "home.why.signed.body": "Každá recenze je{link}událost podepsaná jejím autorizačním klíčem Nostr. Nic zde není editováno, Ranked, nebo odstraněn námi.",
+  "home.why.signed.link": "NIP- 87",
+  "home.why.verify.title": "Ověřte si to sám.",
+  "home.why.verify.body": "Recenze živě na veřejnosti Nostr relays, ne naše databáze. Point každý klient na stejné relé a uvidíte stejné datum.",
+  "home.why.checked.title": "Kontrolováno nepřetržitě",
+  "home.why.checked.body": "Prohledáváme každou mincovnu pro uptime, softwarovou verzi, limitsy a podporované NUTs, takže specifikace, které vidíte, jsou aktuální, ne etablované.",
+  "home.cta.title": "- Přemýšlíte o mincovně?",
+  "home.cta.body": "Mincovna drží vaše ecash. Přečtěte si, co ostatní lidé našli, než jste dali sats in, a zanechte recenzi, když jste použili jeden sám.",
+  "home.cta.explore": "Prozkoumejte všechny mincovny",
+  "home.cta.learn": "Přečtěte si o Cashu",
+  "pulse.mintsIndexed": "mincovny indexované",
+  "pulse.reviewsOnNostr": "Recenze na Nostr",
+  "pulse.lastReview": "poslední přezkum",
+  "pulse.mintsOnline": "mincovny online",
+  "pulse.indexer": "indexovač",
+  "pulse.connected": "připojeno",
+  "pulse.stale": "oschlý",
+  "mints.title": "Všechny Cashu mincovny · Cashumints.space",
+  "mints.description": "Všechny{total}Cashu mincovny indexovány z sítě Nostr,{online}online a{offline}Offline, s komunitou ratingstime, čas a mincovna software. hledání a třídit celý seznam.",
+  "mints.heading": "Všechny Cashu minty",
+  "mints.lede": "Každá mincovna objevil na síti Nostr, včetně těch, které jsou gone. offline mincovny zůstat uveden, takže můžete stále najít a zkontrolovat je.",
+  "mints.search.label": "Hledat mincovny podle názvu nebo domény",
+  "mints.search.placeholder": "Hledání podle jména nebo původu",
+  "mints.sort.label": "Třídit mincovny",
+  "mints.sort.score": "Celkem nejlepší",
+  "mints.sort.rating": "Nejvyšší hodnocení",
+  "mints.sort.reviews": "Nejpřezkoumávanější",
+  "mints.sort.recent": "Nedávno přezkoumáno",
+  "mints.sort.seen": "Nedávno viděn online",
+  "mints.hideOffline": "Skrýt offline",
+  "mints.showing": "Zobrazuji{total}mincovny ({online}online,{offline}offline)",
+  "mints.showingFiltered": "Zobrazuji{shown}z{total}mincovny ({online}online,{offline}offline)",
+  "mints.noResults": "Žádná mincovna neodpovídá. Zkuste doménu nebo vložte URL mincovny.",
+  "mints.clearSearch": "Vymazat vyhledávání",
+  "card.noRatings": "Zatím žádné hodnocení.",
+  "card.reviews.one": "{n}Přezkum",
+  "card.reviews.other": "{n}recenze",
+  "card.reviews.few": "{n}recenze",
+  "card.reviews.many": "{n}recenze",
+  "card.lastSeen": "naposledy viděn{when}",
+  "card.neverSeen": "Nikdy jsem neviděl online",
+  "card.reviewed": "přezkoumáno{when}",
+  "card.noReviews": "dosud žádné recenze",
+  "mint.title": "{name}· Cashu mincovna recenze",
+  "mint.titleFedimint": "{name} · Recenze federace Fedimint",
+  "mint.titleLnurl": "{name} · Recenze LNURL mintu",
+  "mint.breadcrumb": "Drobečková navigace",
+  "mint.crumbMints": "Cashu mincovny",
+  "mint.copyUrl": "Kopírovat URL mincovna",
+  "mint.qrButton": "mincovna QR",
+  "mint.writeReview": "Napište recenzi",
+  "mint.rankByScore": "#{rank}podle skóre",
+  "mint.tagLightning": "Blesk",
+  "mint.summary": "souhrn mincovna",
+  "mint.rating.label": "Hodnocení Společenství",
+  "mint.rating.none": "Zatím žádné hodnocení.",
+  "mint.rating.reviews.one": "{n}Přezkum",
+  "mint.rating.reviews.other": "{n}recenze",
+  "mint.rating.reviews.few": "{n}recenze",
+  "mint.rating.reviews.many": "{n}recenze",
+  "mint.rating.unrated.one": "{n}nehodnoceno",
+  "mint.rating.unrated.other": "{n}nehodnoceno",
+  "mint.rating.unrated.few": "{n}nehodnoceno",
+  "mint.rating.unrated.many": "{n}nehodnoceno",
+  "mint.activity.label": "Činnost",
+  "mint.activity.since": "od posledního přezkumu",
+  "mint.activity.noReviews": "dosud žádné recenze",
+  "mint.activity.recent.one": "{n}přezkum v posledních 90 dnech",
+  "mint.activity.recent.other": "{n}recenze v posledních 90 dnech",
+  "mint.activity.recent.few": "{n}recenze v posledních 90 dnech",
+  "mint.activity.recent.many": "{n}recenze v posledních 90 dnech",
+  "mint.limits.label": "Mezní hodnoty",
+  "mint.limits.notPublished": "nezveřejněno",
+  "mint.limits.min": "min",
+  "mint.limits.max": "max",
+  "mint.limits.mintRow": "ražba",
+  "mint.limits.meltRow": "výběr",
+  "mint.limits.disabled": "deaktivováno",
+  "mint.limits.range": "{min}do{max}{unit}",
+  "mint.limits.upTo": "až do{max}{unit}",
+  "mint.limits.from": "od{min}{unit}",
+  "mint.software.label": "mincovna software",
+  "mint.software.unknown": "neznámý",
+  "mint.checked": "zkontrolováno{when}",
+  "mint.lastSeen": "naposledy viděn{when}",
+  "mint.neverReached": "nedosažen",
+  "mint.uptime.checks": "{ok}Poslední{total}kontroly dosažitelné",
+  "mint.uptime.percent": "{percent}% dosažitelných za 30 dní",
+  "mint.uptime.description": "{ok}Poslední{total}úspěšně provedené kontroly",
+  "mint.operator.title": "Od provozovatele",
+  "mint.operator.motd": "Zpráva dne",
+  "mint.operator.beta": "Tento mincovna popisuje sám sebe jako experimentální nebo v beta. Přečtěte si operatortis vlastní slova níže před uložením něco, co nemůžete ztratit.",
+  "mint.nuts.title": "Podporovaná čísla NUTS",
+  "mint.nuts.noneOffline": "Žádný NUT seznam pro tuto mincovna, to šlo offline před tím, než jeden byl přijat.",
+  "mint.nuts.noneYet": "Na tuhle mincovnu ještě žádný NUT seznam neplatil.",
+  "mint.nuts.supported": "{n}z{total}podporované známé NUTS",
+  "mint.nuts.whatAre": "Co jsou NUTs?",
+  "mint.nutRow.disabled": "deaktivováno",
+  "mint.nutRow.notSupported": "nepodporované",
+  "mint.details.title": "mincovna podrobnosti",
+  "mint.details.pubkey": "Veřejný klíč",
+  "mint.details.nostr": "Nostr",
+  "mint.details.email": "E @-@ mail",
+  "mint.details.serverTime": "Čas serveru",
+  "mint.details.firstSeen": "Poprvé spatřeno",
+  "mint.details.terms": "Podmínky",
+  "mint.kind.identifier": "identifikátor",
+  "mint.kind.mintPubkey": "mincovna pubkey",
+  "mint.kind.nostrAddress": "Nostr adresa",
+  "mint.kind.emailAddress": "e @-@ mailová adresa",
+  "mint.kind.npub": "npub",
+  "mint.disclaimer": "Tato mincovna je uschovatelské diagramu: to drží vaše peníze, a to může přestat dělat tak kdykoliv. Ratings jsou názory komunity a on @-@ line znamená reachable. ne důvěryhodnost.",
+  "mint.disclaimerLink": "Přečtěte si úplné odřeknutí zodpovědnosti",
+  "mint.qr.title": "Přidat{name}do tvé peněženky.",
+  "mint.qr.note": "Proskenujte to pomocí Cashu peněženky přidat mincovna, nebo zkopírujte URL a vložte ji dovnitř.",
+  "mint.qr.warn": "Přidání mincovny znamená svěřit se s penězi.",
+  "mint.qr.whatMeans": "Co to znamená?",
+  "mint.qr.wallets": "Peněženky, které podporují Cashu",
+  "mint.chip.frozen": "Zmrazené",
+  "mint.chip.noWithdrawals": "Žádné výběry",
+  "mint.chip.meltOnly": "Pouze tavit",
+  "mint.warnings.dayCount.one": "{n}den",
+  "mint.warnings.dayCount.other": "{n}dny",
+  "mint.warnings.dayCount.few": "{n}dny",
+  "mint.warnings.dayCount.many": "{n}dny",
+  "mint.warnings.gone.lead": "Pravděpodobně ano.",
+  "mint.warnings.gone.body.since": "Tato mincovna je nedostupná od té doby, co{date}({days}Zacházení s finančními prostředky drženými tam jako v riziku, a neposílejte nové fondy. Podrobnosti níže ukazují jeho poslední známý stav.",
+  "mint.warnings.gone.body.neverDated": "Tato mincovna neodpověděla na jediný šek od doby, co jsme se na to začali dívat v{month}. Léčit fondy držené tam jako v riziku, a neposílejte nové fondy. Cokoliv níže pochází z Nostr oznámení, ne z mincovna.",
+  "mint.warnings.gone.body.never": "Tato mincovna neodpověděla na jediný šek od doby, co jsme začali sledovat. Zacházejte s finančními prostředky drženými tam jako v riziku, a neposílejte nové fondy. Cokoliv níže pochází z Nostr oznámení, ne z mincovna.",
+  "mint.warnings.gone.meta.since": "Offline od{date}",
+  "mint.warnings.gone.meta.never": "Nikdy nedostupný, protože byl objeven.",
+  "mint.warnings.meltDisabled.lead": "Odstoupení je nepoužitelné.",
+  "mint.warnings.meltDisabled.body.online": "Tento mincovna má Lightning tání CITNUT-05) vypnuto: můžete dát sats in, ale nemůžete je stáhnout přes Lightning. neukládat, dokud tání je zpět.",
+  "mint.warnings.meltDisabled.body.offline": "Tento mincovna měl Lightning tání CITNUT-05) vypnuto: můžete dát sats do, ale nemůžete je stáhnout přes Lightning. neukládat, dokud tání je zpět.",
+  "mint.warnings.meltDisabled.meta.online": "V současné době je stahování zakázáno",
+  "mint.warnings.meltDisabled.meta.offline": "Odebrání bylo zakázáno, když bylo naposledy pozorováno",
+  "mint.warnings.frozen.lead": "Mincovna Frozenová.",
+  "mint.warnings.frozen.body.online": "Jak mincovní, tak tavení jsou nepoužitelné. Žádné saturace se nemohou pohybovat dovnitř ani ven přes Lightning.",
+  "mint.warnings.frozen.body.offline": "Vypínání a tavení byly nepoužitelné. Žádné saturace se přes Lightninga ani dovnitř ani ven nemohou pohybovat.",
+  "mint.warnings.frozen.meta.online": "V současné době mražené, nic se pohybuje dovnitř nebo ven",
+  "mint.warnings.frozen.meta.offline": "Zmrazený, když byl naposledy spatřen",
+  "mint.warnings.offlineLong.lead": "Offline pro{days}, od{date}.",
+  "mint.warnings.offlineLong.body": "Mincovna může být pryč. Vše níže je jeho poslední známý stav, a recenze stále fungují.",
+  "mint.warnings.offlineLong.meta": "Offline od{date}",
+  "mint.warnings.meltOnly.lead": "Roztavit se jen tak.",
+  "mint.warnings.meltOnly.body.online": "Nová mincovna je diskvalifikována: nemůžete uložit, ale stávající ecash může být stále zapnutý. To často znamená, že mincovna se stahuje, takže pokud držíte jeho ecash, zvažte tavení ven.",
+  "mint.warnings.meltOnly.body.offline": "Nová mincovna byla zrušena: nemůžete uložit, ale stávající ecash může být stále zapnutý. To často znamená, že mincovna se stahuje, takže pokud máte jeho ecash, zvažte tání ven.",
+  "mint.warnings.meltOnly.meta.online": "V současné době se pouze taví",
+  "mint.warnings.meltOnly.meta.offline": "Rozpustit pouze, když naposledy viděn",
+  "mint.warnings.offline.lead": "Offline od{date}.",
+  "mint.warnings.offline.body": "Detaily byly naposledy potvrzeny. Stále můžete napsat recenzi.",
+  "mint.warnings.offline.meta": "Offline od{date}",
+  "mint.warnings.also.meltDisabled": "Před tím, než šel offline, byl také zakázán s odvodnění.",
+  "mint.warnings.also.mintDisabled": "Před tím, než šel offline to také vyřadila nové minting. color = " # 8FFFF "",
+  "mint.warnings.also.offline": "Je také offline od{date}({days}Izzie.",
+  "nut.0": "Poznamenávání a modely",
+  "nut.1": "mincovna výměna veřejných klíčů",
+  "nut.2": "Klíčové soubory a poplatky",
+  "nut.3": "Výměna žetonů",
+  "nut.4": "Vydávání přes Lightning",
+  "nut.5": "Roztavení pomocí blesku",
+  "nut.6": "informace o mincovně",
+  "nut.7": "Kontrola stavu Token",
+  "nut.8": "Přeplatky za blesky",
+  "nut.9": "Obnovit podpisy",
+  "nut.10": "Podmínky pro uložení",
+  "nut.11": "Platit na veřejný klíč",
+  "nut.12": "Důkazy DLEQ",
+  "nut.13": "Deterministická tajemství",
+  "nut.14": "Kontrakty na hashed timelock",
+  "nut.15": "Vícecestné platby",
+  "nut.16": "Animované kódy QR",
+  "nut.17": "Předplatné WebSocket",
+  "nut.18": "Žádosti o platbu",
+  "nut.19": "Chachované odpovědi",
+  "nut.20": "Podepsané mincovna kotace",
+  "nut.21": "Vyčistit autentizaci",
+  "nut.22": "Ověření slepého provedení",
+  "nut.23": "Platební metoda BOLT11",
+  "nut.24": "HTTP 402 nutná platba",
+  "nut.25": "Metoda platby BOLT12",
+  "reviews.title": "Přezkum",
+  "reviews.anon": "Anonym",
+  "reviews.anonTitle": "Žádný veřejný profil Nostr nenalezen pro tento klíč",
+  "reviews.nip05Title": "Identifikátor NIP- 05 není ověřen touto položkou )",
+  "reviews.filter.group": "Filtrační recenze",
+  "reviews.filter.all": "Všechny",
+  "reviews.filter.five": "5ņ@@",
+  "reviews.filter.critical": "Kritický",
+  "reviews.filter.recent": "Nedávné",
+  "reviews.filter.hideAnon": "Skrýt anon",
+  "reviews.anonHidden.other": "Zobrazuji{n}z{total}Přehled: anon hidden.",
+  "reviews.allAnon.one": "Jedinou recenzí je jeden.",
+  "reviews.allAnon.other": "Všechny{n}Recenze zde jsou anon.",
+  "reviews.allAnon.few": "Všechny{n}Recenze zde jsou anon.",
+  "reviews.allAnon.many": "Všechny{n}Recenze zde jsou anon.",
+  "reviews.allAnonShow.one": "Ukaž to.",
+  "reviews.allAnonShow.other": "Ukaž jim to.",
+  "reviews.allAnonShow.few": "Ukaž jim to.",
+  "reviews.allAnonShow.many": "Ukaž jim to.",
+  "reviews.loading.one": "Načítání{n}přezkum z relé Nostr",
+  "reviews.loading.other": "Načítání{n}recenze z Nostr relays",
+  "reviews.loading.few": "Načítání{n}recenze z Nostr relays",
+  "reviews.loading.many": "Načítání{n}recenze z Nostr relays",
+  "reviews.empty": "Ještě žádné recenze. Buďte první, kdo napsat jeden.",
+  "reviews.emptyWritten": "Už žádné písemné recenze. Buďte první, kdo napsat jeden.",
+  "reviews.emptyFilter": "Žádné recenze se neshodují s tímto filmem.",
+  "reviews.rate.cashu": "Ohodnoťte tento mint",
+  "reviews.rate.fedimint": "Ohodnoťte tuto federaci",
+  "reviews.rate.lnurl": "Ohodnoťte tento mint",
+  "reviews.noscript": "Recenze jsou podepsány na Nostr a načíst do browseru, takže tento seznam potřebuje JavaScript. Hodnocení a počty výše pocházejí z webu sám.",
+  "reviews.relayError": "Nelze dosáhnout relé. Recenze mohou být nedokončené.",
+  "reviews.srRating": "{rating}z 5",
+  "reviews.srNoRating": "Bez ratingu",
+  "reviews.readMore": "Přečtěte si více",
+  "reviews.readLess": "Zobrazit méně",
+  "reviews.actions.copyNpub": "Kopírovat npub",
+  "reviews.actions.openNostr": "Zobrazit tuto událost na Nostr",
+  "reviews.actions.copyLink": "Kopírovat odkaz na tuto recenzi",
+  "reviews.anonNote": "První přezkum z tohoto npub, žádná jiná činnost nenalezena",
+  "reviews.published": "Publikováno.",
+  "reviews.publishedPartial": "Zveřejněno{accepted}z{total}relé.",
+  "reviews.propagating": "Publikování na Nostr relayích",
+  "reviews.summary.line.one": "{count}hodnocení bez komentáře:{breakdown}",
+  "reviews.summary.line.other": "{count}ratingy bez komentáře:{breakdown}",
+  "reviews.summary.line.few": "{count}ratingy bez komentáře:{breakdown}",
+  "reviews.summary.line.many": "{count}ratingy bez komentáře:{breakdown}",
+  "reviews.summary.lineDay.one": "{count}hodnocení bez komentáře k{when}:{breakdown}",
+  "reviews.summary.lineDay.other": "{count}hodnocení bez komentáře k{when}:{breakdown}",
+  "reviews.summary.lineDay.few": "{count}hodnocení bez komentáře k{when}:{breakdown}",
+  "reviews.summary.lineDay.many": "{count}hodnocení bez komentáře k{when}:{breakdown}",
+  "reviews.summary.showOne": "Ukaž to.",
+  "reviews.summary.showMany": "Ukaž jim to.",
+  "reviews.breakdown.5": "{n}5 hvězdiček",
+  "reviews.breakdown.4": "{n}4 hvězdy",
+  "reviews.breakdown.3": "{n}Tři hvězdy.",
+  "reviews.breakdown.2": "{n}Dvě hvězdy.",
+  "reviews.breakdown.1": "{n}jedna hvězda",
+  "reviews.breakdown.none": "{n}bez ratingu",
+  "reviews.dialog.title": "Přezkum{name}",
+  "reviews.dialog.lede.cashu": "Podělte se o svou zkušenost s tímto mintem.",
+  "reviews.dialog.lede.fedimint": "Podělte se o svou zkušenost s touto federací.",
+  "reviews.dialog.lede.lnurl": "Podělte se o svou zkušenost s tímto mintem.",
+  "reviews.dialog.permanent": "Zveřejněno natrvalo na veřejných Nostr relayích.",
+  "reviews.dialog.gate.title": "Přihlaste se, abyste mohli napsat recenzi",
+  "reviews.dialog.gate.lead": "Recenze se podepisují vaším klíčem Nostr. Zůstává ve vašem signeru, tato stránka ho nikdy nevidí.",
+  "reviews.dialog.ratingLegend": "Vaše hodnocení",
+  "reviews.dialog.starsSr.one": "{n}hvězda",
+  "reviews.dialog.starsSr.other": "{n}hvězdy",
+  "reviews.dialog.starsSr.few": "{n}hvězdy",
+  "reviews.dialog.starsSr.many": "{n}hvězdy",
+  "reviews.dialog.chooseRating": "Vyberte si rating",
+  "reviews.dialog.starLabel": "{n}:{phrase}",
+  "reviews.dialog.stars.1": "Vyhněte se tomu.",
+  "reviews.dialog.stars.2": "měl problémy",
+  "reviews.dialog.stars.3": "pracoval, s varováním",
+  "reviews.dialog.stars.4": "Dobře.",
+  "reviews.dialog.stars.5": "funguje skvěle.",
+  "reviews.dialog.bodyLabel": "Co by měli ostatní vědět?",
+  "reviews.dialog.charCount": "{n}/{max}",
+  "reviews.dialog.submit": "Podepsat a zveřejnit",
+  "reviews.dialog.signing": "Signalizační zařízení",
+  "reviews.dialog.publishing": "Vydavatelství",
+  "reviews.dialog.publishingTo": "Publikování relé ({accepted}/{total})",
+  "reviews.dialog.waitingExtension": "Čekám na prodloužení.",
+  "reviews.dialog.waitingSigner": "Čekám na váš podpis.",
+  "reviews.dialog.confirmClose": "Váš návrh zůstane, dokud neopustíte místo.",
+  "reviews.dialog.why.login": "Přihlásit se k publikování",
+  "reviews.dialog.why.words": "Napiš pár slov.",
+  "reviews.dialog.why.more.one": "{n}více charakteru",
+  "reviews.dialog.why.more.other": "{n}více znaků",
+  "reviews.dialog.why.more.few": "{n}více znaků",
+  "reviews.dialog.why.more.many": "{n}více znaků",
+  "reviews.dialog.why.over.one": "{n}charakter nad limit",
+  "reviews.dialog.why.over.other": "{n}znaky nad limitem",
+  "reviews.dialog.why.over.few": "{n}znaky nad limitem",
+  "reviews.dialog.why.over.many": "{n}znaky nad limitem",
+  "reviews.dialog.identity.needSigner": "Musíte Nostr signer publish. Váš klíč zůstane v ní, tato stránka nikdy nevidí.",
+  "reviews.dialog.identity.loginToPublish": "Přihlásit se k publikování",
+  "reviews.dialog.identity.switch": "Přepínač",
+  "reviews.dialog.identity.extension": "Podepisování s rozšířením prohlížeče",
+  "reviews.dialog.identity.readingKey": "Čtení vašich veřejných kláves",
+  "reviews.dialog.identity.willAsk": "Vaše prodloužení bude požádáno o podpis",
+  "reviews.dialog.error.noRelay": "Žádný relé nepřijal recenzi. Zkontrolujte spojení a zkuste to znovu.",
+  "reviews.validate.rating": "Vyberte si hodnocení od 1 do 5 hvězdiček.",
+  "reviews.validate.short": "Napište alespoň:{n}znaky, takže přezkum je užitečný.",
+  "reviews.validate.long": "Recenze jsou omezeny na{n}charakteristické znaky.",
+  "feed.title": "Nejnovější recenze mincovny a federace · Cashumints.space",
+  "feed.description": "Každá recenze mintu, federace a mintu LNURL hned po zveřejnění: {reviews} recenzí na {mints} mintů Cashu, {federations} federací Fedimint a {lnurl} mintů LNURL, podepsaných na Nostr a čitelných zde od nejnovějších. Filtrujte podle ekosystému, hodnocení nebo názvu.",
+  "feed.heading": "Poslední recenze",
+  "feed.lede": "Každá recenze každé Cashu mincovny a Fedimint federace, nejnovější první, číst živě z Nostr relays. Každý z nich je podepsán jeho autor a žije na relays, ne v naší databázi.",
+  "feed.label": "Přezkum",
+  "feed.showingBuild.one": "Zobrazuji poslední recenzi z poslední budovy",
+  "feed.showingBuild.other": "Ukazuji{n}poslední recenze z poslední stavět",
+  "feed.showingBuild.few": "Ukazuji{n}poslední recenze z poslední stavět",
+  "feed.showingBuild.many": "Ukazuji{n}poslední recenze z poslední stavět",
+  "feed.noscript": "Recenze jsou podepsány na Nostr a načíst do browseru, takže filtrování a celý seznam potřebují JavaScript.{n}recenze níže byly čteny z relé, když tato stránka byla postavena.",
+  "feed.emptyBuild": "Při sestavování této stránky se z relé v prohlížeči nedaly číst žádné recenze.",
+  "feed.foot": "Recenze jsou opce Společenství, neověřené žadatelů. Přečtěte si{link}Než budete věřit mincovně s penězi.",
+  "feed.footLink": "Odvolatelnost",
+  "feed.showing": "Zobrazuji{shown}z{total}recenze",
+  "feed.showingMatching": "Zobrazuji{shown}z{matching}hodnocení ({total}celkem )",
+  "feed.emptyRelays": "Žádné recenze se vrátil z relay. otevřete jakékoli mincovna stránky číst a psát recenze tam.",
+  "feed.emptyFilter": "Žádné recenze se shodují s tímto film. Vymazat mincovna boxer, nebo zkuste All.",
+  "feed.relayError": "Nelze dosáhnout relays. Zobrazuji recenze z posledního budová.d",
+  "feed.relayEmpty": "Žádné recenze se vrátil z relays. zobrazuji recenze z poslední budovy.",
+  "feed.reading": "Čtení relaysoth",
+  "login.open": "Přihlásit se",
+  "login.title": "Přihlaste se s Nostrem.",
+  "login.note": "Váš klíč zůstane ve vašem podpisu. Tato stránka nemůže nikdy vidět.",
+  "login.extension.name": "Prodloužení prohlížeče",
+  "login.extension.desc": "Podpis s Albyem, nós2x nebo jiným rozšířením NIP-07",
+  "login.extension.none": "Žádné prodloužení nenalezeno",
+  "login.extension.getOne": "Tak si jednu vem.",
+  "login.remote.name": "Vzdálený signer",
+  "login.remote.desc": "Proskenujte kód se signer app, nebo vložte odkaz na bunkr",
+  "login.primal.name": "Primal",
+  "login.primal.desc": "Povolit přihlášení v aplikaci Primal v telefonu",
+  "login.paste.label": "Nebo vložte odkaz na připojení, který vám dal váš znalec.",
+  "login.copyLink": "Kopírovat spojovací odkaz",
+  "login.whatIsNostr": "Co je Nostrem?",
+  "login.connect.remote.title": "Připojte dálkový signer",
+  "login.connect.remote.lead": "Naskenujte to svým podpisovým appem, nebo zkopírujte odkaz a vložte ho tam.",
+  "login.connect.remote.hint": "Pracuje s jakýmikoli NIP-46 signer: nsec.app, Ambere, Nosrify, váš vlastní bunker.",
+  "login.connect.remote.open": "Otevřít v aplikaci signer",
+  "login.connect.primal.title": "Připojení s Primal",
+  "login.connect.primal.lead": "Otevřít Primal na telefonu, najít dálkové podepisování v jeho usazeninách, a skenovat tento kód.",
+  "login.connect.primal.hint": "Primární značky pro jiné aplikace přes NIP-46, takže je to stejné spojení, jaké používá signer, a váš klíč zůstane v Primalu.{link}",
+  "login.connect.primal.open": "Otevřít v Primal",
+  "login.status.buildingLink": "Vybudování propojovacího spojení",
+  "login.status.waitingExtension": "Čekám na prodloužení.",
+  "login.status.waitingSigner": "Čekám na váš podpis.",
+  "login.status.connecting": "Připojení k vašemu signeru",
+  "login.status.connected": "Připojeno",
+  "login.toast.loggedIn": "Přihlášeno",
+  "login.toast.fetchingProfile": "Načítání vašeho profilu Nostr z relé…",
+  "login.toast.profile": "Profil: {name}",
+  "login.toast.noProfile": "Na relé nebyl nalezen žádný profil",
+  "login.method.extension": "Rozšíření",
+  "login.method.remote": "Vzdálené",
+  "login.method.primal": "Primal",
+  "login.account": "Váš účet Nostr",
+  "login.copyNpub": "Kopírovat celý npub",
+  "login.logout": "Odhlásit se",
+  "signer.status.waitingExtension": "Čekám na prodloužení.",
+  "signer.status.signed": "Podepsáno",
+  "signer.status.reconnecting": "Reunnecting to your signer",
+  "signer.status.approveWindow": "Váš znalec potřebuje, abyste to schválil ve svém vlastním okně.",
+  "signer.status.waitingSigner": "Čekám na váš podpis.",
+  "signer.status.stillWaiting": "Pořád čekám, až mi to podepíše.",
+  "signer.status.connected": "Připojeno",
+  "signer.error.noExtension": "Žádné rozšíření podpisu nenalezeno. Nainstalujte Alby nebo nos2x2x. a pak znovu načíst tuto stránku.",
+  "signer.error.privateKey": "To vypadá jako soukromý klíč, ne spojení link. Tato stránka nikdy bere klávesu. Vložte bunkersburg / odkaz, který vám signer dal.",
+  "signer.error.badLink": "To není odkaz na připojení této stránky rozumí. Vložte bunkersburg / odkaz z vašeho znaku.",
+  "signer.error.noAnswer": "Váš znalec neodpověděl, může být uzavřen, nebo může být jeho relé dole. Otevřete to a zkuste to znovu.",
+  "signer.error.timeout": "Váš znalec neodpověděl včas. Otevřete to, zkontrolujte, zda je to stále propojené, pak zkuste znovu.",
+  "signer.error.cancelled": "Zrušení spojení.",
+  "signer.error.declined": "Žádost o podpis byla zamítnuta.",
+  "notfound.title": "Stránka nenalezena · Cashumints.space",
+  "notfound.description": "Tato stránka neexistuje na Cashumints.space.",
+  "notfound.heading": "Tato stránka neexistuje",
+  "notfound.lede": "Může se pohybovat, nebo mincovna nemusí být indexován yet. hledat mincovna jménem nebo domain, nebo vložit mincovna URL.",
+  "notfound.browse": "Procházet všechny mincovny",
+  "notfound.home": "Jdi domů.",
+  "notfound.loading": "Načítání{host}",
+  "notfound.fb.rating": "Hodnocení",
+  "notfound.fb.reviews": "Přezkum",
+  "notfound.fb.software": "Software",
+  "notfound.fb.lastOnline": "Naposledy online",
+  "notfound.fb.note": "Tenhle mint byl zaindexován až po posledním sestavení webu, takže tohle je souhrn z živého API a pod ním jsou recenze. Celá stránka se objeví při dalším sestavení.",
+  "notfound.resolve.checking": "První návštěva: právě tenhle mint kontroluji.",
+  "notfound.resolve.failed": "Tenhle mint se nepodařilo přidat",
+  "notfound.resolve.failedFedimint": "Tuhle federaci se nepodařilo přidat",
+  "notfound.resolve.retry": "Zkusit jinou adresu",
+  "notfound.resolve.switch": "Otevřít jako mint {kind}",
+  "notfound.resolve.fedimint": "Adresa stránky federace neobsahuje její invite code, takže tuhle nelze najít jen podle odkazu. Vlož invite code a federace se přidá.",
+  "notfound.resolve.ambiguous": "Tuhle adresu nejde z odkazu odvodit. Vlož celou URL mintu a mint se přidá.",
+  "wallets.title": "Cashu peněženky · Cashumints.space",
+  "wallets.description": "Cashu peněženky, které pracují s mincovny uvedeny zde, přes mobilní, webový, prohlížeč a příkazové linky, s tím, co každý z nich je dobrý.",
+  "wallets.heading": "Peněženky",
+  "wallets.lede": "Většina peněženek mluví s několika mincovny najednou, takže nejste vázáni na první pokus.",
+  "wallets.note": "Tento seznam není vyčerpávající a není podporovatelem. Projekt Cashu udržuje širší index{link}. Peněženka drží keys, mincovna drží peníze: přečtěte si recenzi mincovna před tím, než si vybrat, kde vaše sats žije.",
+  "wallets.platform.android": "Android",
+  "wallets.platform.ios": "iOS",
+  "wallets.platform.web": "Web",
+  "wallets.platform.extension": "Prodloužení prohlížeče",
+  "wallets.platform.cli": "CLI",
+  "wallets.platform.python": "Python",
+  "wallets.item.minibits": "Mobilní ekashová peněženka s vlastní mincovna, podpora adresy Lightning a kontakty Nostr.",
+  "wallets.item.nutstash": "Prohlížecí peněženka, která zpracovává více mincovny najednou a importuje a exportuje syrové tokens.",
+  "wallets.item.enuts": "Mobilní peněženka se zaměřuje na multimintové bilance a odesílání ekash přes Nostr.Name",
+  "wallets.item.cashume": "Reference webová peněženka z projektu Cashu. Je plně v prohlížeči, instalovatelná jako PWA.",
+  "wallets.item.boardwalk": "Webové peněženky postavené kolem Blesk adresy a posílání ecash link.",
+  "wallets.item.coinos": "Blesk peněženka a místo prodeje, který také běží své vlastní Cashu mincovna.",
+  "wallets.item.oxchat": "Nostr posel s ekašovou peněženkou postavenou v, pro odesílání saturace uvnitř chats.",
+  "wallets.item.nutshell": "Reference funguje jako peněženka na příkazové řádce a jako mincovna software. name",
+  "about.title": "O Cashumints.space",
+  "about.description": "Co Cashu je, co Mincovna vlastně drží, co NIP-87 je, a jak tato stránka indexuje mincovny a čte recenze z Nostr relays. color",
+  "about.heading": "O",
+  "about.lede": "Cashumints.space uvádí všechny Cashu mincovna, které můžeme najít v síti Nostr a ukazuje vám, co o nich lidé říkají. Je vyroben Azzamo.",
+  "about.cashu.title": "Co je Cashu?",
+  "about.cashu.p1": "Cashu je ekash protokol pro Bitcoin. Mincovna problémy zaslepené tokeny podporované sats to holds. a tyto tokeny se pohybují mezi lidmi bez mincovna učení, který poslal, co na koho. Soukromí je skutečné a je to bod: tokeny nejsou účty, a mincovna nemůže spojit token podepsaný na token, který se vrací.",
+  "about.cashu.p2": "Protokol a jeho specifikace si můžete přečíst na adrese{link}. Specifikace se samy nazývají NUTs, což je místo, kde čísla NUT na každé mincovna stránce přijít from.",
+  "about.mints.title": "To je ale mincovna a ten obchod.",
+  "about.mints.p1": "Mincovna je opatrovnictví. Když Mincovna ecash jste podání sats tomu, kdo běží, že server, a vy věříte jim, aby ctít žetony, když je roztavíte zpět. Neexistuje žádný podvod korektury, žádné smlouvy a žádné opakování. Mincovna operátor může zmizet s balancí, a mincovny mají.",
+  "about.mints.p2": "To je přesně důvod, proč recenze existují zde. Tato stránka vám nikdy neřekne, mincovna je bezpečný. Stav na stránce mincovna říká{code}, ne důvěryhodné, a to jen znamená, že server odpověděl, když jsme se ptali naposledy. Zacházet s ekash zůstatky jako hotovost v kapse kabátu: pokuta za utrácení, špatné pro savings.",
+  "about.nip87.title": "Co je NIP-87?",
+  "about.nip87.p1": "NIP @-@ 87 je Nostr konvence pro oznámení a doporučení ecash mincovny. dva druhy událostí zde záleží:",
+  "about.nip87.li1": "{code}oznamuje mincovna. Mincovna URL je v{tag}Tag. Takhle se na místě objeví Mincovny, kterou nikdy neviděl.",
+  "about.nip87.li2": "{code}je recenzí. Nosí hodnocení a recenzi textury, a body na mincovna je asi s{utag}Značka mincovna URL ) a a{dtag}Značka Mincovnadols vlastní veřejné klíče.",
+  "about.nip87.p2": "Každý přezkum je podepsán svým autorizačním klíčem Nostr. Nikdy jsme volat recenzi ověřené, protože nikdo ověřil: to je signed, což je jiný a užitečnější žadatel. To znamená, že můžete zkontrolovat, kdo ji napsal a že to nebylo změněno. To neznamená, že autor je upřímný nebo někdy použil mincovna.",
+  "about.how.title": "Jak tato stránka funguje",
+  "about.how.p1": "Existují dvě smyčky a jedna pravidla. Pravidlem je, že mincovna vlastní metadata a Nostr vlastní recenzi, takže tato stránka ukládá ani jako autorita.",
+  "about.how.li1": "{strong}žádá všechny známé mincovna pro{code}každých deset minut a zaznamenává, co se říká: jméno, popis, verze, podporované NUTSs, limits, kontaktní údaje. Také zaznamenává, zda Mincovna odpověděl na všechny, což je místo, kde je čas přijde.",
+  "about.how.li1Label": "Sonda smyčka",
+  "about.how.li2": "{strong}se připojí k Nostr relays každou hodinu, čte oznámení a recenze mincovny, a přidává jakékoli mincovna, které dosud neviděl.",
+  "about.how.li2Label": "Objevovací smyčka",
+  "about.how.p2": "Důležitou částí je to, co se stane, když mincovna přestane odpovídat. Jeho cached metadata není nikdy přepsán neúspěšnou probee, takže mrtvý mincovna udržuje svou plnou podívanou: jeho spektrum, jeho historie a jeho recenzí, s banner říká, když šel tmavý. Předchozí verze této stránky ukázal chybové stránky insteadd, což znamenalo, že mincovny lidé nejvíce potřebují, aby se navzájem varoval o byly ty, které nemohly být přezkoumány. To byl hlavní důvod pro přestavení.",
+  "about.how.p3": "Recenze text není nikdy uložen na naší straně. Když otevřete stránku mincovna váš prohlížeč mluví s relé přímo a čte recenze sám o sobě, a když píšete jeden je podepsán vaše vlastní Nostr rozšíření a zaslán přímo do těchto relé. Držíme počet, takže stránky mohou být seřazeny a tříděny, nic víc. Nic zde nelze editovat nebo smazat námi, včetně recenzí bychom raději neměli.",
+  "about.relays.title": "Relé, které čteme",
+  "about.relays.p1": "Toto jsou relé indexeru i vašeho prohlížeče, které se používají:",
+  "about.relays.p2": "Ukazujte každému klientovi Nostr na stejné relé a uvidíte stejné události. To je celý slib: nic zde není pravda, protože říkáme, že ano.",
+  "about.nuts.title": "Co jsou NUTs?",
+  "about.nuts.p1": "NUT jsou číslovány Cashu specifikace. jako BIP pro Bitcoin. Mincovna inzeruje, které z nich implements. a to vám řekne, co to vlastně může dělat: NUT-04 a NUT-05 jsou Minting a tání nad Lightning bez nich mincovna není moc užitečné, NUT-07 nechá peněženka zkontrolovat, zda token byl již rozhazuje, NUT-17 dává peněženky živé aktualizace přes WebSockets místo pollingové, a NUT-20 umožňuje peněženka prokázat mincovna citace byl skutečně vydán na. Plný seznam je na{link}.",
+  "about.numbers.title": "Právě teď.",
+  "about.numbers.p1": "Indexujeme {mints} mincoven, z nichž {online} odpovídá, a z výše uvedených relé jsme započítali {reviews} recenzí.",
+  "about.source.title": "Zdroj a úvěry",
+  "about.source.p1": "Stránka je open source{github}. Je postavena a řízena{azzamo}. Pokud je na stránce mincovna něco špatně, opravte to na source: mincovna metadata pocházejí z Mincovnadolls vlastní{code}a recenze přicházejí z Nostrin.",
+  "terms.title": "Podmínky použití · Cashumints.space",
+  "terms.description": "Podmínky použití pro Cashumints.space: co je to za místo, co nedělá a kdo je zodpovědný za cokoli. žádné účty, žádné záruky, žádné spojení s žádnou mincovna.",
+  "terms.heading": "Podmínky použití",
+  "terms.lede": "Prosté termíny pro stránku, která pouze indexuje veřejné dat. Poslední aktualizované{date}.",
+  "terms.what.title": "Co je to za stránku?",
+  "terms.what.p1": "Cashumints.space je index veřejně dostupných dat o Cashu mincovny. dva druhy dat, a to jak odněkud jinde:",
+  "terms.what.li1": "mincovna metadata, číst z každého mincovnadois vlastní{code}Konečný bod: jméno, popis, softwarová verze, podporované NUTs, kontaktní údaje a zda Mincovna odpověděla, když jsme se naposledy ptali.",
+  "terms.what.li2": "Recenze, čtení z veřejných Nostr relays. Jedná se o NIP-87 události publikované jejich autoři relé kdokoliv může query.",
+  "terms.what.p2": "Shromáždíme data, znormalizujeme je, seřadíme a ukážeme.",
+  "terms.noAccounts.title": "Žádné účty, žádné záruky.",
+  "terms.noAccounts.p1": "Stránka není k zapsání. Stránka je poskytována, protože není záruka jakéhokoliv druhu: ne, že údaje jsou přesné, ne, že je aktuální, ne, že by místo bude k dispozici. Mincovna data mohou být minuty nebo hodiny staré, mincovna může změnit po poslední kontrole, a relé nemůže odpovědět, v takovém případě jste vidět méně než existují.",
+  "terms.noAccounts.p2": "Používejte jej na vlastní riziko. Nejsme odpovědní za žádnou ztrátu, která vyplývá z použití této stránky nebo spoléhá na cokoliv, co jste zde četli. Viz{link}pro zvláštní rizika použití Cashu mincovna. kgm",
+  "terms.noAccounts.link": "Odvolatelnost",
+  "terms.noCustody.title": "Nedržíme vaše peníze.",
+  "terms.noCustody.p1": "Tato stránka nikdy vezme opatrovnictví fondů. Nemá žádné peněženky, to se nedotkne ecash, a to nemůže přesunout, zmrazit nebo obnovit nic. Pokud máte problém s mincovna, operátor mincovna je jediná strana, která vám může pomoci, a nemůžeme se s nimi spojit na vaší behalfth.",
+  "terms.noCustody.p2": "Nejsme přidruženi k žádné mincovna zde uvedené, a žádná mincovna neplatí za jeho listing, jeho hodnost nebo jeho rating. mincovny jsou objeveny z veřejných Nostr oznámení a zařadil algoritmus nad veřejné hodnocení data.",
+  "terms.reviews.title": "Recenze jsou jiná lidová slova",
+  "terms.reviews.p1": "Recenze jsou uživatelsky @-@ generovaný obsah zveřejňovaný veřejnosti Nostr relé jejich autoritami. Zobrazujeme je, nekontrolujeme je. Nenapsali jsme je, nemůžeme je upravovat, a nemůžeme je smazat z relé, které je drží: jsou podepsané události na síti, kterou nemáme vlastní.",
+  "terms.reviews.p2": "Recenze je jedna osoba zkušenosti, ne ověřený fakt. Pokud publikujete jeden, jste zodpovědní za to, co říká. Nezveřejňovat nic nezákonného, a být si vědom toho, že to, co publikujete, je veřejné a trvalé vidět{link}Izzie.",
+  "terms.reviews.link": "stránka ochrany soukromí",
+  "terms.reviews.p3": "Můžeme přestat zobrazovat konkrétní recenzi na tomto místě, a budeme to dělat pro obsah, který je nezákonný. To odstraňuje z těchto stránek pouze. Událost zůstává na relé a každý jiný Nostr klient může stále číst.",
+  "terms.links.title": "Odkazy na jiné stránky",
+  "terms.links.p1": "mincovna URLs, peněženka links, operátorské kontakty a všechno ostatní, co ukazuje na těchto stránkách jsou tam, protože jsou součástí dat. Odkaz není doložka a my neověřujeme, co je na druhém konci.",
+  "terms.changes.title": "Změny",
+  "terms.changes.p1": "Tyto termíny se mohou změnit. Datum na vrcholu říká, kdy naposledy. Stránka je otevřená zdroj, takže každá změna této stránky je v historii odevzdání.",
+  "terms.contact.title": "Kontakt",
+  "terms.contact.p1": "Otázky a žádosti o převzetí jsou nejlépe vyplněny na{github}. Stránka je řízena{azzamo}.",
+  "privacy.title": "Soukromí · Cashumints.space",
+  "privacy.description": "Soukromí na Cashumints.space. žádné účty, žádné sledovací kuchyně, žádné analýzy. localStorage se používá pro ukládání profilů a nic není odesláno nikam. Recenze jsou podepsány ve vašem vlastním prohlížeči.",
+  "privacy.heading": "Ochrana soukromí",
+  "privacy.lede": "Sbíráme tak málo jako webové stránky can. poslední aktualizován{date}.",
+  "privacy.noAccounts.title": "Žádné účty",
+  "privacy.noAccounts.p1": "Není tam žádná známka nahoru, žádné přihlášení a žádný profil. Nic na této stránce se vás ptá, kdo jste, a neexistuje žádný záznam uživatele, který by unikl, protože nejsou žádní uživatelé.",
+  "privacy.noTracking.title": "Žádné sledovací kuchyně, žádná analýza.",
+  "privacy.noTracking.p1": "Stránky nenastavují žádné soubory cookie pro sledování. Neexistuje žádný analytický skript, žádný správce tagů, žádný pixel. žádný záznam relace a žádné reklamní sítě. Nic na stránce hlásí své chování nám nebo komukoliv jinému.",
+  "privacy.logs.title": "Záznamy serverů",
+  "privacy.logs.p1": "Web server udržuje standardní přístupové logs, což je to, co každý webový server dělá default. Log line zaznamenává vaše IP adresu. čas, stránku, kterou jste požádali o, stav odpovědi, a uživatelský agent a referenr váš prohlížeč sent. Záznamy existují pro ladění chyb a skvrn abus. nejsou spojeny s ničím jiným a nejsou prodávány nebo shared.",
+  "privacy.logs.operatorLabel": "Poznámka k obsluze:",
+  "privacy.logs.operator": "Pokud spustíte tuto stránku, uveďte zde svou skutečnou retenci. Zavedení v README používá nginx s jeho výchozí přístupový záznam a bez ohledu na rotaci distribučních lodí Debian a Ubuntu, které je logrotateDaily, uchování 14 dní. Potvrďte, co váš server dělá a nahraďte tento odstavec číslem.",
+  "privacy.storage.title": "Co je uloženo ve vašem prohlížeči",
+  "privacy.storage.p1": "Stránka používá localStorage přesně pro dvě věci, které zůstávají na vašem zařízení a nikdy nejsou odeslány nikam:",
+  "privacy.storage.li1": "Kache profilu Nostr metadata typu 0 events: names, avatars, NIP-05 addressesses ) pro recenzenty, jejichž recenze jste hledali. To ušetří re @-@ kladení relé na každé straně. Záznamy vymazává, a cache je capped a emicted nejstarší první.",
+  "privacy.storage.li2": "Rozhraní preferuje, takže místo se bude chovat stejně příště.",
+  "privacy.storage.p2": "Čištění vašich browsergets data stránky odstraňuje oba. Nic přestávky, profil vyhledávání prostě spustit znovu.",
+  "privacy.thirdParties.title": "S čím váš prohlížeč mluví",
+  "privacy.thirdParties.p1": "Nahrávání stránky spojuje váš prohlížeč na několik míst kromě tohoto místa. To je, jak stránky bez serverside sledování stále čte živé data:",
+  "privacy.thirdParties.li1Label": "Veřejná přenosová zařízení Nostr",
+  "privacy.thirdParties.li1": "{strong}, přes WebSocket, číst recenze a recenzenty profily. Relé vidí váš IP a to, co jste žádali, jako každý server, který připojíte k dělá. Relays jsou uvedeny na seznamu{link}.",
+  "privacy.thirdParties.li1Link": "o stránce",
+  "privacy.thirdParties.li2Label": "Revizor avatar obrázky",
+  "privacy.thirdParties.li2": "{strong}, načteno odkudkoliv, kde je profil reviewers body. Tyto jsou zaslány s ne- @-@ referrer politika, takže hostitel se nedozví, na které stránce jste byli na.",
+  "privacy.publishing.title": "Zveřejnění recenzí",
+  "privacy.publishing.p1": "Psaní recenzi se stane ve vašem browser. ne na našem serveru. Událost je podepsána vaše NIP- 07 rozšíření Albyou. nos2x nebo podoba. a vysílat z vašeho prohlížeče přímo do relé. Váš soukromý klíč nikdy opustí rozšíření a tato stránka nikdy nevidí. Nebudujeme vlastní správu klíčů a my nikdy požádat o klíč nebo semínka fráze.",
+  "privacy.permanent.title": "Všechno, co publikujete Nostrovi, je veřejné a trvalé.",
+  "privacy.permanent.p1": "Toto je část, která stojí za to číst twice. přezkum je podepsaná událost na veřejných relé. Jakmile je to venku, je to out:",
+  "privacy.permanent.li1": "Každý si to může přečíst, nyní i později, pomocí jakéhokoli klienta Nostr. Není to veřejné na Cashumints.spacethern, je to veřejné na síti.",
+  "privacy.permanent.li2": "Je trvale spojen s vaším veřejným klíčem Nostr, spolu se vším ostatním, co kdy ten klíč publikoval.",
+  "privacy.permanent.li3": "Vymazání je požadavek, ne velitel. Můžete publikovat smazání událost a některé relé bude ctít, ale relé je zdarma ignorovat a každý, kdo již kopíroval událost má. Zacházejte s publikovanou recenzi jako permanent.@@",
+  "privacy.permanent.li4": "Nemůžeme vám to smazat. Můžeme to přestat zobrazovat zde, to nic nemění na relé.",
+  "privacy.permanent.p2": "Pokud chcete přezkoumat mincovna, aniž by to bylo vázáno na vaši hlavní identity, použijte samostatný klíč Nostr. Všimněte si, že klíč bez jiné činnosti je zobrazen jako takový na tvrdých recenzích, protože zbrusu nový klíč psaní jedné hvězdy recenze je vzor čtenáři si zaslouží vidět.",
+  "privacy.contact.title": "Otázky",
+  "privacy.contact.p1": "Stránka je otevřená source: pokud chcete zkontrolovat některý z above.read kód na{github}Otázky a opravy mohou jít do problému tam.",
+  "disclaimer.title": "Discovery · Cashumints.space",
+  "disclaimer.description": "Co vědět, než budete používat Cashu mincovna: mincovny jsou custdialdiama, mincovna může zmizet s penězi, recenze jsou názory a on @-@ line znamená reachable. ne důvěřivě.",
+  "disclaimer.heading": "Zveřejnění",
+  "disclaimer.lede": "Přečtěte si to, než jste dát peníze v mincovna. naposledy aktualizováno{date}.",
+  "disclaimer.callout": "Cashu Mincovna drží vaše peníze pro vás. Pokud se rozpustí, vaše ecash je pryč, a není nikdo, kdo by apelovat na. Nechte si jen to, co si můžete dovolit ztratit.",
+  "disclaimer.custodial.title": "Mincovny jsou opatrovníci.",
+  "disclaimer.custodial.p1": "Když mincovna ecash, dáte Bitcoin operátorovi mincovna a získat žetony zpět. Tyto žetony jsou nárok na tento operator. Nejsou Bitcoin jste držet, a operátor je ten, kdo rozhodne, zda je poctít.",
+  "disclaimer.custodial.p2": "To znamená, že každá mincovna nese stejné riziko: operátor může mizet, může být nucen zastavit, může přijít o finanční prostředky přes chybu nebo hacknutí, nebo může jednoduše vypnout server. Neexistuje žádné pojištění vkladů, žádné zálohování, žádná podpůrná linka a žádné právní využití stojí za to počítat na. To je pravda z nejvyšší hodnocené mincovna na tomto místě.",
+  "disclaimer.custodial.p3": "Cashu je určen pro malé množství pohybující se rychle. Použijte to tak, že způsob: držet to, co se chystáte utrácet, ne vaše úspory, a šíří se po mincovny spíše než parkování všechno v jednom.",
+  "disclaimer.reviews.title": "Recenze jsou opinions, neověřená tvrzení",
+  "disclaimer.reviews.p1": "Každá recenze zde byl napsán někým na Nostr a podepsal s jejich klávese. Podepsán znamená, že vám můžeme říct, který klíč napsal. To neznamená, že přezkum je pravda, že autor použil mincovna, nebo že autor není operator, konkurent, nebo jedna osoba s deseti keysna.",
+  "disclaimer.reviews.p2": "Neověřujeme recenzí, a needitujeme ani neodstraňujeme recenze, se kterými nesouhlasíme. Přečtěte si pár, podívejte se na to, co ve skutečnosti říkají, a zvážit mincovna se třemi recenzemi odlišně od jednoho se třemi stovkami.",
+  "disclaimer.status.title": "Online znamená reakhable. ne důvěryhodný",
+  "disclaimer.status.p1": "Pravidelně kontrolujeme každou mincovnu a ukazujeme, zda odpovídá. To vše znamená zelený status: server odpovídá. To neříká nic o tom, zda operátor je solventní, čestný, nebo stále má v úmyslu uctít vaše žetony zítra.",
+  "disclaimer.status.p2": "Mincovna může být online až do okamžiku, kdy není. Uptime historie, podporované NUTs a softwarové verze vám něco říct o tom, jak mincovna je run, ale žádný z nich není slib o vašich peněz.",
+  "disclaimer.ranking.title": "Jak to pořadí funguje a co to neznamená",
+  "disclaimer.ranking.p1": "Mincovny jsou objednány algoritmem přes veřejné hodnocení data: ratinging, počet recenzí a nedávné aktivity, s on @-@ line mincovny před offline ty o default. Detaily jsou v kódu open source.",
+  "disclaimer.ranking.p2": "Nikdo neplatí za umístění. Neexistuje sponzorovaný slota, žádný podporovaný výpis a žádná dohoda s žádnou mincovna na tomto místě. Vysoká hodnost znamená, že algoritmus měl rád veřejná data, a nic víc. Není to doporučení a není to bezpečnost ratinging.",
+  "disclaimer.notAdvice.title": "To není finanční poradenství.",
+  "disclaimer.notAdvice.p1": "Nic na této stránce není finanční, investiční, právní nebo daňové poradenství. Nevíme, vaše situace a my vám neradíme. Použití mincovna, a výběr, který z nich, je vaše rozhodnutí.",
+  "disclaimer.dyor.title": "Proveďte si vlastní výzkum.",
+  "disclaimer.dyor.li1": "Mincovna vedená někým, kdo má veřejnou reputaci, je jiný návrh od anonymního URL.",
+  "disclaimer.dyor.li2": "Přečtěte si vlastní podmínky a jeho MOTD Mincovna, která se nazývá test nebo beta znamená.",
+  "disclaimer.dyor.li3": "Začněte trochu. Mincovna trochu, utraťte to, rozpusťte to, a uvidíte, co se stane, než budete věřit, že s více.",
+  "disclaimer.dyor.li4": "Sledujte omezení. Nízké maximum je často známkou pečlivého operatora a vysoké není známkou bezpečného.",
+  "disclaimer.dyor.li5": "A bojte se svých žetonů a vězte, že znamení jest to, co nese, neboť kdo drží je, ten může utratiti.",
+  "disclaimer.site.title": "O samotném místě",
+  "disclaimer.site.p1": "Data zde může být špatně nebo mimo datu. mincovny jsou zkoušeny na harmonogramu, relé někdy selhávají odpovědět, a stránka, kterou čtete, byla postavena v určitém bodě v minulosti. Stránka je poskytována, jak je, bez záruky. Viz{link}.",
+  "disclaimer.site.link": "Podmínky použití",
+  "disclaimer.updated": "20. srpna 2026",
+  "login.getPrimal": "Get Primal",
+  "reviews.dialog.identity.extensionGone": "Vaše rozšíření prohlížeče neodpovídá. Přihlaste se znovu, nebo použijte dálkový signál.",
+  "seo.orgDescription": "Adresář Cashu mincovnyy, s živým statusem z každé mincovny a komunitní recenze podepsané na Nostra.",
+  "seo.ogImageAlt": "Cashumints.space: najít Cashu mincovna můžete věřit.",
+  "seo.mint.title.one": "{name}Přehledy: jmenovité{rating}od{n}Recenze Cashumints.space",
+  "seo.mint.title.other": "{name}Přehledy: jmenovité{rating}od{n}recenze Cashumints.space",
+  "seo.mint.title.few": "{name}Přehledy: jmenovité{rating}od{n}recenze Cashumints.space",
+  "seo.mint.title.many": "{name}Přehledy: jmenovité{rating}od{n}recenze Cashumints.space",
+  "seo.mint.titleOffline.one": "{name}: offline pro{n}den Cashumints.space",
+  "seo.mint.titleOffline.other": "{name}: offline pro{n}Dny od Cashumints.space",
+  "seo.mint.titleOffline.few": "{name}: offline pro{n}Dny od Cashumints.space",
+  "seo.mint.titleOffline.many": "{name}: offline pro{n}Dny od Cashumints.space",
+  "seo.mint.titleNoReviews": "{name}: informace a recenze Cashu mintu | Cashumints.space",
+  "seo.fedimint.titleNoReviews": "{name}: informace a recenze federace Fedimint | Cashumints.space",
+  "seo.desc.fallback": "Hodnocení Společenství pro{name}({domain}Izzie.",
+  "seo.desc.fallbackDomain": "Recenze Společenství pro Cashu mincovna at{domain}.",
+  "seo.desc.rated.one": "Jmenovité{rating}5 od{n}Podepsal Nostr recenzi.",
+  "seo.desc.rated.other": "Jmenovité{rating}5 od{n}Podepsané recenze Nostra.",
+  "seo.desc.rated.few": "Jmenovité{rating}5 od{n}Podepsané recenze Nostra.",
+  "seo.desc.rated.many": "Jmenovité{rating}5 od{n}Podepsané recenze Nostra.",
+  "seo.desc.noReviews": "Ještě žádné recenze.",
+  "seo.desc.status": "{status}.",
+  "seo.desc.statusLimits": "{status}, omezení{limits}.",
+  "seo.desc.fedModules": "{status}. Moduly:{modules}.",
+  "seo.desc.fedModulesNetwork": "{status}. Moduly:{modules}zapnuto{network}.",
+  "seo.mint.ogAlt.one": "{name}:{rating}hvězdy od{n}přezkum Cashumints.space",
+  "seo.mint.ogAlt.other": "{name}:{rating}hvězdy od{n}recenze na Cashumints.space",
+  "seo.mint.ogAlt.few": "{name}:{rating}hvězdy od{n}recenze na Cashumints.space",
+  "seo.mint.ogAlt.many": "{name}:{rating}hvězdy od{n}recenze na Cashumints.space",
+  "seo.mint.ogAltNoReviews": "{name}na Cashumints.space",
+  "nav.home": "Domů",
+  "mint.more.title": "Více mincovny",
+  "mint.more.all": "Vidět všechny mincovny",
+  "nav.fedimints": "Fedimints",
+  "status.announced": "Pouze ohlášen",
+  "card.unnamedFederation": "Nepojmenovaná federace",
+  "card.notChecked": "nikdy nekontrolováno",
+  "fedimints.title": "Všechny Fedimint federace · Cashumints.space",
+  "fedimints.description": "Všechny{total}Fedimint federace oznámil na síti Nostr:{online}potvrzený běh vnější kontrolou,{announced}Oznámené a nikdy nepotvrzené, obecní daně, moduly a kódy pro každého.",
+  "fedimints.heading": "Všechny federace",
+  "fedimints.lede": "Každá Fedimint federace oznámila na síti Nostr. Federace nemá veřejný status koncový bod jeho vlastní, takže některé z nich jsou potvrzeny běh vnější kontroly a zbytek jsou uvedeny přesně tak, jak byly oznámeny.",
+  "fedimints.search.label": "Pátrací federace podle jména nebo totožnosti",
+  "fedimints.search.placeholder": "Hledání podle jména nebo federace idatis",
+  "fedimints.sort.label": "Třídit federace",
+  "fedimints.hideOffline": "Skrýt offline",
+  "fedimints.showing": "Zobrazuji{total}Federace ({online}potvrzen,{announced}Oznámeno pouze )",
+  "fedimints.showingFiltered": "Zobrazuji{shown}z{total}Federace ({online}potvrzen,{announced}Oznámeno pouze )",
+  "fedimints.announcedNote.one": "Jeden z nich byl oznámen na Nostr a nic nepotvrdilo, protože to běží. Je uveden jako ohlášen spíše než jako on @-@ line nebo offline, protože ani jeden by být pravda.",
+  "fedimints.announcedNote.other": "{n}z nich byly oznámeny na Nostr a nic nepotvrdilo, protože jsou na útěku. Jsou uvedeny jako ohlášené spíše než jako on @-@ line nebo offline, protože ani jeden by být pravda.",
+  "fedimints.announcedNote.few": "{n}z nich byly oznámeny na Nostr a nic nepotvrdilo, protože jsou na útěku. Jsou uvedeny jako ohlášené spíše než jako on @-@ line nebo offline, protože ani jeden by být pravda.",
+  "fedimints.announcedNote.many": "{n}z nich byly oznámeny na Nostr a nic nepotvrdilo, protože jsou na útěku. Jsou uvedeny jako ohlášené spíše než jako on @-@ line nebo offline, protože ani jeden by být pravda.",
+  "fedimints.noResults": "Žádné federace se neshodují. Zkuste jméno, nebo vložte federační ID.",
+  "fedimints.emptyIndex": "Žádné federace nebyly ohlášeny na relé těchto stránek čtení. seznam vyplní sám jako oznámení příchozí.",
+  "fedimint.crumb": "Fedimints",
+  "fedimint.breadcrumb": "Drobečková navigace",
+  "fedimint.unnamed": "Nepojmenovaná federace",
+  "fedimint.idLabel": "Federace",
+  "fedimint.kind.federationId": "Federation id",
+  "fedimint.moduleCount.one": "{n}modul",
+  "fedimint.moduleCount.other": "{n}moduly",
+  "fedimint.moduleCount.few": "{n}moduly",
+  "fedimint.moduleCount.many": "{n}moduly",
+  "fedimint.copyInvite": "Kopírovat kód pozvánky",
+  "fedimint.confirmed.label": "Potvrzeno",
+  "fedimint.confirmed.never": "Nikdy.",
+  "fedimint.confirmed.by": "podle{source}",
+  "fedimint.confirmed.unattributed": "poslední kontrola",
+  "fedimint.announcedOn": "ohlášen{when}",
+  "fedimint.announcedUnknown": "žádné datum oznámení",
+  "fedimint.modules.title": "Moduly",
+  "fedimint.modules.none": "Toto prohlášení federace neobsahuje žádné moduly.",
+  "fedimint.modules.note": "Moduly jsou části federační runy. V oznámení se píše, které jsou prezentovány, a nic o tom, zda některý z nich přijímá depozity.",
+  "fedimint.modules.notListed": "neuvedeno v seznamu",
+  "fedimint.invite.title": "Kód pozvánky",
+  "fedimint.invite.count.one": "{n}Kód",
+  "fedimint.invite.count.other": "{n}kódy",
+  "fedimint.invite.count.few": "{n}kódy",
+  "fedimint.invite.count.many": "{n}kódy",
+  "fedimint.invite.note": "Vložte to do Fedimint peněženky k připojení. To nese federační ID a jeho opatrovnictví adres, a to je určeno ke sdílení.",
+  "fedimint.invite.kind": "volací kód",
+  "fedimint.invite.qr": "QR",
+  "fedimint.invite.qrCaption": "Vyhledej, jak se připojit.{name}",
+  "fedimint.details.federationId": "Federace id",
+  "fedimint.details.network": "Síť",
+  "fedimint.details.announcedBy": "Oznámený",
+  "fedimint.details.announced": "Oznámeno",
+  "fedimint.more.title": "Další federace",
+  "fedimint.more.all": "Viz všechny federace",
+  "fedimint.disclaimer": "Spojení se s federací znamená věřit svým strážcům s vašimi penězi. Ratings jsou komunální názory, a potvrzený běh znamená reakbled, ne důvěryhodnost.",
+  "fedimint.module.lightning": "Blesk",
+  "fedimint.module.mint": "Ecash mincovna",
+  "fedimint.module.wallet": "Peněženka na řetěz",
+  "fedimint.module.meta": "Metadata",
+  "fedimint.module.stability_pool": "Stabilizační fond",
+  "fedimint.module.multi_sig_stability_pool": "Stabilizační pool multimedium sign )",
+  "fedimint.module.fedi-social": "Sociální zotavení",
+  "fedimint.network.mainnet": "Bitcoin mainnet",
+  "fedimint.network.signet": "Signet",
+  "fedimint.network.testnet": "Testnet",
+  "fedimint.network.testnet4": "Testnet4",
+  "fedimint.network.regtest": "Regtest",
+  "feed.ecosystem.group": "Ekosystém",
+  "feed.ecosystem.all": "Všechny",
+  "feed.ecosystem.cashu": "Cashu.",
+  "feed.ecosystem.fedimint": "Fedimint",
+  "feed.filterBySubject": "Filtr pomocí mincovny nebo federace",
+  "feed.anySubject": "Jakákoliv mincovna nebo federace",
+  "feed.clearSubject": "Vymazat jmenný filtr",
+  "home.topFedimints.title": "Top Fedilts",
+  "home.topFedimints.sub": "hodnocené podle hodnocení a hodnocení",
+  "home.topFedimints.all": "Všechny{n}Federace →",
+  "reviews.validate.subject": "Není na co poukázat.",
+  "mint.warnings.fedimintOffline.lead": "Hlášená mimo provoz.",
+  "mint.warnings.fedimintOffline.body.since": "Poslední kontrola, která dosáhla této federace byla na{date}({days}Od té doby její strážci neodpověděli. Zacházejte s finančními prostředky drženými v riziku, a nepřidejte se k nim s novými fondy.",
+  "mint.warnings.fedimintOffline.body.never": "Žádná kontrola této federace nikdy nedosáhla, a poslední selhal. Zacházet s finančními prostředky drženými tam jako v riziku, a nepřipojujte se k ní s novými fondy.",
+  "mint.warnings.fedimintOffline.meta.since": "Hlášené offline od{date}",
+  "mint.warnings.fedimintOffline.meta.never": "Oflinea hlášená, ani jednou nedosažena",
+  "mint.warnings.neverConfirmed.lead": "Oznámené, nikdy nepotvrzené.",
+  "mint.warnings.neverConfirmed.body.reviewed": "Tato federace byla oznámena na Nostr na{date},{days}A od té doby nic nepotvrdilo, že to běží. Recenze níže jsou jedinou známkou života na této soutěži, vše ostatní pochází z oznámení.",
+  "mint.warnings.neverConfirmed.body.quiet": "Tato federace byla oznámena na Nostr na{date},{days}Od té doby nic nepotvrdilo, že to běží, a nikdo to znovu neprověřil. Všechno níže pochází z oznámení.",
+  "mint.warnings.neverConfirmed.meta": "Oznámeno{date}, nikdy nepotvrzen",
+  "footer.allFedimints": "Všechny federace",
+  "reviews.dialog.bodyPlaceholder.cashu": "Jak se Mintingu, tání a podporu práce ven? Buďte specifičtí.",
+  "reviews.dialog.bodyPlaceholder.fedimint": "Jak se joining, Lightning platby a podpora práce ven? Buďte specifičtí.",
+  "fedimint.details.title": "Podrobnosti o federaci",
+  "nav.lnurlMints": "Minty LNURL",
+  "footer.allLnurlMints": "Všechny minty LNURL",
+  "lnurlMints.title": "Minty LNURL: minty směnek na doručitele lnurlcash s recenzemi | Cashumints.space",
+  "lnurlMints.description": "Všech {total} mintů LNURL indexovaných ze sítě Nostr: {online} online, {offline} offline. Hodnocení komunity, limity výběru a možnosti každého z nich.",
+  "lnurlMints.heading": "Minty LNURL",
+  "lnurlMints.lede": "Každý mint LNURL, o kterém tento web ví. Mint LNURL vydává směnky na doručitele lnurlcash: Lightning směnky, které držíte jako tajemství a které lze otočit, rozdělit, sloučit nebo roztavit zpět na Lightning platbu. Každý se každých pár minut kontroluje přes HTTPS.",
+  "lnurlMints.search.label": "Hledat minty LNURL",
+  "lnurlMints.search.placeholder": "Hledat podle jména nebo adresy…",
+  "lnurlMints.sort.label": "Řadit minty LNURL podle",
+  "lnurlMints.hideOffline": "Skrýt offline",
+  "lnurlMints.showing": "Zobrazeno {total} mintů LNURL ({online} online, {offline} offline)",
+  "lnurlMints.showingFiltered": "Zobrazeno {shown} z {total} mintů LNURL ({online} online, {offline} offline)",
+  "lnurlMints.noResults": "Žádný mint LNURL neodpovídá.",
+  "lnurlMints.emptyIndex": "Zatím nejsou indexovány žádné minty LNURL.",
+  "lnurl.crumb": "Minty LNURL",
+  "lnurl.breadcrumb": "Drobečková navigace",
+  "lnurl.copyAddress": "Kopírovat adresu",
+  "lnurl.more.title": "Další minty LNURL",
+  "lnurl.more.all": "Všechny minty LNURL →",
+  "lnurl.disclaimer": "Mint LNURL drží vaše saty, zatímco vy držíte jeho směnky, takže používat ho znamená důvěřovat jeho provozovateli. Hodnocení jsou názory komunity a online znamená dostupný, nikoli důvěryhodný.",
+  "lnurl.features.title": "Funkce",
+  "lnurl.features.none": "Tento mint neoznámil, co podporuje.",
+  "lnurl.features.note": "Funkce jsou to, co provozovatel mintu oznámil na Nostr. Kde to tento web může ověřit přes HTTPS, ověří to, a upozorní, když je něco oznámeného právě teď nedostupné.",
+  "lnurl.features.notListed": "neoznámeno",
+  "lnurl.features.unavailable": "nedostupné",
+  "lnurl.feature.mint": "Mintování přes Lightning (LUD-06)",
+  "lnurl.feature.melt": "Tavení do Lightning",
+  "lnurl.feature.notes": "Otočení / rozdělení / sloučení směnek",
+  "lnurl.feature.lud16": "Lightning adresa",
+  "lnurl.feature.lud21": "Ověření platby (LUD-21)",
+  "lnurl.feature.signed-notes": "Podepsané směnky (offline ověření)",
+  "lnurl.feature.onion": "Tor adresa",
+  "lnurl.feature.rotate": "Otočit směnku",
+  "lnurl.feature.split": "Rozdělit směnku",
+  "lnurl.feature.merge": "Sloučit směnky",
+  "lnurl.feature.lud06": "LUD-06 payRequest",
+  "lnurl.feature.lud03": "LUD-03 withdrawRequest",
+  "lnurl.limits.label": "Limity výběru",
+  "lnurl.limits.notPublished": "nezveřejněno",
+  "lnurl.limits.withdrawRow": "Výběr",
+  "lnurl.limits.disabled": "vypnuto",
+  "lnurl.limits.sats.one": "{n} sat",
+  "lnurl.limits.sats.few": "{n} saty",
+  "lnurl.limits.sats.many": "{n} satu",
+  "lnurl.limits.sats.other": "{n} satů",
+  "lnurl.details.title": "Podrobnosti mintu",
+  "lnurl.details.address": "Lightning adresa",
+  "lnurl.details.mintPubkey": "Veřejný klíč mintu",
+  "lnurl.details.onion": "Tor adresa",
+  "lnurl.details.fee": "Poplatek za mintování",
+  "lnurl.details.node": "Uzel",
+  "lnurl.details.capacity": "Oznámená kapacita",
+  "lnurl.kind.lightningAddress": "Lightning adresa",
+  "lnurl.kind.mintPubkey": "veřejný klíč mintu",
+  "lnurl.kind.onionAddress": "Tor adresa",
+  "lnurl.confirmed.label": "Naposledy potvrzeno",
+  "lnurl.confirmed.when": "potvrzeno {when}",
+  "lnurl.fee.base.one": "{n} sat",
+  "lnurl.fee.base.few": "{n} saty",
+  "lnurl.fee.base.many": "{n} satu",
+  "lnurl.fee.base.other": "{n} satů",
+  "lnurl.fee.percent": "{percent} %",
+  "home.topLnurl.title": "Nejlepší minty LNURL",
+  "home.topLnurl.sub": "seřazeno podle recenzí a hodnocení",
+  "home.topLnurl.all": "Všech {n} mintů LNURL →",
+  "feed.ecosystem.lnurl": "LNURL",
+  "reviews.dialog.bodyPlaceholder.lnurl": "Jak dopadlo mintování, tavení a otáčení směnek? Buďte konkrétní.",
+  "reviews.byUrl.open": "Napsat recenzi",
+  "reviews.byUrl.title": "Napsat recenzi",
+  "reviews.byUrl.lede": "Vlož adresu. Pokud ji tenhle web ještě nezná, teď ji zkontroluje a přidá.",
+  "reviews.byUrl.label.cashu": "URL mintu",
+  "reviews.byUrl.label.fedimint": "Invite code federace",
+  "reviews.byUrl.label.lnurl": "URL LNURL mintu",
+  "reviews.byUrl.placeholder.cashu": "mint.example.com",
+  "reviews.byUrl.placeholder.fedimint": "fed11…",
+  "reviews.byUrl.placeholder.lnurl": "mint.example.com",
+  "reviews.byUrl.check": "Zkontrolovat adresu",
+  "reviews.byUrl.checking": "Kontroluji…",
+  "reviews.byUrl.back": "Použít jinou adresu",
+  "reviews.byUrl.existing": "Už je v seznamu",
+  "reviews.byUrl.indexed": "Právě přidáno",
+  "reviews.byUrl.confirmClose": "Zavřít? Zadaná adresa se neuchová.",
+  "reviews.byUrl.detected": "Ta adresa odpověděla jako mint {kind}.",
+  "reviews.byUrl.switchTo": "Recenzovat jako mint {kind}",
+  "reviews.byUrl.error.empty": "Nejdřív zadej adresu.",
+  "reviews.byUrl.error.badUrl": "Tohle nevypadá jako URL mintu.",
+  "reviews.byUrl.error.badInvite": "Tohle není Fedimint invite code. Kódy začínají na fed11.",
+  "reviews.byUrl.error.badInput": "Tenhle web tuhle adresu zkontrolovat neumí.",
+  "reviews.byUrl.error.blocked": "Tohle není veřejná adresa, takže ji nelze zkontrolovat.",
+  "reviews.byUrl.error.notAMint": "Ta adresa odpověděla, ale ne jako mint tohoto druhu.",
+  "reviews.byUrl.error.wrongType": "Ta adresa odpověděla, ale jako jiný druh mintu.",
+  "reviews.byUrl.error.unverifiable": "Na té adrese nic neodpovědělo a na Nostru po ní zatím není ani stopa.",
+  "reviews.byUrl.error.rateLimited.one": "To je hodně kontrol z jednoho připojení. Zkus to znovu asi za {n} minutu.",
+  "reviews.byUrl.error.rateLimited.other": "To je hodně kontrol z jednoho připojení. Zkus to znovu asi za {n} minut.",
+  "reviews.byUrl.error.network": "Index není dostupný. Zkontroluj připojení a zkus to znovu.",
+  "seo.lnurl.titleNoReviews": "{name}: informace a recenze mintu LNURL | Cashumints.space",
+  "seo.desc.statusWithdraw": "{status}, výběr {min}–{max} sat.",
+  "mint.chip.noFunding": "Bez mintování / tavení",
+  "mint.warnings.lnurlWithdrawalsDisabled.lead": "Výběry vypnuty.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.online": "Tento mint oznamuje maximální výběr nula, takže žádnou jím vydanou směnku nelze za nic vyměnit. Nemintujte zde, dokud se to nezmění.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.offline": "Při posledním kontaktu tento mint oznamoval maximální výběr nula, takže žádnou jím vydanou směnku nešlo za nic vyměnit. Nemintujte zde, dokud se to nezmění.",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.online": "Výběry jsou nyní vypnuté",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.offline": "Při posledním kontaktu byly výběry vypnuté",
+  "mint.warnings.lnurlInvalid.lead": "Endpoint odpovídá, ale neplatně.",
+  "mint.warnings.lnurlInvalid.body": "Host odpovídá, ale ne oznámením mintu, které tento web umí přečíst, takže výběry nemusí fungovat. Níže je poslední stav, který se podařilo načíst, a recenze stále fungují.",
+  "mint.warnings.lnurlInvalid.meta": "Odpovídá, ale ne platným oznámením mintu",
+  "mint.warnings.lnurlNoFunding.lead": "Mintování a tavení nedostupné.",
+  "mint.warnings.lnurlNoFunding.body": "Stávající směnky lze stále otáčet, rozdělovat nebo slučovat, ale právě teď přes Lightning nic nevchází ani nevychází. Samotný mint běží a odpovídá; Lightning uzel za ním pro něj není dostupný.",
+  "mint.warnings.lnurlNoFunding.meta": "Mintování a tavení nedostupné",
+  "mint.warnings.also.noFunding": "Jeho Lightning uzel byl také nedostupný, takže nešlo nic zmintovat ani roztavit."
+}

web/src/i18n/da.json

@@ -0,0 +1,788 @@
+{
+  "site.name": "Cashumints.space",
+  "common.close": "Luk",
+  "common.cancel": "Annuller",
+  "common.done": "Færdig",
+  "common.back": "Tilbage",
+  "common.retry": "Prøv igen",
+  "common.connect": "Opret forbindelse",
+  "common.copied": "Kopieret",
+  "common.copyFull": "Kopier hele {kind}",
+  "common.previousPage": "Forrige side",
+  "common.nextPage": "Næste side",
+  "common.reviewPages": "Anmeldelsessider",
+  "time.never": "aldrig",
+  "time.justNow": "lige nu",
+  "time.none": "-",
+  "time.unknownDate": "en ukendt dato",
+  "time.ago.minute": "{n}m siden",
+  "time.ago.hour": "{n}h for et stykke tid siden",
+  "time.ago.day": "{n}d siden",
+  "time.ago.week": "{n}w siden",
+  "time.ago.month": "{n}mo for et stykke tid siden",
+  "time.ago.year": "{n}y siden",
+  "time.short.minute": "{n}m",
+  "time.short.hour": "{n}h",
+  "time.short.day": "{n}d",
+  "time.short.week": "{n}w",
+  "time.short.month": "{n}mo",
+  "time.short.year": "{n}y",
+  "status.online": "Online",
+  "status.offline": "Offline",
+  "status.degraded": "Uopnåelig",
+  "status.unknown": "Ikke kontrolleret endnu",
+  "nav.skip": "Gå direkte til indholdet",
+  "nav.main": "Hovedside",
+  "nav.mints": "Cashu-mints",
+  "nav.reviews": "Anmeldelser",
+  "nav.wallets": "Punge",
+  "nav.about": "Om",
+  "nav.searchMints": "Søg blandt {n} mints",
+  "lang.label": "Sprog",
+  "lang.switcher": "Vælg et sprog",
+  "footer.copyright": "© {year} Cashumints.space",
+  "footer.allMints": "Alle Cashu-mints",
+  "footer.allReviews": "Alle anmeldelser",
+  "footer.wallets": "Punge",
+  "footer.about": "Om",
+  "footer.disclaimer": "Ansvarsfraskrivelse",
+  "footer.terms": "Vilkår",
+  "footer.privacy": "Privatliv",
+  "footer.madeBy": "Lavet med ❤️ af {azzamo} · Drevet af Cashu og NIP-87",
+  "footer.warning": "Mints er depotbaserede. Et mint kan forsvinde med dine penge.",
+  "footer.tagline": "Anmeldelser fra fællesskabet af ecash-mints, signeret på Nostr.",
+  "footer.col.explore": "Udforsk",
+  "footer.col.site": "Websted",
+  "footer.nav": "Sidefod",
+  "home.title": "Cashumints.space · Find et Cashu-mint du kan stole på",
+  "home.description": "Find et Cashu-mint du kan stole på. {mints} mints i indekset med {reviews} anmeldelser fra fællesskabet, signeret på Nostr, plus live oppetid, understøttede NUTs og mint-software.",
+  "home.hero.title": "Find et Cashu-mint",
+  "home.hero.titleEm": "du kan stole på",
+  "home.hero.lede": "Hvert mint på Nostr-netværket, med rigtige anmeldelser fra fællesskabet. Ingen gatekeepere, bare signerede anmeldelser du selv kan verificere.",
+  "home.search.label": "Søg efter mints på navn, domæne eller URL",
+  "home.search.placeholder": "Søg efter navn, domæne, eller indsæt en Mint-URL…",
+  "home.filters.mostReviewed": "Mest anmeldte",
+  "home.filters.highestRated": "Bedst bedømte",
+  "home.filters.recentlyActive": "Senest aktive",
+  "home.filters.websockets": "Understøtter WebSockets",
+  "home.top.title": "De bedste Cashu-mints",
+  "home.top.sub": "rangeret efter anmeldelser og bedømmelser",
+  "home.top.all": "Alle {n} mints →",
+  "home.latest.title": "Seneste anmeldelser",
+  "home.latest.sub": "live fra Nostr-netværket",
+  "home.latest.prev": "Tidligere anmeldelser",
+  "home.latest.next": "Flere anmeldelser",
+  "home.latest.all": "Alle anmeldelser →",
+  "home.latest.empty": "Det var ikke muligt at læse anmeldelser fra relæerne lige nu. Åbn en hvilken som helst Mint-side for at læse og skrive anmeldelser direkte.",
+  "home.why.title": "Hvorfor kan man stole på disse anmeldelser?",
+  "home.why.signed.title": "Underskrevet, men ikke indsendt",
+  "home.why.signed.body": "Hver anmeldelse er en {link}-begivenhed, der er underskrevet med forfatterens Nostr-nøgle. Intet her redigeres, rangordnes eller fjernes af os.",
+  "home.why.signed.link": "NIP-87",
+  "home.why.verify.title": "Tjek det selv",
+  "home.why.verify.body": "Anmeldelserne findes på de offentlige Nostr-relæer, ikke i vores database. Ret et hvilket som helst cli-relæ mod de samme relæer, så vil du se de samme data.",
+  "home.why.checked.title": "Kontrolleres løbende",
+  "home.why.checked.body": "Vi prober hvert mint for oppetid, softwareversion, grænser og understøttede NUTs, så de specifikationer du ser er aktuelle, ikke selvrapporterede.",
+  "home.cta.title": "Overvejer du et mint? Læs op først.",
+  "home.cta.body": "Et mint holder din ecash. Læs, hvad andre har fundet, før du sætter sats ind, og skriv en anmeldelse, når du selv har brugt et.",
+  "home.cta.explore": "Se alle mints",
+  "home.cta.learn": "Læs mere om Cashu",
+  "pulse.mintsIndexed": "mints indekseret",
+  "pulse.reviewsOnNostr": "anmeldelser af Nostr",
+  "pulse.lastReview": "sidste gennemgang",
+  "pulse.mintsOnline": "mints online",
+  "pulse.indexer": "indekseringsprogram",
+  "pulse.connected": "forbundet",
+  "pulse.stale": "gammel",
+  "mints.title": "Alle Cashu-mints · Cashumints.space",
+  "mints.description": "Alle {total} Cashu-mints indekseret fra Nostr-netværket, {online} online og {offline} offline, med bedømmelser fra fællesskabet, oppetid og mint-software. Søg og sortér hele listen.",
+  "mints.heading": "Alle Cashu-mints",
+  "mints.lede": "Alle mints, der er fundet på Nostr-netværket, herunder dem, der ikke længere findes. Offline-mints forbliver på listen, så du stadig kan finde og gennemse dem.",
+  "mints.search.label": "Søg efter mints på navn eller domæne",
+  "mints.search.placeholder": "Søg efter navn eller domæne…",
+  "mints.sort.label": "Sortér mints",
+  "mints.sort.score": "Bedst samlet set",
+  "mints.sort.rating": "Bedst bedømte",
+  "mints.sort.reviews": "Mest anmeldte",
+  "mints.sort.recent": "Nyligt anmeldt",
+  "mints.sort.seen": "Senest set online",
+  "mints.hideOffline": "Skjul offline",
+  "mints.showing": "Viser {total} mints ({online} online, {offline} offline)",
+  "mints.showingFiltered": "Viser {shown} af {total} mints ({online} online, {offline} offline)",
+  "mints.noResults": "Der findes ingen matchende mints. Prøv med et domæne, eller indsæt en mint-URL.",
+  "mints.clearSearch": "Ryd søgningen",
+  "card.noRatings": "Der er endnu ingen bedømmelser",
+  "card.reviews.one": "Anmeldelse af {n}",
+  "card.reviews.other": "Anmeldelser af {n}",
+  "card.lastSeen": "sidst set {when}",
+  "card.neverSeen": "aldrig set på nettet",
+  "card.reviewed": "anmeldt {when}",
+  "card.noReviews": "Der er endnu ingen anmeldelser",
+  "mint.title": "{name} · anmeldelser af Cashu-mint",
+  "mint.titleFedimint": "{name} · anmeldelser af Fedimint-føderationen",
+  "mint.titleLnurl": "{name} · anmeldelser af LNURL-mint",
+  "mint.breadcrumb": "Navigationsspor",
+  "mint.crumbMints": "Cashu-mints",
+  "mint.copyUrl": "Kopiér mint-URL",
+  "mint.qrButton": "Mint QR",
+  "mint.writeReview": "Skriv en anmeldelse",
+  "mint.rankByScore": "#{rank} efter score",
+  "mint.tagLightning": "Lightning",
+  "mint.summary": "Mint-oversigt",
+  "mint.rating.label": "Fællesskabsvurdering",
+  "mint.rating.none": "Ingen bedømmelser endnu",
+  "mint.rating.reviews.one": "{n} anmeldelse",
+  "mint.rating.reviews.other": "{n} anmeldelser",
+  "mint.rating.unrated.one": "{n} har ikke givet nogen bedømmelse",
+  "mint.rating.unrated.other": "{n} har ikke givet nogen bedømmelse",
+  "mint.activity.label": "Aktivitet",
+  "mint.activity.since": "siden sidste anmeldelse",
+  "mint.activity.noReviews": "ingen anmeldelser endnu",
+  "mint.activity.recent.one": "{n} anmeldelse de seneste 90 dage",
+  "mint.activity.recent.other": "{n} anmeldelser de seneste 90 dage",
+  "mint.limits.label": "Grænser",
+  "mint.limits.notPublished": "ikke offentliggjort",
+  "mint.limits.min": "min",
+  "mint.limits.max": "max",
+  "mint.limits.mintRow": "mint",
+  "mint.limits.meltRow": "melt",
+  "mint.limits.disabled": "deaktiveret",
+  "mint.limits.range": "{min} til {max} {unit}",
+  "mint.limits.upTo": "op til {max} {unit}",
+  "mint.limits.from": "fra {min} {unit}",
+  "mint.software.label": "Mint-software",
+  "mint.software.unknown": "ukendt",
+  "mint.checked": "tjekket {when}",
+  "mint.lastSeen": "sidst set {when}",
+  "mint.neverReached": "aldrig nået",
+  "mint.uptime.checks": "{ok} af de seneste {total} tjek kunne nås",
+  "mint.uptime.percent": "{percent}% kunne nås over 30 dage",
+  "mint.uptime.description": "{ok} af de seneste {total} tjek lykkedes",
+  "mint.operator.title": "Fra operatøren",
+  "mint.operator.motd": "Dagens besked",
+  "mint.operator.beta": "Denne mint beskriver sig selv som eksperimentel eller i beta-fase. Læs udbyderens egne ord nedenfor, inden du opbevarer noget, du ikke har råd til at miste.",
+  "mint.nuts.title": "Understøttede NUTs",
+  "mint.nuts.noneOffline": "Ingen NUT-liste er cachet for dette mint, det gik offline, før en blev registreret.",
+  "mint.nuts.noneYet": "Ingen NUT-liste er cachet for dette mint endnu.",
+  "mint.nuts.supported": "{n} af {total} kendte NUTs understøttes",
+  "mint.nuts.whatAre": "Hvad er NUTs?",
+  "mint.nutRow.disabled": "deaktiveret",
+  "mint.nutRow.notSupported": "understøttes ikke",
+  "mint.details.title": "Mint-oplysninger",
+  "mint.details.pubkey": "Pubkey",
+  "mint.details.nostr": "Nostr",
+  "mint.details.email": "E-mail",
+  "mint.details.serverTime": "Servertid",
+  "mint.details.firstSeen": "Første gang set",
+  "mint.details.terms": "Vilkår",
+  "mint.kind.identifier": "identifikator",
+  "mint.kind.mintPubkey": "mint-pubkey",
+  "mint.kind.nostrAddress": "Nostr-adresse",
+  "mint.kind.emailAddress": "e-mail-adresse",
+  "mint.kind.npub": "npub",
+  "mint.disclaimer": "Dette mint er depotbaseret: det holder dine penge, og det kan holde op når som helst. Bedømmelser er meninger fra fællesskabet, og online betyder tilgængelig, ikke troværdig.",
+  "mint.disclaimerLink": "Læs den fulde ansvarsfraskrivelse",
+  "mint.qr.title": "Føj {name} til din tegnebog",
+  "mint.qr.note": "Scan denne med en Cashu-wallet for at tilføje mintet, eller kopiér URL'en og indsæt den.",
+  "mint.qr.warn": "At tilføje et mint betyder at betro det dine penge.",
+  "mint.qr.whatMeans": "Hvad det betyder",
+  "mint.qr.wallets": "Tegnebøger, der understøtter Cashu",
+  "mint.chip.frozen": "Frossen",
+  "mint.chip.noWithdrawals": "Ingen udbetalinger",
+  "mint.chip.meltOnly": "Kun smeltning",
+  "mint.warnings.dayCount.one": "{n}-dag",
+  "mint.warnings.dayCount.other": "{n} dage",
+  "mint.warnings.gone.lead": "Sandsynligvis væk.",
+  "mint.warnings.gone.body.since": "Dette mint har været utilgængeligt siden {date} ({days}). Betragt midler, der ligger der, som udsatte, og send ikke nye midler. Detaljerne nedenfor viser dets sidst kendte tilstand.",
+  "mint.warnings.gone.body.neverDated": "Dette mint har ikke svaret på et eneste tjek, siden vi begyndte at holde øje med det i {month}. Betragt midler, der ligger der, som udsatte, og send ikke nye midler. Alt nedenfor stammer fra Nostr-annonceringen, ikke fra mintet.",
+  "mint.warnings.gone.body.never": "Dette mint har ikke svaret på et eneste tjek, siden vi begyndte at holde øje med det. Betragt midler, der ligger der, som udsatte, og send ikke nye midler. Alt nedenfor stammer fra Nostr-annonceringen, ikke fra mintet.",
+  "mint.warnings.gone.meta.since": "Offline siden {date}",
+  "mint.warnings.gone.meta.never": "Har aldrig været tilgængelig, siden den blev opdaget",
+  "mint.warnings.meltDisabled.lead": "Udbetalinger er deaktiveret.",
+  "mint.warnings.meltDisabled.body.online": "Denne mint har slået smeltning af Lightning (NUT-05) fra: Du kan indsætte sats, men du kan ikke hæve dem via Lightning. Indsæt ikke penge, før smeltningen er genoptaget.",
+  "mint.warnings.meltDisabled.body.offline": "Denne mint havde smeltningen af Lightning (NUT-05) deaktiveret: Du kan indsætte sats, men du kan ikke hæve dem via Lightning. Indsæt ikke penge, før smeltningen er genoptaget.",
+  "mint.warnings.meltDisabled.meta.online": "Udbetalinger er i øjeblikket deaktiveret",
+  "mint.warnings.meltDisabled.meta.offline": "Udbetalinger var deaktiveret, da de sidst blev set",
+  "mint.warnings.frozen.lead": "Mint frosset.",
+  "mint.warnings.frozen.body.online": "Både minting og melting er slået fra. Ingen sats kan flytte ind eller ud via Lightning.",
+  "mint.warnings.frozen.body.offline": "Både minting og melting var slået fra. Ingen sats kan flytte ind eller ud via Lightning.",
+  "mint.warnings.frozen.meta.online": "Der er i øjeblikket indført en frysning; der foregår ingen ind- eller udførsel",
+  "mint.warnings.frozen.meta.offline": "Frosset, da den sidst blev set",
+  "mint.warnings.offlineLong.lead": "Ikke tilgængelig for {days}, fra og med {date}.",
+  "mint.warnings.offlineLong.body": "Mint-versionen er muligvis ikke længere tilgængelig. Alt nedenfor viser den seneste kendte version, og anmeldelserne fungerer stadig.",
+  "mint.warnings.offlineLong.meta": "Offline siden {date}",
+  "mint.warnings.meltOnly.lead": "Må kun smeltes.",
+  "mint.warnings.meltOnly.body.online": "Ny minting (NUT-04) er slået fra: du kan ikke indbetale, men eksisterende ecash kan stadig hæves. Det betyder ofte, at et mint er ved at lukke ned, så hvis du holder dets ecash, så overvej at melte ud.",
+  "mint.warnings.meltOnly.body.offline": "Ny minting (NUT-04) var slået fra: du kan ikke indbetale, men eksisterende ecash kan stadig hæves. Det betyder ofte, at et mint er ved at lukke ned, så hvis du holder dets ecash, så overvej at melte ud.",
+  "mint.warnings.meltOnly.meta.online": "Kun smeltning i øjeblikket",
+  "mint.warnings.meltOnly.meta.offline": "Smelt kun, når den sidst blev set",
+  "mint.warnings.offline.lead": "Har været offline siden {date}.",
+  "mint.warnings.offline.body": "Detaljerne blev bekræftet dengang. Du kan stadig skrive en anmeldelse.",
+  "mint.warnings.offline.meta": "Offline siden {date}",
+  "mint.warnings.also.meltDisabled": "Inden den gik offline, havde den også deaktiveret udbetalinger.",
+  "mint.warnings.also.mintDisabled": "Inden det gik offline, havde det også slået nyt minting fra.",
+  "mint.warnings.also.offline": "Den har desuden været offline siden {date} ({days}).",
+  "nut.0": "Notation og modeller",
+  "nut.1": "Udveksling af offentlige nøgler i Mint",
+  "nut.2": "Nøglesæt og gebyrer",
+  "nut.3": "Bytning af tokens",
+  "nut.4": "Minting via Lightning",
+  "nut.5": "Smeltning via Lightning",
+  "nut.6": "Mint-information",
+  "nut.7": "Kontrol af tokenets tilstand",
+  "nut.8": "For meget betalte Lightning-gebyrer",
+  "nut.9": "Gendan signaturer",
+  "nut.10": "Udgiftsbetingelser",
+  "nut.11": "Betaling til offentlig nøgle",
+  "nut.12": "DLEQ-prøvetryk",
+  "nut.13": "Deterministiske hemmeligheder",
+  "nut.14": "Hashed timelock-kontrakter",
+  "nut.15": "Betalinger via flere kanaler",
+  "nut.16": "Animerede QR-koder",
+  "nut.17": "WebSocket-abonnementer",
+  "nut.18": "Betalingsanmodninger",
+  "nut.19": "Cachelagrede svar",
+  "nut.20": "Signerede mint-quotes",
+  "nut.21": "Ryd godkendelse",
+  "nut.22": "Blind autentificering",
+  "nut.23": "BOLT11 betalingsmetode",
+  "nut.24": "HTTP 402 – betaling påkrævet",
+  "nut.25": "BOLT12 betalingsmetode",
+  "reviews.title": "Anmeldelser",
+  "reviews.anon": "Anonym",
+  "reviews.anonTitle": "Der blev ikke fundet nogen offentlig Nostr-profil for denne nøgle",
+  "reviews.nip05Title": "NIP-05-identifikator (ikke verificeret af dette websted)",
+  "reviews.filter.group": "Filtrer anmeldelser",
+  "reviews.filter.all": "Alle",
+  "reviews.filter.five": "5★",
+  "reviews.filter.critical": "Kritisk",
+  "reviews.filter.recent": "Seneste",
+  "reviews.filter.hideAnon": "Skjul anonymitet",
+  "reviews.anonHidden.other": "Viser anmeldelser af {n} ud af {total}: Anonym, skjult.",
+  "reviews.allAnon.one": "Den eneste anmeldelse her er fra en anonym bruger.",
+  "reviews.allAnon.other": "Alle anmeldelser af {n} her er anonyme.",
+  "reviews.allAnonShow.one": "Vis det",
+  "reviews.allAnonShow.other": "Vis dem det",
+  "reviews.loading.one": "Indlæser anmeldelse af {n} fra Nostr-relæer",
+  "reviews.loading.other": "Henter anmeldelser af {n} fra Nostr-relæer",
+  "reviews.empty": "Der er endnu ingen anmeldelser. Vær den første til at skrive en.",
+  "reviews.emptyWritten": "Der er endnu ingen skriftlige anmeldelser her. Vær den første til at skrive en.",
+  "reviews.emptyFilter": "Der er ingen anmeldelser, der matcher dette filter.",
+  "reviews.rate.cashu": "Bedøm denne mint",
+  "reviews.rate.fedimint": "Bedøm denne føderation",
+  "reviews.rate.lnurl": "Bedøm denne mint",
+  "reviews.noscript": "Anmeldelserne er underskrevet med Nostr og indlæses i din browser, så denne liste kræver JavaScript. Bedømmelserne og antallet ovenfor stammer fra selve hjemmesiden.",
+  "reviews.relayError": "Det var ikke muligt at oprette forbindelse til relæet. Anmeldelserne kan være ufuldstændige.",
+  "reviews.srRating": "{rating} ud af 5",
+  "reviews.srNoRating": "Ingen bedømmelse angivet",
+  "reviews.readMore": "Læs mere",
+  "reviews.readLess": "Vis mindre",
+  "reviews.actions.copyNpub": "Kopier npub",
+  "reviews.actions.openNostr": "Se denne begivenhed på Nostr",
+  "reviews.actions.copyLink": "Kopier linket til denne anmeldelse",
+  "reviews.anonNote": "Første anmeldelse af denne npub; der er ikke fundet andre aktiviteter",
+  "reviews.published": "Udgivet.",
+  "reviews.publishedPartial": "Udgivet til {accepted} blandt {total}-relæerne.",
+  "reviews.propagating": "Udgiver til Nostr-relays",
+  "reviews.summary.line.one": "{count}-vurdering uden kommentar: {breakdown}",
+  "reviews.summary.line.other": "{count}-vurderinger uden kommentar: {breakdown}",
+  "reviews.summary.lineDay.one": "{count}-vurdering uden kommentar til {when}: {breakdown}",
+  "reviews.summary.lineDay.other": "{count}-vurderinger uden kommentar til {when}: {breakdown}",
+  "reviews.summary.showOne": "Vis det",
+  "reviews.summary.showMany": "Vis dem det",
+  "reviews.breakdown.5": "{n} fem stjerner",
+  "reviews.breakdown.4": "{n} fire stjerner",
+  "reviews.breakdown.3": "{n} tre stjerner",
+  "reviews.breakdown.2": "{n} to stjerner",
+  "reviews.breakdown.1": "{n} én stjerne",
+  "reviews.breakdown.none": "{n} uden bedømmelse",
+  "reviews.dialog.title": "Anmeldelse af {name}",
+  "reviews.dialog.lede.cashu": "Del din oplevelse med denne mint.",
+  "reviews.dialog.lede.fedimint": "Del din oplevelse med denne føderation.",
+  "reviews.dialog.lede.lnurl": "Del din oplevelse med denne mint.",
+  "reviews.dialog.permanent": "Offentliggøres permanent på offentlige Nostr-relays.",
+  "reviews.dialog.gate.title": "Log ind for at skrive en anmeldelse",
+  "reviews.dialog.gate.lead": "Anmeldelser signeres med din Nostr-nøgle. Den bliver i din signer, dette websted ser den aldrig.",
+  "reviews.dialog.ratingLegend": "Din bedømmelse",
+  "reviews.dialog.starsSr.one": "{n}-stjerne",
+  "reviews.dialog.starsSr.other": "{n}-stjerner",
+  "reviews.dialog.chooseRating": "Vælg en bedømmelse",
+  "reviews.dialog.starLabel": "{n}: {phrase}",
+  "reviews.dialog.stars.1": "undgå det",
+  "reviews.dialog.stars.2": "havde problemer",
+  "reviews.dialog.stars.3": "det fungerede, dog med visse forbehold",
+  "reviews.dialog.stars.4": "godt",
+  "reviews.dialog.stars.5": "fungerer rigtig godt",
+  "reviews.dialog.bodyLabel": "Hvad bør andre vide?",
+  "reviews.dialog.charCount": "{n} / {max}",
+  "reviews.dialog.submit": "Underskriv og offentliggør",
+  "reviews.dialog.signing": "Underskriver…",
+  "reviews.dialog.publishing": "Udgiver…",
+  "reviews.dialog.publishingTo": "Udgivelse til relæer ({accepted}/{total})",
+  "reviews.dialog.waitingExtension": "Vi afventer din forlængelse",
+  "reviews.dialog.waitingSigner": "Vi venter på din underskriver",
+  "reviews.dialog.confirmClose": "Vil du lukke denne anmeldelse? Dit udkast gemmes, indtil du forlader siden.",
+  "reviews.dialog.why.login": "Log ind for at offentliggøre",
+  "reviews.dialog.why.words": "Skriv et par ord",
+  "reviews.dialog.why.more.one": "{n} flere tegn",
+  "reviews.dialog.why.more.other": "{n} flere tegn",
+  "reviews.dialog.why.over.one": "{n} – antallet af tegn overskrider grænsen",
+  "reviews.dialog.why.over.other": "{n} – antallet af tegn overskrider grænsen",
+  "reviews.dialog.identity.needSigner": "Du skal bruge en Nostr-signaturenhed for at kunne offentliggøre. Din nøgle forbliver i enheden; denne hjemmeside får aldrig adgang til den.",
+  "reviews.dialog.identity.loginToPublish": "Log ind for at offentliggøre",
+  "reviews.dialog.identity.switch": "Omskifter",
+  "reviews.dialog.identity.extension": "Log ind med din browserudvidelse",
+  "reviews.dialog.identity.readingKey": "Læser din offentlige nøgle…",
+  "reviews.dialog.identity.willAsk": "Din udvidelse vil blive bedt om at underskrive",
+  "reviews.dialog.error.noRelay": "Ingen relæ har accepteret anmeldelsen. Kontroller din forbindelse, og prøv igen.",
+  "reviews.validate.rating": "Vælg en bedømmelse fra 1 til 5 stjerner.",
+  "reviews.validate.short": "Skriv mindst {n} tegn, så anmeldelsen bliver nyttig.",
+  "reviews.validate.long": "Anmeldelser må højst indeholde {n} tegn.",
+  "feed.title": "Seneste anmeldelser af Mint og Federation · Cashumints.space",
+  "feed.description": "Hver anmeldelse af mints, føderationer og LNURL-mints, så snart den offentliggøres: {reviews} anmeldelser af {mints} Cashu-mints, {federations} Fedimint-føderationer og {lnurl} LNURL-mints, signeret på Nostr og læsbare her med nyeste først. Filtrér på økosystem, bedømmelse eller navn.",
+  "feed.heading": "Seneste anmeldelser",
+  "feed.lede": "Alle anmeldelser af alle Cashu-mint- og Fedimint-federationer, med de nyeste først, læses direkte fra Nostr-relæerne. Hver enkelt er underskrevet af sin forfatter og findes på relæerne, ikke i vores database.",
+  "feed.label": "Anmeldelser",
+  "feed.showingBuild.one": "Her vises den seneste anmeldelse fra den seneste build",
+  "feed.showingBuild.other": "Her vises de seneste anmeldelser af {n} fra den seneste version",
+  "feed.noscript": "Anmeldelserne er gemt under Nostr og indlæses i din browser, så filtrering og den fulde liste kræver JavaScript. Anmeldelserne under {n} nedenfor blev hentet fra relæerne, da denne side blev oprettet.",
+  "feed.emptyBuild": "Der kunne ikke hentes nogen anmeldelser fra relæerne, da denne side blev oprettet. Listen opdateres fra relæerne i din browser.",
+  "feed.foot": "Anmeldelser er meninger fra fællesskabet, ikke verificerede påstande. Læs {link}, før du betror et mint dine penge.",
+  "feed.footLink": "ansvarsfraskrivelse",
+  "feed.showing": "Viser anmeldelser af {shown} og {total}",
+  "feed.showingMatching": "Viser {shown} af {matching} relevante anmeldelser (i alt {total})",
+  "feed.emptyRelays": "Der kom ingen anmeldelser tilbage fra relæerne. Åbn en vilkårlig Mint-side for at læse og skrive anmeldelser der.",
+  "feed.emptyFilter": "Ingen anmeldelser matcher dette filter. Ryd mint-feltet, eller prøv Alle.",
+  "feed.relayError": "Det var ikke muligt at oprette forbindelse til relæerne. Her vises anmeldelserne fra den seneste build.",
+  "feed.relayEmpty": "Der kom ingen anmeldelser tilbage fra relæerne. Her vises anmeldelserne fra den seneste build.",
+  "feed.reading": "Aflæsning af relæerne…",
+  "login.open": "Log ind",
+  "login.title": "Log ind med Nostr",
+  "login.note": "Din nøgle forbliver i din signeringsenhed. Dette websted kan aldrig se den.",
+  "login.extension.name": "Browserudvidelse",
+  "login.extension.desc": "Navngiv filen med filtypenavnet Alby, nos2x eller NIP-07",
+  "login.extension.none": "Der blev ikke fundet nogen udvidelse",
+  "login.extension.getOne": "Køb en:",
+  "login.remote.name": "Fjernunderskriver",
+  "login.remote.desc": "Scan en kode med en underskriftsapp, eller indsæt et bunker-link",
+  "login.primal.name": "Primal",
+  "login.primal.desc": "Godkend login i appen Primal på din telefon",
+  "login.paste.label": "Eller indsæt det link, som din underskriver har givet dig",
+  "login.copyLink": "Kopier forbindelseslinket",
+  "login.whatIsNostr": "Hvad er Nostr?",
+  "login.connect.remote.title": "Tilslut en ekstern underskriver",
+  "login.connect.remote.lead": "Scan dette med din Signer-app, eller kopier linket og indsæt det der.",
+  "login.connect.remote.hint": "Fungerer med alle NIP-46-signaturenheder: nsec.app, Amber, Nostrify, din egen bunker.",
+  "login.connect.remote.open": "Åbn i din Signer-app",
+  "login.connect.primal.title": "Følg Primal",
+  "login.connect.primal.lead": "Åbn Primal på din telefon, find »Fjernunderskrift« i indstillingerne, og scan denne kode.",
+  "login.connect.primal.hint": "Primal bruges til at underskrive for andre apps i stedet for NIP-46, så det er den samme forbindelse, som alle underskrivere bruger, og din nøgle forbliver i Primal. {link}",
+  "login.connect.primal.open": "Åbn i Primal",
+  "login.status.buildingLink": "Oprettelse af en forbindelse",
+  "login.status.waitingExtension": "Vi afventer din forlængelse",
+  "login.status.waitingSigner": "Vi venter på din underskriver",
+  "login.status.connecting": "Opret forbindelse til din underskriver",
+  "login.status.connected": "Forbundet",
+  "login.toast.loggedIn": "Logget ind",
+  "login.toast.fetchingProfile": "Henter din Nostr-profil fra relæerne…",
+  "login.toast.profile": "Profil: {name}",
+  "login.toast.noProfile": "Ingen profil fundet på relæerne",
+  "login.method.extension": "Udvidelse",
+  "login.method.remote": "Fjernbetjening",
+  "login.method.primal": "Primal",
+  "login.account": "Din Nostr-konto",
+  "login.copyNpub": "Kopier hele din npub",
+  "login.logout": "Log ud",
+  "signer.status.waitingExtension": "Vi afventer din forlængelse",
+  "signer.status.signed": "Underskrevet",
+  "signer.status.reconnecting": "Genopret forbindelse til din underskriver",
+  "signer.status.approveWindow": "Den, der skal underskrive, beder dig om at godkende dette i et separat vindue",
+  "signer.status.waitingSigner": "Vi venter på din underskriver",
+  "signer.status.stillWaiting": "Vi venter stadig på svar fra din underskriver",
+  "signer.status.connected": "Forbundet",
+  "signer.error.noExtension": "Der blev ikke fundet nogen signaturforlængelse. Installer Alby eller nos2x, og genindlæs derefter denne side.",
+  "signer.error.privateKey": "Det ligner en privat nøgle, ikke et link til oprettelse af forbindelse. Denne side beder aldrig om en nøgle. Indsæt det bunker://-link, som din underskriver har givet dig.",
+  "signer.error.badLink": "Det er ikke et link, som denne side genkender. Indsæt linket bunker:// fra din signaturtjeneste.",
+  "signer.error.noAnswer": "Din signaturudsteder svarede ikke. Den er muligvis lukket, eller dens relæ er måske nede. Åbn den og prøv igen.",
+  "signer.error.timeout": "Din underskriver svarede ikke i tide. Åbn den, kontroller, om den stadig er tilsluttet, og prøv derefter igen.",
+  "signer.error.cancelled": "Forbindelsen er afbrudt.",
+  "signer.error.declined": "Anmodningen om underskrift blev afvist",
+  "notfound.title": "Siden blev ikke fundet · Cashumints.space",
+  "notfound.description": "Den side findes ikke på Cashumints.space.",
+  "notfound.heading": "Denne side findes ikke",
+  "notfound.lede": "Den er måske flyttet, eller mintet er måske ikke indekseret endnu. Søg efter et mint på navn eller domæne, eller indsæt en mint-URL.",
+  "notfound.browse": "Se alle mints",
+  "notfound.home": "Gå hjem",
+  "notfound.loading": "Indlæser {host}",
+  "notfound.fb.rating": "Bedømmelse",
+  "notfound.fb.reviews": "Anmeldelser",
+  "notfound.fb.software": "Software",
+  "notfound.fb.lastOnline": "Sidst online",
+  "notfound.fb.note": "Denne mint blev indekseret efter sidste build af siden, så dette er et resumé fra det live API med anmeldelserne nedenfor. Hele siden kommer med ved næste build.",
+  "notfound.resolve.checking": "Første besøg: tjekker denne mint nu.",
+  "notfound.resolve.failed": "Denne mint kunne ikke tilføjes",
+  "notfound.resolve.failedFedimint": "Denne føderation kunne ikke tilføjes",
+  "notfound.resolve.retry": "Prøv en anden adresse",
+  "notfound.resolve.switch": "Åbn den som {kind}-mint",
+  "notfound.resolve.fedimint": "En føderations sideadresse indeholder ikke dens invite code, så denne kan ikke slås op ud fra linket alene. Indsæt invite code, så bliver den tilføjet.",
+  "notfound.resolve.ambiguous": "Denne adresse kan ikke udledes af linket alene. Indsæt mintens fulde URL, så bliver den tilføjet.",
+  "wallets.title": "Cashu-tegnebøger · Cashumints.space",
+  "wallets.description": "Cashu-tegnebøger, der fungerer sammen med de her anførte mints på mobil, web, i browseren og via kommandolinjen, alt efter hvad den enkelte er bedst til.",
+  "wallets.heading": "Punge",
+  "wallets.lede": "Du skal bruge en wallet for at holde ecash fra et af disse mints. De fleste wallets taler med flere mints ad gangen, så du er ikke bundet til det første, du prøver.",
+  "wallets.note": "Denne liste er ikke udtømmende og udgør ikke en anbefaling. Cashu-projektet fører et mere omfattende register på {link}. En wallet opbevarer nøgler, mens en mint opbevarer pengene: Læs anmeldelserne af mints, før du vælger, hvor din sats skal opbevares.",
+  "wallets.platform.android": "Android",
+  "wallets.platform.ios": "iOS",
+  "wallets.platform.web": "Web",
+  "wallets.platform.extension": "Browserudvidelse",
+  "wallets.platform.cli": "CLI",
+  "wallets.platform.python": "Python",
+  "wallets.item.minibits": "Mobil tegnebog ecash med egen mint, understøttelse af Lightning-adresser og Nostr-kontakter.",
+  "wallets.item.nutstash": "Browser-wallet, der håndterer flere mints ad gangen og importerer og eksporterer rå tokens.",
+  "wallets.item.enuts": "Mobil wallet med fokus på saldi hos flere mints og på at sende ecash over Nostr.",
+  "wallets.item.cashume": "Reference-webwallet fra Cashu-projektet. Kører udelukkende i browseren og kan installeres som en PWA.",
+  "wallets.item.boardwalk": "Web-tegnebog baseret på Lightning-adresser og afsendelse af ecash via et link.",
+  "wallets.item.coinos": "Lightning-wallet og salgssted, der også kører sit eget Cashu-mint.",
+  "wallets.item.oxchat": "Nostr-messenger med en indbygget ecash-tegnebog til at sende sats i chats.",
+  "wallets.item.nutshell": "Referenceimplementeringen. Kører som en wallet på kommandolinjen og som mint-software.",
+  "about.title": "Om Cashumints.space",
+  "about.description": "Hvad Cashu er, hvad en »mint« egentlig indeholder, hvad NIP-87 er, og hvordan dette websted indekserer »mints« og læser anmeldelser fra Nostr-relæer.",
+  "about.heading": "Om",
+  "about.lede": "Cashumints.space viser alle Cashu-mints, vi kan finde på Nostr-netværket, og viser, hvad folk siger om dem. Den er udviklet af Azzamo.",
+  "about.cashu.title": "Hvad er Cashu?",
+  "about.cashu.p1": "Cashu er en ecash-protokol til Bitcoin. Et mint udsteder blindede tokens dækket af de sats, det holder, og de tokens bevæger sig mellem folk, uden at mintet får at vide, hvem der sendte hvad til hvem. Privatlivet er ægte, og det er hele pointen: tokens er ikke konti, og mintet kan ikke koble den token, det signerede, til den token, der kommer tilbage.",
+  "about.cashu.p2": "Du kan læse protokollen og dens specifikationer på {link}. Selve specifikationerne hedder NUTs, og det er her, tallene NUT på hver enkelt mint-side stammer fra.",
+  "about.mints.title": "Hvad en mint er, og hvad der er fordele og ulemper ved den",
+  "about.mints.p1": "Et mint er depotbaseret. Når du minter ecash, giver du sats til den, der driver den server, og du stoler på, at de indfrier dine tokens, når du melter dem ud igen. Der er intet svindelbevis, ingen escrow og ingen klagevej. En mint-operatør kan forsvinde med saldoen, og mints har gjort det.",
+  "about.mints.p2": "Det er netop derfor, der findes anmeldelser her. Denne side siger aldrig, at en mint er sikker. Status på en mint-side angiver {code}, ikke »pålidelig«, og det betyder blot, at serveren svarede, da vi sidst spurgte. Betragt ecash-saldoer som kontanter i en frakkelomme: fine at bruge, men ikke egnet til opsparing.",
+  "about.nip87.title": "Hvad er NIP-87?",
+  "about.nip87.p1": "NIP-87 er Nostr-konventionen for at annoncere og anbefale ecash-mints. To event-typer betyder noget her:",
+  "about.nip87.li1": "{code} annoncerer en mint. URL’en til mintet findes i {tag}-tagget. På denne måde opdager webstedet mints, det aldrig har set før.",
+  "about.nip87.li2": "{code} er en anmeldelse. Den bærer bedømmelsen og anmeldelsesteksten og peger på det mint, den handler om, med et {utag}-tag (mint-URL'en) og et {dtag}-tag (mintets egen offentlige nøgle).",
+  "about.nip87.p2": "Hver anmeldelse er signeret med forfatterens Nostr-nøgle. Vi kalder aldrig en anmeldelse »verificeret«, for ingen har verificeret den: den er signeret, hvilket er en anden og mere nyttig påstand. Det betyder, at du kan se, hvem der skrev den, og at den ikke er ændret. Det betyder ikke, at forfatteren er ærlig eller nogensinde har brugt mintet.",
+  "about.how.title": "Sådan fungerer denne hjemmeside",
+  "about.how.p1": "Der er to sløjfer og én regel. Reglen er, at mintet ejer sine metadata, og Nostr ejer anmeldelserne, så dette websted gemmer ingen af delene som autoritet.",
+  "about.how.li1": "{strong} forespørger alle kendte mints om {code} hver tiende minut og registrerer svarene: navn, beskrivelse, version, understøttede NUTs, begrænsninger, kontaktoplysninger. Den registrerer også, om mienten overhovedet svarede, og det er herfra, at oppetiden stammer.",
+  "about.how.li1Label": "Sonderløkken",
+  "about.how.li2": "{strong} forbinder til Nostr-relæerne hver time, læser mint-annonceringer og anmeldelser og tilføjer ethvert mint, den ikke har set før.",
+  "about.how.li2Label": "Opdagelsessløjfen",
+  "about.how.p2": "Det vigtige er, hvad der sker, når en mint holder op med at svare. Dens cachelagrede metadata overskrives aldrig af en mislykket forespørgsel, så en nedlagt mint bevarer sin fulde side: dens specifikationer, historie og anmeldelser, med et banner, der angiver, hvornår den gik ned. Den tidligere version af dette websted viste i stedet en fejlside, hvilket betød, at netop de mints, som brugerne havde mest brug for at advare hinanden om, var dem, der ikke kunne anmeldes. Det var hovedårsagen til omlægningen.",
+  "about.how.p3": "Anmeldelsestekster gemmes aldrig hos os. Når du åbner en mint-side, kommunikerer din browser direkte med relæerne og henter selv anmeldelserne, og når du skriver en anmeldelse, underskrives den med din egen Nostr-udvidelse og sendes direkte til disse relæer. Vi holder styr på antallet, så siderne kan rangordnes og sorteres – ikke mere end det. Intet her kan redigeres eller slettes af os, heller ikke anmeldelser, som vi helst ville undvære.",
+  "about.relays.title": "Relæer, vi har læst om",
+  "about.relays.p1": "Dette er de relæer, som både indekseringsprogrammet og din browser bruger:",
+  "about.relays.p2": "Ret en hvilken som helst Nostr eller cli mod de samme relæer, og du vil se de samme hændelser. Det er hele løftet: Intet her er kun sandt, fordi vi siger det.",
+  "about.nuts.title": "Hvad er NUTs?",
+  "about.nuts.p1": "NUTs er de nummererede Cashu-specifikationer, ligesom BIP’er for Bitcoin. En mint angiver, hvilke den implementerer, og det fortæller dig, hvad den rent faktisk kan: NUT-04 og NUT-05 står for udstedelse og indløsning via Lightning (uden dem er en mint ikke til megen nytte), NUT-07 giver en tegnebog mulighed for at kontrollere, om et token allerede er blevet brugt, NUT-17 giver tegnebøger liveopdateringer via WebSockets i stedet for polling, og NUT-20 giver en tegnebog mulighed for at bevise, at et mint-tilbud virkelig blev udstedt til den. Den fulde liste findes under {link}.",
+  "about.numbers.title": "Lige nu",
+  "about.numbers.p1": "{mints}-mønstre indekseret, {online} af disse svarer, {reviews}-gennemgange talt fra relæerne ovenfor.",
+  "about.source.title": "Kilde og kreditering",
+  "about.source.p1": "Webstedet er open source på {github}. Det er bygget og drevet af {azzamo}. Hvis noget er galt på en mint-side, så ret det ved kilden: mint-metadata kommer fra mintets eget {code}, og anmeldelser kommer fra Nostr.",
+  "terms.title": "Brugsbetingelser · Cashumints.space",
+  "terms.description": "Brugsbetingelser for Cashumints.space: hvad webstedet er, hvad det ikke gør, og hvem der er ansvarlig for hvad. Ingen konti, ingen garantier, ingen tilknytning til noget mint.",
+  "terms.heading": "Brugsbetingelser",
+  "terms.lede": "Enkel beskrivelse af et websted, der udelukkende indekserer offentlige data. Senest opdateret {date}.",
+  "terms.what.title": "Hvad denne hjemmeside er",
+  "terms.what.p1": "Cashumints.space er et indeks over offentligt tilgængelige data om Cashu-mints. To slags data, begge fra et andet sted:",
+  "terms.what.li1": "Mint-metadata, læst fra hvert mints eget {code}-endpoint: navn, beskrivelse, softwareversion, understøttede NUTs, kontaktoplysninger og om mintet svarede, sidst vi spurgte.",
+  "terms.what.li2": "Anmeldelser, hentet fra de offentlige Nostr-relæer. Dette er NIP-87-begivenheder, som forfatterne har offentliggjort på relæer, som alle kan søge i.",
+  "terms.what.p2": "Vi indsamler disse data, normaliserer dem, rangordner dem og viser dem. Vi skaber dem ikke.",
+  "terms.noAccounts.title": "Ingen garantier, ingen ansvar",
+  "terms.noAccounts.p1": "Der er intet at tilmelde sig. Webstedet stilles til rådighed, som det er, uden nogen form for garanti: ikke for at data er korrekte, ikke for at de er aktuelle, ikke for at webstedet er tilgængeligt. Mint-data kan være minutter eller timer gamle, et mint kan ændre sig, efter vi sidst tjekkede, og et relæ kan undlade at svare, og så ser du mindre, end der findes.",
+  "terms.noAccounts.p2": "Brug det på eget ansvar. Vi er ikke ansvarlige for tab, der følger af at bruge dette websted eller af at stole på noget, du læser her. Se {link} for de specifikke risici ved at bruge et Cashu-mint.",
+  "terms.noAccounts.link": "ansvarsfraskrivelse",
+  "terms.noCustody.title": "Vi opbevarer ikke dine penge",
+  "terms.noCustody.p1": "Dette websted har aldrig midler i sin varetægt. Det har ingen tegnebog, det har ikke adgang til ecash, og det kan ikke flytte, spærre eller gendanne noget som helst. Hvis du har et problem med en mint, er mintoperatøren den eneste, der kan hjælpe dig, og vi kan ikke kontakte dem på dine vegne.",
+  "terms.noCustody.p2": "Vi er ikke tilknyttet noget mint på listen her, og intet mint betaler for sin opførelse, sin placering eller sin bedømmelse. Mints findes via offentlige Nostr-annonceringer og rangordnes af en algoritme over offentlige anmeldelsesdata.",
+  "terms.reviews.title": "Anmeldelser er andres ord",
+  "terms.reviews.p1": "Anmeldelser er brugergenereret indhold, der offentliggøres på de offentlige Nostr-relæer af deres forfattere. Vi viser dem, men vi har ikke kontrol over dem. Vi har ikke skrevet dem, vi kan ikke redigere dem, og vi kan ikke slette dem fra de relæer, hvor de er gemt: Det er signerede begivenheder på et netværk, som vi ikke ejer.",
+  "terms.reviews.p2": "En anmeldelse er en persons oplevelse, ikke et verificeret faktum. Hvis du offentliggør en anmeldelse, er du ansvarlig for indholdet. Offentliggør ikke noget ulovligt, og vær opmærksom på, at det, du offentliggør, er offentligt og forbliver der for altid (se {link}).",
+  "terms.reviews.link": "side om privatlivspolitik",
+  "terms.reviews.p3": "Vi kan vælge ikke længere at vise en bestemt anmeldelse på dette websted, og det vil vi gøre i tilfælde af ulovligt indhold. Det betyder dog kun, at anmeldelsen fjernes fra disse sider. Begivenheden forbliver på relæerne, og alle andre Nostr client kan stadig læse den.",
+  "terms.links.title": "Links til andre hjemmesider",
+  "terms.links.p1": "Mint-URL’er, links til tegnebøger, kontaktoplysninger på udbydere og alt andet, der fører væk fra dette websted, er medtaget, fordi de udgør en del af dataene. Et link er ikke en anbefaling, og vi kontrollerer ikke indholdet på den anden side.",
+  "terms.changes.title": "Ændringer",
+  "terms.changes.p1": "Disse vilkår kan ændres. Datoen øverst angiver, hvornår de senest blev ændret. Hjemmesiden er open source, så alle ændringer på denne side fremgår af commit-historikken.",
+  "terms.contact.title": "Kontakt",
+  "terms.contact.p1": "Problemer og anmodninger om fjernelse indsendes bedst via {github}. Hjemmesiden drives af {azzamo}.",
+  "privacy.title": "Privatliv · Cashumints.space",
+  "privacy.description": "Privatliv på Cashumints.space: ingen konti, ingen sporingscookies, ingen analyseværktøjer. localStorage bruges til cachelagring af profiler, og der sendes intet nogen steder hen. Anmeldelser underskrives i din egen browser.",
+  "privacy.heading": "Privatliv",
+  "privacy.lede": "Vi indsamler så få oplysninger som overhovedet muligt på en hjemmeside. Senest opdateret {date}.",
+  "privacy.noAccounts.title": "Ingen konti",
+  "privacy.noAccounts.p1": "Der er ingen tilmelding, ingen login og ingen profil. Intet på dette websted spørger dig, hvem du er, og der er ingen brugeroplysninger, der kan lækkes, fordi der ikke er nogen brugere.",
+  "privacy.noTracking.title": "Ingen sporingscookies, ingen analyse",
+  "privacy.noTracking.p1": "Hjemmesiden bruger ingen cookies til sporing. Der er ingen analyseskript, ingen tagmanager, ingen pixel, ingen sessionsoptagelse og intet annoncenetværk. Intet på siden videregiver oplysninger om din adfærd til os eller til andre.",
+  "privacy.logs.title": "Serverlogfiler",
+  "privacy.logs.p1": "Webserveren fører standardadgangslogfiler, hvilket er standard for alle webservere. En loglinje indeholder din IP-adresse, klokkeslættet, den side, du har anmodet om, svarstatus samt den brugeragent og den henvisningskilde, som din browser har sendt. Logfilerne bruges til at fejlfinde og opdage misbrug. De sammenkædes ikke med andre oplysninger og sælges eller deles ikke.",
+  "privacy.logs.operatorLabel": "Bemærkning fra operatøren:",
+  "privacy.logs.operator": "Hvis du driver dette websted, skal du angive den faktiske opbevaringsperiode her. Implementeringen i README bruger nginx med dens standardadgangslog og den rotationsindstilling, som din distribution leveres med (på Debian og Ubuntu er det logrotate, dagligt, hvor logfilerne opbevares i 14 dage). Bekræft, hvad din server gør, og erstat dette afsnit med tallet.",
+  "privacy.storage.title": "Hvad gemmes der i din browser?",
+  "privacy.storage.p1": "Webstedet bruger localStorage til præcis to formål, som begge forbliver på din enhed og aldrig sendes videre:",
+  "privacy.storage.li1": "En cache med Nostr-profilmetadata (begivenheder af type 0: navne, avatarer, NIP-05-adresser) for de anmeldere, hvis anmeldelser du har set. Dette sparer dig for at skulle sende forespørgsler til relæerne på hver eneste side. Posterne udløber, og cachen har en størrelsesbegrænsning, hvor de ældste poster fjernes først.",
+  "privacy.storage.li2": "Indstillinger for brugergrænsefladen, så hjemmesiden fungerer på samme måde næste gang.",
+  "privacy.storage.p2": "Hvis du sletter din browsers webstedsdata, fjernes begge dele. Der opstår ingen problemer; profilsøgningerne kører blot igen.",
+  "privacy.thirdParties.title": "Hvad din browser kommunikerer med",
+  "privacy.thirdParties.p1": "Når du indlæser en side, opretter din browser forbindelse til et par andre steder ud over dette websted. På den måde kan et websted uden sporing på serversiden stadig hente data i realtid:",
+  "privacy.thirdParties.li1Label": "Offentlige Nostr-relæer",
+  "privacy.thirdParties.li1": "{strong}, frem for WebSocket, for at læse anmeldelser og anmelderprofiler. Relæet kan se din IP-adresse og hvad du har anmodet om, ligesom enhver server, du opretter forbindelse til. Relæerne er angivet på {link}.",
+  "privacy.thirdParties.li1Link": "Om os-siden",
+  "privacy.thirdParties.li2Label": "Avatarbilleder af anmeldere",
+  "privacy.thirdParties.li2": "{strong}, der hentes fra den adresse, som anmelderens profil angiver. Disse sendes uden henvisningsadresse, så værten ikke kan se, hvilken side du befandt dig på.",
+  "privacy.publishing.title": "Offentliggørelse af en anmeldelse",
+  "privacy.publishing.p1": "Skrivningen af en anmeldelse foregår i din browser, ikke på vores server. Begivenheden signeres af din NIP-07-udvidelse (Alby, nos2x eller lignende) og sendes fra din browser direkte til relæerne. Din private nøgle forlader aldrig udvidelsen, og dette websted får aldrig adgang til den. Vi udvikler ikke brugerdefineret nøgleadministration, og vi beder aldrig om en nøgle eller en seed-sætning.",
+  "privacy.permanent.title": "Alt, hvad du offentliggør på Nostr, er offentligt og permanent",
+  "privacy.permanent.p1": "Dette er den del, der er værd at læse to gange. En anmeldelse er en signeret begivenhed på offentlige relæer. Når den først er ude, er den ude:",
+  "privacy.permanent.li1": "Alle kan læse det, både nu og senere, ved hjælp af enhver Nostr client. Det er ikke »offentligt på Cashumints.space«, men offentligt på netværket.",
+  "privacy.permanent.li2": "Den er permanent knyttet til din offentlige nøgle Nostr sammen med alt andet, som denne nøgle nogensinde har offentliggjort.",
+  "privacy.permanent.li3": "At slette den er en anmodning, ikke en ordre. Du kan offentliggøre en sletningsbegivenhed, og nogle relæer vil efterkomme den, men et relæ kan frit vælge at ignorere den, og alle, der allerede har kopieret begivenheden, har den stadig. Betragt en offentliggjort anmeldelse som permanent.",
+  "privacy.permanent.li4": "Vi kan ikke slette det for dig. Vi kan dog sørge for, at det ikke længere vises her; det ændrer dog ikke noget på relæerne.",
+  "privacy.permanent.p2": "Hvis du vil anmelde et mint, uden at det knyttes til din primære identitet, så brug en separat Nostr-nøgle. Bemærk, at en nøgle uden anden aktivitet vises som sådan ved hårde anmeldelser, fordi en helt ny nøgle, der skriver en anmeldelse på én stjerne, er et mønster, læsere fortjener at se.",
+  "privacy.contact.title": "Spørgsmål",
+  "privacy.contact.p1": "Webstedet er open source: Hvis du vil tjekke noget af det ovenstående, kan du læse koden på {github}. Spørgsmål og rettelser kan indsendes som en issue der.",
+  "disclaimer.title": "Ansvarsfraskrivelse · Cashumints.space",
+  "disclaimer.description": "Hvad du bør vide, før du bruger et Cashu-mint: mints er depotbaserede, et mint kan forsvinde med dine penge, anmeldelser er meninger, og online betyder tilgængelig, ikke troværdig.",
+  "disclaimer.heading": "Ansvarsfraskrivelse",
+  "disclaimer.lede": "Læs dette, før du lægger penge i et mint. Senest opdateret {date}.",
+  "disclaimer.callout": "Et Cashu-mint opbevarer dine penge for dig. Hvis det forsvinder, er din ecash væk, og der er ingen at klage til. Behold kun det, du har råd til at miste.",
+  "disclaimer.custodial.title": "Mints er forvaringsmyndigheder",
+  "disclaimer.custodial.p1": "Når du minter ecash, giver du bitcoin til mint-operatøren og får tokens tilbage. De tokens er et krav på den operatør. De er ikke bitcoin, du holder, og operatøren er den, der bestemmer, om de indfries.",
+  "disclaimer.custodial.p2": "Det betyder, at alle mints er forbundet med de samme risici: operatøren kan forsvinde, blive tvunget til at indstille driften, miste midlerne på grund af en fejl eller et hackerangreb, eller ganske enkelt slukke for serveren. Der er ingen indskudsforsikring, ingen tilbageførsel af betalinger, ingen supportlinje og ingen retsmidler, man kan regne med. Dette gælder også for den bedst vurderede mint på dette websted.",
+  "disclaimer.custodial.p3": "Cashu er lavet til små beløb, der bevæger sig hurtigt. Brug det sådan: hold det, du er ved at bruge, ikke din opsparing, og spred det over flere mints i stedet for at parkere alt i ét.",
+  "disclaimer.reviews.title": "Anmeldelser er meninger, ikke verificerede påstande",
+  "disclaimer.reviews.p1": "Hver anmeldelse her er skrevet af nogen på Nostr og signeret med deres nøgle. Signeret betyder, at vi kan fortælle dig, hvilken nøgle der skrev den. Det betyder ikke, at anmeldelsen er sand, at forfatteren har brugt mintet, eller at forfatteren ikke er operatøren, en konkurrent eller én person med ti nøgler.",
+  "disclaimer.reviews.p2": "Vi verificerer ikke anmeldere, og vi redigerer eller fjerner ikke anmeldelser, vi er uenige i. Læs et par stykker, se hvad de faktisk siger, og vægt et mint med tre anmeldelser anderledes end et med tre hundrede.",
+  "disclaimer.status.title": "»Online« betyder, at man kan få fat i det, ikke at det er pålideligt",
+  "disclaimer.status.p1": "Vi tjekker alle mints regelmæssigt og viser, om de har svaret. Det er alt, hvad en grøn status betyder: serveren har svaret. Det siger intet om, hvorvidt operatøren er solvent, ærlig eller stadig har til hensigt at indfri dine tokens i morgen.",
+  "disclaimer.status.p2": "Et mint kan være online lige indtil det øjeblik, det ikke er. Oppetidshistorik, understøttede NUTs og softwareversion siger noget om, hvordan et mint drives, men ingen af dem er et løfte om dine penge.",
+  "disclaimer.ranking.title": "Sådan fungerer ranglisten, og hvad den ikke betyder",
+  "disclaimer.ranking.p1": "Mints sorteres ved hjælp af en algoritme baseret på data fra offentlige anmeldelser: bedømmelse, antal anmeldelser og seneste aktivitet, hvor online-mints som standard prioriteres frem for offline-mints. De nærmere detaljer fremgår af open source-koden.",
+  "disclaimer.ranking.p2": "Ingen betaler for placering. Der er ingen sponsoreret plads, ingen fremhævet opførelse og ingen aftale med noget mint på dette websted. En høj placering betyder, at algoritmen kunne lide de offentlige data, og intet mere. Det er ikke en anbefaling, og det er ikke en sikkerhedsvurdering.",
+  "disclaimer.notAdvice.title": "Dette er ikke finansiel rådgivning",
+  "disclaimer.notAdvice.p1": "Intet på dette websted er finansiel, investerings-, juridisk eller skattemæssig rådgivning. Vi kender ikke din situation, og vi rådgiver dig ikke. At bruge et mint, og at vælge hvilket, er din beslutning.",
+  "disclaimer.dyor.title": "Undersøg selv",
+  "disclaimer.dyor.li1": "Slå operatøren op. Et mint drevet af nogen med et offentligt omdømme at miste er noget andet end en anonym URL.",
+  "disclaimer.dyor.li2": "Læs selve mintens vilkår og dens MOTD. En mint, der kalder sig selv en test- eller betaversion, mener det alvorligt.",
+  "disclaimer.dyor.li3": "Start i det små. Mint lidt, brug det, melt det ud igen, og se hvad der sker, før du betror det mere.",
+  "disclaimer.dyor.li4": "Vær opmærksom på grænserne. En lav maksimumsgrænse er ofte tegn på en forsigtig operatør, mens en høj grænse ikke nødvendigvis er tegn på en sikker operatør.",
+  "disclaimer.dyor.li5": "Sørg for at tage backup af dine tokens, og husk, at et token er et ihændehaverbevis: den, der er i besiddelse af det, kan bruge det.",
+  "disclaimer.site.title": "Om selve hjemmesiden",
+  "disclaimer.site.p1": "Oplysningerne her kan være forkerte eller forældede. Mints bliver afprøvet efter en fast tidsplan, relæer svarer ikke altid, og den side, du læser, blev oprettet på et tidspunkt i fortiden. Hjemmesiden stilles til rådighed »som den er«, uden nogen form for garanti. Se {link}.",
+  "disclaimer.site.link": "brugsbetingelser",
+  "disclaimer.updated": "20. august 2026",
+  "login.getPrimal": "Få Primal",
+  "reviews.dialog.identity.extensionGone": "Din browserudvidelse reagerer ikke. Log ind igen, eller brug en ekstern underskriver.",
+  "seo.orgDescription": "En oversigt over Cashu-mints, med live status fra hvert mint og anmeldelser fra fællesskabet signeret på Nostr.",
+  "seo.ogImageAlt": "Cashumints.space: find et Cashu-mint du kan stole på.",
+  "seo.mint.title.one": "{name} anmeldelser: {rating} fra {n} anmeldelse | Cashumints.space",
+  "seo.mint.title.other": "{name} anmeldelser: {rating} fra {n} anmeldelser | Cashumints.space",
+  "seo.mint.titleOffline.one": "{name}: offline i {n} dag | Cashumints.space",
+  "seo.mint.titleOffline.other": "{name}: offline i {n} dage | Cashumints.space",
+  "seo.mint.titleNoReviews": "{name}: info og anmeldelser om Cashu-mint | Cashumints.space",
+  "seo.fedimint.titleNoReviews": "{name}: Oplysninger og anmeldelser om Fedimint-føderationen | Cashumints.space",
+  "seo.desc.fallback": "Anmeldelser fra fællesskabet af {name} ({domain}).",
+  "seo.desc.fallbackDomain": "Anmeldelser fra fællesskabet af Cashu-mintet på {domain}.",
+  "seo.desc.rated.one": "{rating}/5 fra {n} signeret Nostr-anmeldelse.",
+  "seo.desc.rated.other": "{rating}/5 fra {n} signerede Nostr-anmeldelser.",
+  "seo.desc.noReviews": "Der er endnu ingen anmeldelser.",
+  "seo.desc.status": "{status}",
+  "seo.desc.statusLimits": "{status}, grænser {limits}.",
+  "seo.desc.fedModules": "{status}. Moduler: {modules}.",
+  "seo.desc.fedModulesNetwork": "{status}. Moduler: {modules} og {network}.",
+  "seo.mint.ogAlt.one": "{name}: {rating}-stjerner fra anmeldelsen af {n} på Cashumints.space",
+  "seo.mint.ogAlt.other": "{name}: {rating}-stjerner fra anmeldelser af {n} på Cashumints.space",
+  "seo.mint.ogAltNoReviews": "{name} på Cashumints.space",
+  "nav.home": "Hjem",
+  "mint.more.title": "Flere mints",
+  "mint.more.all": "Se alle mints",
+  "nav.fedimints": "Fedimints",
+  "status.announced": "Kun annonceret",
+  "card.unnamedFederation": "Ubenævnt forbund",
+  "card.notChecked": "aldrig kontrolleret",
+  "fedimints.title": "Alle Fedimint-forbund · Cashumints.space",
+  "fedimints.description": "Alle {total}- og Fedimint-foreninger, der er annonceret på Nostr-netværket: {online} er bekræftet som aktiv ved en ekstern kontrol, {announced} er annonceret, men aldrig bekræftet. Brugerbedømmelser, moduler og invitationskoder for hver enkelt.",
+  "fedimints.heading": "Alle forbund",
+  "fedimints.lede": "Hver Fedimint-føderation, der er annonceret på Nostr-netværket. En føderation har ikke sit eget offentlige status-endpoint, så det bekræftes ved en ekstern kontrol, at nogle af disse kører, mens resten er opført nøjagtigt som de blev annonceret.",
+  "fedimints.search.label": "Søg efter forbund efter navn eller id",
+  "fedimints.search.placeholder": "Søg efter navn eller forbunds-id…",
+  "fedimints.sort.label": "Sorter forbund",
+  "fedimints.hideOffline": "Skjul offline",
+  "fedimints.showing": "Viser {total}-forbund ({online} bekræftet, {announced} kun annonceret)",
+  "fedimints.showingFiltered": "Viser {shown} blandt {total}-forbundene ({online} er bekræftet, {announced} er kun annonceret)",
+  "fedimints.announcedNote.one": "En af disse blev annonceret på Nostr, og der er siden ikke kommet nogen bekræftelse på, at den er i drift. Den er angivet som »annonceret« i stedet for »online« eller »offline«, da ingen af delene ville være korrekt.",
+  "fedimints.announcedNote.other": "{n} af disse blev annonceret på Nostr, og der er siden ikke kommet nogen bekræftelse på, at de er i drift. De er angivet som »annonceret« i stedet for »online« eller »offline«, da ingen af delene ville være korrekt.",
+  "fedimints.noResults": "Der findes ingen kampe fra denne forbund. Prøv at indtaste et navn, eller indsæt et forbunds-id.",
+  "fedimints.emptyIndex": "Ifølge denne hjemmeside er der endnu ikke offentliggjort nogen holdopstillinger til stafetterne. Listen opdateres løbende, efterhånden som der kommer nye meddelelser.",
+  "fedimint.crumb": "Fedimints",
+  "fedimint.breadcrumb": "Navigationsspor",
+  "fedimint.unnamed": "Ubenævnt forbund",
+  "fedimint.idLabel": "Forbund",
+  "fedimint.kind.federationId": "forenings-id",
+  "fedimint.moduleCount.one": "{n}-modul",
+  "fedimint.moduleCount.other": "{n}-moduler",
+  "fedimint.copyInvite": "Kopier invitationskoden",
+  "fedimint.confirmed.label": "Bekræftet",
+  "fedimint.confirmed.never": "Aldrig",
+  "fedimint.confirmed.by": "af {source}",
+  "fedimint.confirmed.unattributed": "sidste kontrol",
+  "fedimint.announcedOn": "annonceret {when}",
+  "fedimint.announcedUnknown": "ingen dato for offentliggørelsen",
+  "fedimint.modules.title": "Moduler",
+  "fedimint.modules.none": "I denne forenings meddelelse er der ikke anført nogen moduler.",
+  "fedimint.modules.note": "Moduler er de dele, som en sammenslutning driver. I meddelelsen fremgår det, hvilke der findes, men der står intet om, hvorvidt nogen af dem modtager indskud.",
+  "fedimint.modules.notListed": "ikke opført",
+  "fedimint.invite.title": "Inviteringskode",
+  "fedimint.invite.count.one": "Kode {n}",
+  "fedimint.invite.count.other": "{n}-koder",
+  "fedimint.invite.note": "Indsæt dette i en Fedimint-tegnebog for at tilmelde dig. Den indeholder føderations-id’et og adresserne på dens værger, og den er beregnet til at blive delt.",
+  "fedimint.invite.kind": "inviteringskode",
+  "fedimint.invite.qr": "QR",
+  "fedimint.invite.qrCaption": "Scan for at tilmelde dig {name}",
+  "fedimint.details.federationId": "Forbunds-id",
+  "fedimint.details.network": "Netværk",
+  "fedimint.details.announcedBy": "Annonceret af",
+  "fedimint.details.announced": "Annonceret",
+  "fedimint.more.title": "Flere forbund",
+  "fedimint.more.all": "Se alle forbund",
+  "fedimint.disclaimer": "Når man melder sig ind i en sammenslutning, betyder det, at man overlader sine penge til dens forvaltere. Bedømmelserne er udtryk for fællesskabets holdninger, og at en kandidat er bekræftet som opstillet, betyder blot, at vedkommende kan kontaktes – ikke at vedkommende er pålidelig.",
+  "fedimint.module.lightning": "Lightning",
+  "fedimint.module.mint": "Ecash-mint",
+  "fedimint.module.wallet": "On-chain-tegnebog",
+  "fedimint.module.meta": "Metadata",
+  "fedimint.module.stability_pool": "Stabilitetspulje",
+  "fedimint.module.multi_sig_stability_pool": "Stabilitetspulje (multisig)",
+  "fedimint.module.fedi-social": "Social genopretning",
+  "fedimint.network.mainnet": "Bitcoin mainnet",
+  "fedimint.network.signet": "Signet",
+  "fedimint.network.testnet": "Testnet",
+  "fedimint.network.testnet4": "Testnet4",
+  "fedimint.network.regtest": "Regtest",
+  "feed.ecosystem.group": "Økosystem",
+  "feed.ecosystem.all": "Alle",
+  "feed.ecosystem.cashu": "Cashu",
+  "feed.ecosystem.fedimint": "Fedimint",
+  "feed.filterBySubject": "Filtrer efter »mint« eller »federation«",
+  "feed.anySubject": "Ethvert mint eller enhver føderation",
+  "feed.clearSubject": "Ryd navnefilteret",
+  "home.topFedimints.title": "De bedste Fedimint-modeller",
+  "home.topFedimints.sub": "rangeret efter anmeldelser og bedømmelser",
+  "home.topFedimints.all": "Alle {n}-forbund →",
+  "reviews.validate.subject": "Der er intet, som denne anmeldelse kan rette sig mod.",
+  "mint.warnings.fedimintOffline.lead": "Rapporteret som offline.",
+  "mint.warnings.fedimintOffline.body.since": "Den seneste indbetaling, der nåede frem til denne sammenslutning, var på {date} (for {days} siden). Dens forvaltere har ikke svaret siden. Betragt de midler, der er deponeret der, som værende i fare, og indsæt ikke nye midler til kontoen.",
+  "mint.warnings.fedimintOffline.body.never": "Der er aldrig blevet foretaget en revision af denne sammenslutning, og den seneste revision mislykkedes. Betragt de midler, der opbevares der, som værende i fare, og indsæt ikke nye midler i den.",
+  "mint.warnings.fedimintOffline.meta.since": "Har været rapporteret som offline siden {date}",
+  "mint.warnings.fedimintOffline.meta.never": "Rapporteret som offline, er aldrig blevet kontaktet",
+  "mint.warnings.neverConfirmed.lead": "Annonceret, men aldrig bekræftet.",
+  "mint.warnings.neverConfirmed.body.reviewed": "Denne sammenslutning blev annonceret på Nostr for {date} og {days} siden, og der er siden da ikke kommet nogen bekræftelse på, at den er i drift. Anmeldelserne nedenfor er det eneste tegn på liv på denne side; alt andet stammer fra annonceringen.",
+  "mint.warnings.neverConfirmed.body.quiet": "Denne sammenslutning blev annonceret på Nostr for {date} og {days} siden; der er siden da ikke kommet nogen bekræftelse på, at den er i drift, og ingen har anmeldt den for nylig. Alt nedenfor stammer fra annonceringen.",
+  "mint.warnings.neverConfirmed.meta": "{date} blev annonceret, men aldrig bekræftet",
+  "footer.allFedimints": "Alle forbund",
+  "reviews.dialog.bodyPlaceholder.cashu": "Hvordan gik minting, melting og support? Vær konkret.",
+  "reviews.dialog.bodyPlaceholder.fedimint": "Hvordan gik det med tilmeldingen, betalingerne via Lightning og supporten? Vær konkret.",
+  "fedimint.details.title": "Oplysninger om forbundet",
+  "nav.lnurlMints": "LNURL-mints",
+  "footer.allLnurlMints": "Alle LNURL-mints",
+  "lnurlMints.title": "LNURL-mints: mints til lnurlcash-ihændehaversedler, anmeldt | Cashumints.space",
+  "lnurlMints.description": "Alle {total} LNURL-mints indekseret fra Nostr-netværket: {online} online, {offline} offline. Bedømmelser fra fællesskabet, udbetalingsgrænser og funktioner for hver enkelt.",
+  "lnurlMints.heading": "LNURL-mints",
+  "lnurlMints.lede": "Hver LNURL-mint denne side kender til. En LNURL-mint udsteder lnurlcash-ihændehaversedler: Lightning-sedler, du opbevarer som en hemmelighed, og som kan roteres, deles, lægges sammen eller smeltes tilbage til en Lightning-betaling. Hver enkelt tjekkes via HTTPS hvert par minutter.",
+  "lnurlMints.search.label": "Søg i LNURL-mints",
+  "lnurlMints.search.placeholder": "Søg på navn eller adresse…",
+  "lnurlMints.sort.label": "Sortér LNURL-mints efter",
+  "lnurlMints.hideOffline": "Skjul offline",
+  "lnurlMints.showing": "Viser {total} LNURL-mints ({online} online, {offline} offline)",
+  "lnurlMints.showingFiltered": "Viser {shown} af {total} LNURL-mints ({online} online, {offline} offline)",
+  "lnurlMints.noResults": "Ingen LNURL-mint matcher det.",
+  "lnurlMints.emptyIndex": "Der er endnu ikke indekseret nogen LNURL-mints.",
+  "lnurl.crumb": "LNURL-mints",
+  "lnurl.breadcrumb": "Brødkrummesti",
+  "lnurl.copyAddress": "Kopiér adresse",
+  "lnurl.more.title": "Flere LNURL-mints",
+  "lnurl.more.all": "Alle LNURL-mints →",
+  "lnurl.disclaimer": "En LNURL-mint opbevarer dine sats, mens du holder dens sedler, så at bruge en betyder at stole på dens operatør. Bedømmelser er fællesskabets meninger, og online betyder tilgængelig, ikke troværdig.",
+  "lnurl.features.title": "Funktioner",
+  "lnurl.features.none": "Denne mint har ikke annonceret, hvad den understøtter.",
+  "lnurl.features.note": "Funktioner er det, mintens operatør har annonceret på Nostr. Hvor denne side kan tjekke en via HTTPS, gør den det, og siger til, når noget annonceret ikke er tilgængeligt lige nu.",
+  "lnurl.features.notListed": "ikke annonceret",
+  "lnurl.features.unavailable": "utilgængelig",
+  "lnurl.feature.mint": "Mint via Lightning (LUD-06)",
+  "lnurl.feature.melt": "Smelt til Lightning",
+  "lnurl.feature.notes": "Rotér / del / læg sedler sammen",
+  "lnurl.feature.lud16": "Lightning-adresse",
+  "lnurl.feature.lud21": "Betalingsverifikation (LUD-21)",
+  "lnurl.feature.signed-notes": "Signerede sedler (offlineverifikation)",
+  "lnurl.feature.onion": "Tor-adresse",
+  "lnurl.feature.rotate": "Rotér en seddel",
+  "lnurl.feature.split": "Del en seddel",
+  "lnurl.feature.merge": "Læg sedler sammen",
+  "lnurl.feature.lud06": "LUD-06 payRequest",
+  "lnurl.feature.lud03": "LUD-03 withdrawRequest",
+  "lnurl.limits.label": "Udbetalingsgrænser",
+  "lnurl.limits.notPublished": "ikke offentliggjort",
+  "lnurl.limits.withdrawRow": "Udbetaling",
+  "lnurl.limits.disabled": "slået fra",
+  "lnurl.limits.sats.one": "{n} sat",
+  "lnurl.limits.sats.other": "{n} sats",
+  "lnurl.details.title": "Oplysninger om minten",
+  "lnurl.details.address": "Lightning-adresse",
+  "lnurl.details.mintPubkey": "Mintens offentlige nøgle",
+  "lnurl.details.onion": "Tor-adresse",
+  "lnurl.details.fee": "Mint-gebyr",
+  "lnurl.details.node": "Node",
+  "lnurl.details.capacity": "Annonceret kapacitet",
+  "lnurl.kind.lightningAddress": "Lightning-adresse",
+  "lnurl.kind.mintPubkey": "mintens offentlige nøgle",
+  "lnurl.kind.onionAddress": "Tor-adresse",
+  "lnurl.confirmed.label": "Sidst bekræftet",
+  "lnurl.confirmed.when": "bekræftet {when}",
+  "lnurl.fee.base.one": "{n} sat",
+  "lnurl.fee.base.other": "{n} sats",
+  "lnurl.fee.percent": "{percent} %",
+  "home.topLnurl.title": "Bedste LNURL-mints",
+  "home.topLnurl.sub": "rangeret efter anmeldelser og bedømmelse",
+  "home.topLnurl.all": "Alle {n} LNURL-mints →",
+  "feed.ecosystem.lnurl": "LNURL",
+  "reviews.dialog.bodyPlaceholder.lnurl": "Hvordan gik mintning, smeltning og rotation af sedler? Vær konkret.",
+  "reviews.byUrl.open": "Skriv en anmeldelse",
+  "reviews.byUrl.title": "Skriv en anmeldelse",
+  "reviews.byUrl.lede": "Indsæt adressen. Kender siden den ikke endnu, bliver den tjekket og tilføjet nu.",
+  "reviews.byUrl.label.cashu": "Mint-URL",
+  "reviews.byUrl.label.fedimint": "Føderationens invite code",
+  "reviews.byUrl.label.lnurl": "URL til LNURL-mint",
+  "reviews.byUrl.placeholder.cashu": "mint.example.com",
+  "reviews.byUrl.placeholder.fedimint": "fed11…",
+  "reviews.byUrl.placeholder.lnurl": "mint.example.com",
+  "reviews.byUrl.check": "Tjek denne adresse",
+  "reviews.byUrl.checking": "Tjekker…",
+  "reviews.byUrl.back": "Brug en anden adresse",
+  "reviews.byUrl.existing": "Allerede på listen",
+  "reviews.byUrl.indexed": "Lige tilføjet",
+  "reviews.byUrl.confirmClose": "Luk? Adressen du skrev bliver ikke gemt.",
+  "reviews.byUrl.detected": "Den adresse svarede som en {kind}-mint.",
+  "reviews.byUrl.switchTo": "Anmeld den som {kind}-mint",
+  "reviews.byUrl.error.empty": "Skriv en adresse først.",
+  "reviews.byUrl.error.badUrl": "Det ligner ikke en mint-URL.",
+  "reviews.byUrl.error.badInvite": "Det er ikke en Fedimint invite code. Koder starter med fed11.",
+  "reviews.byUrl.error.badInput": "Siden kan ikke tjekke den adresse.",
+  "reviews.byUrl.error.blocked": "Det er ikke en offentlig adresse, så den kan ikke tjekkes.",
+  "reviews.byUrl.error.notAMint": "Adressen svarede, men ikke som en mint af den her slags.",
+  "reviews.byUrl.error.wrongType": "Adressen svarede, men som en anden slags mint.",
+  "reviews.byUrl.error.unverifiable": "Intet svarede på den adresse, og der er endnu ingen spor af den på Nostr.",
+  "reviews.byUrl.error.rateLimited.one": "Det er mange tjek fra én forbindelse. Prøv igen om cirka {n} minut.",
+  "reviews.byUrl.error.rateLimited.other": "Det er mange tjek fra én forbindelse. Prøv igen om cirka {n} minutter.",
+  "reviews.byUrl.error.network": "Indekset kunne ikke nås. Tjek din forbindelse, og prøv igen.",
+  "seo.lnurl.titleNoReviews": "{name}: info og anmeldelser af LNURL-minten | Cashumints.space",
+  "seo.desc.statusWithdraw": "{status}, udbetaling {min}–{max} sat.",
+  "mint.chip.noFunding": "Ingen mint / smelt",
+  "mint.warnings.lnurlWithdrawalsDisabled.lead": "Udbetalinger er slået fra.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.online": "Denne mint annoncerer en maksimal udbetaling på nul, så ingen seddel den udsteder kan indløses til noget. Lad være med at minte her, før det ændrer sig.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.offline": "Denne mint annoncerede en maksimal udbetaling på nul, sidst den blev nået, så ingen seddel den udstedte kunne indløses til noget. Lad være med at minte her, før det ændrer sig.",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.online": "Udbetalinger er slået fra lige nu",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.offline": "Udbetalinger var slået fra, sidst den blev set",
+  "mint.warnings.lnurlInvalid.lead": "Endepunktet svarer, men er ugyldigt.",
+  "mint.warnings.lnurlInvalid.body": "Værten svarer, men ikke med en mint-annoncering, denne side kan læse, så udbetalinger virker måske ikke. Alt nedenfor er den seneste tilstand, der kunne læses, og anmeldelser virker stadig.",
+  "mint.warnings.lnurlInvalid.meta": "Svarer, men ikke med en gyldig mint-annoncering",
+  "mint.warnings.lnurlNoFunding.lead": "Mintning og smeltning er utilgængelige.",
+  "mint.warnings.lnurlNoFunding.body": "Eksisterende sedler kan stadig roteres, deles eller lægges sammen, men lige nu bevæger intet sig ind eller ud via Lightning. Selve minten kører og svarer; Lightning-noden bag den kan ikke nås derfra.",
+  "mint.warnings.lnurlNoFunding.meta": "Mintning og smeltning utilgængelige",
+  "mint.warnings.also.noFunding": "Dens Lightning-node kunne heller ikke nås, så intet kunne mintes eller smeltes."
+}

web/src/i18n/de.json

@@ -0,0 +1,788 @@
+{
+  "site.name": "Cashumints.space",
+  "common.close": "Schließen",
+  "common.cancel": "Abbrechen",
+  "common.done": "Fertig",
+  "common.back": "Zurück",
+  "common.retry": "Erneut versuchen",
+  "common.connect": "Verbinden",
+  "common.copied": "Kopiert",
+  "common.copyFull": "Vollständigen Artikel kopieren: {kind}",
+  "common.previousPage": "Vorherige Seite",
+  "common.nextPage": "Nächste Seite",
+  "common.reviewPages": "Bewertungsseiten",
+  "time.never": "niemals",
+  "time.justNow": "gerade eben",
+  "time.none": "-",
+  "time.unknownDate": "ein unbekanntes Datum",
+  "time.ago.minute": "vor {n} Min.",
+  "time.ago.hour": "vor {n} Std.",
+  "time.ago.day": "vor {n} T.",
+  "time.ago.week": "vor {n} Wo.",
+  "time.ago.month": "vor {n} Mon.",
+  "time.ago.year": "vor {n} J.",
+  "time.short.minute": "{n}m",
+  "time.short.hour": "{n}h",
+  "time.short.day": "{n}d",
+  "time.short.week": "{n}w",
+  "time.short.month": "{n}mo",
+  "time.short.year": "{n}y",
+  "status.online": "Online",
+  "status.offline": "Offline",
+  "status.degraded": "Nicht erreichbar",
+  "status.unknown": "Noch nicht geprüft",
+  "nav.skip": "Zum Inhalt springen",
+  "nav.main": "Hauptseite",
+  "nav.mints": "Cashu-Mints",
+  "nav.reviews": "Rezensionen",
+  "nav.wallets": "Geldbörsen",
+  "nav.about": "Über",
+  "nav.searchMints": "Unter {n} Mints suchen",
+  "lang.label": "Sprache",
+  "lang.switcher": "Wählen Sie eine Sprache aus",
+  "footer.copyright": "© {year} Cashumints.space",
+  "footer.allMints": "Alle Cashu-Mints",
+  "footer.allReviews": "Alle Bewertungen",
+  "footer.wallets": "Geldbörsen",
+  "footer.about": "Über",
+  "footer.disclaimer": "Haftungsausschluss",
+  "footer.terms": "Nutzungsbedingungen",
+  "footer.privacy": "Datenschutz",
+  "footer.madeBy": "Mit ❤️ erstellt von {azzamo} · Unterstützt von Cashu und NIP-87",
+  "footer.warning": "Mints sind treuhänderisch. Ein Mint kann mit deinem Geld verschwinden.",
+  "footer.tagline": "Community-Bewertungen für ecash-Mints, signiert auf Nostr.",
+  "footer.col.explore": "Entdecken",
+  "footer.col.site": "Seite",
+  "footer.nav": "Fußzeile",
+  "home.title": "Cashumints.space · Finde ein Cashu-Mint, dem du vertrauen kannst",
+  "home.description": "Finde ein Cashu-Mint, dem du vertrauen kannst. {mints} Mints im Index, {reviews} auf Nostr signierte Community-Bewertungen, dazu Live-Verfügbarkeit, unterstützte NUTs und Mint-Software.",
+  "home.hero.title": "Finde ein Cashu-Mint",
+  "home.hero.titleEm": "auf die man sich verlassen kann",
+  "home.hero.lede": "Jede Mint im Nostr-Netzwerk, mit echten Bewertungen aus der Community. Keine Gatekeeper, nur signierte Bewertungen, die Sie selbst überprüfen können.",
+  "home.search.label": "Mints nach Name, Domain oder URL suchen",
+  "home.search.placeholder": "Suche nach Name, Domain oder füge eine Mint-URL ein…",
+  "home.filters.mostReviewed": "Am häufigsten bewertet",
+  "home.filters.highestRated": "Am besten bewertet",
+  "home.filters.recentlyActive": "Zuletzt aktiv",
+  "home.filters.websockets": "Unterstützt WebSockets",
+  "home.top.title": "Die besten Cashu-Mints",
+  "home.top.sub": "nach Bewertungen und Sternebewertung sortiert",
+  "home.top.all": "Alle {n} Mints →",
+  "home.latest.title": "Neueste Bewertungen",
+  "home.latest.sub": "Live aus dem Nostr-Netzwerk",
+  "home.latest.prev": "Frühere Rezensionen",
+  "home.latest.next": "Weitere Bewertungen",
+  "home.latest.all": "Alle Bewertungen →",
+  "home.latest.empty": "Derzeit konnten keine Bewertungen aus den Relays ausgelesen werden. Öffne eine beliebige Mint-Seite, um Bewertungen direkt zu lesen und zu schreiben.",
+  "home.why.title": "Warum sollte man diesen Bewertungen vertrauen?",
+  "home.why.signed.title": "Unterzeichnet, nicht eingereicht",
+  "home.why.signed.body": "Jede Rezension ist ein „{link}“-Ereignis, das mit dem Nostr-Schlüssel des Autors signiert ist. Nichts hier wird von uns bearbeitet, bewertet oder entfernt.",
+  "home.why.signed.link": "NIP-87",
+  "home.why.verify.title": "Überzeugen Sie sich selbst davon",
+  "home.why.verify.body": "Die Bewertungen werden auf öffentlichen Nostr-Relays gespeichert, nicht in unserer Datenbank. Wenn Sie einen beliebigen Client auf dieselben Relays verweisen, werden Ihnen dieselben Daten angezeigt.",
+  "home.why.checked.title": "Wird kontinuierlich überprüft",
+  "home.why.checked.body": "Wir überprüfen jede Mint-Version auf Verfügbarkeit, Softwareversion, Einschränkungen und unterstützte NUTs, sodass die angezeigten Spezifikationen aktuell sind und nicht auf Selbstangaben beruhen.",
+  "home.cta.title": "Du denkst über ein Mint nach? Lies erst nach.",
+  "home.cta.body": "Ein Mint verwahrt dein ecash. Lies, was andere herausgefunden haben, bevor du Sats einzahlst, und schreib eine Bewertung, wenn du selbst eines genutzt hast.",
+  "home.cta.explore": "Alle Mints entdecken",
+  "home.cta.learn": "Erfahren Sie mehr über Cashu",
+  "pulse.mintsIndexed": "Mints im Index",
+  "pulse.reviewsOnNostr": "Bewertungen zu Nostr",
+  "pulse.lastReview": "letzte Überprüfung",
+  "pulse.mintsOnline": "Mints online",
+  "pulse.indexer": "Indexierer",
+  "pulse.connected": "verbunden",
+  "pulse.stale": "abgestanden",
+  "mints.title": "Alle Cashu-Mints · Cashumints.space",
+  "mints.description": "Alle {total} Cashu-Mints aus dem Nostr-Netzwerk indexiert, {online} online und {offline} offline, mit Community-Bewertungen, Verfügbarkeit und Mint-Software. Durchsuche und sortiere die ganze Liste.",
+  "mints.heading": "Alle Cashu-Mints",
+  "mints.lede": "Jedes im Nostr-Netzwerk gefundene Mint, auch die, die es nicht mehr gibt. Offline-Mints bleiben gelistet, damit du sie weiterhin finden und bewerten kannst.",
+  "mints.search.label": "Such nach Mints nach Namen oder Domain",
+  "mints.search.placeholder": "Nach Name oder Domain suchen…",
+  "mints.sort.label": "Mints sortieren",
+  "mints.sort.score": "Gesamtbester",
+  "mints.sort.rating": "Am besten bewertet",
+  "mints.sort.reviews": "Am häufigsten bewertet",
+  "mints.sort.recent": "Kürzlich rezensiert",
+  "mints.sort.seen": "Kürzlich online angesehen",
+  "mints.hideOffline": "Als offline ausblenden",
+  "mints.showing": "{total} Mints angezeigt ({online} online, {offline} offline)",
+  "mints.showingFiltered": "Anzeige von „{shown}“ von „{total}“ Mints ({online} online, {offline} offline)",
+  "mints.noResults": "Es wurden keine Übereinstimmungen gefunden. Versuchen Sie es mit einer Domain oder fügen Sie eine Mint-URL ein.",
+  "mints.clearSearch": "Suche löschen",
+  "card.noRatings": "Noch keine Bewertungen",
+  "card.reviews.one": "{n} Bewertung",
+  "card.reviews.other": "{n} Bewertungen",
+  "card.lastSeen": "Zuletzt gesehen unter {when}",
+  "card.neverSeen": "noch nie online gesehen",
+  "card.reviewed": "Rezension zu „{when}“",
+  "card.noReviews": "noch keine Bewertungen",
+  "mint.title": "{name} · Bewertungen zum Cashu-Mint",
+  "mint.titleFedimint": "{name} · Bewertungen zur Fedimint-Föderation",
+  "mint.titleLnurl": "{name} · Bewertungen zum LNURL-Mint",
+  "mint.breadcrumb": "Navigationspfad",
+  "mint.crumbMints": "Cashu-Mints",
+  "mint.copyUrl": "Mint-URL kopieren",
+  "mint.qrButton": "Mint QR",
+  "mint.writeReview": "Eine Bewertung schreiben",
+  "mint.rankByScore": "#{rank} nach Punktestand",
+  "mint.tagLightning": "Lightning",
+  "mint.summary": "Mint-Zusammenfassung",
+  "mint.rating.label": "Community-Bewertung",
+  "mint.rating.none": "Noch keine Bewertungen",
+  "mint.rating.reviews.one": "{n} Bewertung",
+  "mint.rating.reviews.other": "{n} Bewertungen",
+  "mint.rating.unrated.one": "{n} hat keine Bewertung abgegeben",
+  "mint.rating.unrated.other": "{n} haben keine Bewertung abgegeben",
+  "mint.activity.label": "Aktivität",
+  "mint.activity.since": "seit der letzten Bewertung",
+  "mint.activity.noReviews": "noch keine Bewertungen",
+  "mint.activity.recent.one": "{n} Bewertung in den letzten 90 Tagen",
+  "mint.activity.recent.other": "{n} Bewertungen in den letzten 90 Tagen",
+  "mint.limits.label": "Limits",
+  "mint.limits.notPublished": "nicht veröffentlicht",
+  "mint.limits.min": "min",
+  "mint.limits.max": "max",
+  "mint.limits.mintRow": "minten",
+  "mint.limits.meltRow": "schmelzen",
+  "mint.limits.disabled": "deaktiviert",
+  "mint.limits.range": "{min} bis {max} {unit}",
+  "mint.limits.upTo": "bis zu {max} {unit}",
+  "mint.limits.from": "ab {min} {unit}",
+  "mint.software.label": "Mint-Software",
+  "mint.software.unknown": "unbekannt",
+  "mint.checked": "geprüft {when}",
+  "mint.lastSeen": "zuletzt gesehen {when}",
+  "mint.neverReached": "nie erreicht",
+  "mint.uptime.checks": "{ok} der letzten {total} Prüfungen erreichbar",
+  "mint.uptime.percent": "{percent}% erreichbar über 30 Tage",
+  "mint.uptime.description": "{ok} der letzten {total} Prüfungen erfolgreich",
+  "mint.operator.title": "Vom Betreiber",
+  "mint.operator.motd": "Nachricht des Tages",
+  "mint.operator.beta": "Diese Mint bezeichnet sich selbst als experimentell oder als Beta-Version. Lesen Sie die folgenden Aussagen des Betreibers, bevor Sie etwas dort hinterlegen, das Sie nicht verlieren dürfen.",
+  "mint.nuts.title": "Unterstützte NUTs",
+  "mint.nuts.noneOffline": "Für diese Mint wurde keine NUT-Liste zwischengespeichert; sie ging offline, bevor eine Liste erfasst werden konnte.",
+  "mint.nuts.noneYet": "Für dieses Mint wurde noch keine NUT-Liste zwischengespeichert.",
+  "mint.nuts.supported": "{n} von {total} bekannten NUTs unterstützt",
+  "mint.nuts.whatAre": "Was sind NUTs?",
+  "mint.nutRow.disabled": "deaktiviert",
+  "mint.nutRow.notSupported": "wird nicht unterstützt",
+  "mint.details.title": "Mint-Details",
+  "mint.details.pubkey": "Pubkey",
+  "mint.details.nostr": "Nostr",
+  "mint.details.email": "E-Mail",
+  "mint.details.serverTime": "Serverzeit",
+  "mint.details.firstSeen": "Erstmals gesehen",
+  "mint.details.terms": "Nutzungsbedingungen",
+  "mint.kind.identifier": "Bezeichner",
+  "mint.kind.mintPubkey": "Mint-Pubkey",
+  "mint.kind.nostrAddress": "Nostr-Adresse",
+  "mint.kind.emailAddress": "E-Mail-Adresse",
+  "mint.kind.npub": "npub",
+  "mint.disclaimer": "Diese Mint fungiert als Verwahrstelle: Sie verwahrt Ihr Geld und kann dies jederzeit einstellen. Bewertungen sind Meinungen der Community, und „online erreichbar“ bedeutet lediglich, dass die Plattform online verfügbar ist – nicht, dass sie vertrauenswürdig ist.",
+  "mint.disclaimerLink": "Lesen Sie den vollständigen Haftungsausschluss",
+  "mint.qr.title": "Füge „{name}“ zu deinem Wallet hinzu",
+  "mint.qr.note": "Scanne das mit einer Cashu-Wallet, um das Mint hinzuzufügen, oder kopiere die URL und füge sie ein.",
+  "mint.qr.warn": "Ein Mint hinzuzufügen heißt, ihm dein Geld anzuvertrauen.",
+  "mint.qr.whatMeans": "Was das bedeutet",
+  "mint.qr.wallets": "Wallets, die Cashu unterstützen",
+  "mint.chip.frozen": "Gefroren",
+  "mint.chip.noWithdrawals": "Keine Abhebungen",
+  "mint.chip.meltOnly": "Nur schmelzen",
+  "mint.warnings.dayCount.one": "{n}-Tag",
+  "mint.warnings.dayCount.other": "{n}-Tage",
+  "mint.warnings.gone.lead": "Wahrscheinlich weg.",
+  "mint.warnings.gone.body.since": "Diese Mint ist seit dem {date} ({days}) nicht mehr erreichbar. Betrachten Sie die dort hinterlegten Gelder als verloren und überweisen Sie keine neuen Gelder mehr dorthin. Die folgenden Angaben zeigen den letzten bekannten Status.",
+  "mint.warnings.gone.body.neverDated": "Dieses Mint hat seit Beginn unserer Beobachtung im {month} auf keine einzige Prüfung geantwortet. Betrachte dort verwahrtes Geld als gefährdet und zahle nichts Neues ein. Alles Folgende stammt aus der Nostr-Ankündigung, nicht vom Mint.",
+  "mint.warnings.gone.body.never": "Dieses Mint hat seit Beginn unserer Beobachtung auf keine einzige Prüfung geantwortet. Betrachte dort verwahrtes Geld als gefährdet und zahle nichts Neues ein. Alles Folgende stammt aus der Nostr-Ankündigung, nicht vom Mint.",
+  "mint.warnings.gone.meta.since": "Offline seit {date}",
+  "mint.warnings.gone.meta.never": "Seit seiner Entdeckung war es nie erreichbar",
+  "mint.warnings.meltDisabled.lead": "Auszahlungen sind deaktiviert.",
+  "mint.warnings.meltDisabled.body.online": "Bei dieser Mint ist die Funktion „Lightning Melting“ (NUT-05) deaktiviert: Sie können Sats einzahlen, aber nicht über Lightning abheben. Bitte nehmen Sie keine Einzahlungen vor, bis die Funktion wieder verfügbar ist.",
+  "mint.warnings.meltDisabled.body.offline": "Bei dieser Mint war die Funktion „Lightning Melting“ (NUT-05) deaktiviert: Sie können Sats einzahlen, aber nicht über Lightning abheben. Bitte nehmen Sie keine Einzahlungen vor, bis die Funktion wieder verfügbar ist.",
+  "mint.warnings.meltDisabled.meta.online": "Auszahlungen sind derzeit deaktiviert",
+  "mint.warnings.meltDisabled.meta.offline": "Auszahlungen waren zuletzt deaktiviert.",
+  "mint.warnings.frozen.lead": "Mint eingefroren.",
+  "mint.warnings.frozen.body.online": "Minten und Melten sind beide deaktiviert. Über Lightning können keine Sats rein oder raus.",
+  "mint.warnings.frozen.body.offline": "Minten und Melten waren beide deaktiviert. Über Lightning können keine Sats rein oder raus.",
+  "mint.warnings.frozen.meta.online": "Derzeit ist alles eingefroren, es kommt nichts herein und nichts geht hinaus",
+  "mint.warnings.frozen.meta.offline": "Zuletzt gesehen: eingefroren",
+  "mint.warnings.offlineLong.lead": "Für „{days}“ offline, da {date}.",
+  "mint.warnings.offlineLong.body": "Das Mint ist womöglich weg. Alles Folgende ist sein letzter bekannter Stand, und Bewertungen funktionieren weiterhin.",
+  "mint.warnings.offlineLong.meta": "Offline seit {date}",
+  "mint.warnings.meltOnly.lead": "Nur schmelzen.",
+  "mint.warnings.meltOnly.body.online": "Neues Minten (NUT-04) ist deaktiviert: Einzahlen geht nicht, vorhandenes ecash lässt sich aber weiterhin auszahlen. Das heißt oft, dass ein Mint den Betrieb einstellt. Wenn du sein ecash hältst, denk übers Melten nach.",
+  "mint.warnings.meltOnly.body.offline": "Neues Minten (NUT-04) war deaktiviert: Einzahlen geht nicht, vorhandenes ecash lässt sich aber weiterhin auszahlen. Das heißt oft, dass ein Mint den Betrieb einstellt. Wenn du sein ecash hältst, denk übers Melten nach.",
+  "mint.warnings.meltOnly.meta.online": "Derzeit nur schmelzen",
+  "mint.warnings.meltOnly.meta.offline": "Erst schmelzen, wenn zuletzt gesehen",
+  "mint.warnings.offline.lead": "Seit dem {date} offline.",
+  "mint.warnings.offline.body": "Die Details wurden damals zuletzt bestätigt. Sie können weiterhin eine Bewertung abgeben.",
+  "mint.warnings.offline.meta": "Offline seit {date}",
+  "mint.warnings.also.meltDisabled": "Bevor es offline ging, hatte es zudem Auszahlungen deaktiviert.",
+  "mint.warnings.also.mintDisabled": "Vor dem Offlinegehen hatte es auch neues Minten deaktiviert.",
+  "mint.warnings.also.offline": "Außerdem ist die Website „{date}“ ({days}) seit einiger Zeit nicht mehr erreichbar.",
+  "nut.0": "Notation und Modelle",
+  "nut.1": "Austausch öffentlicher Schlüssel bei Mint",
+  "nut.2": "Schlüsselsätze und Gebühren",
+  "nut.3": "Token tauschen",
+  "nut.4": "Minten über Lightning",
+  "nut.5": "Melten über Lightning",
+  "nut.6": "Mint-Informationen",
+  "nut.7": "Überprüfung des Token-Status",
+  "nut.8": "Zu viel gezahlte Lightning-Gebühren",
+  "nut.9": "Signaturen wiederherstellen",
+  "nut.10": "Ausgabebedingungen",
+  "nut.11": "An öffentlichen Schlüssel zahlen",
+  "nut.12": "DLEQ-Prüfberichte",
+  "nut.13": "Deterministische Geheimnisse",
+  "nut.14": "Verträge mit Hash-basierter Zeitverriegelung",
+  "nut.15": "Zahlungen über mehrere Kanäle",
+  "nut.16": "Animierte QR-Codes",
+  "nut.17": "WebSocket-Abonnements",
+  "nut.18": "Zahlungsaufforderungen",
+  "nut.19": "Zwischengespeicherte Antworten",
+  "nut.20": "Signierte Mint-Quotes",
+  "nut.21": "Authentifizierung löschen",
+  "nut.22": "Blinde Authentifizierung",
+  "nut.23": "Zahlungsmethode BOLT11",
+  "nut.24": "HTTP 402 – Zahlung erforderlich",
+  "nut.25": "Zahlungsmethode BOLT12",
+  "reviews.title": "Rezensionen",
+  "reviews.anon": "Anonym",
+  "reviews.anonTitle": "Für diesen Schlüssel wurde kein öffentliches Nostr-Profil gefunden.",
+  "reviews.nip05Title": "NIP-05-Kennung (von dieser Website nicht überprüft)",
+  "reviews.filter.group": "Bewertungen filtern",
+  "reviews.filter.all": "Alle",
+  "reviews.filter.five": "5★",
+  "reviews.filter.critical": "Kritisch",
+  "reviews.filter.recent": "Aktuell",
+  "reviews.filter.hideAnon": "Anonym ausblenden",
+  "reviews.anonHidden.other": "{n} von {total} Bewertungen werden angezeigt: anonym, verborgen.",
+  "reviews.allAnon.one": "Die einzige Bewertung hier stammt von einem anonymen Nutzer.",
+  "reviews.allAnon.other": "Alle Bewertungen zu „{n}“ hier sind anonym.",
+  "reviews.allAnonShow.one": "Zeige es",
+  "reviews.allAnonShow.other": "Zeig es ihnen",
+  "reviews.loading.one": "Lade... Testbericht zu „{n}“ von Nostr Relays",
+  "reviews.loading.other": "{n}-Bewertungen von Nostr-Relais werden geladen",
+  "reviews.empty": "Es gibt noch keine Bewertungen. Schreiben Sie die erste Bewertung.",
+  "reviews.emptyWritten": "Hier gibt es noch keine schriftlichen Bewertungen. Schreiben Sie die erste Bewertung.",
+  "reviews.emptyFilter": "Es gibt keine Bewertungen, die diesem Filter entsprechen.",
+  "reviews.rate.cashu": "Diese Mint bewerten",
+  "reviews.rate.fedimint": "Diese Föderation bewerten",
+  "reviews.rate.lnurl": "Diese Mint bewerten",
+  "reviews.noscript": "Die Bewertungen werden auf Nostr signiert und in Ihrem Browser geladen, daher benötigt diese Liste JavaScript. Die Bewertungen und Zahlen oben stammen von der Website selbst.",
+  "reviews.relayError": "Das Relais konnte nicht erreicht werden. Die Bewertungen sind möglicherweise unvollständig.",
+  "reviews.srRating": "{rating} von 5",
+  "reviews.srNoRating": "Keine Bewertung abgegeben",
+  "reviews.readMore": "Weiterlesen",
+  "reviews.readLess": "Weniger anzeigen",
+  "reviews.actions.copyNpub": "npub kopieren",
+  "reviews.actions.openNostr": "Diese Veranstaltung auf Nostr ansehen",
+  "reviews.actions.copyLink": "Link zu dieser Rezension kopieren",
+  "reviews.anonNote": "Erste Rezension von diesem Verlag, keine weiteren Aktivitäten gefunden",
+  "reviews.published": "Veröffentlicht.",
+  "reviews.publishedPartial": "Veröffentlicht auf {accepted} der {total}-Relais.",
+  "reviews.propagating": "Veröffentlichen auf Nostr-Relays",
+  "reviews.summary.line.one": "{count}-Bewertung ohne Kommentar: {breakdown}",
+  "reviews.summary.line.other": "{count}-Bewertungen ohne Kommentar: {breakdown}",
+  "reviews.summary.lineDay.one": "{count}-Bewertung ohne Kommentar auf {when}: {breakdown}",
+  "reviews.summary.lineDay.other": "{count}-Bewertungen ohne Kommentar auf {when}: {breakdown}",
+  "reviews.summary.showOne": "Zeige es",
+  "reviews.summary.showMany": "Zeig es ihnen",
+  "reviews.breakdown.5": "{n}: Fünf Sterne",
+  "reviews.breakdown.4": "{n}, Vier-Sterne-Hotel",
+  "reviews.breakdown.3": "{n}, drei Sterne",
+  "reviews.breakdown.2": "{n}, zwei Sterne",
+  "reviews.breakdown.1": "{n}, ein Stern",
+  "reviews.breakdown.none": "{n}, ohne Bewertung",
+  "reviews.dialog.title": "Rezension: „{name}“",
+  "reviews.dialog.lede.cashu": "Teilen Sie Ihre Erfahrung mit dieser Mint.",
+  "reviews.dialog.lede.fedimint": "Teilen Sie Ihre Erfahrung mit dieser Föderation.",
+  "reviews.dialog.lede.lnurl": "Teilen Sie Ihre Erfahrung mit dieser Mint.",
+  "reviews.dialog.permanent": "Wird dauerhaft auf öffentlichen Nostr-Relays veröffentlicht.",
+  "reviews.dialog.gate.title": "Melden Sie sich an, um eine Bewertung zu schreiben",
+  "reviews.dialog.gate.lead": "Bewertungen werden mit Ihrem Nostr-Schlüssel signiert. Er bleibt in Ihrem Signierer, diese Website sieht ihn nie.",
+  "reviews.dialog.ratingLegend": "Ihre Bewertung",
+  "reviews.dialog.starsSr.one": "{n}-Star",
+  "reviews.dialog.starsSr.other": "{n}-Stars",
+  "reviews.dialog.chooseRating": "Wählen Sie eine Bewertung aus",
+  "reviews.dialog.starLabel": "{n}: {phrase}",
+  "reviews.dialog.stars.1": "das vermeiden",
+  "reviews.dialog.stars.2": "hatte Probleme",
+  "reviews.dialog.stars.3": "hat funktioniert, allerdings mit Einschränkungen",
+  "reviews.dialog.stars.4": "gut",
+  "reviews.dialog.stars.5": "funktioniert super",
+  "reviews.dialog.bodyLabel": "Was sollten andere Menschen wissen?",
+  "reviews.dialog.charCount": "{n} / {max}",
+  "reviews.dialog.submit": "Unterzeichnen und veröffentlichen",
+  "reviews.dialog.signing": "Unterzeichnung…",
+  "reviews.dialog.publishing": "Veröffentlichung…",
+  "reviews.dialog.publishingTo": "Veröffentlichung auf Relays ({accepted}/{total})",
+  "reviews.dialog.waitingExtension": "Wir warten auf Ihre Verlängerung",
+  "reviews.dialog.waitingSigner": "Warten auf Ihren Unterzeichner",
+  "reviews.dialog.confirmClose": "Diese Bewertung schließen? Ihr Entwurf wird gespeichert, bis Sie die Website verlassen.",
+  "reviews.dialog.why.login": "Anmelden, um zu veröffentlichen",
+  "reviews.dialog.why.words": "Schreib ein paar Worte",
+  "reviews.dialog.why.more.one": "{n}t ein noch charakterstärkerer Charakter",
+  "reviews.dialog.why.more.other": "{n} weitere Zeichen",
+  "reviews.dialog.why.over.one": "{n}-Zeichen überschreiten den Grenzwert",
+  "reviews.dialog.why.over.other": "{n}-Zeichen überschreiten das Limit",
+  "reviews.dialog.identity.needSigner": "Zum Veröffentlichen benötigen Sie einen Nostr-Signierer. Ihr Schlüssel verbleibt darin; diese Website hat keinen Zugriff darauf.",
+  "reviews.dialog.identity.loginToPublish": "Anmelden, um zu veröffentlichen",
+  "reviews.dialog.identity.switch": "Umschalter",
+  "reviews.dialog.identity.extension": "Anmeldung über Ihre Browser-Erweiterung",
+  "reviews.dialog.identity.readingKey": "Deinen öffentlichen Schlüssel wird geladen…",
+  "reviews.dialog.identity.willAsk": "Ihre Erweiterung wird aufgefordert, eine Signatur zu erstellen",
+  "reviews.dialog.error.noRelay": "Kein Relais hat die Überprüfung akzeptiert. Überprüfen Sie Ihre Verbindung und versuchen Sie es erneut.",
+  "reviews.validate.rating": "Wählen Sie eine Bewertung von 1 bis 5 Sternen aus.",
+  "reviews.validate.short": "Schreibe mindestens {n} Zeichen, damit die Bewertung hilfreich ist.",
+  "reviews.validate.long": "Rezensionen sind auf {n} Zeichen begrenzt.",
+  "feed.title": "Aktuelle Bewertungen zu Mints und Föderationen · Cashumints.space",
+  "feed.description": "Jede Bewertung von Mints, Föderationen und LNURL-Mints, sobald sie veröffentlicht wird: {reviews} Bewertungen zu {mints} Cashu-Mints, {federations} Fedimint-Föderationen und {lnurl} LNURL-Mints, auf Nostr signiert und hier neueste zuerst lesbar. Filtere nach Ökosystem, Note oder Name.",
+  "feed.heading": "Neueste Bewertungen",
+  "feed.lede": "Jede Bewertung zu jedem Cashu-Mint und jeder Fedimint-Föderation, neueste zuerst, live von den Nostr-Relays gelesen. Jede ist von ihrem Autor signiert und liegt auf den Relays, nicht in unserer Datenbank.",
+  "feed.label": "Rezensionen",
+  "feed.showingBuild.one": "Anzeige der aktuellsten Überprüfung aus dem letzten Build",
+  "feed.showingBuild.other": "Anzeige der neuesten Bewertungen für „{n}“ aus dem letzten Build",
+  "feed.noscript": "Die Bewertungen sind auf Nostr signiert und werden in Ihrem Browser geladen, daher sind für die Filterfunktion und die vollständige Liste JavaScript erforderlich. Die unten aufgeführten Bewertungen zu „{n}“ wurden beim Erstellen dieser Seite aus den Relays ausgelesen.",
+  "feed.emptyBuild": "Zum Zeitpunkt der Erstellung dieser Seite konnten keine Rückmeldungen von den Relais ausgelesen werden. Die Liste wird in Ihrem Browser automatisch mit den Daten der Relais aktualisiert.",
+  "feed.foot": "Bewertungen sind Meinungen der Community, keine geprüften Angaben. Lies den {link}, bevor du einem Mint dein Geld anvertraust.",
+  "feed.footLink": "Haftungsausschluss",
+  "feed.showing": "{shown} von {total} Bewertungen werden angezeigt",
+  "feed.showingMatching": "{shown} von {matching} passenden Bewertungen werden angezeigt (insgesamt {total})",
+  "feed.emptyRelays": "Von den Relays wurden keine Bewertungen zurückgemeldet. Öffne eine beliebige Mint-Seite, um dort Bewertungen zu lesen und zu schreiben.",
+  "feed.emptyFilter": "Keine Bewertungen passen zu diesem Filter. Leere das Mint-Feld oder probier Alle.",
+  "feed.relayError": "Die Relais konnten nicht erreicht werden. Es werden die Bewertungen aus dem letzten Build angezeigt.",
+  "feed.relayEmpty": "Von den Relais wurden keine Rückmeldungen erhalten. Es werden die Rückmeldungen aus dem letzten Build angezeigt.",
+  "feed.reading": "Die Relais ablesen…",
+  "login.open": "Anmelden",
+  "login.title": "Mit Nostr anmelden",
+  "login.note": "Ihr Schlüssel verbleibt in Ihrem Signaturprogramm. Diese Website hat niemals Zugriff darauf.",
+  "login.extension.name": "Browser-Erweiterung",
+  "login.extension.desc": "Vertragsunterzeichnung mit Alby, nos2x oder einer anderen NIP-07-Verlängerung",
+  "login.extension.none": "Es wurde keine Erweiterung gefunden",
+  "login.extension.getOne": "Hol dir eins:",
+  "login.remote.name": "Fernunterzeichner",
+  "login.remote.desc": "Scannen Sie einen Code mit einer Signatur-App oder fügen Sie einen Bunker-Link ein",
+  "login.primal.name": "Ursprünglich",
+  "login.primal.desc": "Bestätigen Sie die Anmeldung in der Primal-App auf Ihrem Smartphone",
+  "login.paste.label": "Oder fügen Sie den Verbindungslink ein, den Sie von Ihrem Unterzeichner erhalten haben",
+  "login.copyLink": "Kopiere den Verbindungslink",
+  "login.whatIsNostr": "Was ist Nostr?",
+  "login.connect.remote.title": "Einen Remote-Unterzeichner verbinden",
+  "login.connect.remote.lead": "Scannen Sie diesen Link mit Ihrer Signatur-App oder kopieren Sie ihn und fügen Sie ihn dort ein.",
+  "login.connect.remote.hint": "Funktioniert mit jedem NIP-46-Signaturprogramm: nsec.app, Amber, Nostrify, Ihrem eigenen Bunker.",
+  "login.connect.remote.open": "In Ihrer Signatur-App öffnen",
+  "login.connect.primal.title": "Mit Primal in Kontakt treten",
+  "login.connect.primal.lead": "Öffnen Sie „Primal“ auf Ihrem Smartphone, suchen Sie in den Einstellungen den Punkt „Fernanmeldung“ und scannen Sie diesen Code.",
+  "login.connect.primal.hint": "Primal signiert für andere Apps gemäß NIP-46, es handelt sich also um dieselbe Verbindung, die jeder Signierer nutzt, und Ihr Schlüssel verbleibt bei Primal. {link}",
+  "login.connect.primal.open": "In Primal öffnen",
+  "login.status.buildingLink": "Eine Verbindung herstellen",
+  "login.status.waitingExtension": "Wir warten auf Ihre Verlängerung",
+  "login.status.waitingSigner": "Warten auf Ihren Unterzeichner",
+  "login.status.connecting": "Verbindung zum Unterzeichner herstellen",
+  "login.status.connected": "Verbunden",
+  "login.toast.loggedIn": "Angemeldet",
+  "login.toast.fetchingProfile": "Dein Nostr-Profil wird von den Relays geladen…",
+  "login.toast.profile": "Profil: {name}",
+  "login.toast.noProfile": "Kein Profil auf den Relays gefunden",
+  "login.method.extension": "Erweiterung",
+  "login.method.remote": "Fernbedienung",
+  "login.method.primal": "Ursprünglich",
+  "login.account": "Ihr Nostr-Konto",
+  "login.copyNpub": "Kopiere deine vollständige npub-Nummer",
+  "login.logout": "Abmelden",
+  "signer.status.waitingExtension": "Wir warten auf Ihre Verlängerung",
+  "signer.status.signed": "Unterzeichnet",
+  "signer.status.reconnecting": "Erneut eine Verbindung zu Ihrem Unterzeichner herstellen",
+  "signer.status.approveWindow": "Der Unterzeichner benötigt Ihre Zustimmung in einem separaten Fenster.",
+  "signer.status.waitingSigner": "Warten auf Ihren Unterzeichner",
+  "signer.status.stillWaiting": "Ich warte immer noch auf die Antwort Ihres Unterzeichners",
+  "signer.status.connected": "Verbunden",
+  "signer.error.noExtension": "Es wurde keine Signaturerweiterung gefunden. Installieren Sie Alby oder nos2x und laden Sie diese Seite anschließend neu.",
+  "signer.error.privateKey": "Das sieht nach einem privaten Schlüssel aus, nicht nach einem Verbindungslink. Diese Website verlangt niemals einen Schlüssel. Fügen Sie den Link „bunker://“ ein, den Sie von Ihrem Signierer erhalten haben.",
+  "signer.error.badLink": "Das ist kein Link, den diese Website versteht. Fügen Sie den Link „bunker://“ aus Ihrem Signaturprogramm ein.",
+  "signer.error.noAnswer": "Ihr Signierer hat nicht geantwortet. Möglicherweise ist die Verbindung geschlossen oder der Relay-Server ist ausgefallen. Öffnen Sie die Verbindung und versuchen Sie es erneut.",
+  "signer.error.timeout": "Ihr Signaturgerät hat nicht rechtzeitig reagiert. Öffnen Sie es, überprüfen Sie, ob es noch angeschlossen ist, und versuchen Sie es dann erneut.",
+  "signer.error.cancelled": "Verbindung abgebrochen.",
+  "signer.error.declined": "Die Signaturanforderung wurde abgelehnt",
+  "notfound.title": "Seite nicht gefunden · Cashumints.space",
+  "notfound.description": "Diese Seite existiert auf Cashumints.space nicht.",
+  "notfound.heading": "Diese Seite existiert nicht",
+  "notfound.lede": "Möglicherweise wurde sie verschoben, oder die Mint ist noch nicht indexiert. Suchen Sie nach einer Mint anhand des Namens oder der Domain, oder fügen Sie die URL der Mint ein.",
+  "notfound.browse": "Alle Mints ansehen",
+  "notfound.home": "Geh nach Hause",
+  "notfound.loading": "{host} wird geladen",
+  "notfound.fb.rating": "Bewertung",
+  "notfound.fb.reviews": "Rezensionen",
+  "notfound.fb.software": "Software",
+  "notfound.fb.lastOnline": "Zuletzt online",
+  "notfound.fb.note": "Dieser Mint wurde nach dem letzten Build der Seite indexiert. Das hier ist eine Zusammenfassung aus der Live-API, mit den Reviews darunter. Die vollständige Seite erscheint beim nächsten Build.",
+  "notfound.resolve.checking": "Erster Besuch: dieser Mint wird gerade geprüft.",
+  "notfound.resolve.failed": "Dieser Mint konnte nicht aufgenommen werden",
+  "notfound.resolve.failedFedimint": "Diese Föderation konnte nicht aufgenommen werden",
+  "notfound.resolve.retry": "Andere Adresse versuchen",
+  "notfound.resolve.switch": "Als {kind} Mint öffnen",
+  "notfound.resolve.fedimint": "Die Seitenadresse einer Föderation enthält ihren Invite Code nicht, deshalb lässt sich diese nicht allein über den Link finden. Füg den Invite Code ein, dann wird sie aufgenommen.",
+  "notfound.resolve.ambiguous": "Diese Adresse lässt sich nicht allein aus dem Link ableiten. Füg die vollständige URL des Mint ein, dann wird er aufgenommen.",
+  "wallets.title": "Cashu-Wallets · Cashumints.space",
+  "wallets.description": "Cashu-Wallets, die mit den hier aufgeführten Mints kompatibel sind – auf Mobilgeräten, im Web, im Browser und über die Befehlszeile –, wobei jedes seine jeweiligen Stärken hat.",
+  "wallets.heading": "Geldbörsen",
+  "wallets.lede": "Du brauchst eine Wallet, um ecash von einem dieser Mints zu halten. Die meisten Wallets sprechen mit mehreren Mints gleichzeitig, du bist also nicht an das erste gebunden, das du ausprobierst.",
+  "wallets.note": "Diese Liste erhebt keinen Anspruch auf Vollständigkeit und stellt keine Empfehlung dar. Das Cashu-Projekt führt unter {link} ein umfassenderes Verzeichnis. Eine Wallet verwahrt die Schlüssel, eine Mint verwahrt das Geld: Lies dir die Bewertungen der Mints durch, bevor du dich entscheidest, wo deine Sats aufbewahrt werden sollen.",
+  "wallets.platform.android": "Android",
+  "wallets.platform.ios": "iOS",
+  "wallets.platform.web": "Web",
+  "wallets.platform.extension": "Browser-Erweiterung",
+  "wallets.platform.cli": "CLI",
+  "wallets.platform.python": "Python",
+  "wallets.item.minibits": "Mobile ecash-Wallet mit eigenem Mint, Unterstützung für Lightning-Adressen und Nostr-Kontakten.",
+  "wallets.item.nutstash": "Browser-Wallet, das mehrere Mints gleichzeitig verwaltet und Raw-Token importiert und exportiert.",
+  "wallets.item.enuts": "Mobile Wallet mit Fokus auf Guthaben bei mehreren Mints und dem Versenden von ecash über Nostr.",
+  "wallets.item.cashume": "Referenz-Web-Wallet aus dem Cashu-Projekt. Läuft vollständig im Browser und kann als PWA installiert werden.",
+  "wallets.item.boardwalk": "Web-Wallet rund um Lightning-Adressen und das Versenden von ecash per Link.",
+  "wallets.item.coinos": "Lightning-Wallet und Kassensystem, das zudem über eine eigene Cashu-Mint verfügt.",
+  "wallets.item.oxchat": "Nostr Messenger mit integrierter eCash-Geldbörse zum Versenden von Sats in Chats.",
+  "wallets.item.nutshell": "Die Referenzimplementierung. Läuft als Wallet über die Befehlszeile und als Mint-Software.",
+  "about.title": "Über Cashumints.space",
+  "about.description": "Was Cashu ist, was eine „Mint“ eigentlich darstellt, was NIP-87 ist und wie diese Website „Mints“ indexiert und Bewertungen von Nostr-Relays ausliest.",
+  "about.heading": "Über",
+  "about.lede": "Cashumints.space listet alle Cashu-Mints auf, die wir im Nostr-Netzwerk finden können, und zeigt Ihnen, was andere darüber sagen. Die Seite wurde von Azzamo erstellt.",
+  "about.cashu.title": "Was ist Cashu?",
+  "about.cashu.p1": "Cashu ist ein ecash-Protokoll für Bitcoin. Ein Mint gibt blinde Token aus, die durch die von ihm gehaltenen Sats gedeckt sind, und diese Token wandern zwischen Menschen, ohne dass das Mint erfährt, wer wem was geschickt hat. Die Privatsphäre ist echt und sie ist der Punkt: Token sind keine Konten, und das Mint kann den Token, den es signiert hat, nicht mit dem Token verknüpfen, der zurückkommt.",
+  "about.cashu.p2": "Das Protokoll und die dazugehörigen Spezifikationen können Sie unter {link} einsehen. Die Spezifikationen selbst werden als „NUTs“ bezeichnet – daher stammen auch die NUT-Nummern auf jeder Mint-Seite.",
+  "about.mints.title": "Was eine „Mint“ ist und welche Vor- und Nachteile sie mit sich bringt",
+  "about.mints.p1": "Ein Mint ist treuhänderisch. Wenn du ecash mintest, gibst du Sats an denjenigen, der diesen Server betreibt, und vertraust darauf, dass er die Token einlöst, wenn du sie wieder meltest. Es gibt keinen Betrugsbeweis, keine Treuhand und keinen Rechtsweg. Ein Mint-Betreiber kann mit dem Guthaben verschwinden, und Mints haben das getan.",
+  "about.mints.p2": "Genau deshalb gibt es hier Bewertungen. Diese Website sagt dir nie, dass ein Mint sicher ist. Der Status auf einer Mint-Seite sagt {code}, nicht „vertrauenswürdig“, und er heißt nur, dass der Server geantwortet hat, als wir zuletzt gefragt haben. Behandle ecash-Guthaben wie Bargeld in der Manteltasche: gut zum Ausgeben, falsch zum Sparen.",
+  "about.nip87.title": "Was ist NIP-87?",
+  "about.nip87.p1": "NIP-87 ist die Nostr-Konvention, um ecash-Mints anzukündigen und zu empfehlen. Zwei Event-Arten sind hier wichtig:",
+  "about.nip87.li1": "{code} kündigt eine neue „Mint“ an. Die URL der „Mint“ befindet sich im Tag „{tag}“. Auf diese Weise erkennt die Website neue „Mints“, die ihr bisher noch nicht bekannt waren.",
+  "about.nip87.li2": "„{code}“ ist eine Bewertung. Sie enthält die Bewertung und den Bewertungstext und verweist mit einem „{utag}“-Tag (der Mint-URL) und einem „{dtag}“-Tag (dem öffentlichen Schlüssel der Mint) auf die betreffende Mint.",
+  "about.nip87.p2": "Jede Bewertung ist mit dem Nostr-Schlüssel ihres Autors signiert. Wir nennen eine Bewertung nie „verifiziert“, denn niemand hat sie verifiziert: sie ist signiert, was eine andere und nützlichere Aussage ist. Das heißt, du kannst prüfen, wer sie geschrieben hat und dass sie nicht verändert wurde. Es heißt nicht, dass der Autor ehrlich ist oder das Mint je genutzt hat.",
+  "about.how.title": "So funktioniert diese Website",
+  "about.how.p1": "Es gibt zwei Schleifen und eine Regel. Die Regel lautet: dem Mint gehören seine Metadaten und Nostr gehören die Bewertungen, also speichert diese Website beides nicht als maßgebliche Quelle.",
+  "about.how.li1": "{strong} fragt alle bekannten Mint-Server alle zehn Minuten nach „{code}“ ab und protokolliert die Antwort: Name, Beschreibung, Version, unterstützte NUTs, Einschränkungen, Kontaktdaten. Außerdem wird erfasst, ob der Mint-Server überhaupt geantwortet hat – daher stammt auch der Begriff „Verfügbarkeit“.",
+  "about.how.li1Label": "Die Messschleife",
+  "about.how.li2": "{strong} stellt stündlich eine Verbindung zu den Nostr-Relays her, liest Ankündigungen und Bewertungen zu den Mints und fügt alle Mints hinzu, die es zuvor noch nicht gesehen hat.",
+  "about.how.li2Label": "Der Entdeckungskreislauf",
+  "about.how.p2": "Entscheidend ist, was passiert, wenn ein Mint nicht mehr antwortet. Seine zwischengespeicherten Metadaten werden von einer fehlgeschlagenen Abfrage nie überschrieben, also behält ein totes Mint seine vollständige Seite: seine Daten, seine Historie und seine Bewertungen, mit einem Banner, das sagt, wann es verstummt ist. Die vorherige Version dieser Website zeigte stattdessen eine Fehlerseite, was hieß, dass genau die Mints, vor denen sich Leute am dringendsten warnen mussten, nicht bewertet werden konnten. Das war der Hauptgrund für den Neubau.",
+  "about.how.p3": "Bewertungstexte werden bei uns niemals gespeichert. Wenn Sie eine Mint-Seite öffnen, kommuniziert Ihr Browser direkt mit den Relays und liest die Bewertungen selbst aus; wenn Sie eine Bewertung verfassen, wird diese von Ihrer eigenen Nostr-Erweiterung signiert und direkt an diese Relays gesendet. Wir führen lediglich eine Zählung, damit die Seiten bewertet und sortiert werden können – mehr nicht. Nichts davon kann von uns bearbeitet oder gelöscht werden, auch keine Bewertungen, die wir lieber nicht hätten.",
+  "about.relays.title": "Relais, die wir gelesen haben",
+  "about.relays.p1": "Dies sind die Relays, die sowohl der Indexer als auch Ihr Browser verwenden:",
+  "about.relays.p2": "Richten Sie einen beliebigen Nostr-Client auf dieselben Relays aus, und Sie werden dieselben Ereignisse sehen. Das ist das ganze Versprechen: Nichts hier gilt nur deshalb als wahr, weil wir es so sagen.",
+  "about.nuts.title": "Was sind NUTs?",
+  "about.nuts.p1": "NUTs sind die nummerierten Cashu-Spezifikationen, ähnlich wie die BIPs bei Bitcoin. Eine Mint gibt an, welche davon sie implementiert, und daran lässt sich erkennen, was sie tatsächlich leisten kann: NUT-04 und NUT-05 ermöglichen das Prägen und Einlösen über Lightning (ohne sie ist eine Mint kaum von Nutzen), NUT-07 ermöglicht es einer Wallet, zu überprüfen, ob ein Token bereits ausgegeben wurde, NUT-17 liefert Wallets Live-Updates über WebSockets anstelle von Polling, und NUT-20 ermöglicht es einer Wallet, nachzuweisen, dass ein Mint-Angebot tatsächlich an sie ausgestellt wurde. Die vollständige Liste finden Sie unter {link}.",
+  "about.numbers.title": "Im Moment",
+  "about.numbers.p1": "{mints}-Mints indiziert, {online} davon antworten, {reviews} Bewertungen, gezählt anhand der oben genannten Relays.",
+  "about.source.title": "Quelle und Bildnachweis",
+  "about.source.p1": "Die Website ist als Open-Source-Projekt unter {github} verfügbar. Sie wird von {azzamo} erstellt und betrieben. Sollte auf einer Mint-Seite ein Fehler vorliegen, korrigieren Sie diesen bitte direkt an der Quelle: Die Metadaten der Mints stammen von der jeweiligen Mint-eigenen Seite unter {code}, und die Bewertungen stammen von Nostr.",
+  "terms.title": "Nutzungsbedingungen · Cashumints.space",
+  "terms.description": "Nutzungsbedingungen für Cashumints.space: was die Website ist, was sie nicht tut und wer wofür verantwortlich ist. Keine Konten, keine Gewährleistung, keine Verbindung zu irgendeinem Mint.",
+  "terms.heading": "Nutzungsbedingungen",
+  "terms.lede": "Einfach ausgedrückt: Eine Website, die ausschließlich öffentliche Daten indexiert. Zuletzt aktualisiert am {date}.",
+  "terms.what.title": "Was diese Website ist",
+  "terms.what.p1": "Cashumints.space ist ein Verzeichnis öffentlich zugänglicher Daten zu Cashu-Mints. Es gibt zwei Arten von Daten, die beide aus anderen Quellen stammen:",
+  "terms.what.li1": "Metadaten der Mint, die vom jeweiligen Endpunkt „{code}“ der jeweiligen Mint abgerufen werden: Name, Beschreibung, Softwareversion, unterstützte NUTs, Kontaktdaten und die Angabe, ob die Mint bei unserer letzten Anfrage geantwortet hat.",
+  "terms.what.li2": "Bewertungen, die von öffentlichen Nostr-Relays abgerufen werden. Dabei handelt es sich um NIP-87-Ereignisse, die von ihren Autoren auf Relays veröffentlicht wurden, die jeder abfragen kann.",
+  "terms.what.p2": "Wir erfassen diese Daten, normalisieren sie, ordnen sie nach Relevanz und stellen sie dar. Wir erstellen sie nicht selbst.",
+  "terms.noAccounts.title": "Keine Angaben, keine Gewährleistungen",
+  "terms.noAccounts.p1": "Es ist keine Registrierung erforderlich. Die Website wird ohne Mängelgewähr und ohne jegliche Gewährleistung bereitgestellt: weder für die Richtigkeit der Daten, noch für deren Aktualität, noch für die Verfügbarkeit der Website. Die Daten zu den Mints können Minuten oder Stunden alt sein, ein Mint kann sich seit unserer letzten Überprüfung geändert haben, und ein Relay kann möglicherweise nicht antworten – in diesem Fall werden Ihnen weniger Daten angezeigt, als tatsächlich vorhanden sind.",
+  "terms.noAccounts.p2": "Die Nutzung erfolgt auf eigene Gefahr. Wir übernehmen keine Haftung für Verluste, die sich aus der Nutzung dieser Website oder dem Vertrauen auf hier veröffentlichte Informationen ergeben. Die spezifischen Risiken bei der Nutzung einer Cashu-Mint finden Sie unter {link}.",
+  "terms.noAccounts.link": "Haftungsausschluss",
+  "terms.noCustody.title": "Wir verwahren Ihr Geld nicht",
+  "terms.noCustody.p1": "Diese Website nimmt nie Gelder in Verwahrung. Sie hat keine Wallet, sie fasst kein ecash an, und sie kann nichts bewegen, einfrieren oder wiederherstellen. Wenn du ein Problem mit einem Mint hast, ist der Mint-Betreiber der Einzige, der dir helfen kann, und wir können ihn nicht für dich kontaktieren.",
+  "terms.noCustody.p2": "Wir stehen mit keinem hier gelisteten Mint in Verbindung, und kein Mint bezahlt für seinen Eintrag, seinen Rang oder seine Bewertung. Mints werden aus öffentlichen Nostr-Ankündigungen gefunden und von einem Algorithmus über öffentliche Bewertungsdaten eingeordnet.",
+  "terms.reviews.title": "Rezensionen sind die Worte anderer Menschen",
+  "terms.reviews.p1": "Bewertungen sind nutzergenerierte Inhalte, die von ihren Autoren auf öffentlichen Nostr-Relays veröffentlicht werden. Wir zeigen sie an, haben jedoch keinen Einfluss darauf. Wir haben sie nicht verfasst, können sie nicht bearbeiten und auch nicht von den Relays löschen, auf denen sie gespeichert sind: Es handelt sich um signierte Ereignisse in einem Netzwerk, das uns nicht gehört.",
+  "terms.reviews.p2": "Eine Bewertung gibt die Erfahrungen einer einzelnen Person wieder und stellt keine nachgewiesene Tatsache dar. Wenn Sie eine Bewertung veröffentlichen, sind Sie für deren Inhalt verantwortlich. Veröffentlichen Sie keine rechtswidrigen Inhalte und beachten Sie, dass Ihre Veröffentlichung öffentlich und dauerhaft ist (siehe „{link}“).",
+  "terms.reviews.link": "Datenschutzerklärung",
+  "terms.reviews.p3": "Wir können die Anzeige einer bestimmten Bewertung auf dieser Website unterbinden und werden dies bei rechtswidrigen Inhalten auch tun. Dadurch wird die Bewertung lediglich von diesen Seiten entfernt. Der Eintrag bleibt jedoch auf den Relays erhalten, sodass jeder andere Nostr-Client ihn weiterhin lesen kann.",
+  "terms.links.title": "Links zu anderen Websites",
+  "terms.links.p1": "Mint-URLs, Wallet-Links, Kontaktdaten von Betreibern und alles andere, was von dieser Website wegführt, sind dort aufgeführt, weil sie Teil der Daten sind. Ein Link stellt keine Empfehlung dar, und wir überprüfen nicht, was sich hinter dem Link verbirgt.",
+  "terms.changes.title": "Änderungen",
+  "terms.changes.p1": "Diese Bedingungen können sich ändern. Das Datum oben gibt an, wann sie zuletzt geändert wurden. Da es sich um eine Open-Source-Website handelt, ist jede Änderung an dieser Seite im Commit-Verlauf nachverfolgbar.",
+  "terms.contact.title": "Kontakt",
+  "terms.contact.p1": "Probleme und Anträge auf Entfernung von Inhalten reichen Sie am besten unter {github} ein. Die Website wird von {azzamo} betrieben.",
+  "privacy.title": "Datenschutz · Cashumints.space",
+  "privacy.description": "Datenschutz auf Cashumints.space: keine Konten, keine Tracking-Cookies, keine Analysen. „localStorage“ wird zum Zwischenspeichern von Profilen verwendet, und es werden keinerlei Daten an Dritte übermittelt. Bewertungen werden in Ihrem eigenen Browser signiert.",
+  "privacy.heading": "Datenschutz",
+  "privacy.lede": "Wir erheben so wenige Daten wie möglich. Zuletzt aktualisiert am {date}.",
+  "privacy.noAccounts.title": "Keine Konten",
+  "privacy.noAccounts.p1": "Es gibt keine Registrierung, keine Anmeldung und kein Profil. Auf dieser Website werden Sie nirgendwo nach Ihrer Identität gefragt, und es gibt keine Nutzerdaten, die offengelegt werden könnten, da es keine Nutzer gibt.",
+  "privacy.noTracking.title": "Keine Tracking-Cookies, keine Analysen",
+  "privacy.noTracking.p1": "Die Website setzt keine Cookies zum Tracking ein. Es gibt kein Analyseskript, keinen Tag-Manager, kein Pixel, keine Sitzungsaufzeichnung und kein Werbenetzwerk. Nichts auf dieser Seite übermittelt Ihr Verhalten an uns oder an Dritte.",
+  "privacy.logs.title": "Serverprotokolle",
+  "privacy.logs.p1": "Der Webserver führt standardmäßige Zugriffsprotokolle, wie es bei jedem Webserver standardmäßig der Fall ist. In einer Protokolleintragung werden Ihre IP-Adresse, die Uhrzeit, die von Ihnen angeforderte Seite, der Antwortstatus sowie der User-Agent und der Referrer, die Ihr Browser übermittelt hat, erfasst. Die Protokolle dienen dazu, Fehler zu beheben und Missbrauch aufzudecken. Sie werden nicht mit anderen Daten verknüpft und weder verkauft noch weitergegeben.",
+  "privacy.logs.operatorLabel": "Anmerkung des Bedieners:",
+  "privacy.logs.operator": "Wenn Sie diese Website betreiben, geben Sie hier die tatsächliche Aufbewahrungsdauer an. Die in der README-Datei beschriebene Konfiguration verwendet Nginx mit dem Standard-Zugriffsprotokoll und der von Ihrer Distribution vorgegebenen Rotation (unter Debian und Ubuntu ist dies „logrotate“, täglich, wobei die Protokolle 14 Tage lang aufbewahrt werden). Überprüfen Sie, wie Ihr Server konfiguriert ist, und ersetzen Sie diesen Absatz durch die entsprechende Zahl.",
+  "privacy.storage.title": "Was wird in Ihrem Browser gespeichert?",
+  "privacy.storage.p1": "Die Website nutzt localStorage für genau zwei Dinge, die beide auf Ihrem Gerät verbleiben und niemals an Dritte weitergeleitet werden:",
+  "privacy.storage.li1": "Ein Cache mit Nostr-Profil-Metadaten (Ereignisse vom Typ 0: Namen, Avatare, NIP-05-Adressen) für die Rezensenten, deren Rezensionen Sie sich angesehen haben. Dadurch wird vermieden, dass auf jeder Seite erneut Abfragen an die Relays gesendet werden müssen. Die Einträge verfallen, und der Cache ist begrenzt; die ältesten Einträge werden zuerst gelöscht.",
+  "privacy.storage.li2": "Einstellungen für die Benutzeroberfläche, damit sich die Website beim nächsten Mal genauso verhält.",
+  "privacy.storage.p2": "Wenn Sie die Website-Daten Ihres Browsers löschen, werden beide entfernt. Es entsteht kein Problem, die Profilabfragen werden einfach erneut ausgeführt.",
+  "privacy.thirdParties.title": "Mit wem kommuniziert Ihr Browser?",
+  "privacy.thirdParties.p1": "Beim Laden einer Seite stellt Ihr Browser neben dieser Website noch Verbindungen zu einigen anderen Orten her. Auf diese Weise kann eine Website ohne serverseitiges Tracking dennoch Live-Daten abrufen:",
+  "privacy.thirdParties.li1Label": "Öffentliche Nostr-Relais",
+  "privacy.thirdParties.li1": "{strong} über WebSocket, um Rezensionen und Profile von Rezensenten abzurufen. Das Relay erkennt Ihre IP-Adresse und Ihre Anfrage, wie es bei jedem Server der Fall ist, mit dem Sie eine Verbindung herstellen. Die Relays sind auf der Seite „{link}“ aufgelistet.",
+  "privacy.thirdParties.li1Link": "Über uns",
+  "privacy.thirdParties.li2Label": "Avatar-Bilder der Rezensenten",
+  "privacy.thirdParties.li2": "{strong}, geladen von der Adresse, auf die das Profil des Rezensenten verweist. Diese werden ohne Referrer gesendet, sodass der Host nicht erfahren kann, auf welcher Seite Sie sich zuvor befanden.",
+  "privacy.publishing.title": "Eine Rezension veröffentlichen",
+  "privacy.publishing.p1": "Das Verfassen einer Bewertung erfolgt in Ihrem Browser, nicht auf unserem Server. Der Vorgang wird von Ihrer NIP-07-Erweiterung (Alby, nos2x oder ähnlich) signiert und von Ihrem Browser direkt an die Relays gesendet. Ihr privater Schlüssel verlässt die Erweiterung zu keinem Zeitpunkt, und diese Website erhält niemals Einblick in ihn. Wir entwickeln keine eigene Schlüsselverwaltung und fragen niemals nach einem Schlüssel oder einer Seed-Phrase.",
+  "privacy.permanent.title": "Alles, was du auf Nostr veröffentlichst, ist öffentlich und dauerhaft",
+  "privacy.permanent.p1": "Das ist der Teil, den man sich zweimal durchlesen sollte. Eine Rezension ist ein signiertes Ereignis auf öffentlichen Relays. Ist sie erst einmal veröffentlicht, ist sie veröffentlicht:",
+  "privacy.permanent.li1": "Jeder kann es lesen, jetzt und später, mit jedem beliebigen Nostr-Client. Es ist nicht „öffentlich auf Cashumints.space“, sondern im Netzwerk öffentlich.",
+  "privacy.permanent.li2": "Es ist dauerhaft mit Ihrem öffentlichen Nostr-Schlüssel verknüpft, ebenso wie alles andere, was dieser Schlüssel jemals veröffentlicht hat.",
+  "privacy.permanent.li3": "Das Löschen ist eine Anfrage, kein Befehl. Sie können ein Löschereignis veröffentlichen, und einige Relays werden diesem nachkommen, aber es steht einem Relay frei, es zu ignorieren, und jeder, der das Ereignis bereits kopiert hat, verfügt weiterhin darüber. Behandeln Sie eine veröffentlichte Bewertung als dauerhaft.",
+  "privacy.permanent.li4": "Wir können es nicht für Sie löschen. Wir können jedoch verhindern, dass es hier angezeigt wird; das ändert jedoch nichts an den Relais.",
+  "privacy.permanent.p2": "Wenn du ein Mint bewerten willst, ohne dass das an deine Hauptidentität gebunden ist, nimm einen separaten Nostr-Schlüssel. Beachte, dass ein Schlüssel ohne weitere Aktivität bei harten Bewertungen als solcher gekennzeichnet wird, denn ein brandneuer Schlüssel, der eine Ein-Stern-Bewertung schreibt, ist ein Muster, das Leser sehen dürfen.",
+  "privacy.contact.title": "Fragen",
+  "privacy.contact.p1": "Die Website ist Open Source: Wenn Sie einen der oben genannten Punkte überprüfen möchten, können Sie den Quellcode unter {github} einsehen. Fragen und Korrekturen können dort als „Issue“ eingereicht werden.",
+  "disclaimer.title": "Haftungsausschluss · Cashumints.space",
+  "disclaimer.description": "Was Sie vor der Nutzung einer Cashu-Mint wissen sollten: Mints sind Verwahrdienste; eine Mint kann mit Ihrem Geld verschwinden; Bewertungen sind Meinungen, und „online“ bedeutet lediglich „erreichbar“, nicht „vertrauenswürdig“.",
+  "disclaimer.heading": "Haftungsausschluss",
+  "disclaimer.lede": "Lies das, bevor du Geld in ein Mint gibst. Zuletzt aktualisiert am {date}.",
+  "disclaimer.callout": "Ein Cashu-Mint verwahrt dein Geld für dich. Wenn es verschwindet, ist dein ecash weg, und es gibt niemanden, an den du dich wenden kannst. Halte dort nur, was du dir leisten kannst zu verlieren.",
+  "disclaimer.custodial.title": "Mints sind treuhänderisch",
+  "disclaimer.custodial.p1": "Wenn du ecash mintest, gibst du Bitcoin an den Mint-Betreiber und bekommst Token zurück. Diese Token sind ein Anspruch gegen diesen Betreiber. Sie sind kein Bitcoin, das du hältst, und der Betreiber entscheidet, ob er sie einlöst.",
+  "disclaimer.custodial.p2": "Das bedeutet, dass jede Mint dieselben Risiken birgt: Der Betreiber kann verschwinden, zur Einstellung des Betriebs gezwungen werden, die Gelder durch einen Fehler oder einen Hackerangriff verlieren oder den Server einfach abschalten. Es gibt keine Einlagensicherung, keine Rückbuchungen, keinen Kundendienst und keine Rechtsmittel, auf die man sich verlassen könnte. Das gilt sogar für die bestbewertete Mint auf dieser Website.",
+  "disclaimer.custodial.p3": "Cashu ist für schnelle Transaktionen mit kleinen Beträgen konzipiert. Nutzen Sie es entsprechend: Bewahren Sie darin nur das Geld auf, das Sie bald ausgeben möchten, nicht Ihre Ersparnisse, und verteilen Sie es auf verschiedene Mints, anstatt alles in einem zu parken.",
+  "disclaimer.reviews.title": "Bewertungen sind Meinungen, keine überprüften Behauptungen",
+  "disclaimer.reviews.p1": "Jede Bewertung hier wurde von jemandem auf Nostr geschrieben und mit dessen Schlüssel signiert. Signiert heißt, wir können dir sagen, welcher Schlüssel sie geschrieben hat. Es heißt nicht, dass die Bewertung wahr ist, dass der Autor das Mint genutzt hat, oder dass der Autor nicht der Betreiber, ein Konkurrent oder eine Person mit zehn Schlüsseln ist.",
+  "disclaimer.reviews.p2": "Wir verifizieren keine Verfasser, und wir bearbeiten oder löschen keine Bewertungen, mit denen wir nicht einverstanden sind. Lies ein paar, schau, was sie tatsächlich sagen, und gewichte ein Mint mit drei Bewertungen anders als eines mit dreihundert.",
+  "disclaimer.status.title": "„Online“ bedeutet „erreichbar“, nicht „vertrauenswürdig“",
+  "disclaimer.status.p1": "Wir überprüfen jede Mint regelmäßig und zeigen an, ob sie geantwortet hat. Das ist alles, was ein grüner Status bedeutet: Der Server hat geantwortet. Er sagt nichts darüber aus, ob der Betreiber zahlungsfähig oder ehrlich ist oder ob er auch morgen noch beabsichtigt, Ihre Token einzulösen.",
+  "disclaimer.status.p2": "Eine Mint kann so lange online sein, bis sie es nicht mehr ist. Die Verfügbarkeitsstatistik, die unterstützten NUTs und die Softwareversion geben zwar Aufschluss darüber, wie eine Mint betrieben wird, aber keines dieser Elemente ist eine Garantie für Ihr Geld.",
+  "disclaimer.ranking.title": "Wie das Ranking funktioniert und was es nicht bedeutet",
+  "disclaimer.ranking.p1": "Die Mints werden anhand eines Algorithmus auf der Grundlage öffentlicher Bewertungsdaten sortiert: Bewertung, Anzahl der Bewertungen und aktuelle Aktivität, wobei Online-Mints standardmäßig vor Offline-Mints stehen. Die Einzelheiten sind im Open-Source-Code zu finden.",
+  "disclaimer.ranking.p2": "Niemand bezahlt für die Platzierung. Es gibt keinen gesponserten Platz, keinen beworbenen Eintrag und keine Absprache mit irgendeinem Mint auf dieser Website. Ein hoher Rang heißt, dass dem Algorithmus die öffentlichen Daten gefallen haben, mehr nicht. Es ist keine Empfehlung und keine Sicherheitsbewertung.",
+  "disclaimer.notAdvice.title": "Dies ist keine Finanzberatung.",
+  "disclaimer.notAdvice.p1": "Nichts auf dieser Website ist Finanz-, Anlage-, Rechts- oder Steuerberatung. Wir kennen deine Situation nicht und wir beraten dich nicht. Ein Mint zu nutzen, und welches, ist deine Entscheidung.",
+  "disclaimer.dyor.title": "Recherchiere selbst",
+  "disclaimer.dyor.li1": "Informieren Sie sich über den Betreiber. Eine Mint, die von jemandem betrieben wird, der seinen guten Ruf zu verlieren hat, ist etwas ganz anderes als eine anonyme URL.",
+  "disclaimer.dyor.li2": "Lies dir die Nutzungsbedingungen der Mint selbst und deren „MOTD“ durch. Eine Mint, die sich selbst als „Test“ oder „Beta“ bezeichnet, meint das auch so.",
+  "disclaimer.dyor.li3": "Fang klein an. Minte ein wenig, gib es aus, melte es wieder heraus, und schau, was passiert, bevor du ihm mehr anvertraust.",
+  "disclaimer.dyor.li4": "Achten Sie auf die Grenzwerte. Ein niedriger Höchstwert ist oft ein Zeichen für einen umsichtigen Betreiber, während ein hoher Wert nicht unbedingt auf Sicherheit hindeutet.",
+  "disclaimer.dyor.li5": "Erstellen Sie regelmäßig Sicherungskopien Ihrer Token und denken Sie daran, dass ein Token ein Inhaberwert ist: Wer ihn besitzt, kann ihn ausgeben.",
+  "disclaimer.site.title": "Über die Website selbst",
+  "disclaimer.site.p1": "Die hier aufgeführten Daten können fehlerhaft oder veraltet sein. Die Mints werden nach einem festgelegten Zeitplan abgefragt, Relais reagieren manchmal nicht, und die Seite, die Sie gerade lesen, wurde zu einem bestimmten Zeitpunkt in der Vergangenheit erstellt. Die Website wird ohne Mängelgewähr bereitgestellt. Siehe die „{link}“.",
+  "disclaimer.site.link": "Nutzungsbedingungen",
+  "disclaimer.updated": "20. August 2026",
+  "login.getPrimal": "Get Primal",
+  "reviews.dialog.identity.extensionGone": "Ihre Browser-Erweiterung reagiert nicht. Melden Sie sich bitte erneut an oder verwenden Sie einen Remote-Signierer.",
+  "seo.orgDescription": "Ein Verzeichnis von Cashu-Mints, mit Live-Status jedes Mints und Community-Bewertungen, signiert auf Nostr.",
+  "seo.ogImageAlt": "Cashumints.space: finde ein Cashu-Mint, dem du vertrauen kannst.",
+  "seo.mint.title.one": "{name} Bewertungen: {rating} aus {n} Bewertung | Cashumints.space",
+  "seo.mint.title.other": "{name} Bewertungen: {rating} aus {n} Bewertungen | Cashumints.space",
+  "seo.mint.titleOffline.one": "{name}: seit {n} Tag offline | Cashumints.space",
+  "seo.mint.titleOffline.other": "{name}: seit {n} Tagen offline | Cashumints.space",
+  "seo.mint.titleNoReviews": "{name}: Infos und Bewertungen zum Cashu-Mint | Cashumints.space",
+  "seo.fedimint.titleNoReviews": "{name}: Informationen und Bewertungen zur Fedimint-Föderation | Cashumints.space",
+  "seo.desc.fallback": "Community-Bewertungen für {name} ({domain}).",
+  "seo.desc.fallbackDomain": "Community-Bewertungen für das Cashu-Mint unter {domain}.",
+  "seo.desc.rated.one": "{rating}/5 aus {n} signierter Nostr-Bewertung.",
+  "seo.desc.rated.other": "{rating}/5 aus {n} signierten Nostr-Bewertungen.",
+  "seo.desc.noReviews": "Noch keine Bewertungen.",
+  "seo.desc.status": "{status}.",
+  "seo.desc.statusLimits": "{status}, Limits {limits}.",
+  "seo.desc.fedModules": "{status}. Module: {modules}.",
+  "seo.desc.fedModulesNetwork": "{status}. Module: {modules} auf {network}.",
+  "seo.mint.ogAlt.one": "{name}: {rating} Sterne aus {n} Bewertung auf Cashumints.space",
+  "seo.mint.ogAlt.other": "{name}: {rating} Sterne aus {n} Bewertungen auf Cashumints.space",
+  "seo.mint.ogAltNoReviews": "{name} auf Cashumints.space",
+  "nav.home": "Startseite",
+  "mint.more.title": "Mehr Mints",
+  "mint.more.all": "Alle Mints ansehen",
+  "nav.fedimints": "Fedimints",
+  "status.announced": "Nur angekündigt",
+  "card.unnamedFederation": "Unbenannter Verband",
+  "card.notChecked": "nie überprüft",
+  "fedimints.title": "Alle Fedimint-Verbände · Cashumints.space",
+  "fedimints.description": "Alle im Nostr-Netzwerk angekündigten „{total}“-Fedimint-Verbünde: {online} – durch eine externe Überprüfung als funktionsfähig bestätigt; {announced} – angekündigt, aber nie bestätigt. Community-Bewertungen, Module und Einladungscodes für jeden einzelnen.",
+  "fedimints.heading": "Alle Verbände",
+  "fedimints.lede": "Jede Fedimint-Föderation wurde im Nostr-Netzwerk angekündigt. Da eine Föderation über keinen eigenen öffentlichen Status-Endpunkt verfügt, wird bei einigen durch eine externe Überprüfung bestätigt, dass sie aktiv sind, während die übrigen genau so aufgeführt sind, wie sie angekündigt wurden.",
+  "fedimints.search.label": "Suchverbünde nach Name oder ID suchen",
+  "fedimints.search.placeholder": "Nach Namen oder Verbands-ID suchen…",
+  "fedimints.sort.label": "Verbände sortieren",
+  "fedimints.hideOffline": "Offline ausblenden",
+  "fedimints.showing": "{total}-Verbände werden angezeigt ({online} bestätigt, {announced} nur angekündigt)",
+  "fedimints.showingFiltered": "Es werden {shown} von {total} Verbänden angezeigt ({online} sind bestätigt, {announced} wurden lediglich angekündigt)",
+  "fedimints.announcedNote.one": "Eines davon wurde auf Nostr angekündigt, und seitdem gibt es keine Bestätigung dafür, dass es läuft. Es wird als „angekündigt“ und nicht als „online“ oder „offline“ aufgeführt, da beides nicht zutreffen würde.",
+  "fedimints.announcedNote.other": "{n}e diese wurden auf Nostr angekündigt, und seitdem gibt es keine Bestätigung dafür, dass sie in Betrieb sind. Sie werden als „angekündigt“ und nicht als „online“ oder „offline“ aufgeführt, da beides nicht zutreffen würde.",
+  "fedimints.noResults": "Es wurde kein Verband gefunden. Geben Sie einen Namen ein oder fügen Sie eine Verbands-ID ein.",
+  "fedimints.emptyIndex": "Auf dieser Website ist zu lesen, dass noch keine Verbände für die Staffeln bekannt gegeben wurden. Die Liste wird automatisch ergänzt, sobald Ankündigungen eingehen.",
+  "fedimint.crumb": "Fedimints",
+  "fedimint.breadcrumb": "Navigationspfad",
+  "fedimint.unnamed": "Unbenannter Verband",
+  "fedimint.idLabel": "Verband",
+  "fedimint.kind.federationId": "Verbands-ID",
+  "fedimint.moduleCount.one": "{n}-Modul",
+  "fedimint.moduleCount.other": "{n}-Module",
+  "fedimint.copyInvite": "Einladungscode kopieren",
+  "fedimint.confirmed.label": "Bestätigt",
+  "fedimint.confirmed.never": "Niemals",
+  "fedimint.confirmed.by": "von {source}",
+  "fedimint.confirmed.unattributed": "letzte Überprüfung",
+  "fedimint.announcedOn": "{when} angekündigt",
+  "fedimint.announcedUnknown": "kein Ankündigungstermin",
+  "fedimint.modules.title": "Module",
+  "fedimint.modules.none": "In der Ankündigung dieses Verbandes werden keine Module aufgeführt.",
+  "fedimint.modules.note": "Module sind die Komponenten, die ein Verbund betreibt. In der Ankündigung wird angegeben, welche Module vorhanden sind, es wird jedoch nicht erwähnt, ob eines davon Einzahlungen entgegennimmt.",
+  "fedimint.modules.notListed": "nicht aufgeführt",
+  "fedimint.invite.title": "Einladungscode",
+  "fedimint.invite.count.one": "{n}-Code",
+  "fedimint.invite.count.other": "{n}-Codes",
+  "fedimint.invite.note": "Füge dies in eine Fedimint-Wallet ein, um beizutreten. Es enthält die Föderations-ID und die Adressen der Verwalter und ist dazu gedacht, weitergegeben zu werden.",
+  "fedimint.invite.kind": "Einladungscode",
+  "fedimint.invite.qr": "QR",
+  "fedimint.invite.qrCaption": "Scannen Sie den QR-Code, um der Gruppe „{name}“ beizutreten",
+  "fedimint.details.federationId": "Verbands-ID",
+  "fedimint.details.network": "Netzwerk",
+  "fedimint.details.announcedBy": "Bekannt gegeben von",
+  "fedimint.details.announced": "Angekündigt",
+  "fedimint.more.title": "Weitere Verbände",
+  "fedimint.more.all": "Alle Verbände anzeigen",
+  "fedimint.disclaimer": "Einem Verband beizutreten bedeutet, seinen Verantwortlichen das eigene Geld anzuvertrauen. Bewertungen spiegeln die Meinungen der Community wider, und „bestätigt“ bedeutet lediglich, dass der Anbieter erreichbar ist – nicht, dass er vertrauenswürdig ist.",
+  "fedimint.module.lightning": "Lightning",
+  "fedimint.module.mint": "ecash-Mint",
+  "fedimint.module.wallet": "On-Chain-Wallet",
+  "fedimint.module.meta": "Metadaten",
+  "fedimint.module.stability_pool": "Stabilitätspool",
+  "fedimint.module.multi_sig_stability_pool": "Stabilitätspool (Multisig)",
+  "fedimint.module.fedi-social": "Soziale Wiedereingliederung",
+  "fedimint.network.mainnet": "Bitcoin-Mainnet",
+  "fedimint.network.signet": "Siegel",
+  "fedimint.network.testnet": "Testnetz",
+  "fedimint.network.testnet4": "Testnetz 4",
+  "fedimint.network.regtest": "Regtest",
+  "feed.ecosystem.group": "Ökosystem",
+  "feed.ecosystem.all": "Alle",
+  "feed.ecosystem.cashu": "Cashu",
+  "feed.ecosystem.fedimint": "Fedimint",
+  "feed.filterBySubject": "Nach Mint oder Föderation filtern",
+  "feed.anySubject": "Jedes Mint oder jede Föderation",
+  "feed.clearSubject": "Namensfilter löschen",
+  "home.topFedimints.title": "Top-Fedimints",
+  "home.topFedimints.sub": "nach Bewertungen und Sternebewertung sortiert",
+  "home.topFedimints.all": "Alle Verbände unter {n} →",
+  "reviews.validate.subject": "Es gibt nichts, worauf sich diese Rezension beziehen könnte.",
+  "mint.warnings.fedimintOffline.lead": "Als offline gemeldet.",
+  "mint.warnings.fedimintOffline.body.since": "Der letzte Scheck, der bei diesem Verband eingegangen ist, stammte vom {date} (vor {days}). Die Verantwortlichen haben seitdem nicht mehr geantwortet. Betrachten Sie die dort hinterlegten Gelder als gefährdet und führen Sie keine neuen Gelder ein.",
+  "mint.warnings.fedimintOffline.body.never": "Es ist noch nie eine Überprüfung dieses Verbandes erfolgt, und die letzte ist gescheitert. Behandeln Sie die dort gehaltenen Gelder als gefährdet und führen Sie keine neuen Gelder diesem Verband zu.",
+  "mint.warnings.fedimintOffline.meta.since": "Seit {date} als offline gemeldet",
+  "mint.warnings.fedimintOffline.meta.never": "Als offline gemeldet, wurde nie erreicht",
+  "mint.warnings.neverConfirmed.lead": "Angekündigt, aber nie bestätigt.",
+  "mint.warnings.neverConfirmed.body.reviewed": "Dieser Zusammenschluss wurde vor einiger Zeit auf Nostr unter {date}, {days} angekündigt, und seitdem gibt es keine Bestätigungen dafür, dass er tatsächlich besteht. Die folgenden Rezensionen sind das einzige Lebenszeichen auf dieser Seite; alles andere stammt aus der Ankündigung.",
+  "mint.warnings.neverConfirmed.body.quiet": "Diese Föderation wurde vor einiger Zeit auf Nostr unter {date}, {days} angekündigt; seitdem gibt es keine Bestätigung dafür, dass sie noch besteht, und niemand hat sie in letzter Zeit bewertet. Alle folgenden Informationen stammen aus der Ankündigung.",
+  "mint.warnings.neverConfirmed.meta": "{date} angekündigt, nie bestätigt",
+  "footer.allFedimints": "Alle Verbände",
+  "reviews.dialog.bodyPlaceholder.cashu": "Wie liefen Minten, Melten und Support? Werde konkret.",
+  "reviews.dialog.bodyPlaceholder.fedimint": "Wie haben sich die Integration, Lightning-Zahlungen und der Support bewährt? Gehen Sie bitte konkret darauf ein.",
+  "fedimint.details.title": "Angaben zum Verband",
+  "nav.lnurlMints": "LNURL-Mints",
+  "footer.allLnurlMints": "Alle LNURL-Mints",
+  "lnurlMints.title": "LNURL-Mints: Mints für lnurlcash-Inhaberscheine, bewertet | Cashumints.space",
+  "lnurlMints.description": "Alle {total} aus dem Nostr-Netzwerk indexierten LNURL-Mints: {online} online, {offline} offline. Community-Bewertungen, Auszahlungsgrenzen und Funktionen für jeden.",
+  "lnurlMints.heading": "LNURL-Mints",
+  "lnurlMints.lede": "Jeder LNURL-Mint, den diese Seite kennt. Ein LNURL-Mint gibt lnurlcash-Inhaberscheine aus: Lightning-Scheine, die man als Geheimnis hält und die sich rotieren, teilen, zusammenführen oder zurück zu einer Lightning-Zahlung schmelzen lassen. Jeder wird alle paar Minuten über HTTPS geprüft.",
+  "lnurlMints.search.label": "LNURL-Mints durchsuchen",
+  "lnurlMints.search.placeholder": "Nach Name oder Adresse suchen…",
+  "lnurlMints.sort.label": "LNURL-Mints sortieren nach",
+  "lnurlMints.hideOffline": "Offline ausblenden",
+  "lnurlMints.showing": "{total} LNURL-Mints ({online} online, {offline} offline)",
+  "lnurlMints.showingFiltered": "{shown} von {total} LNURL-Mints ({online} online, {offline} offline)",
+  "lnurlMints.noResults": "Kein LNURL-Mint passt dazu.",
+  "lnurlMints.emptyIndex": "Es sind noch keine LNURL-Mints indexiert.",
+  "lnurl.crumb": "LNURL-Mints",
+  "lnurl.breadcrumb": "Brotkrumenpfad",
+  "lnurl.copyAddress": "Adresse kopieren",
+  "lnurl.more.title": "Weitere LNURL-Mints",
+  "lnurl.more.all": "Alle LNURL-Mints →",
+  "lnurl.disclaimer": "Ein LNURL-Mint verwahrt deine Sats, während du seine Scheine hältst – ihn zu nutzen heißt also, seinem Betreiber zu vertrauen. Bewertungen sind Meinungen der Community, und online heißt erreichbar, nicht vertrauenswürdig.",
+  "lnurl.features.title": "Funktionen",
+  "lnurl.features.none": "Dieser Mint hat nicht angekündigt, was er unterstützt.",
+  "lnurl.features.note": "Funktionen sind das, was der Betreiber des Mints auf Nostr angekündigt hat. Wo diese Seite eine davon über HTTPS prüfen kann, tut sie das, und sie sagt es, wenn etwas Angekündigtes gerade nicht verfügbar ist.",
+  "lnurl.features.notListed": "nicht angekündigt",
+  "lnurl.features.unavailable": "nicht verfügbar",
+  "lnurl.feature.mint": "Minten über Lightning (LUD-06)",
+  "lnurl.feature.melt": "Schmelzen zu Lightning",
+  "lnurl.feature.notes": "Scheine rotieren / teilen / zusammenführen",
+  "lnurl.feature.lud16": "Lightning-Adresse",
+  "lnurl.feature.lud21": "Zahlungsprüfung (LUD-21)",
+  "lnurl.feature.signed-notes": "Signierte Scheine (Offline-Prüfung)",
+  "lnurl.feature.onion": "Tor-Adresse",
+  "lnurl.feature.rotate": "Einen Schein rotieren",
+  "lnurl.feature.split": "Einen Schein teilen",
+  "lnurl.feature.merge": "Scheine zusammenführen",
+  "lnurl.feature.lud06": "LUD-06 payRequest",
+  "lnurl.feature.lud03": "LUD-03 withdrawRequest",
+  "lnurl.limits.label": "Auszahlungsgrenzen",
+  "lnurl.limits.notPublished": "nicht veröffentlicht",
+  "lnurl.limits.withdrawRow": "Auszahlung",
+  "lnurl.limits.disabled": "deaktiviert",
+  "lnurl.limits.sats.one": "{n} Sat",
+  "lnurl.limits.sats.other": "{n} Sats",
+  "lnurl.details.title": "Details zum Mint",
+  "lnurl.details.address": "Lightning-Adresse",
+  "lnurl.details.mintPubkey": "Öffentlicher Schlüssel des Mints",
+  "lnurl.details.onion": "Tor-Adresse",
+  "lnurl.details.fee": "Mint-Gebühr",
+  "lnurl.details.node": "Node",
+  "lnurl.details.capacity": "Angekündigte Kapazität",
+  "lnurl.kind.lightningAddress": "Lightning-Adresse",
+  "lnurl.kind.mintPubkey": "öffentlicher Schlüssel des Mints",
+  "lnurl.kind.onionAddress": "Tor-Adresse",
+  "lnurl.confirmed.label": "Zuletzt bestätigt",
+  "lnurl.confirmed.when": "bestätigt {when}",
+  "lnurl.fee.base.one": "{n} Sat",
+  "lnurl.fee.base.other": "{n} Sats",
+  "lnurl.fee.percent": "{percent} %",
+  "home.topLnurl.title": "Top LNURL-Mints",
+  "home.topLnurl.sub": "nach Bewertungen und Note sortiert",
+  "home.topLnurl.all": "Alle {n} LNURL-Mints →",
+  "feed.ecosystem.lnurl": "LNURL",
+  "reviews.dialog.bodyPlaceholder.lnurl": "Wie liefen Minten, Melten und das Rotieren von Scheinen? Werde konkret.",
+  "reviews.byUrl.open": "Review schreiben",
+  "reviews.byUrl.title": "Review schreiben",
+  "reviews.byUrl.lede": "Adresse einfügen. Kennt diese Seite sie noch nicht, wird sie jetzt geprüft und aufgenommen.",
+  "reviews.byUrl.label.cashu": "Mint-URL",
+  "reviews.byUrl.label.fedimint": "Invite Code der Föderation",
+  "reviews.byUrl.label.lnurl": "URL des LNURL Mint",
+  "reviews.byUrl.placeholder.cashu": "mint.example.com",
+  "reviews.byUrl.placeholder.fedimint": "fed11…",
+  "reviews.byUrl.placeholder.lnurl": "mint.example.com",
+  "reviews.byUrl.check": "Diese Adresse prüfen",
+  "reviews.byUrl.checking": "Wird geprüft…",
+  "reviews.byUrl.back": "Andere Adresse verwenden",
+  "reviews.byUrl.existing": "Schon gelistet",
+  "reviews.byUrl.indexed": "Gerade aufgenommen",
+  "reviews.byUrl.confirmClose": "Schließen? Die eingegebene Adresse wird nicht behalten.",
+  "reviews.byUrl.detected": "Diese Adresse hat als {kind} Mint geantwortet.",
+  "reviews.byUrl.switchTo": "Als {kind} Mint bewerten",
+  "reviews.byUrl.error.empty": "Gib zuerst eine Adresse ein.",
+  "reviews.byUrl.error.badUrl": "Das sieht nicht nach einer Mint-URL aus.",
+  "reviews.byUrl.error.badInvite": "Das ist kein Fedimint Invite Code. Codes beginnen mit fed11.",
+  "reviews.byUrl.error.badInput": "Diese Seite kann diese Adresse nicht prüfen.",
+  "reviews.byUrl.error.blocked": "Das ist keine öffentliche Adresse, sie kann also nicht geprüft werden.",
+  "reviews.byUrl.error.notAMint": "Diese Adresse hat geantwortet, aber nicht als Mint dieser Art.",
+  "reviews.byUrl.error.wrongType": "Diese Adresse hat geantwortet, aber als eine andere Art von Mint.",
+  "reviews.byUrl.error.unverifiable": "Unter dieser Adresse hat nichts geantwortet, und auf Nostr gibt es bisher keine Spur davon.",
+  "reviews.byUrl.error.rateLimited.one": "Das sind viele Prüfungen von einer Verbindung. Versuch es in etwa {n} Minute noch einmal.",
+  "reviews.byUrl.error.rateLimited.other": "Das sind viele Prüfungen von einer Verbindung. Versuch es in etwa {n} Minuten noch einmal.",
+  "reviews.byUrl.error.network": "Der Index war nicht erreichbar. Prüf deine Verbindung und versuch es noch einmal.",
+  "seo.lnurl.titleNoReviews": "{name}: Infos und Bewertungen zum LNURL-Mint | Cashumints.space",
+  "seo.desc.statusWithdraw": "{status}, Auszahlung {min}–{max} Sat.",
+  "mint.chip.noFunding": "Kein Minten / Melten",
+  "mint.warnings.lnurlWithdrawalsDisabled.lead": "Auszahlungen sind deaktiviert.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.online": "Dieser Mint gibt eine maximale Auszahlung von null an, also lässt sich kein von ihm ausgegebener Schein gegen irgendetwas einlösen. Präge hier nichts, solange das so bleibt.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.offline": "Dieser Mint gab beim letzten Kontakt eine maximale Auszahlung von null an, also ließ sich kein von ihm ausgegebener Schein gegen irgendetwas einlösen. Präge hier nichts, solange das so bleibt.",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.online": "Auszahlungen derzeit deaktiviert",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.offline": "Auszahlungen waren beim letzten Kontakt deaktiviert",
+  "mint.warnings.lnurlInvalid.lead": "Endpunkt antwortet, ist aber ungültig.",
+  "mint.warnings.lnurlInvalid.body": "Der Host antwortet, aber nicht mit einer Mint-Ankündigung, die diese Seite lesen kann – Auszahlungen funktionieren also möglicherweise nicht. Alles darunter ist der letzte lesbare Stand, und Bewertungen funktionieren weiterhin.",
+  "mint.warnings.lnurlInvalid.meta": "Antwortet, aber nicht mit einer gültigen Mint-Ankündigung",
+  "mint.warnings.lnurlNoFunding.lead": "Minten und Melten nicht verfügbar.",
+  "mint.warnings.lnurlNoFunding.body": "Vorhandene Scheine lassen sich weiterhin rotieren, teilen oder zusammenführen, aber über Lightning bewegt sich gerade nichts hinein oder hinaus. Der Mint selbst läuft und antwortet; die Lightning-Node dahinter ist von ihm aus nicht erreichbar.",
+  "mint.warnings.lnurlNoFunding.meta": "Minten und Melten nicht verfügbar",
+  "mint.warnings.also.noFunding": "Auch seine Lightning-Node war nicht erreichbar, es konnte also weder gemintet noch gemeltet werden."
+}

web/src/i18n/el.json

@@ -0,0 +1,788 @@
+{
+  "site.name": "Cashumints.space",
+  "common.close": "Κλείσιμο",
+  "common.cancel": "Ακύρωση",
+  "common.done": "Τέλος",
+  "common.back": "Πίσω",
+  "common.retry": "Δοκιμή ξανά",
+  "common.connect": "Σύνδεση",
+  "common.copied": "Αντιγράφηκε",
+  "common.copyFull": "Αντιγραφή πλήρους{kind}",
+  "common.previousPage": "Προηγούμενη σελίδα",
+  "common.nextPage": "Επόμενη σελίδα",
+  "common.reviewPages": "Σελίδα αναθεώρησης",
+  "time.never": "ποτέ",
+  "time.justNow": "μόλις τώρα",
+  "time.none": "- Ναι.",
+  "time.unknownDate": "άγνωστη ημερομηνία",
+  "time.ago.minute": "{n} Πριν από m",
+  "time.ago.hour": "{n}h πριν",
+  "time.ago.day": "{n}d πριν",
+  "time.ago.week": "{n}w πριν",
+  "time.ago.month": "{n}mo πριν",
+  "time.ago.year": "{n}y πριν",
+  "time.short.minute": "{n}Μ",
+  "time.short.hour": "{n}Η",
+  "time.short.day": "{n} δ",
+  "time.short.week": "{n} ο",
+  "time.short.month": "{n}mo",
+  "time.short.year": "{n}y",
+  "status.online": "Σε σύνδεση",
+  "status.offline": "Εκτός σύνδεσης",
+  "status.degraded": "Απροσπέλαστη",
+  "status.unknown": "Δεν έχει ελεγχθεί ακόμα",
+  "nav.skip": "Μετάβαση στο περιεχόμενο",
+  "nav.main": "Κύριο",
+  "nav.mints": "Cashu mints",
+  "nav.reviews": "Κριτικές",
+  "nav.wallets": "Πορτοφόλια",
+  "nav.about": "Σχετικά",
+  "nav.searchMints": "Αναζήτηση σε {n} mints",
+  "lang.label": "Γλώσσα",
+  "lang.switcher": "Επιλέξτε μια γλώσσα",
+  "footer.copyright": "© {year} Cashumints.space",
+  "footer.allMints": "Όλα τα Cashu mints",
+  "footer.allReviews": "Όλες οι κριτικές",
+  "footer.wallets": "Πορτοφόλια",
+  "footer.about": "Σχετικά",
+  "footer.disclaimer": "Αποποίηση ευθύνης",
+  "footer.terms": "Όροι",
+  "footer.privacy": "Ιδιωτικότητα",
+  "footer.madeBy": "Φτιαγμένο με ❤️ από {azzamo} · Με τη δύναμη των Cashu και NIP-87",
+  "footer.warning": "Τα mints είναι θεματοφύλακες. Ένα mint μπορεί να εξαφανιστεί με τα χρήματά σας.",
+  "footer.tagline": "Κριτικές της κοινότητας για ecash mints, υπογεγραμμένες στο Nostr.",
+  "footer.col.explore": "Εξερεύνηση",
+  "footer.col.site": "Ιστότοπος",
+  "footer.nav": "Υποσέλιδο",
+  "home.title": "Cashumints.space · Βρες ένα Cashu mint που μπορείς να εμπιστευτείς",
+  "home.description": "Βρες ένα Cashu mint που μπορείς να εμπιστευτείς. {mints} mints στο ευρετήριο με {reviews} κριτικές της κοινότητας υπογεγραμμένες στο Nostr, μαζί με ζωντανή διαθεσιμότητα, υποστηριζόμενα NUTs και λογισμικό του mint.",
+  "home.hero.title": "Βρες ένα Cashu mint",
+  "home.hero.titleEm": "Μπορείς να εμπιστευτείς.",
+  "home.hero.lede": "Κάθε νόμισμα στο δίκτυο Nostr, με πραγματικές κριτικές της κοινότητας. Χωρίς φύλακες, απλά υπογεγραμμένες κριτικές μπορείτε να επιβεβαιώσετε τον εαυτό σας.",
+  "home.search.label": "Αναζήτηση ονόματος, domain, ή URL",
+  "home.search.placeholder": "Αναζήτηση με όνομα, domain, ή επικόλληση ενός vomismatokopoo URL...",
+  "home.filters.mostReviewed": "Τα περισσότερα αναθεωρήθηκαν",
+  "home.filters.highestRated": "Υψηλότερη βαθμολογία",
+  "home.filters.recentlyActive": "Πρόσφατα ενεργό",
+  "home.filters.websockets": "Υποστηρίζει WebSockets",
+  "home.top.title": "Κορυφή Κασού νόμισματοκηπίας",
+  "home.top.sub": "κατατάσσεται ανά αξιολόγηση και αξιολόγηση",
+  "home.top.all": "Όλα{n} νομισματοκώπεια →",
+  "home.latest.title": "Τελευταίες κριτικές",
+  "home.latest.sub": "ζωντανά από το δίκτυο Nostr",
+  "home.latest.prev": "Προηγούμενες κριτικές",
+  "home.latest.next": "Περισσότερες κριτικές",
+  "home.latest.all": "Όλες οι κριτικές →",
+  "home.latest.empty": "Δεν υπάρχουν κριτικές που θα μπορούσαν να διαβαστούν από τα relays μόλις τώρα. Ανοίξτε οποιαδήποτε σελίδα vomismatopo για να διαβάσετε και να γράψετε άμεσα σχόλια.",
+  "home.why.title": "Γιατί εμπιστεύεσαι αυτές τις κριτικές;",
+  "home.why.signed.title": "Υπογραφή, δεν υποβλήθηκε",
+  "home.why.signed.body": "Κάθε κριτική είναι μια{link}event υπογεγραμμένο από το κλειδί Nostr του συγγραφέα του. Τίποτα εδώ δεν έχει επεξεργαστεί, ταξινομηθεί, ή αφαιρεθεί από εμάς.",
+  "home.why.signed.link": "NIP-87",
+  "home.why.verify.title": "Επαλήθευσε το μόνος σου.",
+  "home.why.verify.body": "Κριτικές ζωντανά σε δημόσιες αναμεταδόσεις Nost, όχι στη βάση δεδομένων μας.",
+  "home.why.checked.title": "Ελέγχθηκε συνεχώς",
+  "home.why.checked.body": "Ερευνούμε κάθε νόμισμα για uptime, έκδοση λογισμικού, όρια και υποστηριζόμενα NUTs, έτσι ώστε οι προδιαγραφές που βλέπετε να είναι τρέχουσες, όχι αυτοαναφερόμενες.",
+  "home.cta.title": "Σκέφτεσαι ένα νόμισμα; Διαβάστε πρώτα.",
+  "home.cta.body": "Διαβάστε τι βρήκαν άλλοι άνθρωποι πριν βάλετε sats σε, και αφήστε μια κριτική όταν έχετε χρησιμοποιήσει τον εαυτό σας.",
+  "home.cta.explore": "Εξερευνήστε όλες τις νομισματοποιίες",
+  "home.cta.learn": "Μάθετε για το Cashu",
+  "pulse.mintsIndexed": "Βιβλιοδεσία",
+  "pulse.reviewsOnNostr": "σχόλια για Nostr",
+  "pulse.lastReview": "τελευταία επανεξέταση",
+  "pulse.mintsOnline": "vomismatokopeia σε απευθείας σύνδεση",
+  "pulse.indexer": "ευρετηριαστής",
+  "pulse.connected": "συνδεδεμένος",
+  "pulse.stale": "μπαγιάτικο",
+  "mints.title": "Όλα Κασσού νόμισμα · Cashumints.space",
+  "mints.description": "Όλα{total}Cashu vomismatopopeia indexed from the Nostr network, Διεύθυνση:{online}online και{offline}offline, με την κοινότητα βαθμολογίες, uptime και vomismatopo λογισμικό. Αναζήτηση και ταξινόμηση της πλήρους λίστας.",
+  "mints.heading": "Όλα τα Cashu mints",
+  "mints.lede": "Κάθε νόμισμα που ανακαλύφθηκε στο δίκτυο Nostr, συμπεριλαμβανομένων και αυτών που έχουν φύγει. Offline νόμισμα που βρίσκεται στον κατάλογο ώστε να μπορείτε ακόμα να βρείτε και να τα ανασκοπήσετε.",
+  "mints.search.label": "Αναζήτηση ονόματος ή domain",
+  "mints.search.placeholder": "Αναζήτηση με όνομα ή τομέα...",
+  "mints.sort.label": "Ταξινόμηση νόμισματοκοπία",
+  "mints.sort.score": "Καλύτερο σύνολο",
+  "mints.sort.rating": "Υψηλότερη βαθμολογία",
+  "mints.sort.reviews": "Τα περισσότερα αναθεωρήθηκαν",
+  "mints.sort.recent": "Πρόσφατα αναθεωρήθηκε",
+  "mints.sort.seen": "Πρόσφατες σε απευθείας σύνδεση",
+  "mints.hideOffline": "Απόκρυψη εκτός σύνδεσης",
+  "mints.showing": "Εμφάνιση{total}ΝΟΜΟΘΕΣΜΑΤΟΠΟΕΙΑ ({online} σε απευθείας σύνδεση,{offline}offline)",
+  "mints.showingFiltered": "Εμφάνιση{shown} του{total}ΝΟΜΟΘΕΣΜΑΤΟΠΟΕΙΑ ({online} σε απευθείας σύνδεση,{offline}offline)",
+  "mints.noResults": "Δεν ταιριάζει κανένα νομισματοκοπείο. Δοκιμάστε έναν τομέα ή επικολλήστε το URL ενός νομισματοκοπείου.",
+  "mints.clearSearch": "Καθαρισμός της αναζήτησης",
+  "card.noRatings": "Καμία αξιολόγηση ακόμα",
+  "card.reviews.one": "{n} επανεξέταση",
+  "card.reviews.other": "{n} αναθεωρήσεις",
+  "card.lastSeen": "τελευταίας εμφάνισης{when}",
+  "card.neverSeen": "δεν έχει δει ποτέ στο διαδίκτυο",
+  "card.reviewed": "επανεξετάζεται{when}",
+  "card.noReviews": "δεν υπάρχουν ακόμη αξιολογήσεις",
+  "mint.title": "{name}· Κασσού νόμισμα των κριτικών",
+  "mint.titleFedimint": "{name} · Κριτικές της ομοσπονδίας Fedimint",
+  "mint.titleLnurl": "{name} · Κριτικές του LNURL mint",
+  "mint.breadcrumb": "Ψωμί",
+  "mint.crumbMints": "Κασσού νόμισματοκοπία",
+  "mint.copyUrl": "Αντιγραφή νομισματοκοπίου URL",
+  "mint.qrButton": "ΝΟΜΙΣΜΑΤΟΚΟΠΙΟ QR",
+  "mint.writeReview": "Γράψτε μια κριτική",
+  "mint.rankByScore": "#{rank} κατά βαθμολογία",
+  "mint.tagLightning": "Αστραπή",
+  "mint.summary": "Περίληψη vomismatokopoo",
+  "mint.rating.label": "Κοινοτική βαθμολογία",
+  "mint.rating.none": "Καμία αξιολόγηση ακόμα",
+  "mint.rating.reviews.one": "{n} επανεξέταση",
+  "mint.rating.reviews.other": "{n} αναθεωρήσεις",
+  "mint.rating.unrated.one": "{n} δεν άφησε καμία αξιολόγηση",
+  "mint.rating.unrated.other": "{n} δεν άφησε καμία αξιολόγηση",
+  "mint.activity.label": "Δραστηριότητα",
+  "mint.activity.since": "από την τελευταία επανεξέταση",
+  "mint.activity.noReviews": "δεν υπάρχουν ακόμη αξιολογήσεις",
+  "mint.activity.recent.one": "{n} ανασκόπηση τις τελευταίες 90 ημέρες",
+  "mint.activity.recent.other": "{n} σχόλια τις τελευταίες 90 ημέρες",
+  "mint.limits.label": "Όρια",
+  "mint.limits.notPublished": "δεν έχει δημοσιευθεί",
+  "mint.limits.min": "λεπτά",
+  "mint.limits.max": "max",
+  "mint.limits.mintRow": "έκδοση",
+  "mint.limits.meltRow": "εξαργύρωση",
+  "mint.limits.disabled": "Απενεργοποίηση",
+  "mint.limits.range": "{min} σε{max}{unit}",
+  "mint.limits.upTo": "έως{max}{unit}",
+  "mint.limits.from": "από{min}{unit}",
+  "mint.software.label": "ΝΟΜΙΣΜΑΤΟΚΟΠΙΟ software",
+  "mint.software.unknown": "άγνωστο",
+  "mint.checked": "ελέγχθηκε{when}",
+  "mint.lastSeen": "τελευταίας εμφάνισης{when}",
+  "mint.neverReached": "δεν έχει φτάσει ποτέ",
+  "mint.uptime.checks": "{ok} του τελευταίου{total} έλεγχοι που είναι προσβάσιμοι",
+  "mint.uptime.percent": "{percent}% προσβάσιμη σε διάστημα 30 ημερών",
+  "mint.uptime.description": "{ok} του τελευταίου{total}εpiιτυχηθέντες έλεγχοι",
+  "mint.operator.title": "Από τον χειριστή",
+  "mint.operator.motd": "Μήνυμα της ημέρας",
+  "mint.operator.beta": "Αυτό το νόμισμα περιγράφει τον εαυτό του ως πειραματικό ή σε βήτα. Διαβάστε τα λόγια του χειριστή παρακάτω πριν αποθηκεύσετε οτιδήποτε δεν μπορείτε να χάσετε.",
+  "mint.nuts.title": "Υποστηριζόμενες NUTs",
+  "mint.nuts.noneOffline": "Δεν υπάρχει λίστα NUT κρυμμένη για αυτό το νόμισμα, βγήκε εκτός σύνδεσης πριν ηχογραφηθεί.",
+  "mint.nuts.noneYet": "Καμία λίστα NUT δεν έχει καψουρευτεί για αυτό το νόμισμα ακόμα.",
+  "mint.nuts.supported": "{n} του{total} υποστήριξη γνωστών NUTs",
+  "mint.nuts.whatAre": "Τι είναι NUTs;",
+  "mint.nutRow.disabled": "Απενεργοποίηση",
+  "mint.nutRow.notSupported": "δεν υποστηρίζεται",
+  "mint.details.title": "ΝΟΜΟΘΕΣΜΑΤΟΚΟΠΙΟ λεπτομέρειες",
+  "mint.details.pubkey": "Δημόσιο κλειδί",
+  "mint.details.nostr": "Νοστρ",
+  "mint.details.email": "Ηλ. ταχυδρομείο",
+  "mint.details.serverTime": "Χρόνος εξυπηρετητή",
+  "mint.details.firstSeen": "Πρώτη φορά φαίνεται",
+  "mint.details.terms": "Όροι",
+  "mint.kind.identifier": "αναγνωριστικό",
+  "mint.kind.mintPubkey": "vomismatokopoo pubkey (στα Αγγλικά)",
+  "mint.kind.nostrAddress": "Διεύθυνση Nostr",
+  "mint.kind.emailAddress": "Διεύθυνση ηλεκτρονικού ταχυδρομείου",
+  "mint.kind.npub": "npub",
+  "mint.disclaimer": "Αυτό το vomismatokopoo είναι θεματοφύλακας: κατέχει τα χρήματά σας, και μπορεί να σταματήσει να το κάνει ανά πάσα στιγμή.",
+  "mint.disclaimerLink": "Διαβάστε την πλήρη αποποίηση ευθύνης",
+  "mint.qr.title": "Προσθήκη{name} στο πορτοφόλι σου.",
+  "mint.qr.note": "Σαρώστε αυτό με ένα πορτοφόλι Cashu για να προσθέσετε το νόμισμα, ή να αντιγράψετε το URL και επικολλήστε το σε.",
+  "mint.qr.warn": "Προσθέτοντας ένα νόμισμα σημαίνει ότι το εμπιστεύεστε με τα χρήματά σας.",
+  "mint.qr.whatMeans": "Τι σημαίνει αυτό;",
+  "mint.qr.wallets": "Πορτοφόλια που υποστηρίζουν Cashu",
+  "mint.chip.frozen": "Κατεψυγμένοι",
+  "mint.chip.noWithdrawals": "Χωρίς αναλήψεις",
+  "mint.chip.meltOnly": "Λιώσιμο μόνο",
+  "mint.warnings.dayCount.one": "{n} ημέρα",
+  "mint.warnings.dayCount.other": "{n} ημέρες",
+  "mint.warnings.gone.lead": "Μάλλον έφυγε.",
+  "mint.warnings.gone.body.since": "Αυτό το νόμισμα είναι απρόσιτο από τότε.{date}({days}. Αντιμετωπίστε τα κεφάλαια που κρατούνται εκεί ως σε κίνδυνο, και μην στείλετε νέα κεφάλαια.",
+  "mint.warnings.gone.body.neverDated": "Αυτό το νόμισμα δεν έχει απαντήσει ούτε μια επιταγή από τότε που αρχίσαμε να το βλέπουμε.{month}. Αντιμετωπίστε τα κεφάλαια που κρατούνται εκεί ως σε κίνδυνο, και μην στείλετε νέα κεφάλαια.",
+  "mint.warnings.gone.body.never": "Αυτό το νόμισμα δεν έχει απαντήσει ούτε μια επιταγή από τότε που αρχίσαμε να το παρακολουθούμε. Αντιμετωπίστε τα κεφάλαια που κρατούνται εκεί ως σε κίνδυνο, και μην στέλνετε νέα κεφάλαια.",
+  "mint.warnings.gone.meta.since": "Εκτός σύνδεσης από{date}",
+  "mint.warnings.gone.meta.never": "Ποτέ δεν είναι εφικτό από τότε που ανακαλύφθηκε",
+  "mint.warnings.meltDisabled.lead": "Αποσύρσεις απενεργοποιημένες.",
+  "mint.warnings.meltDisabled.body.online": "Αυτό το νόμισμα έχει Lightning τήξη (NUT-05) απενεργοποιημένο: μπορείτε να βάλετε κορμούς, αλλά δεν μπορείτε να τα αποσύρετε μέσω Lightning. Μην το καταθέσετε μέχρι να επιστρέψει το λιώσιμο.",
+  "mint.warnings.meltDisabled.body.offline": "Αυτό το νόμισμα είχε Lightning λιώσει (NUT-05) απενεργοποιημένο: μπορείτε να βάλετε κορμούς, αλλά δεν μπορείτε να τα αποσύρετε μέσω Lightning. Μην το καταθέσετε μέχρι το λιώσιμο να επιστρέψει.",
+  "mint.warnings.meltDisabled.meta.online": "Αποσύρσεις προς το παρόν απενεργοποιημένες",
+  "mint.warnings.meltDisabled.meta.offline": "Οι αναλήψεις απενεργοποιήθηκαν την τελευταία φορά.",
+  "mint.warnings.frozen.lead": "vomismatokopoo παγωμένο.",
+  "mint.warnings.frozen.body.online": "Η κοπή και το λιώσιμο είναι απενεργοποιημένα.",
+  "mint.warnings.frozen.body.offline": "Κανένα κορεσμό δεν μπορεί να κινηθεί μέσα ή έξω μέσω Lightning.",
+  "mint.warnings.frozen.meta.online": "Αυτή τη στιγμή παγωμένο, τίποτα δεν κινείται μέσα ή έξω",
+  "mint.warnings.frozen.meta.offline": "Κατεψυγμένα όταν εθεάθησαν τελευταία φορά",
+  "mint.warnings.offlineLong.lead": "Εκτός σύνδεσης για{days}, από{date}.",
+  "mint.warnings.offlineLong.body": "Τα πάντα παρακάτω είναι η τελευταία γνωστή του κατάσταση, και οι κριτικές εξακολουθούν να λειτουργούν.",
+  "mint.warnings.offlineLong.meta": "Εκτός σύνδεσης από{date}",
+  "mint.warnings.meltOnly.lead": "Λιώσε μόνο.",
+  "mint.warnings.meltOnly.body.online": "Το νέο κόψιμο (NUT-04) είναι απενεργοποιημένο: δεν μπορείτε να το καταθέσετε, αλλά το υπάρχον έκας μπορεί ακόμα να αποσυρθεί.",
+  "mint.warnings.meltOnly.body.offline": "Η νέα κοπή (NUT-04) απενεργοποιήθηκε: δεν μπορείτε να καταθέσετε, αλλά η υπάρχουσα εκάς μπορεί ακόμα να αποσυρθεί.",
+  "mint.warnings.meltOnly.meta.online": "Αυτή τη στιγμή λιώνουν μόνο",
+  "mint.warnings.meltOnly.meta.offline": "Λιώσιμο μόνο όταν έχει παρατηρηθεί τελευταία φορά",
+  "mint.warnings.offline.lead": "Εκτός σύνδεσης από{date}.",
+  "mint.warnings.offline.body": "Οι λεπτομέρειες επιβεβαιώθηκαν τελευταία φορά.",
+  "mint.warnings.offline.meta": "Εκτός σύνδεσης από{date}",
+  "mint.warnings.also.meltDisabled": "Πριν απενεργοποιηθεί, είχε επίσης απενεργοποιήσει τις αναλήψεις.",
+  "mint.warnings.also.mintDisabled": "Πριν απενεργοποιηθεί είχε επίσης απενεργοποιήσει νέα κοπή.",
+  "mint.warnings.also.offline": "Έχει επίσης απενεργοποιηθεί από{date}({days}).",
+  "nut.0": "Σημειωματάριο και υποδείγματα",
+  "nut.1": "ΝΟΜΙΣΜΑΤΟΚΟΠΙΟ ΣΥΝΑΛΛΑΓΕΣ ΛΟΓΑΡΙΑΣΜΟΥ",
+  "nut.2": "Κιβώτια και τέλη",
+  "nut.3": "Ανταλλάσσουν μάρκες",
+  "nut.4": "Ορεκτικά μέσω Lightning",
+  "nut.5": "Λιώνει μέσω Lightning",
+  "nut.6": "Πληροφορίες σχετικά με το θέμα",
+  "nut.7": "Έλεγχος κατάστασης στοιχήματος",
+  "nut.8": "Υπερπληρωμένα τέλη Lightning",
+  "nut.9": "Επαναφορά υπογραφών",
+  "nut.10": "Συνθήκες δαπανών",
+  "nut.11": "Πληρώστε στο δημόσιο κλειδί",
+  "nut.12": "Αποδείξεις DLEQ",
+  "nut.13": "Αποφασιστικά μυστικά",
+  "nut.14": "Συμβόλαια με χρονοθυρίδες σε κατάσταση αναμονής",
+  "nut.15": "Πληρωμές πολλαπλών διαδρομών",
+  "nut.16": "Κινούμενοι κωδικοί QR",
+  "nut.17": "Συνδρομές στο WebSocket",
+  "nut.18": "Αιτήσεις πληρωμής",
+  "nut.19": "Ακυρωθείσες απαντήσεις",
+  "nut.20": "Υπογεγραμμένες vomismatopo quotes",
+  "nut.21": "Καθαρισμός ταυτοποίησης",
+  "nut.22": "Τυφλή ταυτοποίηση",
+  "nut.23": "Μέθοδος πληρωμής BOLT11",
+  "nut.24": "Απαιτείται πληρωμή HTTP 402",
+  "nut.25": "Μέθοδος πληρωμής BOLT12",
+  "reviews.title": "Επανεξέταση",
+  "reviews.anon": "Ανώνυμος",
+  "reviews.anonTitle": "Δε βρέθηκε δημόσιο προφίλ Nostr για αυτό το κλειδί",
+  "reviews.nip05Title": "Αναγνωριστικός κωδικός NIP-05 (δεν επαληθεύτηκε από αυτόν τον ιστότοπο)",
+  "reviews.filter.group": "Κριτικές φίλτρων",
+  "reviews.filter.all": "Όλες",
+  "reviews.filter.five": "5 ⁇",
+  "reviews.filter.critical": "Κρίσιμη",
+  "reviews.filter.recent": "Πρόσφατες",
+  "reviews.filter.hideAnon": "Απόκρυψη anon",
+  "reviews.anonHidden.other": "Εμφάνιση{n} του{total} σχόλια: anon κρυμμένο.",
+  "reviews.allAnon.one": "Η μόνη κριτική εδώ είναι ο Άνον.",
+  "reviews.allAnon.other": "Όλα{n} Οι κριτικές εδώ είναι anoon.",
+  "reviews.allAnonShow.one": "Δείξ' το.",
+  "reviews.allAnonShow.other": "Δείξτε τους.",
+  "reviews.loading.one": "Φόρτωση{n} επανεξέταση από τα αναμεταδότες Nostr",
+  "reviews.loading.other": "Φόρτωση{n} σχόλια από Nost relays",
+  "reviews.empty": "Δεν υπάρχουν κριτικές ακόμα.",
+  "reviews.emptyWritten": "Δεν υπάρχουν γραπτές κριτικές εδώ ακόμα.",
+  "reviews.emptyFilter": "Καμία αξιολόγηση δεν ταιριάζει με αυτό το φίλτρο.",
+  "reviews.rate.cashu": "Βαθμολογήστε αυτό το mint",
+  "reviews.rate.fedimint": "Βαθμολογήστε αυτή την ομοσπονδία",
+  "reviews.rate.lnurl": "Βαθμολογήστε αυτό το mint",
+  "reviews.noscript": "Οι κριτικές είναι υπογεγραμμένες στο Nostr και φορτώνουν στο πρόγραμμα περιήγησης σας, οπότε αυτή η λίστα χρειάζεται JavaScript. Η αξιολόγηση και οι μετρήσεις παραπάνω προέρχονται από την ίδια την ιστοσελίδα.",
+  "reviews.relayError": "Δεν μπόρεσε να φτάσει στο ρελέ. Οι κριτικές μπορεί να είναι ελλιπείς.",
+  "reviews.srRating": "{rating} από 5",
+  "reviews.srNoRating": "Δεν έχει δοθεί αξιολόγηση",
+  "reviews.readMore": "Διαβάστε περισσότερα",
+  "reviews.readLess": "Εμφάνιση λιγότερου",
+  "reviews.actions.copyNpub": "Αντιγραφή npub",
+  "reviews.actions.openNostr": "Προβολή αυτής της εκδήλωσης στο Nostr",
+  "reviews.actions.copyLink": "Αντιγραφή link σε αυτή την κριτική",
+  "reviews.anonNote": "Πρώτη κριτική από αυτό το npub, δεν βρέθηκε άλλη δραστηριότητα",
+  "reviews.published": "Δημοσίευση.",
+  "reviews.publishedPartial": "Δημοσίευση στο{accepted} του{total} ⁇ λεμάν.",
+  "reviews.propagating": "Δημοσίευση στα relays του Nostr",
+  "reviews.summary.line.one": "{count} αξιολόγηση χωρίς σχόλιο:{breakdown}",
+  "reviews.summary.line.other": "{count} αξιολογήσεις χωρίς σχόλιο:{breakdown}",
+  "reviews.summary.lineDay.one": "{count} αξιολόγηση χωρίς σχόλιο σχετικά με{when}:{breakdown}",
+  "reviews.summary.lineDay.other": "{count} βαθμολογίες χωρίς σχόλιο σχετικά με{when}:{breakdown}",
+  "reviews.summary.showOne": "Δείξ' το.",
+  "reviews.summary.showMany": "Δείξτε τους.",
+  "reviews.breakdown.5": "{n} πέντε αστέρων",
+  "reviews.breakdown.4": "{n}4 αστέρων",
+  "reviews.breakdown.3": "{n} τρία αστέρια",
+  "reviews.breakdown.2": "{n} δύο αστέρων",
+  "reviews.breakdown.1": "{n} ένα αστέρι",
+  "reviews.breakdown.none": "{n} χωρίς βαθμολογία",
+  "reviews.dialog.title": "Επανάληψη{name}",
+  "reviews.dialog.lede.cashu": "Μοιραστείτε την εμπειρία σας με αυτό το mint.",
+  "reviews.dialog.lede.fedimint": "Μοιραστείτε την εμπειρία σας με αυτή την ομοσπονδία.",
+  "reviews.dialog.lede.lnurl": "Μοιραστείτε την εμπειρία σας με αυτό το mint.",
+  "reviews.dialog.permanent": "Δημοσιεύεται μόνιμα σε δημόσια relays του Nostr.",
+  "reviews.dialog.gate.title": "Συνδεθείτε για να γράψετε μια κριτική",
+  "reviews.dialog.gate.lead": "Οι κριτικές υπογράφονται με το κλειδί σας Nostr. Παραμένει στον signer σας, αυτό το site δεν το βλέπει ποτέ.",
+  "reviews.dialog.ratingLegend": "Η βαθμολογία σας",
+  "reviews.dialog.starsSr.one": "{n} άστρο",
+  "reviews.dialog.starsSr.other": "{n} αστέρια",
+  "reviews.dialog.chooseRating": "Επιλέξτε μια βαθμολογία",
+  "reviews.dialog.starLabel": "{n}:{phrase}",
+  "reviews.dialog.stars.1": "να το αποφύγεις.",
+  "reviews.dialog.stars.2": "είχε προβλήματα",
+  "reviews.dialog.stars.3": "Που έχουν υποστεί κατεργασία με σπηλαιώδη υλικά",
+  "reviews.dialog.stars.4": "Ωραία.",
+  "reviews.dialog.stars.5": "έργα μεγάλη",
+  "reviews.dialog.bodyLabel": "Τι πρέπει να ξέρουν οι άλλοι;",
+  "reviews.dialog.charCount": "{n}- Ναι.{max}",
+  "reviews.dialog.submit": "Υπογραφή και δημοσίευση",
+  "reviews.dialog.signing": "Υπογραφή...",
+  "reviews.dialog.publishing": "Εκδόσεις...",
+  "reviews.dialog.publishingTo": "Έκδοση σε ρελέ ({accepted}- Ναι.{total})",
+  "reviews.dialog.waitingExtension": "Αναμονή για την επέκτασή σας",
+  "reviews.dialog.waitingSigner": "Περιμένω τον υπογράφοντα σου.",
+  "reviews.dialog.confirmClose": "Κλείστε αυτή την κριτική; Το προσχέδιο σας διατηρείται μέχρι να φύγετε από το site.",
+  "reviews.dialog.why.login": "Σύνδεση για δημοσίευση",
+  "reviews.dialog.why.words": "Γράψε μερικές λέξεις.",
+  "reviews.dialog.why.more.one": "{n} περισσότερο χαρακτήρα",
+  "reviews.dialog.why.more.other": "{n} περισσότεροι χαρακτήρες",
+  "reviews.dialog.why.over.one": "{n} χαρακτήρας πέραν του ορίου",
+  "reviews.dialog.why.over.other": "{n} χαρακτήρες πέραν του ορίου",
+  "reviews.dialog.identity.needSigner": "Χρειάζεστε έναν υπογράφοντα της Nostr για να δημοσιεύσετε. Το κλειδί σας παραμένει σε αυτό, αυτό το site δεν το βλέπει ποτέ.",
+  "reviews.dialog.identity.loginToPublish": "Σύνδεση για δημοσίευση",
+  "reviews.dialog.identity.switch": "Εναλλαγή",
+  "reviews.dialog.identity.extension": "Υπογραφή με την επέκταση του περιηγητή σας",
+  "reviews.dialog.identity.readingKey": "Διαβάζοντας το δημόσιο κλειδί σας...",
+  "reviews.dialog.identity.willAsk": "Η παράτασή σας θα ζητηθεί να υπογράψετε",
+  "reviews.dialog.error.noRelay": "Δεν αναμεταδότης αποδέχτηκε την αναθεώρηση. Ελέγξτε τη σύνδεσή σας, στη συνέχεια, προσπαθήστε ξανά.",
+  "reviews.validate.rating": "Επιλέξτε μια βαθμολογία από 1 έως 5 αστέρια.",
+  "reviews.validate.short": "Γράψε τουλάχιστον{n} χαρακτήρες έτσι ώστε η κριτική είναι χρήσιμη.",
+  "reviews.validate.long": "Οι κριτικές περιορίζονται σε{n} χαρακτήρες.",
+  "feed.title": "Τελευταίες κριτικές για το vomismatokopoo και την ομοσπονδία · Cashumints.space",
+  "feed.description": "Κάθε κριτική για mint, ομοσπονδία και mint LNURL μόλις δημοσιεύεται: {reviews} κριτικές για {mints} mints Cashu, {federations} ομοσπονδίες Fedimint και {lnurl} mints LNURL, υπογεγραμμένες στο Nostr και αναγνώσιμες εδώ με τις νεότερες πρώτα. Φιλτράρετε ανά οικοσύστημα, βαθμολογία ή όνομα.",
+  "feed.heading": "Τελευταίες κριτικές",
+  "feed.lede": "Κάθε κριτική για κάθε Κασού νομοτόπο και Fedimint ομοσπονδία, νεότερος πρώτα, διαβάστε ζωντανά από τα ρελέ Nostr. Κάθε ένα είναι υπογεγραμμένο από τον συγγραφέα του και ζει στα ρελέ, όχι στη βάση δεδομένων μας.",
+  "feed.label": "Επανεξέταση",
+  "feed.showingBuild.one": "Εμφάνιση της πιο πρόσφατης κριτικής από το τελευταίο build",
+  "feed.showingBuild.other": "Δείχνοντας το{n} πιο πρόσφατες κριτικές από το τελευταίο build",
+  "feed.noscript": "Οι κριτικές είναι υπογεγραμμένες στο Nostr και φορτώστε το πρόγραμμα περιήγησης, έτσι ώστε το φιλτράρισμα και η πλήρης λίστα να χρειάζονται JavaScript.{n} σχόλια παρακάτω διαβάστηκαν από τα ρελέ όταν χτίστηκε αυτή η σελίδα.",
+  "feed.emptyBuild": "Δεν υπάρχουν σχόλια που θα μπορούσαν να διαβαστούν από τα ρελέ όταν αυτή η σελίδα χτίστηκε. Η λίστα επαναφορτώνει από τα ρελέ στον browser σας.",
+  "feed.foot": "Οι κριτικές είναι γνώμες της κοινότητας, δεν επαληθεύονται αξιώσεις.{link} πριν εμπιστευτείς ένα νόμισμα με χρήματα.",
+  "feed.footLink": "αποποίηση ευθύνης",
+  "feed.showing": "Εμφάνιση{shown} του{total} αναθεωρήσεις",
+  "feed.showingMatching": "Εμφάνιση{shown} του{matching} Αντιστοίχιση των ανασκοπήσεων ({total} Σύνολο)",
+  "feed.emptyRelays": "Δεν υπάρχουν κριτικές από τα ρελέ. Ανοίξτε οποιαδήποτε σελίδα vomismatopo για να διαβάσετε και να γράψετε σχόλια εκεί.",
+  "feed.emptyFilter": "Δεν υπάρχουν σχόλια που να ταιριάζουν με αυτό το φίλτρο. Καθαρίστε το κουτί με το νόμισμα ή δοκιμάστε τα όλα.",
+  "feed.relayError": "Αδύνατη η πρόσβαση στα ρελέ. Εμφάνιση των κριτικών από την τελευταία κατασκευή.",
+  "feed.relayEmpty": "Δεν υπάρχουν κριτικές από τα ρελέ. Εμφάνιση των κριτικών από το τελευταίο κτίριο.",
+  "feed.reading": "Διαβάζω τους αναμεταδότες...",
+  "login.open": "Σύνδεση",
+  "login.title": "Σύνδεση με τη Nostr",
+  "login.note": "Το κλειδί σου μένει στην υπογραφή σου.",
+  "login.extension.name": "Επέκταση περιηγητή",
+  "login.extension.desc": "Υπογραφή με Alby, nos2x ή άλλη επέκταση NIP-07",
+  "login.extension.none": "Δε βρέθηκε επέκταση",
+  "login.extension.getOne": "Πάρε ένα:",
+  "login.remote.name": "Απομακρυσμένη υπογραφή",
+  "login.remote.desc": "Ανίχνευση κώδικα με εφαρμογή σήμανσης, ή επικόλληση ενός συνδέσμου αποθήκης",
+  "login.primal.name": "Πρωτεύων",
+  "login.primal.desc": "Εγκρίνετε την σύνδεση στην εφαρμογή Primal στο τηλέφωνό σας",
+  "login.paste.label": "Ή επικολλήστε το σύνδεσμο σύνδεσης που σας έδωσε ο υπογράφων σας",
+  "login.copyLink": "Αντιγραφή του συνδέσμου σύνδεσης",
+  "login.whatIsNostr": "Τι είναι το Νοστρ;",
+  "login.connect.remote.title": "Σύνδεση απομακρυσμένου υπογραφέα",
+  "login.connect.remote.lead": "Σαρώστε αυτό με την εφαρμογή υπογραφέα σας, ή αντιγράψτε το σύνδεσμο και επικολλήστε το εκεί.",
+  "login.connect.remote.hint": "Λειτουργεί με οποιοδήποτε NIP-46 υπογραφή: Nsec.app, Amber, Nostrify, δικό σας καταφύγιο.",
+  "login.connect.remote.open": "Άνοιγμα στην εφαρμογή του υπογράφοντος",
+  "login.connect.primal.title": "Σύνδεση με το Primal",
+  "login.connect.primal.lead": "Ανοίξτε το Primal στο τηλέφωνό σας, βρείτε απομακρυσμένη υπογραφή στις ρυθμίσεις του, και σαρώστε αυτόν τον κωδικό.",
+  "login.connect.primal.hint": "Primal πινακίδες για άλλες εφαρμογές πάνω από το NIP-46, έτσι αυτή είναι η ίδια σύνδεση που χρησιμοποιεί οποιοσδήποτε υπογράφων, και το κλειδί σας παραμένει στο Primal.{link}",
+  "login.connect.primal.open": "Άνοιγμα σε Primal",
+  "login.status.buildingLink": "Κατασκευή ενός συνδέσμου",
+  "login.status.waitingExtension": "Αναμονή για την επέκτασή σας",
+  "login.status.waitingSigner": "Περιμένω τον υπογράφοντα σου.",
+  "login.status.connecting": "Σύνδεση με τον υπογράφοντα",
+  "login.status.connected": "Συνδεδεμένο",
+  "login.toast.loggedIn": "Συνδεθήκατε",
+  "login.toast.fetchingProfile": "Λήψη του προφίλ σας στο Nostr από τα relays…",
+  "login.toast.profile": "Προφίλ: {name}",
+  "login.toast.noProfile": "Δεν βρέθηκε προφίλ στα relays",
+  "login.method.extension": "Επέκταση",
+  "login.method.remote": "Απομακρυσμένο",
+  "login.method.primal": "Πρωτεύων",
+  "login.account": "Ο λογαριασμός σας στη Nostr",
+  "login.copyNpub": "Αντιγραφή πλήρους npub σας",
+  "login.logout": "Αποσύνδεση",
+  "signer.status.waitingExtension": "Αναμονή για την επέκτασή σας",
+  "signer.status.signed": "Υπογραφή",
+  "signer.status.reconnecting": "Επανασύνδεση στον υπογράφοντα",
+  "signer.status.approveWindow": "Ο υπογράφων σας θέλει να το εγκρίνετε αυτό στο δικό του παράθυρο.",
+  "signer.status.waitingSigner": "Περιμένω τον υπογράφοντα σου.",
+  "signer.status.stillWaiting": "Ακόμα περιμένω να απαντήσει ο υπογράφων σου.",
+  "signer.status.connected": "Συνδεδεμένο",
+  "signer.error.noExtension": "Δεν βρέθηκε επέκταση υπογραφής. Εγκαταστήστε το Alby ή nos2x, στη συνέχεια επαναφόρτωση αυτής της σελίδας.",
+  "signer.error.privateKey": "Αυτό μοιάζει με ένα ιδιωτικό κλειδί, όχι με σύνδεση σύνδεσης. Αυτή η τοποθεσία δεν παίρνει ποτέ ένα κλειδί. Επικόλληση της αποθήκης:// σύνδεση που σας έδωσε ο υπογράφων σας.",
+  "signer.error.badLink": "Αυτό δεν είναι μια σύνδεση σύνδεση αυτή η ιστοσελίδα καταλαβαίνει. Επικόλληση του καταφυγίου:// σύνδεση από τον υπογράφοντα σας.",
+  "signer.error.noAnswer": "Ο υπογράφων σας δεν απάντησε. Μπορεί να είναι κλειστός, ή το ρελέ του μπορεί να είναι κάτω. Ανοίξτε το και προσπαθήστε ξανά.",
+  "signer.error.timeout": "Ο υπογράφων σας δεν απάντησε εγκαίρως. Ανοίξτε το, ελέγξτε ότι είναι ακόμα συνδεδεμένο, στη συνέχεια, προσπαθήστε ξανά.",
+  "signer.error.cancelled": "Η σύνδεση ακυρώθηκε.",
+  "signer.error.declined": "Η αίτηση υπογραφής απορρίφθηκε.",
+  "notfound.title": "Η σελίδα δε βρέθηκε · Cashumints.space",
+  "notfound.description": "Αυτή η σελίδα δεν υπάρχει στο Cashumints.space.",
+  "notfound.heading": "Αυτή η σελίδα δεν υπάρχει",
+  "notfound.lede": "Μπορεί να έχει μετακινηθεί, ή το νόμισμα μπορεί να μην είναι ακόμη ευρετηριασμένο. Αναζήτηση για ένα νόμισμα από το όνομα ή το domain, ή επικόλληση ενός νόμισματος URL.",
+  "notfound.browse": "Περιήγηση σε όλες τις νομεατικές περιοχές",
+  "notfound.home": "Πήγαινε σπίτι.",
+  "notfound.loading": "Φόρτωση{host}",
+  "notfound.fb.rating": "Αξιολόγηση",
+  "notfound.fb.reviews": "Επανεξέταση",
+  "notfound.fb.software": "Λογισμικό",
+  "notfound.fb.lastOnline": "Τελευταία σύνδεση",
+  "notfound.fb.note": "Αυτό το mint καταχωρήθηκε μετά την τελευταία κατασκευή του ιστότοπου, οπότε αυτή είναι μια σύνοψη από το ζωντανό API, με τις κριτικές από κάτω. Η πλήρης σελίδα εμφανίζεται στην επόμενη κατασκευή.",
+  "notfound.resolve.checking": "Πρώτη επίσκεψη: ελέγχεται τώρα αυτό το mint.",
+  "notfound.resolve.failed": "Αυτό το mint δεν μπόρεσε να προστεθεί",
+  "notfound.resolve.failedFedimint": "Αυτή η ομοσπονδία δεν μπόρεσε να προστεθεί",
+  "notfound.resolve.retry": "Δοκίμασε άλλη διεύθυνση",
+  "notfound.resolve.switch": "Άνοιξέ το ως mint {kind}",
+  "notfound.resolve.fedimint": "Η διεύθυνση σελίδας μιας ομοσπονδίας δεν περιέχει τον κωδικό πρόσκλησής της, οπότε αυτή δεν βρίσκεται μόνο από τον σύνδεσμο. Επικόλλησε τον κωδικό πρόσκλησης και προστίθεται.",
+  "notfound.resolve.ambiguous": "Αυτή η διεύθυνση δεν προκύπτει μόνο από τον σύνδεσμο. Επικόλλησε το πλήρες URL του mint και προστίθεται.",
+  "wallets.title": "Πορτοφόλια Cashu · Cashumints.space",
+  "wallets.description": "Πορτοφόλια Cashu που λειτουργούν με τη νόμισμα που αναφέρεται εδώ, σε όλα τα κινητά, web, browser και τη γραμμή εντολών, με ό, τι ο καθένας είναι καλός σε.",
+  "wallets.heading": "Πορτοφόλια",
+  "wallets.lede": "Χρειάζεται ένα πορτοφόλι για να κρατήσει εκάς από οποιοδήποτε από αυτά τα νόμισμα. Τα περισσότερα πορτοφόλια μιλούν με αρκετά νόμισμα ταυτόχρονα, έτσι ώστε να μην είναι δεμένα με το πρώτο που θα δοκιμάσετε.",
+  "wallets.note": "Ο κατάλογος αυτός δεν είναι εξαντλητικός και δεν αποτελεί έγκριση.{link}. Ένα πορτοφόλι κρατά τα κλειδιά, ένα vomismatokopoo κρατά τα χρήματα: διαβάστε το vomismatopo σχόλια πριν να επιλέξετε όπου σας sats ζουν.",
+  "wallets.platform.android": "Ανδροειδές",
+  "wallets.platform.ios": "iOS",
+  "wallets.platform.web": "Ιστός",
+  "wallets.platform.extension": "Επέκταση περιηγητή",
+  "wallets.platform.cli": "CLI",
+  "wallets.platform.python": "Πάιθον",
+  "wallets.item.minibits": "Κινητό πορτοφόλι εκάς με το δικό του vomismatopo, υποστήριξη διεύθυνσης Lightning και επαφές Nostr.",
+  "wallets.item.nutstash": "Browser πορτοφόλι που χειρίζεται πολλαπλές νόμισμα και ταυτόχρονα και τις εισαγωγές και εξαγωγές ακατέργαστα μάρκες.",
+  "wallets.item.enuts": "Κινητό πορτοφόλι επικεντρώθηκε σε multimint υπόλοιπα και αποστολή εκάς πάνω από Nostr.",
+  "wallets.item.cashume": "Αναφορά web πορτοφόλι από το έργο Cashu. Τρέχει εξ ολοκλήρου στο πρόγραμμα περιήγησης, μπορεί να εγκατασταθεί ως PWA.",
+  "wallets.item.boardwalk": "Web πορτοφόλι χτισμένο γύρω από διευθύνσεις Lightning και αποστολή εκάς από το σύνδεσμο.",
+  "wallets.item.coinos": "Κεραυνός πορτοφόλι και σημείο πώλησης που τρέχει επίσης το δικό του Cassu νόμισμα στοπίου.",
+  "wallets.item.oxchat": "Nοστρ αγγελιοφόρος με ένα πορτοφόλι εκάς ενσωματωμένο, για την αποστολή sats μέσα συνομιλίες.",
+  "wallets.item.nutshell": "Η εφαρμογή αναφοράς. Λειτουργεί ως πορτοφόλι στη γραμμή εντολών και ως λογισμικό vomismatokopoo.",
+  "about.title": "Σχετικά με το Cashumints.space",
+  "about.description": "Τι είναι το Cashu, τι είναι ένα vomismatopo, τι είναι το NIP-87, και πώς αυτό το site indexes vomismatopopeia και διαβάζει κριτικές από το Nostr relays.",
+  "about.heading": "Σχετικά",
+  "about.lede": "Cashumints.space απαριθμεί κάθε Cashu νόμισμα που μπορούμε να βρούμε στο δίκτυο Nostr και σας δείχνει τι λένε οι άνθρωποι γι 'αυτούς.",
+  "about.cashu.title": "Τι είναι το Cashu",
+  "about.cashu.p1": "Το Cashu είναι ένα πρωτόκολλο εκάς για το Bitcoin. Ένα νόμισμα θέμα τυφλών σημείων που υποστηρίζονται από sats που κρατά, και αυτά τα σημεία κινούνται μεταξύ των ανθρώπων χωρίς το νόμιμο μάθησης που έστειλε τι. Η ιδιωτικότητα είναι πραγματική και είναι το σημείο: τα σημεία δεν είναι λογαριασμοί, και το vomismatokopoo δεν μπορεί να συνδέσει το σημείο που υπογράφεται με το σημείο που επιστρέφει.",
+  "about.cashu.p2": "Μπορείτε να διαβάσετε το πρωτόκολλο και τις προδιαγραφές του στο{link}. Οι ίδιες οι προδιαγραφές ονομάζονται NUTs, από όπου προέρχονται οι αριθμοί NUT σε κάθε σελίδα νόμισμα.",
+  "about.mints.title": "Τι νόμισμα είναι αυτό, και η ανταλλαγή",
+  "about.mints.p1": "Ένα νόμισμα είναι θεματοφύλακας. Όταν voμισματοκόπιο εκάς μοιράζει κορμούς σε όποιον τρέχει τον διακομιστή, και τους εμπιστεύεσαι να τιμήσουν τα σημεία όταν τα λιώνεις πίσω. Δεν υπάρχει απόδειξη απάτης, δεν υπάρχει εγγύηση και δεν υπάρχει προσφυγή. Ένας vomismatokopoo operator μπορεί να εξαφανιστεί με την ισορροπία, και η vomismatokopeia έχουν.",
+  "about.mints.p2": "Αυτός είναι ακριβώς ο λόγος που οι κριτικές υπάρχουν εδώ. Αυτή η ιστοσελίδα δεν σας λέει ποτέ ένα vomismatokopoo είναι ασφαλές.{code}, δεν είναι ⁇ εμπιστευμένο ⁇ και αυτό σημαίνει μόνο ο διακομιστής απάντησε όταν ζητήσαμε τελευταία φορά. Αντιμετωπίστε τα υπόλοιπα εκάς όπως μετρητά σε μια τσέπη παλτό: πρόστιμο για τις δαπάνες, λάθος για τις αποταμιεύσεις.",
+  "about.nip87.title": "Τι είναι το NIP- 87",
+  "about.nip87.p1": "Το NIP-87 είναι το συνέδριο της Nostr για την ανακοίνωση και τη σύσταση εκάς νόμισμα. Δύο είδη εκδηλώσεων έχουν σημασία εδώ:",
+  "about.nip87.li1": "{code} ανακοινώνει ένα vomismatokopoo. Το vomismatokopoo URL είναι στο{tag}tag. Έτσι ανακαλύπτει η ιστοσελίδα τη νομισματοποιία που δεν έχει δει ποτέ.",
+  "about.nip87.li2": "{code} είναι μια κριτική. Περιέχει την αξιολόγηση και το κείμενο κριτικής, και σημεία στο νόμισμα είναι περίπου με ένα{utag}tag (το vomismatokopoo URL) και a{dtag}tag (το δημόσιο κλειδί του νόμιμου).",
+  "about.nip87.p2": "Κάθε κριτική υπογράφεται από το κλειδί Nostr του συγγραφέα του. Ποτέ δεν καλέσετε μια κριτική ⁇ επιβεβαιώθηκε ⁇ γιατί κανείς δεν το επιβεβαίωσε: είναι υπογεγραμμένο, η οποία είναι μια διαφορετική και πιο χρήσιμη αξίωση. Αυτό σημαίνει ότι μπορείτε να ελέγξετε ποιος το έγραψε και ότι δεν έχει τροποποιηθεί.",
+  "about.how.title": "Πώς λειτουργεί αυτό το site",
+  "about.how.p1": "Υπάρχουν δύο βρόχοι και ένας κανόνας. Ο κανόνας είναι ότι το νόμισμα έχει τα μεταδεδομένα του και η Nostr κατέχει τις κριτικές, έτσι αυτή η ιστοσελίδα δεν αποθηκεύει ούτε ως αρχή.",
+  "about.how.li1": "{strong} ⁇ ωτά κάθε γνωστό νόμισμα για{code} κάθε δέκα λεπτά και καταγράφει τι λέει: όνομα, περιγραφή, έκδοση, υποστηριζόμενη NUTs, όρια, στοιχεία επικοινωνίας. Επίσης, καταγράφει αν το vomismatopo απάντησε καθόλου, από όπου προέρχεται ο χρόνος up.",
+  "about.how.li1Label": "Ο βρόχος του καθετήρα",
+  "about.how.li2": "{strong} Συνδέεται με Nost relays κάθε ώρα, διαβάζει vomismatopo ανακοινώσεις και κριτικές, και προσθέτει οποιοδήποτε vomismatopo που δεν έχει ξαναδεί.",
+  "about.how.li2Label": "Ο βρόχος ανακάλυψης",
+  "about.how.p2": "Το σημαντικό μέρος είναι αυτό που συμβαίνει όταν ένα νόμισμα σταματά να απαντά. Τα κρυμμένα μεταδεδομένα του δεν έχουν αντικατασταθεί ποτέ από ένα αποτυχημένο καθετήρα, οπότε ένα νεκρό νόμισμα κρατά την πλήρη σελίδα του: τα specs, την ιστορία του και τις κριτικές του, με ένα banner που λέει όταν σκοτείνιασε. Η προηγούμενη έκδοση αυτού του site έδειξε μια σελίδα λάθους αντί, που σήμαινε ότι οι άνθρωποι της νομισματοπηίας που ήταν πιο απαραίτητοι να προειδοποιηθούν ο ένας για τους άλλους ήταν αυτοί που δεν μπορούσαν να αναθεωρηθούν. Αυτός ήταν ο κύριος λόγος για την ανοικοδόμηση.",
+  "about.how.p3": "Το κείμενο αναθεώρησης δεν αποθηκεύεται ποτέ από την πλευρά μας. Όταν ανοίγετε μια σελίδα vomismatopo ο περιηγητής σας μιλάει στα ρελέ απευθείας και διαβάζει τα σχόλια από μόνο του, και όταν γράφετε ένα αυτό υπογράφεται από τη δική σας επέκταση Nost και αποστέλλεται κατ 'ευθείαν σε αυτά τα ρελέ. Κρατάμε μια καταμέτρηση έτσι ώστε οι σελίδες να μπορούν να ταξινομηθούν και να ταξινομηθούν, τίποτα περισσότερο. Τίποτα εδώ δεν μπορεί να επεξεργαστεί ή να διαγραφεί από εμάς, συμπεριλαμβανομένων των κριτικών που θα προτιμούσαμε να μην έχουν.",
+  "about.relays.title": "Αναδιατάξεις που διαβάζουμε",
+  "about.relays.p1": "Αυτά είναι τα relays ο indexer και ο περιηγητής σας χρησιμοποιούν:",
+  "about.relays.p2": "Αυτή είναι η όλη υπόσχεση: τίποτα εδώ δεν είναι αλήθεια μόνο επειδή το λέμε εμείς.",
+  "about.nuts.title": "Τι είναι τα NUTs;",
+  "about.nuts.p1": "NUTs είναι οι αριθμημένες προδιαγραφές Cashu, όπως BIPs για Bitcoin. Ένα νόμισμα που διαφημίζει ποια είναι αυτά που εφαρμόζει, και αυτό σας λέει τι μπορεί να κάνει: NUT-04 και NUT-05 κόβουν και λιώνουν πάνω από Lightning (χωρίς αυτά ένα νόμισμα που δεν είναι πολύ χρήση), NUT-07 επιτρέπει έναν έλεγχο πορτοφολιού αν ένα token ήταν ήδη δαπανημένο, NUT-17 δίνει πορτοφόλια ζωντανές ενημερώσεις πάνω από WebSockets αντί για δημοσκοπήσεις, και NUT-20 επιτρέπει ένα πορτοφόλι αποδεικνύει ένα νόμισμα που περιέχει πραγματικά εκδόθηκε σε αυτό.{link}.",
+  "about.numbers.title": "Τώρα αμέσως.",
+  "about.numbers.p1": "{mints} καταχωρισμένα νομισματοκοπεία, από τα οποία {online} ανταποκρίνονται, και {reviews} κριτικές μετρημένες από τους παραπάνω αναμεταδότες.",
+  "about.source.title": "Πηγή και πίστωση",
+  "about.source.p1": "Το site είναι ανοιχτό κώδικα στο{github}. Είναι χτισμένο και διοικείται από{azzamo}. Αν μια σελίδα vomismatopo έχει κάτι λάθος πάνω της, διορθώστε το στην πηγή: τα μεταδεδομένα vomismakopoo προέρχονται από το vomismatokopoo του δικού του{code}, και οι κριτικές προέρχονται από Nostr.",
+  "terms.title": "Όροι χρήσης · Cashumints.space",
+  "terms.description": "Όροι χρήσης για το Cashumints.space: τι είναι το site, τι δεν κάνει, και ποιος είναι υπεύθυνος για τι. Χωρίς λογαριασμούς, χωρίς εγγυήσεις, καμία σχέση με οποιοδήποτε νόμισμα.",
+  "terms.heading": "Όροι χρήσης",
+  "terms.lede": "Απλοί όροι για μια ιστοσελίδα που μόνο ευρετήρια δημόσια στοιχεία. Τελευταία ενημέρωση{date}.",
+  "terms.what.title": "Τι είναι αυτό το site",
+  "terms.what.p1": "Cashumints.space είναι ένας δείκτης των διαθέσιμων στο κοινό δεδομένων σχετικά με Cassu vomismatopopeia. Δύο είδη δεδομένων, και τα δύο από κάπου αλλού:",
+  "terms.what.li1": "μεταδεδομένα vomismatokopoo, που διαβάζονται από κάθε vomismatopopoo του δικού του{code}endpoint: όνομα, περιγραφή, έκδοση λογισμικού, υποστηριζόμενη NUTs, στοιχεία επικοινωνίας και αν το vomismatopo απάντησε όταν ρωτήσαμε τελευταία φορά.",
+  "terms.what.li2": "Reviews, read from public Nostr relays. Αυτά είναι τα γεγονότα NIP-87 που δημοσιεύονται από τους συγγραφείς τους για να αναμεταδίδει ο καθένας μπορεί να ρωτήσει.",
+  "terms.what.p2": "Συλλέγουμε αυτά τα δεδομένα, τα ομαλοποιούμε, τα κατατάσσουμε και τα δείχνουμε.",
+  "terms.noAccounts.title": "Χωρίς λογαριασμούς, χωρίς εγγυήσεις.",
+  "terms.noAccounts.p1": "Δεν υπάρχει τίποτα για να εγγραφείτε. Η ιστοσελίδα παρέχεται όπως είναι, χωρίς καμία εγγύηση οποιουδήποτε είδους: όχι ότι τα δεδομένα είναι ακριβή, όχι ότι είναι τρέχουσα, όχι ότι η ιστοσελίδα θα είναι διαθέσιμη. νόμισμα δεδομένων μπορεί να είναι λεπτά ή ώρες παλιό, ένα νόμισμα μπορεί να αλλάξει μετά την τελευταία φορά που ελέγχαμε, και ένα ρελέ μπορεί να αποτύχει να απαντήσει, οπότε και βλέπετε λιγότερο από ό, τι υπάρχει.",
+  "terms.noAccounts.p2": "Δεν είμαστε υπεύθυνοι για οποιαδήποτε απώλεια που προκύπτει από τη χρήση αυτής της ιστοσελίδας ή βασίζεται σε οτιδήποτε διαβάζετε εδώ.{link} για τους συγκεκριμένους κινδύνους χρήσης ενός Cassu vomismatopo.",
+  "terms.noAccounts.link": "αποποίηση ευθύνης",
+  "terms.noCustody.title": "Δεν κρατάμε τα χρήματά σας.",
+  "terms.noCustody.p1": "Δεν έχει πορτοφόλι, δεν αγγίζει εκάς, και δεν μπορεί να κινηθεί, να παγώσει ή να ανακτήσει τίποτα. Αν έχετε πρόβλημα με ένα νομισματοκοπείο, το vomismatokopo operator είναι το μόνο μέρος που μπορεί να σας βοηθήσει, και δεν μπορούμε να επικοινωνήσουμε μαζί τους για λογαριασμό σας.",
+  "terms.noCustody.p2": "Δεν είμαστε συνδεδεμένοι με κανένα νόμισμα που αναφέρεται εδώ, και κανένα νόμισμα δεν πληρώνει για την καταχώρισή του, την κατάταξη του ή την αξιολόγηση του.",
+  "terms.reviews.title": "Οι κριτικές είναι λέξεις άλλων ανθρώπων",
+  "terms.reviews.p1": "Οι κριτικές είναι περιεχόμενο που δημιουργείται από το χρήστη και δημοσιεύεται σε δημόσιες αναμεταδόσεις Nostr από τους συντάκτες τους. Τους προβάλλουμε, δεν τους ελέγχουμε. Δεν τους γράψαμε, δεν μπορούμε να τους επεξεργαστούμε, και δεν μπορούμε να τους διαγράψουμε από τα ρελέ που τους κρατούν: είναι υπογεγραμμένα γεγονότα σε ένα δίκτυο που δεν έχουμε.",
+  "terms.reviews.p2": "Μια ανασκόπηση είναι μια εμπειρία ενός ατόμου, όχι ένα επαληθευμένο γεγονός. Αν δημοσιεύσετε ένα, είστε υπεύθυνοι για ό, τι λέει. Μην δημοσιεύσετε τίποτα παράνομο, και να γνωρίζετε ότι αυτό που δημοσιεύετε είναι δημόσιο και μόνιμο (βλ.{link}).",
+  "terms.reviews.link": "σελίδα απορρήτου",
+  "terms.reviews.p3": "Μπορούμε να σταματήσουμε να επιδεικνύουμε μια συγκεκριμένη αναθεώρηση σε αυτό το site, και θα το κάνουμε αυτό για περιεχόμενο που είναι παράνομο. Αυτό το αφαιρεί μόνο από αυτές τις σελίδες. Το γεγονός παραμένει στα ρελέ και κάθε άλλος πελάτης της Nostr μπορεί ακόμα να το διαβάσει.",
+  "terms.links.title": "Σύνδεσμοι με άλλους ιστότοπους",
+  "terms.links.p1": "vomismatokopoo URLs, σύνδεσμοι πορτοφολιού, επαφές τελεστών και οτιδήποτε άλλο που δείχνει από αυτό το site είναι εκεί επειδή είναι μέρος των δεδομένων. Ένας σύνδεσμος δεν είναι μια υποστήριξη και δεν εξετάζουμε τι είναι στην άλλη άκρη.",
+  "terms.changes.title": "Αλλαγές",
+  "terms.changes.p1": "Οι όροι αυτοί μπορούν να αλλάξουν. Η ημερομηνία στην κορυφή λέει πότε το έκαναν τελευταία φορά. Η ιστοσελίδα είναι ανοιχτή πηγή, έτσι κάθε αλλαγή σε αυτή τη σελίδα είναι στην ιστορία της δέσμευσης.",
+  "terms.contact.title": "Επαφή",
+  "terms.contact.p1": "Θέματα και αιτήσεις για λήψη είναι καλύτερα να υποβληθούν σε{github}. Το site διοικείται από{azzamo}.",
+  "privacy.title": "Ιδιωτικότητα · Cashumints.space",
+  "privacy.description": "Ιδιωτικότητα στο Cashumints.space: χωρίς λογαριασμούς, χωρίς cookies παρακολούθησης, χωρίς αναλυτικά. Το localStorage χρησιμοποιείται για την προσωρινή αποθήκευση προφίλ και τίποτα δεν αποστέλλεται πουθενά. Οι κριτικές υπογράφονται στον δικό σας browser.",
+  "privacy.heading": "Ιδιωτικότητα",
+  "privacy.lede": "Συλλέγουμε όσο λιγότερα μπορεί μια ιστοσελίδα.{date}.",
+  "privacy.noAccounts.title": "Χωρίς λογαριασμούς",
+  "privacy.noAccounts.p1": "Δεν υπάρχει εγγραφή, καμία σύνδεση και κανένα προφίλ. Τίποτα σε αυτό το site σας ρωτάει ποιος είστε, και δεν υπάρχει εγγραφή χρήστη για να διαρρεύσει, επειδή δεν υπάρχουν χρήστες.",
+  "privacy.noTracking.title": "Χωρίς cookies παρακολούθησης, χωρίς ανάλυση",
+  "privacy.noTracking.p1": "Ο ιστότοπος δεν θέτει cookies για παρακολούθηση. Δεν υπάρχει σενάριο ανάλυσης, δεν υπάρχει διαχειριστής ετικέτας, κανένα pixel, καμία εγγραφή συνεδρίας και κανένα διαφημιστικό δίκτυο.",
+  "privacy.logs.title": "Καταγραφές εξυπηρετητή",
+  "privacy.logs.p1": "Ο web server διατηρεί τα τυποποιημένα αρχεία καταγραφής πρόσβασης, που είναι αυτό που κάνει ο κάθε web server εξ ορισμού. Μια γραμμή καταγραφής καταγράφει τη διεύθυνση IP σας, τη στιγμή, τη σελίδα που ζητήσατε, την κατάσταση απόκρισης, και τον πράκτορα χρήστη και referrer που σας έστειλε ο browser σας. Τα αρχεία καταγραφής υπάρχουν για να αποσφαλματώσετε σφάλματα και κατάχρησης θέσης. Δεν ενώνονται σε τίποτα άλλο και δεν πωλούνται ή μοιράζονται.",
+  "privacy.logs.operatorLabel": "Σημείωση τελεστή:",
+  "privacy.logs.operator": "Αν εκτελέσετε αυτή την τοποθεσία, δηλώστε την πραγματική κατακράτησή σας εδώ. Η ανάπτυξη στο README χρησιμοποιεί το nginx με το προκαθορισμένο αρχείο καταγραφής πρόσβασης και όποια περιστροφή τα πλοία διανομής σας (στο Debian και το Ubuntu που είναι logrotate, καθημερινά, διατηρώντας 14 ημέρες). Επιβεβαιώστε τι κάνει ο διακομιστής σας και αντικαταστήστε αυτή την παράγραφο με τον αριθμό.",
+  "privacy.storage.title": "Τι είναι αποθηκευμένο στον browser σας",
+  "privacy.storage.p1": "Η ιστοσελίδα χρησιμοποιεί το τοπικόΑποθήκευση για ακριβώς δύο πράγματα, τα οποία παραμένουν στη συσκευή σας και δεν αποστέλλονται ποτέ πουθενά:",
+  "privacy.storage.li1": "Μια λανθάνουσα μνήμη μεταδεδομένων προφίλ Nostr (είδος 0 γεγονότα: ονόματα, avatars, διευθύνσεις NIP-05) για τους κριτές των οποίων τις κριτικές έχετε εξετάσει. Αυτό αποθηκεύει re-querying ρελέ σε κάθε σελίδα.",
+  "privacy.storage.li2": "Προτιμήσεις διεπαφής, έτσι ώστε η ιστοσελίδα συμπεριφέρεται με τον ίδιο τρόπο την επόμενη φορά.",
+  "privacy.storage.p2": "Τίποτα δεν σπάει, οι αναζητήσεις προφίλ απλά τρέχουν και πάλι.",
+  "privacy.thirdParties.title": "Σε τι μιλάει ο περιηγητής σας",
+  "privacy.thirdParties.p1": "Φόρτωση μιας σελίδας συνδέει το πρόγραμμα περιήγησης σας σε μερικά μέρη εκτός από αυτό το site. Έτσι ένας ιστότοπος χωρίς παρακολούθηση από πλευράς διακομιστή εξακολουθεί να διαβάζει ζωντανά δεδομένα:",
+  "privacy.thirdParties.li1Label": "Δημόσιοι αναμεταδότες Nostr",
+  "privacy.thirdParties.li1": "{strong}, πάνω από το WebSocket, για να διαβάσετε τις κριτικές και τα προφίλ του κριτή. Το ρελέ βλέπει IP σας και ό, τι ζητήσατε, όπως κάθε διακομιστή που συνδέετε με κάνει. Τα ρελέ αναφέρονται στο{link}.",
+  "privacy.thirdParties.li1Link": "σχετικά με τη σελίδα",
+  "privacy.thirdParties.li2Label": "Εικόνες avatar κριτών",
+  "privacy.thirdParties.li2": "{strong}, φορτωμένο από όπου τα σημεία προφίλ του κριτή. Αυτά αποστέλλονται με μια πολιτική μη referrer, έτσι ώστε ο οικοδεσπότης δεν μαθαίνει σε ποια σελίδα ήσασταν.",
+  "privacy.publishing.title": "Έκδοση μιας ανασκόπησης",
+  "privacy.publishing.p1": "Γράφοντας μια κριτική συμβαίνει στο πρόγραμμα περιήγησής σας, όχι στο διακομιστή μας. Το γεγονός υπογράφεται από την επέκταση NIP-07 (Alby, nos2x ή παρόμοια) και μεταδίδεται από το πρόγραμμα περιήγησής σας κατευθείαν στα ρελέ. Το ιδιωτικό κλειδί σας δεν αφήνει ποτέ την επέκταση και αυτή η ιστοσελίδα δεν το βλέπει ποτέ.",
+  "privacy.permanent.title": "Ό,τι δημοσιεύσεις στη Νοστρ είναι δημόσιο και μόνιμο.",
+  "privacy.permanent.p1": "Αυτό είναι το μέρος που αξίζει να διαβαστεί δύο φορές. Μια αναθεώρηση είναι ένα υπογεγραμμένο γεγονός σε δημόσιες αναμεταδόσεις.",
+  "privacy.permanent.li1": "Ο καθένας μπορεί να το διαβάσει, τώρα και αργότερα, χρησιμοποιώντας οποιοδήποτε πελάτη Nostr. Δεν είναι ⁇ δημόσιο στο Cashumints.space ⁇ είναι δημόσια στο δίκτυο.",
+  "privacy.permanent.li2": "Είναι μόνιμα συνδεδεμένο με το δημόσιο κλειδί της Nostr σας, μαζί με όλα τα άλλα που το κλειδί έχει δημοσιεύσει ποτέ.",
+  "privacy.permanent.li3": "Διαγραφή είναι μια αίτηση, όχι μια εντολή. Μπορείτε να δημοσιεύσετε ένα γεγονός διαγραφής και κάποια ρελέ θα το τιμήσει, αλλά ένα ρελέ είναι ελεύθερο να το αγνοήσει και όποιος έχει ήδη αντιγράψει το γεγονός εξακολουθεί να το έχει.",
+  "privacy.permanent.li4": "Δεν μπορούμε να το διαγράψουμε για σας. Μπορούμε να σταματήσουμε την εμφάνιση εδώ, αυτό δεν αλλάζει τίποτα στα ρελέ.",
+  "privacy.permanent.p2": "Αν θέλετε να ανασκοπήσετε ένα νόμισμα χωρίς αυτό να είναι συνδεδεμένο με την κύρια ταυτότητά σας, χρησιμοποιήστε ένα ξεχωριστό πλήκτρο Nostr. Σημειώστε ότι ένα κλειδί χωρίς καμία άλλη δραστηριότητα εμφανίζεται ως τέτοιο σε σκληρές κριτικές, επειδή ένα ολοκαίνουργιο κλειδί που γράφει μια κριτική ενός αστεριού είναι ένα μοτίβο που αξίζει να δουν οι αναγνώστες.",
+  "privacy.contact.title": "Ερωτήσεις",
+  "privacy.contact.p1": "Ο ιστότοπος είναι ανοιχτός: αν θέλετε να ελέγξετε κάποιο από τα παραπάνω, διαβάστε τον κωδικό στο{github}. Ερωτήσεις και διορθώσεις μπορούν να υπεισέλθουν σε ένα θέμα.",
+  "disclaimer.title": "Αποποίηση ευθύνης · Cashumints.space",
+  "disclaimer.description": "Τι πρέπει να ξέρετε πριν χρησιμοποιήσετε ένα Cassu vomismatokopoo: vomismatokopeia are stepterel, ένα vomismatokopoo μπορεί να εξαφανιστεί με τα χρήματά σας, οι κριτικές είναι απόψεις και σε απευθείας σύνδεση μέσα προσβάσιμα, όχι αξιόπιστα.",
+  "disclaimer.heading": "Αποποίηση ευθύνης",
+  "disclaimer.lede": "Διαβάστε αυτό πριν βάλετε τα χρήματα σε ένα νόμισμα. Τελευταία ενημέρωση{date}.",
+  "disclaimer.callout": "Ένα Κασού νόμισμα κρατά τα χρήματά σας για σας. Αν εξαφανιστεί, η εκάς σας έχει φύγει, και δεν υπάρχει κανείς να προσελκύσετε. Κρατήστε μόνο ό, τι μπορείτε να αντέξετε οικονομικά να χάσετε.",
+  "disclaimer.custodial.title": "Η νομισματοποιία είναι θεματοφυλακή",
+  "disclaimer.custodial.p1": "Όταν κάνετε vomismatokopoo ecash, μπορείτε να Bitcoin χέρι στο vomismatokopoo operator και να πάρει τα σημεία πίσω. Αυτά τα σημεία είναι μια απαίτηση για αυτό το τελεστή. Δεν είναι Bitcoin σας κρατήσει, και ο χειριστής είναι αυτός που αποφασίζει αν θα τα τιμήσει.",
+  "disclaimer.custodial.p2": "Αυτό σημαίνει ότι κάθε νόμισμα φέρει τους ίδιους κινδύνους: ο χειριστής μπορεί να εξαφανιστεί, μπορεί να αναγκαστεί να σταματήσει, μπορεί να χάσει τα κεφάλαια μέσω ενός bug ή ενός hack, ή μπορεί απλά να απενεργοποιήσει το διακομιστή.",
+  "disclaimer.custodial.p3": "Το Cashu έχει σχεδιαστεί για μικρές ποσότητες που κινούνται γρήγορα. Χρησιμοποιήστε το έτσι: κρατήστε ό,τι πρόκειται να δαπανήσετε, όχι τις αποταμιεύσεις σας, και εξαπλώστε σε όλη τη νόμισμα και όχι να παρκάρετε τα πάντα σε ένα.",
+  "disclaimer.reviews.title": "Οι κριτικές είναι γνώμες, όχι επαληθευμένες απαιτήσεις",
+  "disclaimer.reviews.p1": "Κάθε κριτική εδώ γράφτηκε από κάποιον στο Nostr και υπέγραψε με το κλειδί του. Υπογεγραμμένο σημαίνει ότι μπορούμε να σας πούμε ποιο κλειδί το έγραψε. Αυτό δεν σημαίνει ότι η κριτική είναι αλήθεια, ότι ο συγγραφέας χρησιμοποίησε το vomismatokopoo, ή ότι ο συγγραφέας δεν είναι ο χειριστής, ένας ανταγωνιστής, ή ένα άτομο με δέκα πλήκτρα.",
+  "disclaimer.reviews.p2": "Δεν επαληθεύουμε τους κριτές, και δεν επεξεργαστούμε ή αφαιρέσουμε κριτικές με τις οποίες διαφωνούμε. Διαβάστε μερικές, δείτε τι λένε πραγματικά, και ζυγίστε ένα νόμισμα με τρεις κριτικές διαφορετικά από ένα με τριακόσιες.",
+  "disclaimer.status.title": "Σε απευθείας σύνδεση μέσα προσιτό, δεν είναι αξιόπιστο",
+  "disclaimer.status.p1": "Ελέγχουμε κάθε νόμισμα τακτικά και δείχνουμε αν απαντήθηκε. Αυτό είναι ένα πράσινο καθεστώς σημαίνει: ο διακομιστής απάντησε. Δεν λέει τίποτα για το αν ο χειριστής είναι διαλύτης, ειλικρινής, ή εξακολουθεί να σκοπεύει να τιμήσει τις μάρκες σας αύριο.",
+  "disclaimer.status.p2": "Ένα vomismatokopoo μπορεί να είναι online μέχρι τη στιγμή που δεν είναι. Uptime ιστορία, υποστηριζόμενη NUTs και έκδοση λογισμικού σας πω κάτι για το πώς ένα vomismatokopoo τρέχει, αλλά κανείς από αυτούς δεν είναι μια υπόσχεση για τα χρήματά σας.",
+  "disclaimer.ranking.title": "Πώς λειτουργεί η κατάταξη, και τι δεν σημαίνει",
+  "disclaimer.ranking.p1": "Η νομισματοποιία παραγγέλλεται από έναν αλγόριθμο πάνω από τα δεδομένα δημόσιας κριτικής: αξιολόγηση, αριθμός κριτικών και πρόσφατη δραστηριότητα, με online νομισματοκοπεία μπροστά από τα offlines από προεπιλογή.",
+  "disclaimer.ranking.p2": "Κανείς δεν πληρώνει για την τοποθέτηση. Δεν υπάρχει χορηγός υποδοχή, δεν προωθήθηκε λίστα και καμία ρύθμιση με οποιοδήποτε vomismatokopoo σε αυτό το site. Μια υψηλή κατάταξη σημαίνει ότι ο αλγόριθμος άρεσε τα δημόσια δεδομένα, και τίποτα περισσότερο.",
+  "disclaimer.notAdvice.title": "Αυτό δεν είναι οικονομική συμβουλή.",
+  "disclaimer.notAdvice.p1": "Τίποτα σε αυτό το site δεν είναι οικονομική, επένδυση, νομική ή φορολογική συμβουλές. Δεν γνωρίζουμε την κατάστασή σας και δεν σας συμβουλεύουμε. Χρησιμοποιώντας ένα νόμιμο, και επιλέγοντας ποια από τις δύο, είναι η απόφασή σας.",
+  "disclaimer.dyor.title": "Κάνε τη δική σου έρευνα.",
+  "disclaimer.dyor.li1": "Ένα vomismatokopo από κάποιον με δημόσια φήμη να χάσει είναι μια διαφορετική πρόταση από ένα ανώνυμο URL.",
+  "disclaimer.dyor.li2": "Διαβάστε τους ίδιους τους όρους του vomismatokopoo και το MOTD του. Ένα vomismatokopoo που αυτοαποκαλείται test ή beta σημαίνει it.",
+  "disclaimer.dyor.li3": "Ξεκινήστε το μικρό. vomismatopo λίγο, ξοδέψτε το, λιώστε το πίσω προς τα έξω, και να δούμε τι θα συμβεί πριν το εμπιστευτείτε με περισσότερα.",
+  "disclaimer.dyor.li4": "Ένα χαμηλό μέγιστο είναι συχνά ένα σημάδι ενός προσεκτικού χειριστή, και ένα υψηλό δεν είναι ένα σημάδι ενός ασφαλούς.",
+  "disclaimer.dyor.li5": "Κρατήστε τα σημειώματά σας στη θέση τους και να θυμάστε ότι ένα δείγμα είναι ένα περιουσιακό στοιχείο που φέρει: όποιος το κατέχει μπορεί να το δαπανήσει.",
+  "disclaimer.site.title": "Σχετικά με την ίδια την ιστοσελίδα",
+  "disclaimer.site.p1": "Τα δεδομένα εδώ μπορεί να είναι λανθασμένα ή ξεπερασμένα. Η νομοθεσία ερευνάται σε ένα πρόγραμμα, τα ρελέ μερικές φορές αποτυγχάνουν να απαντήσουν, και μια σελίδα που διαβάζετε χτίστηκε κάποια στιγμή στο παρελθόν. Η ιστοσελίδα παρέχεται όπως είναι, χωρίς εγγύηση.{link}.",
+  "disclaimer.site.link": "Όροι χρήσης",
+  "disclaimer.updated": "20 Αυγούστου 2026",
+  "login.getPrimal": "Πάρτε το Primal",
+  "reviews.dialog.identity.extensionGone": "Η επέκταση του προγράμματος περιήγησης σας δεν απαντά. Συνδεθείτε ξανά ή χρησιμοποιήστε έναν απομακρυσμένο υπογράφοντα.",
+  "seo.orgDescription": "Ένας κατάλογος της Cassu vomismatopopeia, με ζωντανή κατάσταση από κάθε vomismatopo και κοινοτικές κριτικές υπογεγραμμένες στο Nostr.",
+  "seo.ogImageAlt": "Cashumints.space: βρείτε ένα Cashu νόμισμα που μπορείτε να εμπιστευτείτε.",
+  "seo.mint.title.one": "{name} κριτικές: βαθμολογία {rating} από {n} κριτική | Cashumints.space",
+  "seo.mint.title.other": "{name} αξιολογήσεις: βαθμολογημένες{rating} από{n} σχόλια. Cashumints.space",
+  "seo.mint.titleOffline.one": "{name}: εκτός σύνδεσης για {n} ημέρα | Cashumints.space",
+  "seo.mint.titleOffline.other": "{name}: εκτός σύνδεσης για{n} ημέρες. Cashumints.space",
+  "seo.mint.titleNoReviews": "{name}: πληροφορίες και κριτικές για το Cashu mint | Cashumints.space",
+  "seo.fedimint.titleNoReviews": "{name}: πληροφορίες και κριτικές για την ομοσπονδία Fedimint | Cashumints.space",
+  "seo.desc.fallback": "Κοινοτικές αναθεωρήσεις{name}({domain}).",
+  "seo.desc.fallbackDomain": "Κοινοτικές κριτικές για το Cashu vomismatokopo στο{domain}.",
+  "seo.desc.rated.one": "Ονομαστική{rating}/5 από{n} υπογεγραμμένη αναθεώρηση Nostr.",
+  "seo.desc.rated.other": "Ονομαστική{rating}/5 από{n} υπογεγραμμένες κριτικές της Nostr.",
+  "seo.desc.noReviews": "Δεν υπάρχουν κριτικές ακόμα.",
+  "seo.desc.status": "{status}.",
+  "seo.desc.statusLimits": "{status}, όρια{limits}.",
+  "seo.desc.fedModules": "{status} Ενότητες:{modules}.",
+  "seo.desc.fedModulesNetwork": "{status} Ενότητες:{modules} Εμπρός{network}.",
+  "seo.mint.ogAlt.one": "{name}:{rating} αστέρια από{n} ανασκόπηση του Cashumints.space",
+  "seo.mint.ogAlt.other": "{name}:{rating} αστέρια από{n} σχόλια για Cashumints.space",
+  "seo.mint.ogAltNoReviews": "{name} στο Cashumints.space",
+  "nav.home": "Αρχική",
+  "mint.more.title": "Περισσότερα νομισματοκοπεία",
+  "mint.more.all": "Προβολή όλων των νομευμάτων",
+  "nav.fedimints": "Fedimints",
+  "status.announced": "Ανακοινώθηκε μόνο",
+  "card.unnamedFederation": "Ανώνυμη ομοσπονδία",
+  "card.notChecked": "δεν ελέγχθηκε ποτέ",
+  "fedimints.title": "Όλες οι ομοσπονδίες της Fedimint · Cashumints.space",
+  "fedimints.description": "Όλα{total} Οι ομοσπονδίες Fedimint ανακοίνωσαν στο δίκτυο Nostr:{online}επιβεβαιωμένη με εξωτερικό έλεγχο,{announced} Κοινοτικές αξιολογήσεις, ενότητες και να καλέσει τους κωδικούς για το καθένα.",
+  "fedimints.heading": "Όλες οι ομοσπονδίες",
+  "fedimints.lede": "Κάθε ομοσπονδία Fedimint ανακοίνωσε στο δίκτυο Nostr. Μια ομοσπονδία δεν έχει κανένα δημόσιο καθεστώς τελικό σημείο της, έτσι ώστε μερικά από αυτά επιβεβαιώνονται με εξωτερικό έλεγχο και τα υπόλοιπα είναι καταχωρημένα ακριβώς όπως ανακοινώθηκε.",
+  "fedimints.search.label": "Αναζήτηση ομοσπονδιών με όνομα ή ταυτότητα",
+  "fedimints.search.placeholder": "Αναζήτηση με το όνομα ή την ομοσπονδία id...",
+  "fedimints.sort.label": "Ταξινόμηση ομοσπονδιών",
+  "fedimints.hideOffline": "Απόκρυψη εκτός σύνδεσης",
+  "fedimints.showing": "Εμφάνιση{total} ομοσπονδίες ({online} Επιβεβαιώθηκε,{announced} μόνο)",
+  "fedimints.showingFiltered": "Εμφάνιση{shown} του{total} ομοσπονδίες ({online} Επιβεβαιώθηκε,{announced} μόνο)",
+  "fedimints.announcedNote.one": "Ένα από αυτά ανακοινώθηκε στο Nostr και τίποτα δεν έχει επιβεβαιώσει από τότε που λειτουργεί. Είναι καταχωρημένο ως αναγγελθέν και όχι ως online ή offline, επειδή κανένα από τα δύο δεν θα ήταν αλήθεια.",
+  "fedimints.announcedNote.other": "{n} από αυτά ανακοινώθηκαν στη Nostr και τίποτα δεν έχει επιβεβαιωθεί από τότε που τρέχουν.",
+  "fedimints.noResults": "Δοκίμασε ένα όνομα, ή επικόλλησε μια ταυτότητα ομοσπονδίας.",
+  "fedimints.emptyIndex": "Δεν έχουν ανακοινωθεί ομοσπονδίες στις αναμεταδόσεις που διαβάζει αυτή η ιστοσελίδα.",
+  "fedimint.crumb": "Φοινικισμοί",
+  "fedimint.breadcrumb": "Ψωμί",
+  "fedimint.unnamed": "Ανώνυμη ομοσπονδία",
+  "fedimint.idLabel": "Ομοσπονδία",
+  "fedimint.kind.federationId": "id ομοσπονδίας",
+  "fedimint.moduleCount.one": "{n} μονάδα",
+  "fedimint.moduleCount.other": "{n} δομοστοιχεία",
+  "fedimint.copyInvite": "Αντιγραφή κωδικού πρόσκλησης",
+  "fedimint.confirmed.label": "Επιβεβαιώθηκε",
+  "fedimint.confirmed.never": "Ποτέ.",
+  "fedimint.confirmed.by": "από{source}",
+  "fedimint.confirmed.unattributed": "Τελευταίος έλεγχος",
+  "fedimint.announcedOn": "αναγγέλθηκε{when}",
+  "fedimint.announcedUnknown": "δεν ημερομηνία ανακοίνωσης",
+  "fedimint.modules.title": "Ενότητες",
+  "fedimint.modules.none": "Η ανακοίνωση της ομοσπονδίας δεν περιλαμβάνει ενότητες.",
+  "fedimint.modules.note": "Οι ενότητες είναι τα μέρη που λειτουργεί μια ομοσπονδία. \\\" ανακοίνωση λέει τα οποία είναι παρόντα, και τίποτα για το αν κάποιος από αυτούς δέχεται καταθέσεις.",
+  "fedimint.modules.notListed": "μη εισηγμένη",
+  "fedimint.invite.title": "Κωδικός πρόσκλησης",
+  "fedimint.invite.count.one": "{n} κωδικός",
+  "fedimint.invite.count.other": "{n} κωδικοί",
+  "fedimint.invite.note": "Προσκολλήστε αυτό σε ένα πορτοφόλι Fedimint για να ενταχθούν. Μεταφέρει την ταυτότητα της ομοσπονδίας και τις διευθύνσεις των κηδεμόνων της, και προορίζεται να μοιραστεί.",
+  "fedimint.invite.kind": "κωδικός πρόσκλησης",
+  "fedimint.invite.qr": "QR",
+  "fedimint.invite.qrCaption": "Σάρωση για ένταξη{name}",
+  "fedimint.details.federationId": "id Ομοσπονδία",
+  "fedimint.details.network": "Δίκτυο",
+  "fedimint.details.announcedBy": "Ανακοινώθηκε από",
+  "fedimint.details.announced": "Ανακοινώθηκε",
+  "fedimint.more.title": "Περισσότερες ομοσπονδίες",
+  "fedimint.more.all": "Δείτε όλες τις ομοσπονδίες",
+  "fedimint.disclaimer": "Η συμμετοχή σε μια ομοσπονδία σημαίνει να εμπιστεύονται τους κηδεμόνες της με τα χρήματά σας. Οι αξιολογήσεις είναι κοινοτικές απόψεις, και επιβεβαιωμένα τρέχοντα μέσα που μπορούν να επιτευχθούν, δεν είναι αξιόπιστη.",
+  "fedimint.module.lightning": "Αστραπή",
+  "fedimint.module.mint": "Εκκρεμές τοκετό",
+  "fedimint.module.wallet": "Πορτοφόλι με αλυσίδα",
+  "fedimint.module.meta": "Μεταδεδομένα",
+  "fedimint.module.stability_pool": "Πίνακας 2",
+  "fedimint.module.multi_sig_stability_pool": "Πίνακας 2",
+  "fedimint.module.fedi-social": "Κοινωνική αποκατάσταση",
+  "fedimint.network.mainnet": "Κεντρικό δίκτυο Bitcoin",
+  "fedimint.network.signet": "Σημαντικό",
+  "fedimint.network.testnet": "Δακτύλιος δοκιμής",
+  "fedimint.network.testnet4": "Δίχτυ ελέγχου4",
+  "fedimint.network.regtest": "Επανεξέταση",
+  "feed.ecosystem.group": "Οικολογικό σύστημα",
+  "feed.ecosystem.all": "Όλα",
+  "feed.ecosystem.cashu": "Κασού",
+  "feed.ecosystem.fedimint": "Fedimint (Φεντιμίντ)",
+  "feed.filterBySubject": "Φίλτρο από το vomismatokopoo ή την ομοσπονδία",
+  "feed.anySubject": "Οποιοδήποτε νόμισμα ή ομοσπονδία",
+  "feed.clearSubject": "Καθαρισμός του φίλτρου ονόματος",
+  "home.topFedimints.title": "Κορυφαία Fedimints",
+  "home.topFedimints.sub": "κατατάσσεται ανά αξιολόγηση και αξιολόγηση",
+  "home.topFedimints.all": "Όλα{n} ομοσπονδίες →",
+  "reviews.validate.subject": "Δεν υπάρχει τίποτα που να δείχνει αυτή την αναθεώρηση.",
+  "mint.warnings.fedimintOffline.lead": "Αναφέρθηκε εκτός σύνδεσης.",
+  "mint.warnings.fedimintOffline.body.since": "Ο τελευταίος έλεγχος που έφτασε σε αυτή την ομοσπονδία ήταν για{date}({days} Οι κηδεμόνες του δεν έχουν απαντήσει από τότε. Αντιμετωπίστε τα κεφάλαια που κρατούνται εκεί ως σε κίνδυνο, και μην ενωθείτε με νέα κεφάλαια.",
+  "mint.warnings.fedimintOffline.body.never": "Κανένας έλεγχος αυτής της ομοσπονδίας δεν έχει φτάσει ποτέ σε αυτήν, και η πιο πρόσφατη απέτυχε.",
+  "mint.warnings.fedimintOffline.meta.since": "Αναφέρθηκε εκτός σύνδεσης από την{date}",
+  "mint.warnings.fedimintOffline.meta.never": "Αναφέρθηκε εκτός σύνδεσης, ποτέ δεν έφτασε.",
+  "mint.warnings.neverConfirmed.lead": "Ανακοινώθηκε, δεν επιβεβαιώθηκε ποτέ.",
+  "mint.warnings.neverConfirmed.body.reviewed": "Αυτή η ομοσπονδία ανακοινώθηκε στο Nostr για{date},{days} Τα σχόλια που ακολουθούν είναι το μόνο σημάδι ζωής σε αυτή τη σελίδα? όλα τα άλλα προήλθε από την ανακοίνωση.",
+  "mint.warnings.neverConfirmed.body.quiet": "Αυτή η ομοσπονδία ανακοινώθηκε στο Nostr για{date},{days}Η Επιτροπή θα πρέπει να λάβει υπόψη της τις προτάσεις της Επιτροπής.",
+  "mint.warnings.neverConfirmed.meta": "Ανακοινώθηκε{date}, δεν επιβεβαιώθηκε ποτέ",
+  "footer.allFedimints": "Όλες οι ομοσπονδίες",
+  "reviews.dialog.bodyPlaceholder.cashu": "Πώς λειτούργησε η κοπή, το λιώσιμο και η υποστήριξη; Να είστε συγκεκριμένοι.",
+  "reviews.dialog.bodyPlaceholder.fedimint": "Πώς λειτούργησε η ένταξη, οι πληρωμές Lightning και η υποστήριξη; Να είστε συγκεκριμένοι.",
+  "fedimint.details.title": "Στοιχεία Ομοσπονδίας",
+  "nav.lnurlMints": "Mints LNURL",
+  "footer.allLnurlMints": "Όλα τα mints LNURL",
+  "lnurlMints.title": "Mints LNURL: mints για κομιστικά γραμμάτια lnurlcash, με κριτικές | Cashumints.space",
+  "lnurlMints.description": "Και τα {total} mints LNURL που έχουν ευρετηριαστεί από το δίκτυο Nostr: {online} σε σύνδεση, {offline} εκτός σύνδεσης. Βαθμολογίες της κοινότητας, όρια ανάληψης και δυνατότητες για το καθένα.",
+  "lnurlMints.heading": "Mints LNURL",
+  "lnurlMints.lede": "Κάθε mint LNURL που γνωρίζει αυτός ο ιστότοπος. Ένα mint LNURL εκδίδει κομιστικά γραμμάτια lnurlcash: γραμμάτια Lightning που κρατάτε ως μυστικό και που μπορούν να περιστραφούν, να διαιρεθούν, να συγχωνευθούν ή να λιώσουν πίσω σε μια πληρωμή Lightning. Το καθένα ελέγχεται μέσω HTTPS κάθε λίγα λεπτά.",
+  "lnurlMints.search.label": "Αναζήτηση mints LNURL",
+  "lnurlMints.search.placeholder": "Αναζήτηση με όνομα ή διεύθυνση…",
+  "lnurlMints.sort.label": "Ταξινόμηση mints LNURL κατά",
+  "lnurlMints.hideOffline": "Απόκρυψη εκτός σύνδεσης",
+  "lnurlMints.showing": "Εμφανίζονται {total} mints LNURL ({online} σε σύνδεση, {offline} εκτός σύνδεσης)",
+  "lnurlMints.showingFiltered": "Εμφανίζονται {shown} από {total} mints LNURL ({online} σε σύνδεση, {offline} εκτός σύνδεσης)",
+  "lnurlMints.noResults": "Κανένα mint LNURL δεν ταιριάζει.",
+  "lnurlMints.emptyIndex": "Δεν έχει ευρετηριαστεί ακόμη κανένα mint LNURL.",
+  "lnurl.crumb": "Mints LNURL",
+  "lnurl.breadcrumb": "Διαδρομή πλοήγησης",
+  "lnurl.copyAddress": "Αντιγραφή διεύθυνσης",
+  "lnurl.more.title": "Περισσότερα mints LNURL",
+  "lnurl.more.all": "Όλα τα mints LNURL →",
+  "lnurl.disclaimer": "Ένα mint LNURL κρατά τα sats σας ενώ εσείς κρατάτε τα γραμμάτιά του, οπότε η χρήση του σημαίνει εμπιστοσύνη στον διαχειριστή του. Οι βαθμολογίες είναι απόψεις της κοινότητας, και «σε σύνδεση» σημαίνει προσβάσιμο, όχι αξιόπιστο.",
+  "lnurl.features.title": "Δυνατότητες",
+  "lnurl.features.none": "Αυτό το mint δεν έχει ανακοινώσει τι υποστηρίζει.",
+  "lnurl.features.note": "Οι δυνατότητες είναι όσα ανακοίνωσε ο διαχειριστής του mint στο Nostr. Όπου αυτός ο ιστότοπος μπορεί να ελέγξει κάποια μέσω HTTPS το κάνει, και το αναφέρει όταν κάτι ανακοινωμένο δεν είναι διαθέσιμο αυτή τη στιγμή.",
+  "lnurl.features.notListed": "μη ανακοινωμένο",
+  "lnurl.features.unavailable": "μη διαθέσιμο",
+  "lnurl.feature.mint": "Κοπή μέσω Lightning (LUD-06)",
+  "lnurl.feature.melt": "Λιώσιμο προς Lightning",
+  "lnurl.feature.notes": "Περιστροφή / διαίρεση / συγχώνευση γραμματίων",
+  "lnurl.feature.lud16": "Διεύθυνση Lightning",
+  "lnurl.feature.lud21": "Επαλήθευση πληρωμής (LUD-21)",
+  "lnurl.feature.signed-notes": "Υπογεγραμμένα γραμμάτια (επαλήθευση εκτός σύνδεσης)",
+  "lnurl.feature.onion": "Διεύθυνση Tor",
+  "lnurl.feature.rotate": "Περιστροφή γραμματίου",
+  "lnurl.feature.split": "Διαίρεση γραμματίου",
+  "lnurl.feature.merge": "Συγχώνευση γραμματίων",
+  "lnurl.feature.lud06": "LUD-06 payRequest",
+  "lnurl.feature.lud03": "LUD-03 withdrawRequest",
+  "lnurl.limits.label": "Όρια ανάληψης",
+  "lnurl.limits.notPublished": "μη δημοσιευμένο",
+  "lnurl.limits.withdrawRow": "Ανάληψη",
+  "lnurl.limits.disabled": "απενεργοποιημένο",
+  "lnurl.limits.sats.one": "{n} sat",
+  "lnurl.limits.sats.other": "{n} sats",
+  "lnurl.details.title": "Στοιχεία mint",
+  "lnurl.details.address": "Διεύθυνση Lightning",
+  "lnurl.details.mintPubkey": "Δημόσιο κλειδί του mint",
+  "lnurl.details.onion": "Διεύθυνση Tor",
+  "lnurl.details.fee": "Προμήθεια κοπής",
+  "lnurl.details.node": "Κόμβος",
+  "lnurl.details.capacity": "Ανακοινωμένη χωρητικότητα",
+  "lnurl.kind.lightningAddress": "διεύθυνση Lightning",
+  "lnurl.kind.mintPubkey": "δημόσιο κλειδί του mint",
+  "lnurl.kind.onionAddress": "διεύθυνση Tor",
+  "lnurl.confirmed.label": "Τελευταία επιβεβαίωση",
+  "lnurl.confirmed.when": "επιβεβαιώθηκε {when}",
+  "lnurl.fee.base.one": "{n} sat",
+  "lnurl.fee.base.other": "{n} sats",
+  "lnurl.fee.percent": "{percent}%",
+  "home.topLnurl.title": "Κορυφαία mints LNURL",
+  "home.topLnurl.sub": "κατάταξη βάσει κριτικών και βαθμολογίας",
+  "home.topLnurl.all": "Και τα {n} mints LNURL →",
+  "feed.ecosystem.lnurl": "LNURL",
+  "reviews.dialog.bodyPlaceholder.lnurl": "Πώς πήγαν η κοπή, το λιώσιμο και η περιστροφή γραμματίων; Γίνετε συγκεκριμένοι.",
+  "reviews.byUrl.open": "Γράψε μια κριτική",
+  "reviews.byUrl.title": "Γράψε μια κριτική",
+  "reviews.byUrl.lede": "Επικόλλησε τη διεύθυνση. Αν ο ιστότοπος δεν την ξέρει ακόμα, την ελέγχει και την προσθέτει τώρα.",
+  "reviews.byUrl.label.cashu": "URL του mint",
+  "reviews.byUrl.label.fedimint": "Κωδικός πρόσκλησης της ομοσπονδίας",
+  "reviews.byUrl.label.lnurl": "URL του LNURL mint",
+  "reviews.byUrl.placeholder.cashu": "mint.example.com",
+  "reviews.byUrl.placeholder.fedimint": "fed11…",
+  "reviews.byUrl.placeholder.lnurl": "mint.example.com",
+  "reviews.byUrl.check": "Έλεγξε αυτή τη διεύθυνση",
+  "reviews.byUrl.checking": "Γίνεται έλεγχος…",
+  "reviews.byUrl.back": "Χρήση άλλης διεύθυνσης",
+  "reviews.byUrl.existing": "Ήδη καταχωρημένο",
+  "reviews.byUrl.indexed": "Μόλις προστέθηκε",
+  "reviews.byUrl.confirmClose": "Να κλείσει; Η διεύθυνση που έγραψες δεν κρατιέται.",
+  "reviews.byUrl.detected": "Αυτή η διεύθυνση απάντησε ως mint {kind}.",
+  "reviews.byUrl.switchTo": "Κάνε κριτική ως mint {kind}",
+  "reviews.byUrl.error.empty": "Γράψε πρώτα μια διεύθυνση.",
+  "reviews.byUrl.error.badUrl": "Αυτό δεν μοιάζει με URL mint.",
+  "reviews.byUrl.error.badInvite": "Αυτός δεν είναι κωδικός πρόσκλησης Fedimint. Οι κωδικοί ξεκινούν με fed11.",
+  "reviews.byUrl.error.badInput": "Ο ιστότοπος δεν μπορεί να ελέγξει αυτή τη διεύθυνση.",
+  "reviews.byUrl.error.blocked": "Δεν είναι δημόσια διεύθυνση, οπότε δεν μπορεί να ελεγχθεί.",
+  "reviews.byUrl.error.notAMint": "Αυτή η διεύθυνση απάντησε, αλλά όχι ως mint αυτού του είδους.",
+  "reviews.byUrl.error.wrongType": "Αυτή η διεύθυνση απάντησε, αλλά ως άλλο είδος mint.",
+  "reviews.byUrl.error.unverifiable": "Τίποτα δεν απάντησε σε αυτή τη διεύθυνση, και δεν υπάρχει ακόμα ίχνος της στο Nostr.",
+  "reviews.byUrl.error.rateLimited.one": "Πολλοί έλεγχοι από μία σύνδεση. Δοκίμασε ξανά σε περίπου {n} λεπτό.",
+  "reviews.byUrl.error.rateLimited.other": "Πολλοί έλεγχοι από μία σύνδεση. Δοκίμασε ξανά σε περίπου {n} λεπτά.",
+  "reviews.byUrl.error.network": "Δεν ήταν δυνατή η σύνδεση με το ευρετήριο. Έλεγξε τη σύνδεσή σου και δοκίμασε ξανά.",
+  "seo.lnurl.titleNoReviews": "{name}: πληροφορίες και κριτικές για το mint LNURL | Cashumints.space",
+  "seo.desc.statusWithdraw": "{status}, ανάληψη {min}–{max} sat.",
+  "mint.chip.noFunding": "Χωρίς κοπή / λιώσιμο",
+  "mint.warnings.lnurlWithdrawalsDisabled.lead": "Οι αναλήψεις είναι απενεργοποιημένες.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.online": "Αυτό το mint ανακοινώνει μέγιστη ανάληψη μηδέν, οπότε κανένα γραμμάτιο που εκδίδει δεν μπορεί να εξαργυρωθεί με τίποτα. Μην κόβετε εδώ μέχρι να αλλάξει αυτό.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.offline": "Την τελευταία φορά που έγινε προσβάσιμο, αυτό το mint ανακοίνωνε μέγιστη ανάληψη μηδέν, οπότε κανένα γραμμάτιο που εξέδιδε δεν μπορούσε να εξαργυρωθεί με τίποτα. Μην κόβετε εδώ μέχρι να αλλάξει αυτό.",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.online": "Οι αναλήψεις είναι προς το παρόν απενεργοποιημένες",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.offline": "Οι αναλήψεις ήταν απενεργοποιημένες την τελευταία φορά",
+  "mint.warnings.lnurlInvalid.lead": "Το endpoint απαντά αλλά είναι άκυρο.",
+  "mint.warnings.lnurlInvalid.body": "Ο διακομιστής απαντά, αλλά όχι με ανακοίνωση mint που μπορεί να διαβάσει αυτός ο ιστότοπος, οπότε οι αναλήψεις ίσως δεν λειτουργούν. Όσα ακολουθούν είναι η τελευταία κατάσταση που διαβάστηκε, και οι κριτικές εξακολουθούν να λειτουργούν.",
+  "mint.warnings.lnurlInvalid.meta": "Απαντά, αλλά όχι με έγκυρη ανακοίνωση mint",
+  "mint.warnings.lnurlNoFunding.lead": "Η κοπή και το λιώσιμο δεν είναι διαθέσιμα.",
+  "mint.warnings.lnurlNoFunding.body": "Τα υπάρχοντα γραμμάτια μπορούν ακόμη να περιστραφούν, να διαιρεθούν ή να συγχωνευθούν, αλλά αυτή τη στιγμή τίποτα δεν μπαίνει ή βγαίνει μέσω Lightning. Το ίδιο το mint λειτουργεί και απαντά· ο κόμβος Lightning πίσω του δεν είναι προσβάσιμος από αυτό.",
+  "mint.warnings.lnurlNoFunding.meta": "Κοπή και λιώσιμο μη διαθέσιμα",
+  "mint.warnings.also.noFunding": "Και ο κόμβος Lightning του ήταν απροσπέλαστος, οπότε τίποτα δεν μπορούσε να κοπεί ή να λιώσει."
+}

web/src/i18n/en.json

@@ -50,6 +50,10 @@
   "footer.privacy": "Privacy",
   "footer.madeBy": "Made with ❤️ by {azzamo} · Powered by Cashu and NIP-87",
   "footer.warning": "Mints are custodial. A mint can disappear with your money.",
+  "footer.tagline": "Community reviews for ecash mints, signed on Nostr.",
+  "footer.col.explore": "Explore",
+  "footer.col.site": "Site",
+  "footer.nav": "Footer",
   "home.title": "Cashumints.space · Find a Cashu mint you can trust",
   "home.description": "Find a Cashu mint you can trust. {mints} mints indexed with {reviews} community reviews signed on Nostr, plus live uptime, supported NUTs and mint software.",
   "home.hero.title": "Find a Cashu mint",
@@ -61,7 +65,7 @@
   "home.filters.highestRated": "Highest rated",
   "home.filters.recentlyActive": "Recently active",
   "home.filters.websockets": "Supports WebSockets",
-  "home.top.title": "Top mints",
+  "home.top.title": "Top Cashu mints",
   "home.top.sub": "ranked by reviews and rating",
   "home.top.all": "All {n} mints →",
   "home.latest.title": "Latest reviews",
@@ -114,6 +118,8 @@
   "card.reviewed": "reviewed {when}",
   "card.noReviews": "no reviews yet",
   "mint.title": "{name} · Cashu mint reviews",
+  "mint.titleFedimint": "{name} · Fedimint federation reviews",
+  "mint.titleLnurl": "{name} · LNURL mint reviews",
   "mint.breadcrumb": "Breadcrumb",
   "mint.crumbMints": "Cashu mints",
   "mint.copyUrl": "Copy mint URL",
@@ -243,24 +249,40 @@
   "nut.25": "BOLT12 payment method",
   "reviews.title": "Reviews",
   "reviews.anon": "Anon",
+  "reviews.anonTitle": "No public Nostr profile found for this key",
+  "reviews.nip05Title": "NIP-05 identifier (not verified by this site)",
   "reviews.filter.group": "Filter reviews",
   "reviews.filter.all": "All",
   "reviews.filter.five": "5★",
   "reviews.filter.critical": "Critical",
   "reviews.filter.recent": "Recent",
+  "reviews.filter.hideAnon": "Hide anon",
+  "reviews.anonHidden.other": "Showing {n} of {total} reviews: anon hidden.",
+  "reviews.allAnon.one": "The only review here is anon.",
+  "reviews.allAnon.other": "All {n} reviews here are anon.",
+  "reviews.allAnonShow.one": "Show it",
+  "reviews.allAnonShow.other": "Show them",
   "reviews.loading.one": "Loading {n} review from Nostr relays",
   "reviews.loading.other": "Loading {n} reviews from Nostr relays",
   "reviews.empty": "No reviews yet. Be the first to write one.",
   "reviews.emptyWritten": "No written reviews here yet. Be the first to write one.",
   "reviews.emptyFilter": "No reviews match this filter.",
+  "reviews.rate.cashu": "Rate this mint",
+  "reviews.rate.fedimint": "Rate this federation",
+  "reviews.rate.lnurl": "Rate this mint",
   "reviews.noscript": "Reviews are signed on Nostr and load in your browser, so this list needs JavaScript. The rating and counts above come from the site itself.",
   "reviews.relayError": "Could not reach the relay. Reviews may be incomplete.",
   "reviews.srRating": "{rating} out of 5",
   "reviews.srNoRating": "No rating given",
+  "reviews.readMore": "Read more",
+  "reviews.readLess": "Show less",
+  "reviews.actions.copyNpub": "Copy npub",
+  "reviews.actions.openNostr": "View this event on Nostr",
+  "reviews.actions.copyLink": "Copy link to this review",
   "reviews.anonNote": "First review from this npub, no other activity found",
   "reviews.published": "Published.",
   "reviews.publishedPartial": "Published to {accepted} of {total} relays.",
-  "reviews.propagating": "Propagating, it may take a moment to appear elsewhere.",
+  "reviews.propagating": "Publishing to Nostr relays",
   "reviews.summary.line.one": "{count} rating without a comment: {breakdown}",
   "reviews.summary.line.other": "{count} ratings without a comment: {breakdown}",
   "reviews.summary.lineDay.one": "{count} rating without a comment on {when}: {breakdown}",
@@ -274,7 +296,12 @@
   "reviews.breakdown.1": "{n} one star",
   "reviews.breakdown.none": "{n} with no rating",
   "reviews.dialog.title": "Review {name}",
-  "reviews.dialog.note": "Signed with your Nostr key and published to public relays. It cannot be edited or deleted.",
+  "reviews.dialog.lede.cashu": "Share your experience with this mint.",
+  "reviews.dialog.lede.fedimint": "Share your experience with this federation.",
+  "reviews.dialog.lede.lnurl": "Share your experience with this mint.",
+  "reviews.dialog.permanent": "Published permanently to public Nostr relays.",
+  "reviews.dialog.gate.title": "Log in to write a review",
+  "reviews.dialog.gate.lead": "Reviews are signed with your Nostr key. It stays in your signer, this site never sees it.",
   "reviews.dialog.ratingLegend": "Your rating",
   "reviews.dialog.starsSr.one": "{n} star",
   "reviews.dialog.starsSr.other": "{n} stars",
@@ -295,7 +322,6 @@
   "reviews.dialog.waitingSigner": "Waiting for your signer",
   "reviews.dialog.confirmClose": "Close this review? Your draft is kept until you leave the site.",
   "reviews.dialog.why.login": "Log in to publish",
-  "reviews.dialog.why.rating": "Choose a rating",
   "reviews.dialog.why.words": "Write a few words",
   "reviews.dialog.why.more.one": "{n} more character",
   "reviews.dialog.why.more.other": "{n} more characters",
@@ -312,7 +338,7 @@
   "reviews.validate.short": "Write at least {n} characters so the review is useful.",
   "reviews.validate.long": "Reviews are limited to {n} characters.",
   "feed.title": "Latest mint and federation reviews · Cashumints.space",
-  "feed.description": "Every mint and federation review as it is published: {reviews} reviews across {mints} Cashu mints and {federations} Fedimint federations, signed on Nostr and readable here newest first. Filter by ecosystem, by rating, or by name.",
+  "feed.description": "Every mint, federation and LNURL mint review as it is published: {reviews} reviews across {mints} Cashu mints, {federations} Fedimint federations and {lnurl} LNURL mints, signed on Nostr and readable here newest first. Filter by ecosystem, by rating, or by name.",
   "feed.heading": "Latest reviews",
   "feed.lede": "Every review of every Cashu mint and Fedimint federation, newest first, read live from the Nostr relays. Each one is signed by its author and lives on the relays, not in our database.",
   "feed.label": "Reviews",
@@ -346,14 +372,20 @@
   "login.connect.remote.title": "Connect a remote signer",
   "login.connect.remote.lead": "Scan this with your signer app, or copy the link and paste it there.",
   "login.connect.remote.hint": "Works with any NIP-46 signer: nsec.app, Amber, Nostrify, your own bunker.",
+  "login.connect.remote.open": "Open in your signer app",
   "login.connect.primal.title": "Connect with Primal",
   "login.connect.primal.lead": "Open Primal on your phone, find remote signing in its settings, and scan this code.",
   "login.connect.primal.hint": "Primal signs for other apps over NIP-46, so this is the same connection any signer uses, and your key stays in Primal. {link}",
+  "login.connect.primal.open": "Open in Primal",
   "login.status.buildingLink": "Building a connection link",
   "login.status.waitingExtension": "Waiting for your extension",
   "login.status.waitingSigner": "Waiting for your signer",
   "login.status.connecting": "Connecting to your signer",
   "login.status.connected": "Connected",
+  "login.toast.loggedIn": "Logged in",
+  "login.toast.fetchingProfile": "Fetching your Nostr profile from relays…",
+  "login.toast.profile": "Profile: {name}",
+  "login.toast.noProfile": "No profile found on the relays",
   "login.method.extension": "Extension",
   "login.method.remote": "Remote",
   "login.method.primal": "Primal",
@@ -385,7 +417,14 @@
   "notfound.fb.reviews": "Reviews",
   "notfound.fb.software": "Software",
   "notfound.fb.lastOnline": "Last online",
-  "notfound.fb.note": "This mint was indexed after the site was last built, so this is a summary from the live API. The full page with reviews appears at the next rebuild.",
+  "notfound.fb.note": "This mint was indexed after the site was last built, so this is a summary from the live API, with its reviews below. The full page appears at the next rebuild.",
+  "notfound.resolve.checking": "First visit: checking this mint now.",
+  "notfound.resolve.failed": "This mint could not be added",
+  "notfound.resolve.failedFedimint": "This federation could not be added",
+  "notfound.resolve.retry": "Try another address",
+  "notfound.resolve.switch": "Open it on {kind}",
+  "notfound.resolve.fedimint": "A federation page address does not carry its invite code, so this one cannot be looked up from the link alone. Paste the invite code and it is added.",
+  "notfound.resolve.ambiguous": "This address cannot be worked out from the link alone. Paste the mint’s full URL and it is added.",
   "wallets.title": "Cashu wallets · Cashumints.space",
   "wallets.description": "Cashu wallets that work with the mints listed here, across mobile, web, browser and the command line, with what each one is good at.",
   "wallets.heading": "Wallets",
@@ -623,9 +662,9 @@
   "feed.filterBySubject": "Filter by mint or federation",
   "feed.anySubject": "Any mint or federation",
   "feed.clearSubject": "Clear the name filter",
-  "home.fedimint.title": "Fedimint federations",
-  "home.fedimint.body": "{total} announced on Nostr, {online} confirmed running, {announced} never confirmed.",
-  "home.fedimint.link": "Browse federations",
+  "home.topFedimints.title": "Top Fedimints",
+  "home.topFedimints.sub": "ranked by reviews and rating",
+  "home.topFedimints.all": "All {n} federations →",
   "reviews.validate.subject": "There is nothing to point this review at.",
   "mint.warnings.fedimintOffline.lead": "Reported offline.",
   "mint.warnings.fedimintOffline.body.since": "The last check that reached this federation was on {date} ({days} ago). Its guardians have not answered since. Treat funds held there as at risk, and do not join it with new funds.",
@@ -639,5 +678,111 @@
   "footer.allFedimints": "All federations",
   "reviews.dialog.bodyPlaceholder.cashu": "How did minting, melting and support work out? Be specific.",
   "reviews.dialog.bodyPlaceholder.fedimint": "How did joining, Lightning payments and support work out? Be specific.",
-  "fedimint.details.title": "Federation details"
+  "fedimint.details.title": "Federation details",
+  "nav.lnurlMints": "LNURL mints",
+  "footer.allLnurlMints": "All LNURL mints",
+  "lnurlMints.title": "LNURL mints: lnurlcash bearer note mints, reviewed | Cashumints.space",
+  "lnurlMints.description": "All {total} LNURL mints indexed from the Nostr network: {online} online, {offline} offline. Community ratings, withdraw limits and capabilities for each.",
+  "lnurlMints.heading": "LNURL mints",
+  "lnurlMints.lede": "Every LNURL mint this site knows about. An LNURL mint issues lnurlcash bearer notes: Lightning notes you hold as a secret, which can be rotated, split, merged or melted back to a Lightning payment. Each one is checked over HTTPS every few minutes.",
+  "lnurlMints.search.label": "Search LNURL mints",
+  "lnurlMints.search.placeholder": "Search by name or address…",
+  "lnurlMints.sort.label": "Sort LNURL mints by",
+  "lnurlMints.hideOffline": "Hide offline",
+  "lnurlMints.showing": "Showing {total} LNURL mints ({online} online, {offline} offline)",
+  "lnurlMints.showingFiltered": "Showing {shown} of {total} LNURL mints ({online} online, {offline} offline)",
+  "lnurlMints.noResults": "No LNURL mint matches that.",
+  "lnurlMints.emptyIndex": "No LNURL mints are indexed yet.",
+  "lnurl.crumb": "LNURL mints",
+  "lnurl.breadcrumb": "Breadcrumb",
+  "lnurl.copyAddress": "Copy address",
+  "lnurl.more.title": "More LNURL mints",
+  "lnurl.more.all": "All LNURL mints →",
+  "lnurl.disclaimer": "An LNURL mint holds your sats while you hold its notes, so using one means trusting its operator. Ratings are community opinions, and online means reachable, not trustworthy.",
+  "lnurl.features.title": "Features",
+  "lnurl.features.none": "This mint has not announced what it supports.",
+  "lnurl.features.note": "Features are what the mint's operator announced on Nostr. Where this site can check one over HTTPS it does, and says so when something announced is unavailable right now.",
+  "lnurl.features.notListed": "not announced",
+  "lnurl.features.unavailable": "unavailable",
+  "lnurl.feature.mint": "Mint via Lightning (LUD-06)",
+  "lnurl.feature.melt": "Melt to Lightning",
+  "lnurl.feature.notes": "Rotate / split / merge notes",
+  "lnurl.feature.lud16": "Lightning address",
+  "lnurl.feature.lud21": "Payment verification (LUD-21)",
+  "lnurl.feature.signed-notes": "Signed notes (offline verification)",
+  "lnurl.feature.onion": "Tor address",
+  "lnurl.feature.rotate": "Rotate a note",
+  "lnurl.feature.split": "Split a note",
+  "lnurl.feature.merge": "Merge notes",
+  "lnurl.feature.lud06": "LUD-06 payRequest",
+  "lnurl.feature.lud03": "LUD-03 withdrawRequest",
+  "lnurl.limits.label": "Withdraw limits",
+  "lnurl.limits.notPublished": "not published",
+  "lnurl.limits.withdrawRow": "Withdraw",
+  "lnurl.limits.disabled": "disabled",
+  "lnurl.limits.sats.one": "{n} sat",
+  "lnurl.limits.sats.other": "{n} sats",
+  "lnurl.details.title": "Details",
+  "lnurl.details.address": "Lightning address",
+  "lnurl.details.mintPubkey": "Mint pubkey",
+  "lnurl.details.onion": "Tor address",
+  "lnurl.details.fee": "Mint fee",
+  "lnurl.details.node": "Node",
+  "lnurl.details.capacity": "Announced capacity",
+  "lnurl.kind.lightningAddress": "lightning address",
+  "lnurl.kind.mintPubkey": "mint pubkey",
+  "lnurl.kind.onionAddress": "Tor address",
+  "lnurl.confirmed.label": "Last confirmed",
+  "lnurl.confirmed.when": "confirmed {when}",
+  "lnurl.fee.base.one": "{n} sat",
+  "lnurl.fee.base.other": "{n} sats",
+  "lnurl.fee.percent": "{percent}%",
+  "home.topLnurl.title": "Top LNURL mints",
+  "home.topLnurl.sub": "ranked by reviews and rating",
+  "home.topLnurl.all": "All {n} LNURL mints →",
+  "feed.ecosystem.lnurl": "LNURL",
+  "reviews.dialog.bodyPlaceholder.lnurl": "How did minting, melting and rotating notes work out? Be specific.",
+  "reviews.byUrl.open": "Write a review",
+  "reviews.byUrl.title": "Write a review",
+  "reviews.byUrl.lede": "Paste the address. If this site does not know it yet, it is checked and added now.",
+  "reviews.byUrl.label.cashu": "Mint URL",
+  "reviews.byUrl.label.fedimint": "Federation invite code",
+  "reviews.byUrl.label.lnurl": "LNURL mint URL",
+  "reviews.byUrl.placeholder.cashu": "mint.example.com",
+  "reviews.byUrl.placeholder.fedimint": "fed11…",
+  "reviews.byUrl.placeholder.lnurl": "mint.example.com",
+  "reviews.byUrl.check": "Check this address",
+  "reviews.byUrl.checking": "Checking…",
+  "reviews.byUrl.back": "Use a different address",
+  "reviews.byUrl.existing": "Already listed",
+  "reviews.byUrl.indexed": "Just added",
+  "reviews.byUrl.confirmClose": "Close this? The address you typed is not kept.",
+  "reviews.byUrl.detected": "That address answered as a mint on {kind}.",
+  "reviews.byUrl.switchTo": "Review it on {kind}",
+  "reviews.byUrl.error.empty": "Enter an address first.",
+  "reviews.byUrl.error.badUrl": "That does not look like a mint URL.",
+  "reviews.byUrl.error.badInvite": "That is not a Fedimint invite code. Codes start with fed11.",
+  "reviews.byUrl.error.badInput": "This site cannot check that address.",
+  "reviews.byUrl.error.blocked": "That is not a public address, so it cannot be checked.",
+  "reviews.byUrl.error.notAMint": "That address answered, but not as a mint of this kind.",
+  "reviews.byUrl.error.wrongType": "That address answered, but as a different kind of mint.",
+  "reviews.byUrl.error.unverifiable": "Nothing responded at that address, and no trace of it exists on Nostr yet.",
+  "reviews.byUrl.error.rateLimited.one": "That is a lot of checks from one connection. Try again in about {n} minute.",
+  "reviews.byUrl.error.rateLimited.other": "That is a lot of checks from one connection. Try again in about {n} minutes.",
+  "reviews.byUrl.error.network": "The index could not be reached. Check your connection, then try again.",
+  "seo.lnurl.titleNoReviews": "{name}: LNURL mint info and reviews | Cashumints.space",
+  "seo.desc.statusWithdraw": "{status}, withdraw {min}–{max} sat.",
+  "mint.chip.noFunding": "No mint / melt",
+  "mint.warnings.lnurlWithdrawalsDisabled.lead": "Withdrawals disabled.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.online": "This mint advertises a maximum withdrawal of zero, so no note it issues can be redeemed for anything. Do not mint here until that changes.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.offline": "This mint advertised a maximum withdrawal of zero when it was last reached, so no note it issued could be redeemed for anything. Do not mint here until that changes.",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.online": "Withdrawals currently disabled",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.offline": "Withdrawals were disabled when last seen",
+  "mint.warnings.lnurlInvalid.lead": "Endpoint responding but invalid.",
+  "mint.warnings.lnurlInvalid.body": "The host answers, but not with a mint advertisement this site can read, so withdrawals may not work. Anything below is the last state that did parse, and reviews still work.",
+  "mint.warnings.lnurlInvalid.meta": "Responding, but not with a valid mint advertisement",
+  "mint.warnings.lnurlNoFunding.lead": "Minting and melting unavailable.",
+  "mint.warnings.lnurlNoFunding.body": "Existing notes can still be rotated, split, or merged, but nothing moves in or out via Lightning right now. The mint itself is up and answering; the Lightning node behind it is not reachable from it.",
+  "mint.warnings.lnurlNoFunding.meta": "Minting and melting unavailable",
+  "mint.warnings.also.noFunding": "Its Lightning node was also unreachable, so nothing could be minted or melted."
 }

web/src/i18n/es.json

@@ -54,6 +54,10 @@
   "footer.privacy": "Privacidad",
   "footer.madeBy": "Hecho con ❤️ por {azzamo} · Funciona con Cashu y NIP-87",
   "footer.warning": "Los mints son custodiales. Un mint puede desaparecer con tu dinero.",
+  "footer.tagline": "Reseñas de la comunidad para mints de ecash, firmadas en Nostr.",
+  "footer.col.explore": "Explorar",
+  "footer.col.site": "Sitio",
+  "footer.nav": "Pie de página",
   "home.title": "Cashumints.space · Encuentra un mint Cashu en el que confiar",
   "home.description": "Encuentra un mint Cashu en el que confiar. {mints} mints indexados con {reviews} reseñas de la comunidad firmadas en Nostr, además de disponibilidad en directo, NUTs compatibles y software del mint.",
   "home.hero.title": "Encuentra un mint Cashu",
@@ -65,7 +69,7 @@
   "home.filters.highestRated": "Mejor valorados",
   "home.filters.recentlyActive": "Activos hace poco",
   "home.filters.websockets": "Compatibles con WebSockets",
-  "home.top.title": "Mejores mints",
+  "home.top.title": "Mejores mints de Cashu",
   "home.top.sub": "ordenados por reseñas y valoración",
   "home.top.all": "Ver los {n} mints →",
   "home.latest.title": "Últimas reseñas",
@@ -118,6 +122,8 @@
   "card.reviewed": "reseñado {when}",
   "card.noReviews": "sin reseñas aún",
   "mint.title": "{name} · Reseñas del mint Cashu",
+  "mint.titleFedimint": "{name} · Reseñas de la federación Fedimint",
+  "mint.titleLnurl": "{name} · Reseñas del mint LNURL",
   "mint.breadcrumb": "Ruta de navegación",
   "mint.crumbMints": "Mints Cashu",
   "mint.copyUrl": "Copiar la URL del mint",
@@ -247,24 +253,40 @@
   "nut.25": "Método de pago BOLT12",
   "reviews.title": "Reseñas",
   "reviews.anon": "Anón",
+  "reviews.anonTitle": "No se encontró un perfil público de Nostr para esta clave",
+  "reviews.nip05Title": "Identificador NIP-05 (no verificado por este sitio)",
   "reviews.filter.group": "Filtrar reseñas",
   "reviews.filter.all": "Todas",
   "reviews.filter.five": "5★",
   "reviews.filter.critical": "Críticas",
   "reviews.filter.recent": "Recientes",
+  "reviews.filter.hideAnon": "Ocultar anón",
+  "reviews.anonHidden.other": "Mostrando {n} de {total} reseñas: anón oculto.",
+  "reviews.allAnon.one": "La única reseña aquí es anónima.",
+  "reviews.allAnon.other": "Todas las {n} reseñas aquí son anónimas.",
+  "reviews.allAnonShow.one": "Mostrarla",
+  "reviews.allAnonShow.other": "Mostrarlas",
   "reviews.loading.one": "Cargando {n} reseña de los relays de Nostr",
   "reviews.loading.other": "Cargando {n} reseñas de los relays de Nostr",
   "reviews.empty": "Todavía no hay reseñas. Sé la primera persona en escribir una.",
   "reviews.emptyWritten": "Todavía no hay reseñas escritas aquí. Sé quien escriba la primera.",
   "reviews.emptyFilter": "Ninguna reseña coincide con este filtro.",
+  "reviews.rate.cashu": "Valora este mint",
+  "reviews.rate.fedimint": "Valora esta federación",
+  "reviews.rate.lnurl": "Valora este mint",
   "reviews.noscript": "Las reseñas están firmadas en Nostr y se cargan en tu navegador, así que esta lista necesita JavaScript. La valoración y los recuentos de arriba vienen del propio sitio.",
   "reviews.relayError": "No se ha podido llegar al relay. Puede que falten reseñas.",
   "reviews.srRating": "{rating} sobre 5",
   "reviews.srNoRating": "Sin valoración",
+  "reviews.readMore": "Leer más",
+  "reviews.readLess": "Mostrar menos",
+  "reviews.actions.copyNpub": "Copiar npub",
+  "reviews.actions.openNostr": "Ver este evento en Nostr",
+  "reviews.actions.copyLink": "Copiar el enlace a esta reseña",
   "reviews.anonNote": "Primera reseña de este npub, no se ha encontrado ninguna otra actividad",
   "reviews.published": "Publicada.",
   "reviews.publishedPartial": "Publicada en {accepted} de {total} relays.",
-  "reviews.propagating": "Propagándose, puede tardar un momento en aparecer en otros sitios.",
+  "reviews.propagating": "Publicando en relés Nostr",
   "reviews.summary.line.one": "{count} valoración sin comentario: {breakdown}",
   "reviews.summary.line.other": "{count} valoraciones sin comentario: {breakdown}",
   "reviews.summary.lineDay.one": "{count} valoración sin comentario del {when}: {breakdown}",
@@ -278,7 +300,12 @@
   "reviews.breakdown.1": "{n} de una estrella",
   "reviews.breakdown.none": "{n} sin valoración",
   "reviews.dialog.title": "Reseñar {name}",
-  "reviews.dialog.note": "Se firma con tu clave Nostr y se publica en relays públicos. No se puede editar ni borrar.",
+  "reviews.dialog.lede.cashu": "Cuenta tu experiencia con este mint.",
+  "reviews.dialog.lede.fedimint": "Cuenta tu experiencia con esta federación.",
+  "reviews.dialog.lede.lnurl": "Cuenta tu experiencia con este mint.",
+  "reviews.dialog.permanent": "Se publica de forma permanente en relays públicos de Nostr.",
+  "reviews.dialog.gate.title": "Inicia sesión para escribir una reseña",
+  "reviews.dialog.gate.lead": "Las reseñas se firman con tu clave Nostr. Se queda en tu firmante, este sitio no la ve nunca.",
   "reviews.dialog.ratingLegend": "Tu valoración",
   "reviews.dialog.starsSr.one": "{n} estrella",
   "reviews.dialog.starsSr.other": "{n} estrellas",
@@ -299,7 +326,6 @@
   "reviews.dialog.waitingSigner": "Esperando a tu firmante",
   "reviews.dialog.confirmClose": "¿Cerrar esta reseña? Tu borrador se guarda hasta que salgas del sitio.",
   "reviews.dialog.why.login": "Inicia sesión para publicar",
-  "reviews.dialog.why.rating": "Elige una valoración",
   "reviews.dialog.why.words": "Escribe unas palabras",
   "reviews.dialog.why.more.one": "{n} carácter más",
   "reviews.dialog.why.more.other": "{n} caracteres más",
@@ -316,7 +342,7 @@
   "reviews.validate.short": "Escribe al menos {n} caracteres para que la reseña sirva de algo.",
   "reviews.validate.long": "Las reseñas están limitadas a {n} caracteres.",
   "feed.title": "Últimas reseñas de mints y federaciones · Cashumints.space",
-  "feed.description": "Cada reseña de un mint o una federación según se publica: {reviews} reseñas de {mints} mints Cashu y {federations} federaciones Fedimint, firmadas en Nostr y legibles aquí de la más nueva a la más antigua. Filtra por ecosistema, por valoración o por nombre.",
+  "feed.description": "Cada reseña de mint, federación y mint LNURL según se publica: {reviews} reseñas sobre {mints} mints Cashu, {federations} federaciones Fedimint y {lnurl} mints LNURL, firmadas en Nostr y legibles aquí de más nueva a más antigua. Filtra por ecosistema, por valoración o por nombre.",
   "feed.heading": "Últimas reseñas",
   "feed.lede": "Todas las reseñas de todos los mints Cashu y federaciones Fedimint, de la más nueva a la más antigua, leídas en directo de los relays de Nostr. Cada una está firmada por quien la escribió y vive en los relays, no en nuestra base de datos.",
   "feed.label": "Reseñas",
@@ -350,14 +376,20 @@
   "login.connect.remote.title": "Conectar un firmante remoto",
   "login.connect.remote.lead": "Escanea esto con tu app de firma, o copia el enlace y pégalo ahí.",
   "login.connect.remote.hint": "Funciona con cualquier firmante NIP-46: nsec.app, Amber, Nostrify, tu propio bunker.",
+  "login.connect.remote.open": "Abrir en tu app de firma",
   "login.connect.primal.title": "Conectar con Primal",
   "login.connect.primal.lead": "Abre Primal en tu móvil, busca la firma remota en sus ajustes y escanea este código.",
   "login.connect.primal.hint": "Primal firma para otras apps por NIP-46, así que esta es la misma conexión que usa cualquier firmante, y tu clave se queda en Primal. {link}",
+  "login.connect.primal.open": "Abrir en Primal",
   "login.status.buildingLink": "Creando un enlace de conexión",
   "login.status.waitingExtension": "Esperando a tu extensión",
   "login.status.waitingSigner": "Esperando a tu firmante",
   "login.status.connecting": "Conectando con tu firmante",
   "login.status.connected": "Conectado",
+  "login.toast.loggedIn": "Sesión iniciada",
+  "login.toast.fetchingProfile": "Obteniendo tu perfil de Nostr desde los relays…",
+  "login.toast.profile": "Perfil: {name}",
+  "login.toast.noProfile": "No se encontró ningún perfil en los relays",
   "login.method.extension": "Extensión",
   "login.method.remote": "Remoto",
   "login.method.primal": "Primal",
@@ -389,7 +421,14 @@
   "notfound.fb.reviews": "Reseñas",
   "notfound.fb.software": "Software",
   "notfound.fb.lastOnline": "Última vez en línea",
-  "notfound.fb.note": "Este mint se indexó después de la última compilación del sitio, así que esto es un resumen sacado de la API en directo. La página completa con reseñas aparecerá en la próxima compilación.",
+  "notfound.fb.note": "Este mint se indexó después de la última compilación del sitio, así que este es un resumen de la API en vivo, con sus reseñas debajo. La página completa aparece en la siguiente compilación.",
+  "notfound.resolve.checking": "Primera visita: comprobando este mint ahora.",
+  "notfound.resolve.failed": "No se pudo añadir este mint",
+  "notfound.resolve.failedFedimint": "No se pudo añadir esta federación",
+  "notfound.resolve.retry": "Probar otra dirección",
+  "notfound.resolve.switch": "Abrirlo como mint {kind}",
+  "notfound.resolve.fedimint": "La dirección de la página de una federación no lleva su código de invitación, así que esta no se puede buscar solo con el enlace. Pega el código de invitación y se añade.",
+  "notfound.resolve.ambiguous": "Esta dirección no se puede deducir solo con el enlace. Pega la URL completa del mint y se añade.",
   "wallets.title": "Monederos Cashu · Cashumints.space",
   "wallets.description": "Monederos Cashu que funcionan con los mints listados aquí, para móvil, web, navegador y línea de comandos, con lo que hace bien cada uno.",
   "wallets.heading": "Monederos",
@@ -627,9 +666,9 @@
   "feed.filterBySubject": "Filtrar por mint o federación",
   "feed.anySubject": "Cualquier mint o federación",
   "feed.clearSubject": "Borrar el filtro por nombre",
-  "home.fedimint.title": "Federaciones Fedimint",
-  "home.fedimint.body": "{total} anunciadas en Nostr, {online} confirmadas en funcionamiento, {announced} nunca confirmadas.",
-  "home.fedimint.link": "Ver federaciones",
+  "home.topFedimints.title": "Mejores Fedimints",
+  "home.topFedimints.sub": "ordenados por reseñas y valoración",
+  "home.topFedimints.all": "Ver las {n} federaciones →",
   "reviews.validate.subject": "No hay nada a lo que apuntar esta reseña.",
   "mint.warnings.fedimintOffline.lead": "Reportada sin conexión.",
   "mint.warnings.fedimintOffline.body.since": "La última comprobación que llegó a esta federación fue el {date} (hace {days}). Sus guardianes no responden desde entonces. Da por perdido el dinero que tengas ahí y no te unas con dinero nuevo.",
@@ -643,5 +682,111 @@
   "footer.allFedimints": "Todas las federaciones",
   "reviews.dialog.bodyPlaceholder.cashu": "¿Qué tal fueron la acuñación, el fundido y el soporte? Sé concreto.",
   "reviews.dialog.bodyPlaceholder.fedimint": "¿Qué tal fueron unirte, los pagos Lightning y el soporte? Sé concreto.",
-  "fedimint.details.title": "Datos de la federación"
+  "fedimint.details.title": "Datos de la federación",
+  "nav.lnurlMints": "Mints LNURL",
+  "footer.allLnurlMints": "Todos los mints LNURL",
+  "lnurlMints.title": "Mints LNURL: mints de notas al portador lnurlcash, con reseñas | Cashumints.space",
+  "lnurlMints.description": "Los {total} mints LNURL indexados desde la red Nostr: {online} en línea, {offline} fuera de línea. Valoraciones de la comunidad, límites de retirada y capacidades de cada uno.",
+  "lnurlMints.heading": "Mints LNURL",
+  "lnurlMints.lede": "Todos los mints LNURL que este sitio conoce. Un mint LNURL emite notas al portador lnurlcash: notas Lightning que guardas como un secreto y que se pueden rotar, dividir, fusionar o fundir de vuelta a un pago Lightning. Cada uno se comprueba por HTTPS cada pocos minutos.",
+  "lnurlMints.search.label": "Buscar mints LNURL",
+  "lnurlMints.search.placeholder": "Buscar por nombre o dirección…",
+  "lnurlMints.sort.label": "Ordenar mints LNURL por",
+  "lnurlMints.hideOffline": "Ocultar fuera de línea",
+  "lnurlMints.showing": "Mostrando {total} mints LNURL ({online} en línea, {offline} fuera de línea)",
+  "lnurlMints.showingFiltered": "Mostrando {shown} de {total} mints LNURL ({online} en línea, {offline} fuera de línea)",
+  "lnurlMints.noResults": "Ningún mint LNURL coincide con eso.",
+  "lnurlMints.emptyIndex": "Todavía no hay mints LNURL indexados.",
+  "lnurl.crumb": "Mints LNURL",
+  "lnurl.breadcrumb": "Ruta de navegación",
+  "lnurl.copyAddress": "Copiar dirección",
+  "lnurl.more.title": "Más mints LNURL",
+  "lnurl.more.all": "Todos los mints LNURL →",
+  "lnurl.disclaimer": "Un mint LNURL guarda tus sats mientras tú guardas sus notas, así que usar uno significa confiar en su operador. Las valoraciones son opiniones de la comunidad, y en línea significa accesible, no confiable.",
+  "lnurl.features.title": "Funciones",
+  "lnurl.features.none": "Este mint no ha anunciado qué admite.",
+  "lnurl.features.note": "Las funciones son lo que el operador del mint anunció en Nostr. Cuando este sitio puede comprobar alguna por HTTPS lo hace, y avisa cuando algo anunciado no está disponible ahora mismo.",
+  "lnurl.features.notListed": "no anunciado",
+  "lnurl.features.unavailable": "no disponible",
+  "lnurl.feature.mint": "Acuñar por Lightning (LUD-06)",
+  "lnurl.feature.melt": "Fundir a Lightning",
+  "lnurl.feature.notes": "Rotar / dividir / fusionar notas",
+  "lnurl.feature.lud16": "Dirección Lightning",
+  "lnurl.feature.lud21": "Verificación de pago (LUD-21)",
+  "lnurl.feature.signed-notes": "Notas firmadas (verificación sin conexión)",
+  "lnurl.feature.onion": "Dirección Tor",
+  "lnurl.feature.rotate": "Rotar una nota",
+  "lnurl.feature.split": "Dividir una nota",
+  "lnurl.feature.merge": "Fusionar notas",
+  "lnurl.feature.lud06": "payRequest LUD-06",
+  "lnurl.feature.lud03": "withdrawRequest LUD-03",
+  "lnurl.limits.label": "Límites de retirada",
+  "lnurl.limits.notPublished": "no publicado",
+  "lnurl.limits.withdrawRow": "Retirada",
+  "lnurl.limits.disabled": "desactivado",
+  "lnurl.limits.sats.one": "{n} sat",
+  "lnurl.limits.sats.other": "{n} sats",
+  "lnurl.details.title": "Datos del mint",
+  "lnurl.details.address": "Dirección Lightning",
+  "lnurl.details.mintPubkey": "Clave pública del mint",
+  "lnurl.details.onion": "Dirección Tor",
+  "lnurl.details.fee": "Comisión de acuñación",
+  "lnurl.details.node": "Nodo",
+  "lnurl.details.capacity": "Capacidad anunciada",
+  "lnurl.kind.lightningAddress": "dirección Lightning",
+  "lnurl.kind.mintPubkey": "clave pública del mint",
+  "lnurl.kind.onionAddress": "dirección Tor",
+  "lnurl.confirmed.label": "Última confirmación",
+  "lnurl.confirmed.when": "confirmado {when}",
+  "lnurl.fee.base.one": "{n} sat",
+  "lnurl.fee.base.other": "{n} sats",
+  "lnurl.fee.percent": "{percent}%",
+  "home.topLnurl.title": "Mejores mints LNURL",
+  "home.topLnurl.sub": "ordenados por reseñas y valoración",
+  "home.topLnurl.all": "Los {n} mints LNURL →",
+  "feed.ecosystem.lnurl": "LNURL",
+  "reviews.dialog.bodyPlaceholder.lnurl": "¿Qué tal fueron acuñar, fundir y rotar notas? Sé concreto.",
+  "reviews.byUrl.open": "Escribir una reseña",
+  "reviews.byUrl.title": "Escribir una reseña",
+  "reviews.byUrl.lede": "Pega la dirección. Si este sitio aún no la conoce, la comprueba y la añade ahora.",
+  "reviews.byUrl.label.cashu": "URL del mint",
+  "reviews.byUrl.label.fedimint": "Código de invitación de la federación",
+  "reviews.byUrl.label.lnurl": "URL del mint LNURL",
+  "reviews.byUrl.placeholder.cashu": "mint.example.com",
+  "reviews.byUrl.placeholder.fedimint": "fed11…",
+  "reviews.byUrl.placeholder.lnurl": "mint.example.com",
+  "reviews.byUrl.check": "Comprobar esta dirección",
+  "reviews.byUrl.checking": "Comprobando…",
+  "reviews.byUrl.back": "Usar otra dirección",
+  "reviews.byUrl.existing": "Ya está en la lista",
+  "reviews.byUrl.indexed": "Recién añadido",
+  "reviews.byUrl.confirmClose": "¿Cerrar? La dirección que escribiste no se guarda.",
+  "reviews.byUrl.detected": "Esa dirección respondió como un mint {kind}.",
+  "reviews.byUrl.switchTo": "Reseñarlo como mint {kind}",
+  "reviews.byUrl.error.empty": "Escribe una dirección primero.",
+  "reviews.byUrl.error.badUrl": "Eso no parece la URL de un mint.",
+  "reviews.byUrl.error.badInvite": "Eso no es un código de invitación de Fedimint. Los códigos empiezan por fed11.",
+  "reviews.byUrl.error.badInput": "Este sitio no puede comprobar esa dirección.",
+  "reviews.byUrl.error.blocked": "Esa no es una dirección pública, así que no se puede comprobar.",
+  "reviews.byUrl.error.notAMint": "Esa dirección respondió, pero no como un mint de este tipo.",
+  "reviews.byUrl.error.wrongType": "Esa dirección respondió, pero como un mint de otro tipo.",
+  "reviews.byUrl.error.unverifiable": "Nada respondió en esa dirección, y todavía no hay ni rastro de ella en Nostr.",
+  "reviews.byUrl.error.rateLimited.one": "Son muchas comprobaciones desde una misma conexión. Inténtalo otra vez en unos {n} minuto.",
+  "reviews.byUrl.error.rateLimited.other": "Son muchas comprobaciones desde una misma conexión. Inténtalo otra vez en unos {n} minutos.",
+  "reviews.byUrl.error.network": "No se pudo contactar con el índice. Comprueba tu conexión y vuelve a intentarlo.",
+  "seo.lnurl.titleNoReviews": "{name}: información y reseñas del mint LNURL | Cashumints.space",
+  "seo.desc.statusWithdraw": "{status}, retirada {min}–{max} sat.",
+  "mint.chip.noFunding": "Sin acuñar / fundir",
+  "mint.warnings.lnurlWithdrawalsDisabled.lead": "Retiradas desactivadas.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.online": "Este mint anuncia una retirada máxima de cero, así que ninguna nota que emita puede canjearse por nada. No acuñes aquí hasta que eso cambie.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.offline": "Este mint anunciaba una retirada máxima de cero la última vez que se pudo contactar, así que ninguna nota que emitiera podía canjearse por nada. No acuñes aquí hasta que eso cambie.",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.online": "Retiradas desactivadas actualmente",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.offline": "Las retiradas estaban desactivadas la última vez que se vio",
+  "mint.warnings.lnurlInvalid.lead": "El endpoint responde pero no es válido.",
+  "mint.warnings.lnurlInvalid.body": "El servidor responde, pero no con un anuncio de mint que este sitio pueda leer, así que las retiradas podrían no funcionar. Lo de abajo es el último estado que sí se pudo leer, y las reseñas siguen funcionando.",
+  "mint.warnings.lnurlInvalid.meta": "Responde, pero no con un anuncio de mint válido",
+  "mint.warnings.lnurlNoFunding.lead": "Acuñación y fundido no disponibles.",
+  "mint.warnings.lnurlNoFunding.body": "Las notas existentes todavía se pueden rotar, dividir o fusionar, pero ahora mismo nada entra ni sale por Lightning. El mint está activo y responde; el nodo Lightning que hay detrás no es accesible desde él.",
+  "mint.warnings.lnurlNoFunding.meta": "Acuñación y fundido no disponibles",
+  "mint.warnings.also.noFunding": "Su nodo Lightning también estaba inaccesible, así que no se podía acuñar ni fundir nada."
 }

web/src/i18n/format.ts

@@ -175,6 +175,9 @@ export function formatters(t: Translator): Formatters {
 /** Locale-free, so it lives here beside the rest rather than in two places. */
 export function starString(rating: number | null): string {
   if (rating === null) return '☆☆☆☆☆';
-  const filled = Math.round(rating);
-  return '★'.repeat(filled) + '☆'.repeat(Math.max(0, 5 - filled));
+  // Ratings are integers 0 to 5 in the data; anything else is clamped rather than
+  // trusted, so a stray fractional or out-of-range value can never emit a malformed
+  // row (six stars, negative repeat counts, a half glyph).
+  const filled = Math.min(5, Math.max(0, Math.round(rating)));
+  return '★'.repeat(filled) + '☆'.repeat(5 - filled);
 }

web/src/i18n/fr.json

@@ -0,0 +1,788 @@
+{
+  "site.name": "Cashumints.space",
+  "common.close": "Fermer",
+  "common.cancel": "Annuler",
+  "common.done": "Fait",
+  "common.back": "Dos",
+  "common.retry": "Réessayer",
+  "common.connect": "Connecter",
+  "common.copied": "Copié",
+  "common.copyFull": "Copie complète {kind}",
+  "common.previousPage": "Page précédente",
+  "common.nextPage": "Page suivante",
+  "common.reviewPages": "Pages de révision",
+  "time.never": "jamais",
+  "time.justNow": "tout à l' heure",
+  "time.none": "-",
+  "time.unknownDate": "une date inconnue",
+  "time.ago.minute": "Il y a {n}m",
+  "time.ago.hour": "Il y a {n}h",
+  "time.ago.day": "Il y a {n}d",
+  "time.ago.week": "Il y a {n}w",
+  "time.ago.month": "{n}il y a mois",
+  "time.ago.year": "Il y a {n}y",
+  "time.short.minute": "{n}m",
+  "time.short.hour": "{n}h",
+  "time.short.day": "{n}d",
+  "time.short.week": "{n}w",
+  "time.short.month": "{n}mo",
+  "time.short.year": "{n}y",
+  "status.online": "En ligne",
+  "status.offline": "Hors ligne",
+  "status.degraded": "Injoignable",
+  "status.unknown": "Pas encore vérifié",
+  "nav.skip": "Passer au contenu",
+  "nav.main": "Principal",
+  "nav.mints": "Cashu mints",
+  "nav.reviews": "Avis",
+  "nav.wallets": "Portefeuilles",
+  "nav.about": "À propos",
+  "nav.searchMints": "Rechercher parmi {n} mints",
+  "lang.label": "Langue",
+  "lang.switcher": "Choisissez une langue",
+  "footer.copyright": "© {year} Cashumints.space",
+  "footer.allMints": "Tous les Cashu mints",
+  "footer.allReviews": "Tous les avis",
+  "footer.wallets": "Portefeuilles",
+  "footer.about": "À propos",
+  "footer.disclaimer": "Clause de non-responsabilité",
+  "footer.terms": "Conditions",
+  "footer.privacy": "Confidentialité",
+  "footer.madeBy": "Réalisé avec ❤️ par {azzamo} · Propulsé par Cashu et NIP-87",
+  "footer.warning": "Les mints sont custodiaux. Un mint peut disparaître avec votre argent.",
+  "footer.tagline": "Les avis de la communauté sur les mints ecash, signés sur Nostr.",
+  "footer.col.explore": "Explorer",
+  "footer.col.site": "Site",
+  "footer.nav": "Pied de page",
+  "home.title": "Cashumints.space · Trouve un mint Cashu en qui tu peux avoir confiance",
+  "home.description": "Trouve un mint Cashu en qui tu peux avoir confiance. {mints} mints indexés, {reviews} avis de la communauté signés sur Nostr, plus la disponibilité en direct, les NUTs pris en charge et le logiciel du mint.",
+  "home.hero.title": "Trouver un mint Cashu",
+  "home.hero.titleEm": "tu peux faire confiance",
+  "home.hero.lede": "Chaque mint sur le réseau Nostr, avec de vrais avis communautaires. Pas de gardiens, juste des avis signés que vous pouvez vérifier vous-même.",
+  "home.search.label": "Recherchez mints par nom, domaine ou URL",
+  "home.search.placeholder": "Recherchez par nom, domaine ou collez une URL mint…",
+  "home.filters.mostReviewed": "Les plus commentés",
+  "home.filters.highestRated": "Les mieux notés",
+  "home.filters.recentlyActive": "Récemment actif",
+  "home.filters.websockets": "Prend en charge WebSockets",
+  "home.top.title": "Haut Cashu mints",
+  "home.top.sub": "classé par avis et notes",
+  "home.top.all": "Tous les {n} mints →",
+  "home.latest.title": "Derniers avis",
+  "home.latest.sub": "en direct du réseau Nostr",
+  "home.latest.prev": "Avis précédents",
+  "home.latest.next": "Plus d'avis",
+  "home.latest.all": "Tous les avis →",
+  "home.latest.empty": "Aucun avis n’a pu être lu sur les relais pour le moment. Ouvrez n'importe quelle page mint pour lire et rédiger des avis directement.",
+  "home.why.title": "Pourquoi faire confiance à ces avis ?",
+  "home.why.signed.title": "Signé, non soumis",
+  "home.why.signed.body": "Chaque revue est un événement {link} signé par la clé Nostr de son auteur. Rien ici n’est modifié, classé ou supprimé par nos soins.",
+  "home.why.signed.link": "NIP-87",
+  "home.why.verify.title": "Vérifiez-le vous-même",
+  "home.why.verify.body": "Les avis sont en direct sur les relais publics Nostr, et non sur notre base de données. Dirigez n'importe quel client vers les mêmes relais et vous verrez les mêmes données.",
+  "home.why.checked.title": "Vérifié en permanence",
+  "home.why.checked.body": "Nous sondons chaque mint pour connaître la disponibilité, la version du logiciel, les limites et le NUTs pris en charge, de sorte que les spécifications que vous voyez sont actuelles et non auto-déclarées.",
+  "home.cta.title": "Vous pensez à un mint ? Lisez-le d'abord.",
+  "home.cta.body": "Un mint contient votre ecash. Lisez ce que d'autres personnes ont trouvé avant d'installer sats et laissez un commentaire lorsque vous en avez utilisé un vous-même.",
+  "home.cta.explore": "Découvrez tous les mints",
+  "home.cta.learn": "En savoir plus sur Cashu",
+  "pulse.mintsIndexed": "mints indexé",
+  "pulse.reviewsOnNostr": "avis sur Nostr",
+  "pulse.lastReview": "dernière révision",
+  "pulse.mintsOnline": "mints en ligne",
+  "pulse.indexer": "indexeur",
+  "pulse.connected": "connecté",
+  "pulse.stale": "vicié",
+  "mints.title": "Tous les Cashu mints · Cashumints.space",
+  "mints.description": "Tous les {total} Cashu mints indexés à partir du réseau Nostr, {online} en ligne et {offline} hors ligne, avec évaluations de la communauté, disponibilité et logiciel mint. Recherchez et triez la liste complète.",
+  "mints.heading": "Tous les Cashu mints",
+  "mints.lede": "Chaque mint découvert sur le réseau Nostr, y compris ceux qui ont disparu. Hors ligne, les mints restent répertoriés afin que vous puissiez toujours les trouver et les consulter.",
+  "mints.search.label": "Rechercher mints par nom ou domaine",
+  "mints.search.placeholder": "Rechercher par nom ou domaine…",
+  "mints.sort.label": "Trier mints",
+  "mints.sort.score": "Meilleur dans l'ensemble",
+  "mints.sort.rating": "Les mieux notés",
+  "mints.sort.reviews": "Les plus commentés",
+  "mints.sort.recent": "Récemment examiné",
+  "mints.sort.seen": "Vu récemment en ligne",
+  "mints.hideOffline": "Masquer hors ligne",
+  "mints.showing": "Affichage de {total} mints ({online} en ligne, {offline} hors ligne)",
+  "mints.showingFiltered": "Affichage de {shown} de {total} mints ({online} en ligne, {offline} hors ligne)",
+  "mints.noResults": "Aucune correspondance mints. Essayez un domaine ou collez une URL mint.",
+  "mints.clearSearch": "Effacer la recherche",
+  "card.noRatings": "Aucune note pour l'instant",
+  "card.reviews.one": "Avis {n}",
+  "card.reviews.other": "Avis sur {n}",
+  "card.lastSeen": "vu pour la dernière fois {when}",
+  "card.neverSeen": "jamais vu en ligne",
+  "card.reviewed": "a évalué {when}",
+  "card.noReviews": "pas encore d'avis",
+  "mint.title": "{name} · Cashu mint avis",
+  "mint.titleFedimint": "{name} · Avis sur la fédération Fedimint",
+  "mint.titleLnurl": "{name} · Avis sur le mint LNURL",
+  "mint.breadcrumb": "Fil d'Ariane",
+  "mint.crumbMints": "Cashu mints",
+  "mint.copyUrl": "Copier l'URL mint",
+  "mint.qrButton": "Mint QR",
+  "mint.writeReview": "Écrire un avis",
+  "mint.rankByScore": "#{rank} par score",
+  "mint.tagLightning": "Lightning",
+  "mint.summary": "Résumé Mint",
+  "mint.rating.label": "Évaluation de la communauté",
+  "mint.rating.none": "Aucune note pour l'instant",
+  "mint.rating.reviews.one": "Avis {n}",
+  "mint.rating.reviews.other": "Avis sur {n}",
+  "mint.rating.unrated.one": "{n} n'a laissé aucune note",
+  "mint.rating.unrated.other": "{n} n'a laissé aucune note",
+  "mint.activity.label": "Activité",
+  "mint.activity.since": "depuis le dernier examen",
+  "mint.activity.noReviews": "pas encore d'avis",
+  "mint.activity.recent.one": "Examen du {n} au cours des 90 derniers jours",
+  "mint.activity.recent.other": "Avis sur {n} au cours des 90 derniers jours",
+  "mint.limits.label": "Limites",
+  "mint.limits.notPublished": "non publié",
+  "mint.limits.min": "min",
+  "mint.limits.max": "maximum",
+  "mint.limits.mintRow": "mint",
+  "mint.limits.meltRow": "fondre",
+  "mint.limits.disabled": "désactivé",
+  "mint.limits.range": "{min} à {max} {unit}",
+  "mint.limits.upTo": "jusqu'à {max} {unit}",
+  "mint.limits.from": "à partir de {min} {unit}",
+  "mint.software.label": "Logiciel Mint",
+  "mint.software.unknown": "inconnu",
+  "mint.checked": "vérifié {when}",
+  "mint.lastSeen": "vu pour la dernière fois {when}",
+  "mint.neverReached": "jamais atteint",
+  "mint.uptime.checks": "{ok} des derniers chèques {total} accessibles",
+  "mint.uptime.percent": "{percent}% joignable sur 30 jours",
+  "mint.uptime.description": "{ok} des derniers contrôles {total} réussis",
+  "mint.operator.title": "De l'opérateur",
+  "mint.operator.motd": "Message du jour",
+  "mint.operator.beta": "Ce mint se décrit comme expérimental ou en version bêta. Lisez les propres mots de l'opérateur ci-dessous avant de stocker tout ce que vous ne pouvez pas perdre.",
+  "mint.nuts.title": "NUTs pris en charge",
+  "mint.nuts.noneOffline": "Aucune liste NUT mise en cache pour ce mint, elle s'est déconnectée avant qu'une liste ne soit enregistrée.",
+  "mint.nuts.noneYet": "Aucune liste NUT mise en cache pour ce mint pour le moment.",
+  "mint.nuts.supported": "{n} de {total} connu NUTs pris en charge",
+  "mint.nuts.whatAre": "que sont les NUTs ?",
+  "mint.nutRow.disabled": "désactivé",
+  "mint.nutRow.notSupported": "non pris en charge",
+  "mint.details.title": "Détails du Mint",
+  "mint.details.pubkey": "Pubkey",
+  "mint.details.nostr": "Nostr",
+  "mint.details.email": "E-mail",
+  "mint.details.serverTime": "Heure du serveur",
+  "mint.details.firstSeen": "Vu pour la première fois",
+  "mint.details.terms": "Termes",
+  "mint.kind.identifier": "identifiant",
+  "mint.kind.mintPubkey": "mint pubkey",
+  "mint.kind.nostrAddress": "Adresse Nostr",
+  "mint.kind.emailAddress": "adresse email",
+  "mint.kind.npub": "npub",
+  "mint.disclaimer": "Ce mint est dépositaire : il retient votre argent, et il peut cesser de le faire à tout moment. Les évaluations sont des opinions de la communauté et en ligne signifient accessibles et non dignes de confiance.",
+  "mint.disclaimerLink": "Lire l'intégralité de la clause de non-responsabilité",
+  "mint.qr.title": "Ajoutez {name} à votre portefeuille",
+  "mint.qr.note": "Scannez-le avec un portefeuille Cashu pour ajouter le mint, ou copiez l'URL et collez-la.",
+  "mint.qr.warn": "Ajouter un mint signifie lui confier votre argent.",
+  "mint.qr.whatMeans": "Qu'est-ce que ça veut dire",
+  "mint.qr.wallets": "Portefeuilles prenant en charge Cashu",
+  "mint.chip.frozen": "Congelé",
+  "mint.chip.noWithdrawals": "Aucun retrait",
+  "mint.chip.meltOnly": "Faire fondre seulement",
+  "mint.warnings.dayCount.one": "Jour {n}",
+  "mint.warnings.dayCount.other": "Jours {n}",
+  "mint.warnings.gone.lead": "Probablement parti.",
+  "mint.warnings.gone.body.since": "Ce mint est inaccessible depuis {date} ({days}). Considérez les fonds qui y sont détenus comme étant à risque et n'envoyez pas de nouveaux fonds. Les détails ci-dessous montrent son dernier état connu.",
+  "mint.warnings.gone.body.neverDated": "Ce mint n'a répondu à aucun contrôle depuis que nous avons commencé à le regarder dans {month}. Considérez les fonds qui y sont détenus comme étant à risque et n'envoyez pas de nouveaux fonds. Tout ce qui suit provient de l'annonce du Nostr, et non du mint.",
+  "mint.warnings.gone.body.never": "Ce mint n'a répondu à aucun contrôle depuis que nous avons commencé à le regarder. Considérez les fonds qui y sont détenus comme étant à risque et n'envoyez pas de nouveaux fonds. Tout ce qui suit provient de l'annonce du Nostr, et non du mint.",
+  "mint.warnings.gone.meta.since": "Hors ligne depuis {date}",
+  "mint.warnings.gone.meta.never": "Jamais accessible depuis sa découverte",
+  "mint.warnings.meltDisabled.lead": "Retraits désactivés.",
+  "mint.warnings.meltDisabled.body.online": "Ce mint a désactivé Lightning melting (NUT-05) : vous pouvez y insérer des sats, mais vous ne pouvez pas les retirer via Lightning. Ne déposez pas avant le retour du melting.",
+  "mint.warnings.meltDisabled.body.offline": "Ce mint avait désactivé Lightning melting (NUT-05) : vous pouvez y insérer des sats, mais vous ne pouvez pas les retirer via Lightning. Ne déposez pas avant le retour du melting.",
+  "mint.warnings.meltDisabled.meta.online": "Retraits actuellement désactivés",
+  "mint.warnings.meltDisabled.meta.offline": "Les retraits ont été désactivés lors de leur dernière visite",
+  "mint.warnings.frozen.lead": "Mint gelé.",
+  "mint.warnings.frozen.body.online": "minting et melting sont désactivés. Aucun sats ne peut entrer ou sortir via Lightning.",
+  "mint.warnings.frozen.body.offline": "minting et melting ont été désactivés. Aucun sats ne peut entrer ou sortir via Lightning.",
+  "mint.warnings.frozen.meta.online": "Actuellement gelé, rien ne bouge ni ne sort",
+  "mint.warnings.frozen.meta.offline": "Gelé lors de sa dernière visite",
+  "mint.warnings.offlineLong.lead": "Hors ligne pour {days}, depuis {date}.",
+  "mint.warnings.offlineLong.body": "Le mint a peut-être disparu. Tout ce qui se trouve ci-dessous correspond à son dernier état connu et les avis fonctionnent toujours.",
+  "mint.warnings.offlineLong.meta": "Hors ligne depuis {date}",
+  "mint.warnings.meltOnly.lead": "Faire fondre seulement.",
+  "mint.warnings.meltOnly.body.online": "Le nouveau minting (NUT-04) est désactivé : vous ne pouvez pas déposer, mais le ecash existant peut toujours être retiré. Cela signifie souvent qu'un mint est en train de se terminer, donc si vous conservez son ecash, envisagez de retirer le melting.",
+  "mint.warnings.meltOnly.body.offline": "Le nouveau minting (NUT-04) a été désactivé : vous ne pouvez pas déposer, mais le ecash existant peut toujours être retiré. Cela signifie souvent qu'un mint est en train de se terminer, donc si vous conservez son ecash, envisagez de retirer le melting.",
+  "mint.warnings.meltOnly.meta.online": "Actuellement fondre seulement",
+  "mint.warnings.meltOnly.meta.offline": "Fondre seulement lors de la dernière vue",
+  "mint.warnings.offline.lead": "Hors ligne depuis {date}.",
+  "mint.warnings.offline.body": "Les détails ont alors été confirmés pour la dernière fois. Vous pouvez toujours rédiger un avis.",
+  "mint.warnings.offline.meta": "Hors ligne depuis {date}",
+  "mint.warnings.also.meltDisabled": "Avant de se déconnecter, il avait également désactivé les retraits.",
+  "mint.warnings.also.mintDisabled": "Avant de se déconnecter, il avait également désactivé le nouveau minting.",
+  "mint.warnings.also.offline": "Il est également hors ligne depuis {date} ({days}).",
+  "nut.0": "Notation et modèles",
+  "nut.1": "Échange de clé publique Mint",
+  "nut.2": "Jeux de clés et frais",
+  "nut.3": "Échanger des jetons",
+  "nut.4": "Minting via Lightning",
+  "nut.5": "Melting via Lightning",
+  "nut.6": "Informations Mint",
+  "nut.7": "Vérification de l'état du jeton",
+  "nut.8": "Frais Lightning payés en trop",
+  "nut.9": "Restaurer les signatures",
+  "nut.10": "Conditions de dépenses",
+  "nut.11": "Payer à la clé publique",
+  "nut.12": "Epreuves DLEQ",
+  "nut.13": "Secrets déterministes",
+  "nut.14": "Contrats timelock hachés",
+  "nut.15": "Paiements multivoies",
+  "nut.16": "Codes QR animés",
+  "nut.17": "Abonnements WebSocket",
+  "nut.18": "Demandes de paiement",
+  "nut.19": "Réponses mises en cache",
+  "nut.20": "Devis mint signés",
+  "nut.21": "Effacer l'authentification",
+  "nut.22": "Authentification aveugle",
+  "nut.23": "Mode de paiement BOLT11",
+  "nut.24": "Paiement HTTP 402 requis",
+  "nut.25": "Mode de paiement BOLT12",
+  "reviews.title": "Avis",
+  "reviews.anon": "Anon",
+  "reviews.anonTitle": "Aucun profil public Nostr trouvé pour cette clé",
+  "reviews.nip05Title": "Identifiant NIP-05 (non vérifié par ce site)",
+  "reviews.filter.group": "Filtrer les avis",
+  "reviews.filter.all": "Tous",
+  "reviews.filter.five": "5★",
+  "reviews.filter.critical": "Critique",
+  "reviews.filter.recent": "Récent",
+  "reviews.filter.hideAnon": "Masquer immédiatement",
+  "reviews.anonHidden.other": "Affichage des avis sur {n} sur {total} : anon masqué.",
+  "reviews.allAnon.one": "La seule critique ici est anonyme.",
+  "reviews.allAnon.other": "Tous les commentaires sur le {n} ici sont anonymes.",
+  "reviews.allAnonShow.one": "Montre-le",
+  "reviews.allAnonShow.other": "Montre-leur",
+  "reviews.loading.one": "Chargement de la revue {n} des relais Nostr",
+  "reviews.loading.other": "Chargement des avis {n} des relais Nostr",
+  "reviews.empty": "Aucun avis pour l'instant. Soyez le premier à en écrire un.",
+  "reviews.emptyWritten": "Pas encore de critiques écrites ici. Soyez le premier à en écrire un.",
+  "reviews.emptyFilter": "Aucun avis ne correspond à ce filtre.",
+  "reviews.rate.cashu": "Évaluer ce mint",
+  "reviews.rate.fedimint": "Évaluer cette fédération",
+  "reviews.rate.lnurl": "Évaluer ce mint",
+  "reviews.noscript": "Les avis sont signés sur Nostr et chargés dans votre navigateur, cette liste nécessite donc JavaScript. La note et les décomptes ci-dessus proviennent du site lui-même.",
+  "reviews.relayError": "Impossible d'atteindre le relais. Les avis peuvent être incomplets.",
+  "reviews.srRating": "{rating} sur 5",
+  "reviews.srNoRating": "Aucune note donnée",
+  "reviews.readMore": "En savoir plus",
+  "reviews.readLess": "Afficher moins",
+  "reviews.actions.copyNpub": "Copier npub",
+  "reviews.actions.openNostr": "Voir cet événement sur Nostr",
+  "reviews.actions.copyLink": "Copier le lien vers cet avis",
+  "reviews.anonNote": "Premier avis sur ce npub, aucune autre activité trouvée",
+  "reviews.published": "Publié.",
+  "reviews.publishedPartial": "Publié sur {accepted} des relais {total}.",
+  "reviews.propagating": "Publication sur les relais Nostr",
+  "reviews.summary.line.one": "Note {count} sans commentaire : {breakdown}",
+  "reviews.summary.line.other": "Notes {count} sans commentaire : {breakdown}",
+  "reviews.summary.lineDay.one": "Note {count} sans commentaire sur {when} : {breakdown}",
+  "reviews.summary.lineDay.other": "Notes de {count} sans commentaire sur {when} : {breakdown}",
+  "reviews.summary.showOne": "Montre-le",
+  "reviews.summary.showMany": "Montre-leur",
+  "reviews.breakdown.5": "{n} cinq étoiles",
+  "reviews.breakdown.4": "{n} quatre étoiles",
+  "reviews.breakdown.3": "{n} trois étoiles",
+  "reviews.breakdown.2": "{n} deux étoiles",
+  "reviews.breakdown.1": "{n} une étoile",
+  "reviews.breakdown.none": "{n} sans note",
+  "reviews.dialog.title": "Avis {name}",
+  "reviews.dialog.lede.cashu": "Partagez votre expérience avec ce mint.",
+  "reviews.dialog.lede.fedimint": "Partagez votre expérience avec cette fédération.",
+  "reviews.dialog.lede.lnurl": "Partagez votre expérience avec ce mint.",
+  "reviews.dialog.permanent": "Publié de façon permanente sur des relais Nostr publics.",
+  "reviews.dialog.gate.title": "Connectez-vous pour écrire un avis",
+  "reviews.dialog.gate.lead": "Les avis sont signés avec votre clé Nostr. Elle reste dans votre signataire, ce site ne la voit jamais.",
+  "reviews.dialog.ratingLegend": "Votre note",
+  "reviews.dialog.starsSr.one": "Étoile {n}",
+  "reviews.dialog.starsSr.other": "Étoiles {n}",
+  "reviews.dialog.chooseRating": "Choisissez une note",
+  "reviews.dialog.starLabel": "{n} : {phrase}",
+  "reviews.dialog.stars.1": "évitez-le",
+  "reviews.dialog.stars.2": "eu des problèmes",
+  "reviews.dialog.stars.3": "a fonctionné, avec des mises en garde",
+  "reviews.dialog.stars.4": "bien",
+  "reviews.dialog.stars.5": "fonctionne très bien",
+  "reviews.dialog.bodyLabel": "Que devraient savoir les autres ?",
+  "reviews.dialog.charCount": "{n} / {max}",
+  "reviews.dialog.submit": "Signer et publier",
+  "reviews.dialog.signing": "Signature…",
+  "reviews.dialog.publishing": "Édition…",
+  "reviews.dialog.publishingTo": "Publication sur des relais ({accepted}/{total})",
+  "reviews.dialog.waitingExtension": "En attente de votre prolongation",
+  "reviews.dialog.waitingSigner": "En attente de votre signataire",
+  "reviews.dialog.confirmClose": "Fermer cet avis ? Votre brouillon est conservé jusqu'à votre départ du site.",
+  "reviews.dialog.why.login": "Connectez-vous pour publier",
+  "reviews.dialog.why.words": "Écrivez quelques mots",
+  "reviews.dialog.why.more.one": "{n} plus de caractère",
+  "reviews.dialog.why.more.other": "{n} plus de caractères",
+  "reviews.dialog.why.over.one": "Caractère {n} dépassant la limite",
+  "reviews.dialog.why.over.other": "Caractères {n} dépassant la limite",
+  "reviews.dialog.identity.needSigner": "Vous avez besoin d'un signataire Nostr pour publier. Votre clé y reste, ce site ne la voit jamais.",
+  "reviews.dialog.identity.loginToPublish": "Connectez-vous pour publier",
+  "reviews.dialog.identity.switch": "Changer",
+  "reviews.dialog.identity.extension": "Signer avec l'extension de votre navigateur",
+  "reviews.dialog.identity.readingKey": "Lecture de votre clé publique…",
+  "reviews.dialog.identity.willAsk": "Votre extension sera invitée à signer",
+  "reviews.dialog.error.noRelay": "Aucun relais n'a accepté l'avis. Vérifiez votre connexion, puis réessayez.",
+  "reviews.validate.rating": "Choisissez une note de 1 à 5 étoiles.",
+  "reviews.validate.short": "Écrivez au moins les caractères {n} pour que l'examen soit utile.",
+  "reviews.validate.long": "Les avis sont limités aux personnages {n}.",
+  "feed.title": "Derniers avis sur le mint et la fédération · Cashumints.space",
+  "feed.description": "Chaque avis sur un mint, une fédération et un mint LNURL dès sa publication : {reviews} avis portant sur {mints} mints Cashu, {federations} fédérations Fedimint et {lnurl} mints LNURL, signés sur Nostr et lisibles ici du plus récent au plus ancien. Filtrez par écosystème, par note ou par nom.",
+  "feed.heading": "Derniers avis",
+  "feed.lede": "Chaque revue de chaque fédération Cashu mint et Fedimint, la plus récente en premier, lue en direct depuis les relais Nostr. Chacun est signé par son auteur et vit sur les relais, pas dans notre base de données.",
+  "feed.label": "Avis",
+  "feed.showingBuild.one": "Affichage de l'avis le plus récent de la dernière version",
+  "feed.showingBuild.other": "Affichage des avis les plus récents sur le {n} de la dernière version",
+  "feed.noscript": "Les avis sont signés sur Nostr et chargés dans votre navigateur, le filtrage et la liste complète nécessitent donc JavaScript. Les critiques {n} ci-dessous ont été lues à partir des relais lors de la création de cette page.",
+  "feed.emptyBuild": "Aucun avis n'a pu être lu sur les relais lors de la création de cette page. La liste se recharge depuis les relais dans votre navigateur.",
+  "feed.foot": "Les avis sont des opinions de la communauté et non des affirmations vérifiées. Lisez le {link} avant de faire confiance à un mint avec de l'argent.",
+  "feed.footLink": "clause de non-responsabilité",
+  "feed.showing": "Affichage des avis sur {shown} sur {total}",
+  "feed.showingMatching": "Affichage des avis correspondants à {shown} sur {matching} ({total} au total)",
+  "feed.emptyRelays": "Aucun avis n'est revenu des relais. Ouvrez n'importe quelle page mint pour y lire et rédiger des critiques.",
+  "feed.emptyFilter": "Aucun avis ne correspond à ce filtre. Décochez la case mint ou essayez Tous.",
+  "feed.relayError": "Impossible d'atteindre les relais. Affichage des avis de la dernière version.",
+  "feed.relayEmpty": "Aucun avis n'est revenu des relais. Affichage des avis de la dernière version.",
+  "feed.reading": "Lecture des relais…",
+  "login.open": "Se connecter",
+  "login.title": "Connectez-vous avec Nostr",
+  "login.note": "Votre clé reste dans votre signataire. Ce site ne peut jamais le voir.",
+  "login.extension.name": "Extension de navigateur",
+  "login.extension.desc": "Signez avec Alby, nos2x ou une autre extension NIP-07",
+  "login.extension.none": "Aucune extension trouvée",
+  "login.extension.getOne": "Obtenez-en un :",
+  "login.remote.name": "Signataire distant",
+  "login.remote.desc": "Scannez un code avec une application de signature ou collez un lien de bunker",
+  "login.primal.name": "Primal",
+  "login.primal.desc": "Approuvez la connexion dans l'application Primal sur votre téléphone",
+  "login.paste.label": "Ou collez le lien de connexion que votre signataire vous a donné",
+  "login.copyLink": "Copiez le lien de connexion",
+  "login.whatIsNostr": "Qu'est-ce que le Nostr ?",
+  "login.connect.remote.title": "Connecter un signataire distant",
+  "login.connect.remote.lead": "Scannez-le avec votre application de signature ou copiez le lien et collez-le ici.",
+  "login.connect.remote.hint": "Fonctionne avec n'importe quel signataire NIP-46 : nsec.app, Amber, Nostrify, votre propre bunker.",
+  "login.connect.remote.open": "Ouvrir dans votre application de signataire",
+  "login.connect.primal.title": "Connectez-vous avec Primal",
+  "login.connect.primal.lead": "Ouvrez Primal sur votre téléphone, recherchez la signature à distance dans ses paramètres et scannez ce code.",
+  "login.connect.primal.hint": "Primal signe pour d'autres applications via NIP-46. Il s'agit donc de la même connexion qu'utilise tout signataire, et votre clé reste dans Primal. {link}",
+  "login.connect.primal.open": "Ouvert dans Primal",
+  "login.status.buildingLink": "Construire un lien de connexion",
+  "login.status.waitingExtension": "En attente de votre prolongation",
+  "login.status.waitingSigner": "En attente de votre signataire",
+  "login.status.connecting": "Connexion à votre signataire",
+  "login.status.connected": "Connecté",
+  "login.toast.loggedIn": "Connecté",
+  "login.toast.fetchingProfile": "Récupération de votre profil Nostr depuis les relais…",
+  "login.toast.profile": "Profil : {name}",
+  "login.toast.noProfile": "Aucun profil trouvé sur les relais",
+  "login.method.extension": "Extension",
+  "login.method.remote": "Télécommande",
+  "login.method.primal": "Primal",
+  "login.account": "Votre compte Nostr",
+  "login.copyNpub": "Copiez votre npub complet",
+  "login.logout": "Se déconnecter",
+  "signer.status.waitingExtension": "En attente de votre prolongation",
+  "signer.status.signed": "Signé",
+  "signer.status.reconnecting": "Reconnexion à votre signataire",
+  "signer.status.approveWindow": "Votre signataire a besoin de votre approbation dans sa propre fenêtre",
+  "signer.status.waitingSigner": "En attente de votre signataire",
+  "signer.status.stillWaiting": "J'attends toujours la réponse de votre signataire",
+  "signer.status.connected": "Connecté",
+  "signer.error.noExtension": "Aucune extension de signature trouvée. Installez Alby ou nos2x, puis rechargez cette page.",
+  "signer.error.privateKey": "Cela ressemble à une clé privée, pas à un lien de connexion. Ce site ne prend jamais de clé. Collez le lien bunker:// que votre signataire vous a fourni.",
+  "signer.error.badLink": "Ce n'est pas un lien de connexion que ce site comprend. Collez le lien bunker:// de votre signataire.",
+  "signer.error.noAnswer": "Votre signataire n'a pas répondu. Il est peut-être fermé ou son relais est peut-être en panne. Ouvrez-le et réessayez.",
+  "signer.error.timeout": "Votre signataire n'a pas répondu à temps. Ouvrez-le, vérifiez qu'il est toujours connecté, puis réessayez.",
+  "signer.error.cancelled": "Connexion annulée.",
+  "signer.error.declined": "La demande de signature a été refusée",
+  "notfound.title": "Page introuvable · Cashumints.space",
+  "notfound.description": "Cette page n'existe pas sur Cashumints.space.",
+  "notfound.heading": "Cette page n'existe pas",
+  "notfound.lede": "Il a peut-être bougé ou le mint n'est peut-être pas encore indexé. Recherchez un mint par nom ou domaine, ou collez une URL mint.",
+  "notfound.browse": "Parcourez tous les mints",
+  "notfound.home": "Rentre chez toi",
+  "notfound.loading": "Chargement de {host}",
+  "notfound.fb.rating": "Notation",
+  "notfound.fb.reviews": "Avis",
+  "notfound.fb.software": "Logiciel",
+  "notfound.fb.lastOnline": "Dernière connexion",
+  "notfound.fb.note": "Ce mint a été indexé après la dernière construction du site : voici un résumé issu de l’API en direct, avec ses avis en dessous. La page complète apparaît à la prochaine construction.",
+  "notfound.resolve.checking": "Première visite : ce mint est en cours de vérification.",
+  "notfound.resolve.failed": "Ce mint n’a pas pu être ajouté",
+  "notfound.resolve.failedFedimint": "Cette fédération n’a pas pu être ajoutée",
+  "notfound.resolve.retry": "Essayer une autre adresse",
+  "notfound.resolve.switch": "L’ouvrir comme mint {kind}",
+  "notfound.resolve.fedimint": "L’adresse de la page d’une fédération ne contient pas son code d’invitation, donc celle-ci ne peut pas être retrouvée à partir du lien seul. Colle le code d’invitation et elle est ajoutée.",
+  "notfound.resolve.ambiguous": "Cette adresse ne peut pas être déduite du lien seul. Colle l’URL complète du mint et il est ajouté.",
+  "wallets.title": "Portefeuilles Cashu · Cashumints.space",
+  "wallets.description": "Portefeuilles Cashu qui fonctionnent avec le mints répertorié ici, sur mobile, Web, navigateur et ligne de commande, avec ce pour quoi chacun est bon.",
+  "wallets.heading": "Portefeuilles",
+  "wallets.lede": "Vous avez besoin d'un portefeuille pour contenir les ecash de l'un de ces mints. La plupart des portefeuilles communiquent avec plusieurs mints à la fois, vous n'êtes donc pas lié au premier que vous essayez.",
+  "wallets.note": "Cette liste n'est pas exhaustive et ne constitue pas une approbation. Le projet Cashu conserve un index plus large à {link}. Un portefeuille contient les clés, un mint contient l'argent : lisez les critiques du mint avant de choisir où se trouve votre sats.",
+  "wallets.platform.android": "Android",
+  "wallets.platform.ios": "iOS",
+  "wallets.platform.web": "Web",
+  "wallets.platform.extension": "Extension de navigateur",
+  "wallets.platform.cli": "CLI",
+  "wallets.platform.python": "Python",
+  "wallets.item.minibits": "Portefeuille mobile ecash avec sa propre prise en charge des adresses mint, Lightning et des contacts Nostr.",
+  "wallets.item.nutstash": "Portefeuille de navigateur qui gère plusieurs mints à la fois et importe et exporte des jetons bruts.",
+  "wallets.item.enuts": "Portefeuille mobile axé sur les soldes multi-monnaies et l'envoi de ecash via Nostr.",
+  "wallets.item.cashume": "Portefeuille Web de référence du projet Cashu. Fonctionne entièrement dans le navigateur, installable en tant que PWA.",
+  "wallets.item.boardwalk": "Portefeuille Web construit autour des adresses Lightning et envoyant ecash par lien.",
+  "wallets.item.coinos": "Portefeuille Lightning et point de vente qui gère également son propre Cashu mint.",
+  "wallets.item.oxchat": "Messagerie Nostr avec un portefeuille ecash intégré, pour envoyer des sats dans les discussions.",
+  "wallets.item.nutshell": "L’implémentation de référence. Fonctionne comme un portefeuille sur la ligne de commande et comme logiciel mint.",
+  "about.title": "À propos de Cashumints.space",
+  "about.description": "Qu'est-ce que Cashu, que contient réellement un mint, qu'est-ce que NIP-87 et comment ce site indexe le mints et lit les avis des relais Nostr.",
+  "about.heading": "À propos",
+  "about.lede": "Cashumints.space répertorie tous les Cashu mint que nous pouvons trouver sur le réseau Nostr et vous montre ce que les gens disent à leur sujet. Il est fabriqué par Azzamo.",
+  "about.cashu.title": "Qu'est-ce que le Cashu ?",
+  "about.cashu.p1": "Cashu est un protocole ecash pour Bitcoin. Un mint émet des jetons aveugles soutenus par le sats qu'il détient, et ces jetons se déplacent entre les personnes sans que le mint sache qui a envoyé quoi à qui. La confidentialité est réelle et c'est là l'essentiel : les jetons ne sont pas des comptes et le mint ne peut pas lier le jeton qu'il a signé au jeton qui revient.",
+  "about.cashu.p2": "Vous pouvez lire le protocole et ses spécifications sur {link}. Les spécifications elles-mêmes sont appelées NUTs, d'où proviennent les numéros NUT sur chaque page mint.",
+  "about.mints.title": "Qu'est-ce qu'un mint et le compromis",
+  "about.mints.p1": "Un mint est gardien. Lorsque vous mint ecash, vous remettez sats à celui qui gère ce serveur, et vous lui faites confiance pour honorer les jetons lorsque vous les fondez. Il n'y a aucune preuve de fraude, aucun séquestre et aucun recours. Un opérateur mint peut disparaître avec la balance, et un mints l'a fait.",
+  "about.mints.p2": "C'est exactement pourquoi les critiques existent ici. Ce site ne vous dit jamais qu'un mint est sûr. Le statut sur une page mint indique {code}, et non « de confiance », et cela signifie uniquement que le serveur a répondu lors de notre dernière demande. Traitez les soldes ecash comme de l’argent liquide dans la poche d’un manteau : c’est bien pour dépenser, pas pour économiser.",
+  "about.nip87.title": "Qu'est-ce que le NIP-87 ?",
+  "about.nip87.p1": "NIP-87 est la convention Nostr pour annoncer et recommander ecash mints. Deux types d’événements comptent ici :",
+  "about.nip87.li1": "{code} annonce un mint. L'URL mint se trouve dans la balise {tag}. C'est ainsi que le site découvre un mints qu'il n'a jamais vu.",
+  "about.nip87.li2": "{code} est une critique. Il porte l'évaluation et le texte de l'évaluation, et pointe vers le mint dont il s'agit avec une balise {utag} (l'URL du mint) et une balise {dtag} (la propre clé publique du mint).",
+  "about.nip87.p2": "Chaque avis est signé par la clé Nostr de son auteur. Nous ne disons jamais qu'un avis est « vérifié », car personne ne l'a vérifié : il est signé, ce qui est une affirmation différente et plus utile. Cela signifie que vous pouvez vérifier qui l'a écrit et qu'il n'a pas été modifié. Cela ne signifie pas que l'auteur est honnête ou qu'il a déjà utilisé le mint.",
+  "about.how.title": "Comment fonctionne ce site",
+  "about.how.p1": "Il y a deux boucles et une règle. La règle est que le mint est propriétaire de ses métadonnées et que le Nostr est propriétaire des avis, donc ce site ne stocke ni l'un ni l'autre en tant qu'autorité.",
+  "about.how.li1": "{strong} demande à chaque mint connu {code} toutes les dix minutes et enregistre ce qu'il dit : nom, description, version, NUTs pris en charge, limites, coordonnées. Il enregistre également si le mint a répondu, ce qui explique la disponibilité.",
+  "about.how.li1Label": "La boucle de la sonde",
+  "about.how.li2": "Le {strong} se connecte aux relais Nostr toutes les heures, lit les annonces et les critiques du mint et ajoute tout mint qu'il n'a pas vu auparavant.",
+  "about.how.li2Label": "La boucle découverte",
+  "about.how.p2": "La partie importante est ce qui se passe lorsqu'un mint cesse de répondre. Ses métadonnées mises en cache ne sont jamais écrasées par une sonde défaillante, donc un mint mort conserve sa page complète : ses spécifications, son historique et ses critiques, avec une bannière indiquant quand il est devenu sombre. La version précédente de ce site affichait à la place une page d'erreur, ce qui signifiait que les personnes mints dont les personnes avaient le plus besoin de s'avertir mutuellement étaient celles qui ne pouvaient pas être examinées. C'était la principale raison de la reconstruction.",
+  "about.how.p3": "Le texte de l’avis n’est jamais stocké de notre côté. Lorsque vous ouvrez une page mint, votre navigateur communique directement avec les relais et lit lui-même les avis. Lorsque vous en écrivez une, elle est signée par votre propre extension Nostr et envoyée directement à ces relais. Nous gardons un décompte pour que les pages puissent être classées et triées, rien de plus. Rien ici ne peut être modifié ou supprimé par nous, y compris les avis que nous préférerions ne pas avoir.",
+  "about.relays.title": "Relais que nous lisons",
+  "about.relays.p1": "Voici les relais que l'indexeur et votre navigateur utilisent tous deux :",
+  "about.relays.p2": "Pointez n'importe quel client Nostr vers les mêmes relais et vous verrez les mêmes événements. C’est là toute la promesse : rien ici n’est vrai seulement parce que nous le disons.",
+  "about.nuts.title": "Que sont les NUTs ?",
+  "about.nuts.p1": "NUTs sont les spécifications numérotées Cashu, comme BIPs pour Bitcoin. Un mint annonce ceux qu'il implémente, et cela vous indique ce qu'il peut réellement faire : NUT-04 et NUT-05 sont des minting et melting sur Lightning (sans eux, un mint n'est pas très utile), NUT-07 permet à un portefeuille de vérifier si un jeton a déjà été dépensé, NUT-17 donne les portefeuilles sont mis à jour en direct sur WebSockets au lieu d'une interrogation, et NUT-20 permet à un portefeuille de prouver qu'un devis mint lui a réellement été émis. La liste complète se trouve à {link}.",
+  "about.numbers.title": "Tout de suite",
+  "about.numbers.p1": "{mints} mints indexés, {online} parmi eux répondant, avis {reviews} comptés à partir des relais ci-dessus.",
+  "about.source.title": "Source et crédit",
+  "about.source.p1": "Le site est open source à {github}. Il est construit et géré par {azzamo}. Si une page mint contient un problème, corrigez-le à la source : les métadonnées mint proviennent du {code} du mint et les critiques proviennent du Nostr.",
+  "terms.title": "Conditions d'utilisation · Cashumints.space",
+  "terms.description": "Conditions d'utilisation de Cashumints.space : qu'est-ce que le site, ce qu'il ne fait pas et qui est responsable de quoi. Aucun compte, aucune garantie, aucune affiliation avec un mint.",
+  "terms.heading": "Conditions d'utilisation",
+  "terms.lede": "Termes simples pour un site qui indexe uniquement des données publiques. Dernière mise à jour {date}.",
+  "terms.what.title": "Qu'est-ce que ce site",
+  "terms.what.p1": "Cashumints.space est un index de données accessibles au public sur Cashu mints. Deux types de données, toutes deux provenant d’ailleurs :",
+  "terms.what.li1": "Métadonnées Mint, lues à partir du point de terminaison {code} de chaque mint : nom, description, version du logiciel, NUTs pris en charge, coordonnées et si le mint a répondu à notre dernière demande.",
+  "terms.what.li2": "Avis, lus sur les relais publics Nostr. Ce sont des événements NIP-87 publiés par leurs auteurs sur des relais que tout le monde peut interroger.",
+  "terms.what.p2": "Nous collectons ces données, les normalisons, les classons et les montrons. Nous ne le créons pas.",
+  "terms.noAccounts.title": "Pas de comptes, pas de garanties",
+  "terms.noAccounts.p1": "Il n'y a rien à inscrire. Le site est fourni tel quel, sans aucune garantie d'aucune sorte : ni que les données soient exactes, ni qu'elles soient actuelles, ni que le site soit disponible. Les données d'un Mint peuvent dater de quelques minutes ou heures, un mint peut changer après notre dernière vérification et un relais peut ne pas répondre, auquel cas vous voyez moins que ce qui existe.",
+  "terms.noAccounts.p2": "Utilisez-le à vos propres risques. Nous ne sommes pas responsables de toute perte résultant de l'utilisation de ce site ou de la confiance dans tout ce que vous lisez ici. Consultez le {link} pour connaître les risques spécifiques liés à l'utilisation d'un Cashu mint.",
+  "terms.noAccounts.link": "clause de non-responsabilité",
+  "terms.noCustody.title": "Nous ne détenons pas votre argent",
+  "terms.noCustody.p1": "Ce site ne prend jamais la garde des fonds. Il n'a pas de portefeuille, il ne touche pas au ecash et il ne peut rien déplacer, geler ou récupérer. Si vous rencontrez un problème avec un mint, l'opérateur du mint est le seul à pouvoir vous aider et nous ne pouvons pas le contacter en votre nom.",
+  "terms.noCustody.p2": "Nous ne sommes affiliés à aucun mint répertorié ici, et aucun mint ne paie pour son inscription, son classement ou sa note. Les Mints sont découverts à partir des annonces publiques Nostr et classés par un algorithme sur les données d'examen public.",
+  "terms.reviews.title": "Les avis sont les mots des autres",
+  "terms.reviews.p1": "Les avis sont du contenu généré par les utilisateurs et publié sur les relais publics Nostr par leurs auteurs. Nous les affichons, nous ne les contrôlons pas. Nous ne les avons pas écrits, nous ne pouvons pas les éditer, et nous ne pouvons pas les supprimer des relais qui les détiennent : ce sont des événements signés sur un réseau qui ne nous appartient pas.",
+  "terms.reviews.p2": "Un avis est l'expérience d'une personne et non un fait vérifié. Si vous en publiez un, vous êtes responsable de ce qu’il dit. Ne publiez rien d'illégal et sachez que ce que vous publiez est public et permanent (voir le {link}).",
+  "terms.reviews.link": "page de confidentialité",
+  "terms.reviews.p3": "Nous pouvons arrêter d'afficher un avis spécifique sur ce site, et nous le ferons pour le contenu illégal. Cela le supprime de ces pages uniquement. L'événement reste sur les relais et tout autre client Nostr peut toujours le lire.",
+  "terms.links.title": "Liens vers d'autres sites",
+  "terms.links.p1": "Les URL Mint, les liens de portefeuille, les contacts des opérateurs et tout ce qui pointe vers ce site sont là car ils font partie des données. Un lien n’est pas une approbation et nous ne vérifions pas ce qui se trouve à l’autre bout.",
+  "terms.changes.title": "Changements",
+  "terms.changes.p1": "Ces termes peuvent changer. La date en haut indique la date à laquelle ils l'ont fait pour la dernière fois. Le site est open source, donc chaque modification apportée à cette page figure dans l'historique des validations.",
+  "terms.contact.title": "Contact",
+  "terms.contact.p1": "Il est préférable de déposer les problèmes et les demandes de retrait sur {github}. Le site est géré par {azzamo}.",
+  "privacy.title": "Confidentialité · Cashumints.space",
+  "privacy.description": "Confidentialité sur Cashumints.space : pas de compte, pas de cookies de suivi, pas d'analyse. localStorage est utilisé pour la mise en cache des profils et rien n’est envoyé nulle part. Les avis sont signés dans votre propre navigateur.",
+  "privacy.heading": "Confidentialité",
+  "privacy.lede": "Nous collectons aussi peu qu’un site Web peut le faire. Dernière mise à jour {date}.",
+  "privacy.noAccounts.title": "Aucun compte",
+  "privacy.noAccounts.p1": "Il n'y a pas d'inscription, pas de connexion et pas de profil. Rien sur ce site ne vous demande qui vous êtes, et il n'y a aucun enregistrement d'utilisateur à divulguer car il n'y a aucun utilisateur.",
+  "privacy.noTracking.title": "Pas de cookies de suivi, pas d'analyse",
+  "privacy.noTracking.p1": "Le site ne définit aucun cookie pour le suivi. Il n'y a pas de script d'analyse, pas de gestionnaire de balises, pas de pixel, pas d'enregistrement de session et pas de réseau publicitaire. Rien sur la page ne nous signale votre comportement ni à quiconque.",
+  "privacy.logs.title": "Journaux du serveur",
+  "privacy.logs.p1": "Le serveur Web conserve des journaux d'accès standard, ce que fait tout serveur Web par défaut. Une ligne de journal enregistre votre adresse IP, l'heure, la page que vous avez demandée, l'état de la réponse, ainsi que l'agent utilisateur et le référent envoyés par votre navigateur. Les journaux existent pour déboguer les erreurs et détecter les abus. Ils ne sont joints à rien d’autre et ne sont ni vendus ni partagés.",
+  "privacy.logs.operatorLabel": "Remarque de l'opérateur :",
+  "privacy.logs.operator": "si vous exploitez ce site, indiquez ici votre véritable rétention. Le déploiement dans README utilise nginx avec son journal d'accès par défaut et quelle que soit la rotation expédiée par votre distribution (sur Debian et Ubuntu, c'est-à-dire logrotate, quotidiennement, pendant 14 jours). Confirmez ce que fait votre serveur et remplacez ce paragraphe par le numéro.",
+  "privacy.storage.title": "Ce qui est stocké dans votre navigateur",
+  "privacy.storage.p1": "Le site utilise localStorage pour exactement deux choses, qui restent toutes deux sur votre appareil et ne sont jamais envoyées nulle part :",
+  "privacy.storage.li1": "Un cache de métadonnées de profil Nostr (événements de type 0 : noms, avatars, adresses NIP-05) pour les évaluateurs dont vous avez consulté les avis. Cela évite de réinterroger les relais sur chaque page. Les entrées expirent et le cache est plafonné et expulsé en premier.",
+  "privacy.storage.li2": "Préférences d'interface, afin que le site se comporte de la même manière la prochaine fois.",
+  "privacy.storage.p2": "Effacer les données du site de votre navigateur supprime les deux. Rien ne se casse, les recherches de profil se relancent.",
+  "privacy.thirdParties.title": "À quoi parle votre navigateur",
+  "privacy.thirdParties.p1": "Le chargement d'une page connecte votre navigateur à quelques endroits en plus de ce site. C'est ainsi qu'un site sans suivi côté serveur lit toujours les données en direct :",
+  "privacy.thirdParties.li1Label": "Relais publics Nostr",
+  "privacy.thirdParties.li1": "{strong}, sur WebSocket, pour lire les avis et les profils des évaluateurs. Le relais voit votre adresse IP et ce que vous avez demandé, comme le fait tout serveur auquel vous vous connectez. Les relais sont répertoriés sur le {link}.",
+  "privacy.thirdParties.li1Link": "à propos de la page",
+  "privacy.thirdParties.li2Label": "Images d'avatar du réviseur",
+  "privacy.thirdParties.li2": "{strong}, chargé depuis n'importe quel endroit indiqué par le profil du réviseur. Ceux-ci sont envoyés avec une politique de non-référence, de sorte que l'hôte ne sache pas sur quelle page vous vous trouviez.",
+  "privacy.publishing.title": "Publier un avis",
+  "privacy.publishing.p1": "La rédaction d'un avis s'effectue dans votre navigateur, pas sur notre serveur. L'événement est signé par votre extension NIP-07 (Alby, nos2x ou similaire) et diffusé depuis votre navigateur directement vers les relais. Votre clé privée ne quitte jamais l'extension et ce site ne la voit jamais. Nous ne construisons pas de gestion de clés personnalisée et nous ne demandons jamais de clé ou de phrase de départ.",
+  "privacy.permanent.title": "Tout ce que vous publiez sur Nostr est public et permanent",
+  "privacy.permanent.p1": "C'est la partie qui mérite d'être lue deux fois. Une revue est un événement signé sur des relais publics. Une fois sorti, il sort :",
+  "privacy.permanent.li1": "N'importe qui peut le lire, maintenant et plus tard, en utilisant n'importe quel client Nostr. Ce n'est pas \"public sur Cashumints.space\", c'est public sur le réseau.",
+  "privacy.permanent.li2": "Il est lié en permanence à votre clé publique Nostr, aux côtés de tout ce que cette clé a déjà publié.",
+  "privacy.permanent.li3": "Le supprimer est une demande, pas une commande. Vous pouvez publier un événement de suppression et certains relais l'honoreront, mais un relais est libre de l'ignorer et toute personne ayant déjà copié l'événement l'a toujours. Traitez une critique publiée comme permanente.",
+  "privacy.permanent.li4": "Nous ne pouvons pas le supprimer pour vous. Nous pouvons arrêter de l'afficher ici ; ça ne change rien au niveau des relais.",
+  "privacy.permanent.p2": "Si vous souhaitez consulter un mint sans que cela soit lié à votre identité principale, utilisez une clé Nostr distincte. Notez qu'une clé sans autre activité est affichée comme telle sur les critiques sévères, car une toute nouvelle clé écrivant une critique d'une étoile est un modèle que les lecteurs méritent de voir.",
+  "privacy.contact.title": "Questions",
+  "privacy.contact.p1": "Le site est open source : si vous souhaitez vérifier l'un des éléments ci-dessus, lisez le code sur {github}. Les questions et les corrections peuvent y figurer dans un numéro.",
+  "disclaimer.title": "Avis de non-responsabilité · Cashumints.space",
+  "disclaimer.description": "Ce qu'il faut savoir avant d'utiliser un Cashu mint : Les mints sont en garde, un mint peut disparaître avec votre argent, les avis sont des avis et des moyens en ligne accessibles, non dignes de confiance.",
+  "disclaimer.heading": "Clause de non-responsabilité",
+  "disclaimer.lede": "Lisez ceci avant d’investir dans un mint. Dernière mise à jour {date}.",
+  "disclaimer.callout": "Un Cashu mint détient votre argent pour vous. S'il disparaît, votre ecash a disparu et il n'y a personne à qui faire appel. Ne gardez que ce que vous pouvez vous permettre de perdre.",
+  "disclaimer.custodial.title": "Les Mints sont gardiens",
+  "disclaimer.custodial.p1": "Lorsque vous mint ecash, vous remettez bitcoin à l'opérateur mint et récupérez les jetons. Ces jetons constituent une créance sur cet opérateur. Ce ne sont pas des bitcoin que vous détenez, et c'est l'opérateur qui décide de les honorer.",
+  "disclaimer.custodial.p2": "Cela signifie que chaque mint comporte les mêmes risques : l'opérateur peut disparaître, être contraint de s'arrêter, perdre les fonds à cause d'un bug ou d'un piratage, ou simplement éteindre le serveur. Il n'y a pas d'assurance-dépôt, pas de rétrofacturation, pas de ligne d'assistance et aucun recours juridique sur lequel on peut compter. Cela est vrai pour le mint le mieux noté sur ce site.",
+  "disclaimer.custodial.p3": "Le Cashu est conçu pour les petites quantités circulant rapidement. Utilisez-le de cette façon : conservez ce que vous êtes sur le point de dépenser, pas vos économies, et répartissez-le sur le mints plutôt que de tout ranger en un seul.",
+  "disclaimer.reviews.title": "Les avis sont des opinions et non des affirmations vérifiées",
+  "disclaimer.reviews.p1": "Chaque avis ici a été rédigé par quelqu'un sur Nostr et signé avec sa clé. Signé signifie que nous pouvons vous dire quelle clé l'a écrit. Cela ne signifie pas que l'avis est vrai, que l'auteur a utilisé le mint ou que l'auteur n'est pas l'opérateur, un concurrent ou une personne possédant dix clés.",
+  "disclaimer.reviews.p2": "Nous ne vérifions pas les évaluateurs et nous ne modifions ni ne supprimons les avis avec lesquels nous ne sommes pas d'accord. Lisez-en quelques-uns, regardez ce qu'ils disent réellement et pesez un mint avec trois avis différemment d'un avec trois cents.",
+  "disclaimer.status.title": "En ligne signifie accessible, pas digne de confiance",
+  "disclaimer.status.p1": "Nous vérifions régulièrement chaque mint et montrons s'il a répondu. C'est tout ce que signifie un statut vert : le serveur a répondu. Cela ne dit rien si l'opérateur est solvable, honnête ou a toujours l'intention d'honorer vos jetons demain.",
+  "disclaimer.status.p2": "Un mint peut être en ligne jusqu'au moment où il ne l'est pas. L'historique de disponibilité, le NUTs pris en charge et la version du logiciel vous renseignent sur le fonctionnement d'un mint, mais aucun d'entre eux ne constitue une promesse concernant votre argent.",
+  "disclaimer.ranking.title": "Comment fonctionne le classement et ce qu'il ne signifie pas",
+  "disclaimer.ranking.p1": "Les Mints sont classés par un algorithme sur la base des données d'avis publics : note, nombre d'avis et activité récente, les mints en ligne devant par défaut ceux hors ligne. Les détails sont dans le code open source.",
+  "disclaimer.ranking.p2": "Personne ne paie pour le placement. Il n'y a pas de machine à sous sponsorisée, pas de liste promue et aucun accord avec un mint sur ce site. Un classement élevé signifie que l’algorithme a apprécié les données publiques, et rien de plus. Il ne s'agit pas d'une recommandation ni d'une évaluation de sécurité.",
+  "disclaimer.notAdvice.title": "Ce n'est pas un conseil financier",
+  "disclaimer.notAdvice.p1": "Rien sur ce site ne constitue un conseil financier, d'investissement, juridique ou fiscal. Nous ne connaissons pas votre situation et nous ne vous conseillons pas. Utiliser un mint et choisir lequel est votre décision.",
+  "disclaimer.dyor.title": "Faites vos propres recherches",
+  "disclaimer.dyor.li1": "Recherchez l'opérateur. Un mint géré par quelqu'un ayant une réputation publique à perdre est une proposition différente d'une URL anonyme.",
+  "disclaimer.dyor.li2": "Lisez les propres termes du mint et de son MOTD. Un mint qui s'appelle lui-même un test ou une version bêta le signifie.",
+  "disclaimer.dyor.li3": "Commencez petit. Mint un peu, dépensez-le, faites-le fondre et voyez ce qui se passe avant de lui confier davantage.",
+  "disclaimer.dyor.li4": "Attention aux limites. Un maximum faible est souvent le signe d'un opérateur prudent, et un maximum élevé n'est pas le signe d'un opérateur sûr.",
+  "disclaimer.dyor.li5": "Conservez une sauvegarde de vos jetons et n'oubliez pas qu'un jeton est un actif au porteur : celui qui le détient peut le dépenser.",
+  "disclaimer.site.title": "À propos du site lui-même",
+  "disclaimer.site.p1": "Les données ici peuvent être erronées ou obsolètes. Les Mints sont interrogés selon un calendrier, les relais ne parviennent parfois pas à répondre et une page que vous lisez a été créée à un moment donné dans le passé. Le site est fourni tel quel, sans garantie. Voir le {link}.",
+  "disclaimer.site.link": "conditions d'utilisation",
+  "disclaimer.updated": "20 août 2026",
+  "login.getPrimal": "Obtenez Primal",
+  "reviews.dialog.identity.extensionGone": "L'extension de votre navigateur ne répond pas. Connectez-vous à nouveau ou utilisez un signataire distant.",
+  "seo.orgDescription": "Un répertoire des Cashu mints, avec le statut en direct de chaque mint et les avis de la communauté signés sur Nostr.",
+  "seo.ogImageAlt": "Cashumints.space : trouvez un Cashu mint de confiance.",
+  "seo.mint.title.one": "Avis sur {name} : évalué {rating} par rapport à l'examen {n} | Cashumints.space",
+  "seo.mint.title.other": "Commentaires sur {name} : noté {rating} à partir des commentaires sur {n} | Cashumints.space",
+  "seo.mint.titleOffline.one": "{name} : hors ligne pour la journée {n} | Cashumints.space",
+  "seo.mint.titleOffline.other": "{name} : hors ligne pendant les jours {n} | Cashumints.space",
+  "seo.mint.titleNoReviews": "{name}: Cashu mint informations et avis | Cashumints.space",
+  "seo.fedimint.titleNoReviews": "{name} : informations et avis sur la fédération Fedimint | Cashumints.space",
+  "seo.desc.fallback": "Avis de la communauté pour {name} ({domain}).",
+  "seo.desc.fallbackDomain": "Commentaires de la communauté pour le Cashu mint sur {domain}.",
+  "seo.desc.rated.one": "Classé {rating}/5 par {n}, avis signé Nostr.",
+  "seo.desc.rated.other": "Noté {rating}/5 selon les avis {n} signés Nostr.",
+  "seo.desc.noReviews": "Aucun avis pour l'instant.",
+  "seo.desc.status": "{status}.",
+  "seo.desc.statusLimits": "{status}, limite {limits}.",
+  "seo.desc.fedModules": "{status}. Modules : {modules}.",
+  "seo.desc.fedModulesNetwork": "{status}. Modules : {modules} sur {network}.",
+  "seo.mint.ogAlt.one": "{name} : les étoiles du {rating} de l'examen du {n} sur le Cashumints.space",
+  "seo.mint.ogAlt.other": "{name} : Étoiles {rating} de {n} avis sur Cashumints.space",
+  "seo.mint.ogAltNoReviews": "{name} sur Cashumints.space",
+  "nav.home": "Accueil",
+  "mint.more.title": "Plus mints",
+  "mint.more.all": "Tout afficher mints",
+  "nav.fedimints": "Fedimints",
+  "status.announced": "Annoncé seulement",
+  "card.unnamedFederation": "Fédération sans nom",
+  "card.notChecked": "jamais vérifié",
+  "fedimints.title": "Toutes les fédérations Fedimint · Cashumints.space",
+  "fedimints.description": "Toutes les fédérations {total} Fedimint annoncées sur le réseau Nostr : {online} confirmée par un contrôle extérieur, {announced} annoncée et jamais confirmée. Notes de la communauté, modules et codes d'invitation pour chacun.",
+  "fedimints.heading": "Toutes les fédérations",
+  "fedimints.lede": "Chaque fédération Fedimint annoncée sur le réseau Nostr. Une fédération n'a pas de point de terminaison de statut public qui lui est propre, donc certains d'entre eux sont confirmés par un contrôle externe et les autres sont répertoriés exactement comme ils ont été annoncés.",
+  "fedimints.search.label": "Rechercher des fédérations par nom ou identifiant",
+  "fedimints.search.placeholder": "Recherche par nom ou identifiant de fédération…",
+  "fedimints.sort.label": "Trier les fédérations",
+  "fedimints.hideOffline": "Masquer hors ligne",
+  "fedimints.showing": "Affichage des fédérations {total} ({online} confirmé, {announced} annoncé uniquement)",
+  "fedimints.showingFiltered": "Montrant {shown} des fédérations {total} ({online} confirmé, {announced} annoncé uniquement)",
+  "fedimints.announcedNote.one": "L'un d'eux a été annoncé sur Nostr et rien n'a confirmé depuis qu'il fonctionne. Il est répertorié comme annoncé plutôt que comme en ligne ou hors ligne, car ni l’un ni l’autre ne serait vrai.",
+  "fedimints.announcedNote.other": "Parmi ceux-ci, {n} ont été annoncés sur Nostr et rien n'a confirmé depuis qu'ils fonctionnent. Ils sont répertoriés comme annoncés plutôt qu’en ligne ou hors ligne, car ni l’un ni l’autre ne serait vrai.",
+  "fedimints.noResults": "Aucune fédération ne correspond. Essayez un nom ou collez un identifiant de fédération.",
+  "fedimints.emptyIndex": "Aucune fédération n'a été annoncée sur les relais indiqués sur ce site. La liste se remplit au fur et à mesure des annonces.",
+  "fedimint.crumb": "Fedimints",
+  "fedimint.breadcrumb": "Fil d'Ariane",
+  "fedimint.unnamed": "Fédération sans nom",
+  "fedimint.idLabel": "Fédération",
+  "fedimint.kind.federationId": "identifiant de la fédération",
+  "fedimint.moduleCount.one": "Module {n}",
+  "fedimint.moduleCount.other": "Modules {n}",
+  "fedimint.copyInvite": "Copier le code d'invitation",
+  "fedimint.confirmed.label": "Confirmé",
+  "fedimint.confirmed.never": "Jamais",
+  "fedimint.confirmed.by": "par {source}",
+  "fedimint.confirmed.unattributed": "dernier contrôle",
+  "fedimint.announcedOn": "annoncé {when}",
+  "fedimint.announcedUnknown": "pas de date d'annonce",
+  "fedimint.modules.title": "Modules",
+  "fedimint.modules.none": "L'annonce de cette fédération ne répertorie aucun module.",
+  "fedimint.modules.note": "Les modules sont les parties gérées par une fédération. L’annonce indique lesquels sont présents, mais ne précise pas si l’un d’entre eux accepte des dépôts.",
+  "fedimint.modules.notListed": "non répertorié",
+  "fedimint.invite.title": "Code d'invitation",
+  "fedimint.invite.count.one": "Code {n}",
+  "fedimint.invite.count.other": "Codes {n}",
+  "fedimint.invite.note": "Collez-le dans un portefeuille Fedimint pour vous inscrire. Il porte l'identifiant de la fédération et les adresses de ses tuteurs, et il est destiné à être partagé.",
+  "fedimint.invite.kind": "code d'invitation",
+  "fedimint.invite.qr": "QR",
+  "fedimint.invite.qrCaption": "Scannez pour rejoindre {name}",
+  "fedimint.details.federationId": "Identifiant de la fédération",
+  "fedimint.details.network": "Réseau",
+  "fedimint.details.announcedBy": "Annoncé par",
+  "fedimint.details.announced": "Annoncé",
+  "fedimint.more.title": "Plus de fédérations",
+  "fedimint.more.all": "Voir toutes les fédérations",
+  "fedimint.disclaimer": "Rejoindre une fédération, c’est confier votre argent à ses tuteurs. Les notes sont des opinions de la communauté, et une course confirmée signifie accessible et non digne de confiance.",
+  "fedimint.module.lightning": "Lightning",
+  "fedimint.module.mint": "Ecash mint",
+  "fedimint.module.wallet": "Portefeuille en chaîne",
+  "fedimint.module.meta": "Métadonnées",
+  "fedimint.module.stability_pool": "Bassin de stabilité",
+  "fedimint.module.multi_sig_stability_pool": "Pool de stabilité (multisig)",
+  "fedimint.module.fedi-social": "Récupération sociale",
+  "fedimint.network.mainnet": "Réseau principal Bitcoin",
+  "fedimint.network.signet": "Signet",
+  "fedimint.network.testnet": "Testnet",
+  "fedimint.network.testnet4": "Testnet4",
+  "fedimint.network.regtest": "Regtest",
+  "feed.ecosystem.group": "Écosystème",
+  "feed.ecosystem.all": "Tous",
+  "feed.ecosystem.cashu": "Cashu",
+  "feed.ecosystem.fedimint": "Fedimint",
+  "feed.filterBySubject": "Filtrer par mint ou fédération",
+  "feed.anySubject": "Tout mint ou fédération",
+  "feed.clearSubject": "Effacer le filtre de nom",
+  "home.topFedimints.title": "Meilleurs Fedimints",
+  "home.topFedimints.sub": "classé par avis et notes",
+  "home.topFedimints.all": "Toutes les fédérations {n} →",
+  "reviews.validate.subject": "Il n’y a rien qui justifie cette critique.",
+  "mint.warnings.fedimintOffline.lead": "Signalé hors ligne.",
+  "mint.warnings.fedimintOffline.body.since": "Le dernier chèque parvenu à cette fédération portait sur {date} (il y a {days}). Ses gardiens n'ont pas répondu depuis. Considérez les fonds qui y sont détenus comme étant à risque et ne les rejoignez pas avec de nouveaux fonds.",
+  "mint.warnings.fedimintOffline.body.never": "Aucun chèque de cette fédération ne lui est jamais parvenu, et le dernier en date a échoué. Considérez les fonds qui y sont détenus comme étant à risque et ne les rejoignez pas avec de nouveaux fonds.",
+  "mint.warnings.fedimintOffline.meta.since": "Signalé hors ligne depuis {date}",
+  "mint.warnings.fedimintOffline.meta.never": "Signalé hors ligne, jamais atteint",
+  "mint.warnings.neverConfirmed.lead": "Annoncé, jamais confirmé.",
+  "mint.warnings.neverConfirmed.body.reviewed": "Cette fédération a été annoncée il y a Nostr sur {date}, {days}, et rien n'a confirmé depuis lors qu'elle fonctionne. Les critiques ci-dessous sont le seul signe de vie sur cette page ; tout le reste est venu de l'annonce.",
+  "mint.warnings.neverConfirmed.body.quiet": "Cette fédération a été annoncée il y a Nostr sur {date}, {days}, rien n'a confirmé depuis lors qu'elle fonctionne, et personne ne l'a examinée récemment. Tout ce qui suit provient de l'annonce.",
+  "mint.warnings.neverConfirmed.meta": "Annoncé {date}, jamais confirmé",
+  "footer.allFedimints": "Toutes les fédérations",
+  "reviews.dialog.bodyPlaceholder.cashu": "Comment se sont déroulés les minting, melting et le support ? Soyez précis.",
+  "reviews.dialog.bodyPlaceholder.fedimint": "Comment s'est déroulée l'adhésion, les paiements Lightning et l'assistance ? Soyez précis.",
+  "fedimint.details.title": "Détails de la fédération",
+  "nav.lnurlMints": "Mints LNURL",
+  "footer.allLnurlMints": "Tous les mints LNURL",
+  "lnurlMints.title": "Mints LNURL : mints de billets au porteur lnurlcash, avec avis | Cashumints.space",
+  "lnurlMints.description": "Les {total} mints LNURL indexés depuis le réseau Nostr : {online} en ligne, {offline} hors ligne. Notes de la communauté, limites de retrait et fonctionnalités de chacun.",
+  "lnurlMints.heading": "Mints LNURL",
+  "lnurlMints.lede": "Tous les mints LNURL que ce site connaît. Un mint LNURL émet des billets au porteur lnurlcash : des billets Lightning que vous conservez comme un secret et qui peuvent être tournés, divisés, fusionnés ou refondus en un paiement Lightning. Chacun est vérifié en HTTPS toutes les quelques minutes.",
+  "lnurlMints.search.label": "Rechercher des mints LNURL",
+  "lnurlMints.search.placeholder": "Rechercher par nom ou adresse…",
+  "lnurlMints.sort.label": "Trier les mints LNURL par",
+  "lnurlMints.hideOffline": "Masquer hors ligne",
+  "lnurlMints.showing": "{total} mints LNURL affichés ({online} en ligne, {offline} hors ligne)",
+  "lnurlMints.showingFiltered": "{shown} sur {total} mints LNURL affichés ({online} en ligne, {offline} hors ligne)",
+  "lnurlMints.noResults": "Aucun mint LNURL ne correspond.",
+  "lnurlMints.emptyIndex": "Aucun mint LNURL n'est encore indexé.",
+  "lnurl.crumb": "Mints LNURL",
+  "lnurl.breadcrumb": "Fil d'Ariane",
+  "lnurl.copyAddress": "Copier l'adresse",
+  "lnurl.more.title": "Plus de mints LNURL",
+  "lnurl.more.all": "Tous les mints LNURL →",
+  "lnurl.disclaimer": "Un mint LNURL détient vos sats pendant que vous détenez ses billets : l'utiliser revient donc à faire confiance à son opérateur. Les notes sont des avis de la communauté, et en ligne signifie joignable, pas digne de confiance.",
+  "lnurl.features.title": "Fonctionnalités",
+  "lnurl.features.none": "Ce mint n'a pas annoncé ce qu'il prend en charge.",
+  "lnurl.features.note": "Les fonctionnalités sont ce que l'opérateur du mint a annoncé sur Nostr. Quand ce site peut en vérifier une en HTTPS, il le fait, et il le signale lorsqu'une fonctionnalité annoncée est indisponible en ce moment.",
+  "lnurl.features.notListed": "non annoncé",
+  "lnurl.features.unavailable": "indisponible",
+  "lnurl.feature.mint": "Minting via Lightning (LUD-06)",
+  "lnurl.feature.melt": "Melting vers Lightning",
+  "lnurl.feature.notes": "Tourner / diviser / fusionner des billets",
+  "lnurl.feature.lud16": "Adresse Lightning",
+  "lnurl.feature.lud21": "Vérification de paiement (LUD-21)",
+  "lnurl.feature.signed-notes": "Billets signés (vérification hors ligne)",
+  "lnurl.feature.onion": "Adresse Tor",
+  "lnurl.feature.rotate": "Tourner un billet",
+  "lnurl.feature.split": "Diviser un billet",
+  "lnurl.feature.merge": "Fusionner des billets",
+  "lnurl.feature.lud06": "payRequest LUD-06",
+  "lnurl.feature.lud03": "withdrawRequest LUD-03",
+  "lnurl.limits.label": "Limites de retrait",
+  "lnurl.limits.notPublished": "non publié",
+  "lnurl.limits.withdrawRow": "Retrait",
+  "lnurl.limits.disabled": "désactivé",
+  "lnurl.limits.sats.one": "{n} sat",
+  "lnurl.limits.sats.other": "{n} sats",
+  "lnurl.details.title": "Détails du mint",
+  "lnurl.details.address": "Adresse Lightning",
+  "lnurl.details.mintPubkey": "Clé publique du mint",
+  "lnurl.details.onion": "Adresse Tor",
+  "lnurl.details.fee": "Frais de minting",
+  "lnurl.details.node": "Nœud",
+  "lnurl.details.capacity": "Capacité annoncée",
+  "lnurl.kind.lightningAddress": "adresse Lightning",
+  "lnurl.kind.mintPubkey": "clé publique du mint",
+  "lnurl.kind.onionAddress": "adresse Tor",
+  "lnurl.confirmed.label": "Dernière confirmation",
+  "lnurl.confirmed.when": "confirmé {when}",
+  "lnurl.fee.base.one": "{n} sat",
+  "lnurl.fee.base.other": "{n} sats",
+  "lnurl.fee.percent": "{percent} %",
+  "home.topLnurl.title": "Meilleurs mints LNURL",
+  "home.topLnurl.sub": "classés par avis et note",
+  "home.topLnurl.all": "Les {n} mints LNURL →",
+  "feed.ecosystem.lnurl": "LNURL",
+  "reviews.dialog.bodyPlaceholder.lnurl": "Comment se sont passés le minting, le melting et la rotation des billets ? Soyez précis.",
+  "reviews.byUrl.open": "Écrire un avis",
+  "reviews.byUrl.title": "Écrire un avis",
+  "reviews.byUrl.lede": "Colle l’adresse. Si ce site ne la connaît pas encore, elle est vérifiée et ajoutée maintenant.",
+  "reviews.byUrl.label.cashu": "URL du mint",
+  "reviews.byUrl.label.fedimint": "Code d’invitation de la fédération",
+  "reviews.byUrl.label.lnurl": "URL du mint LNURL",
+  "reviews.byUrl.placeholder.cashu": "mint.example.com",
+  "reviews.byUrl.placeholder.fedimint": "fed11…",
+  "reviews.byUrl.placeholder.lnurl": "mint.example.com",
+  "reviews.byUrl.check": "Vérifier cette adresse",
+  "reviews.byUrl.checking": "Vérification…",
+  "reviews.byUrl.back": "Utiliser une autre adresse",
+  "reviews.byUrl.existing": "Déjà répertorié",
+  "reviews.byUrl.indexed": "Ajouté à l’instant",
+  "reviews.byUrl.confirmClose": "Fermer ? L’adresse saisie n’est pas conservée.",
+  "reviews.byUrl.detected": "Cette adresse a répondu comme un mint {kind}.",
+  "reviews.byUrl.switchTo": "L’évaluer comme mint {kind}",
+  "reviews.byUrl.error.empty": "Saisis d’abord une adresse.",
+  "reviews.byUrl.error.badUrl": "Cela ne ressemble pas à une URL de mint.",
+  "reviews.byUrl.error.badInvite": "Ce n’est pas un code d’invitation Fedimint. Les codes commencent par fed11.",
+  "reviews.byUrl.error.badInput": "Ce site ne peut pas vérifier cette adresse.",
+  "reviews.byUrl.error.blocked": "Ce n’est pas une adresse publique, elle ne peut donc pas être vérifiée.",
+  "reviews.byUrl.error.notAMint": "Cette adresse a répondu, mais pas comme un mint de ce type.",
+  "reviews.byUrl.error.wrongType": "Cette adresse a répondu, mais comme un autre type de mint.",
+  "reviews.byUrl.error.unverifiable": "Rien n’a répondu à cette adresse, et il n’en existe encore aucune trace sur Nostr.",
+  "reviews.byUrl.error.rateLimited.one": "Cela fait beaucoup de vérifications depuis une seule connexion. Réessaie dans environ {n} minute.",
+  "reviews.byUrl.error.rateLimited.other": "Cela fait beaucoup de vérifications depuis une seule connexion. Réessaie dans environ {n} minutes.",
+  "reviews.byUrl.error.network": "L’index est injoignable. Vérifie ta connexion, puis réessaie.",
+  "seo.lnurl.titleNoReviews": "{name} : infos et avis sur le mint LNURL | Cashumints.space",
+  "seo.desc.statusWithdraw": "{status}, retrait {min}–{max} sat.",
+  "mint.chip.noFunding": "Ni minting ni melting",
+  "mint.warnings.lnurlWithdrawalsDisabled.lead": "Retraits désactivés.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.online": "Ce mint annonce un retrait maximum de zéro : aucun billet qu'il émet ne peut donc être échangé contre quoi que ce soit. N'y faites pas de minting tant que cela n'a pas changé.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.offline": "Ce mint annonçait un retrait maximum de zéro lors du dernier contact : aucun billet qu'il émettait ne pouvait donc être échangé contre quoi que ce soit. N'y faites pas de minting tant que cela n'a pas changé.",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.online": "Retraits actuellement désactivés",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.offline": "Les retraits étaient désactivés lors du dernier contact",
+  "mint.warnings.lnurlInvalid.lead": "Le point de terminaison répond mais est invalide.",
+  "mint.warnings.lnurlInvalid.body": "L'hôte répond, mais pas avec une annonce de mint que ce site sait lire : les retraits risquent donc de ne pas fonctionner. Tout ce qui suit correspond au dernier état lisible, et les avis fonctionnent toujours.",
+  "mint.warnings.lnurlInvalid.meta": "Répond, mais pas avec une annonce de mint valide",
+  "mint.warnings.lnurlNoFunding.lead": "Minting et melting indisponibles.",
+  "mint.warnings.lnurlNoFunding.body": "Les billets existants peuvent toujours être tournés, divisés ou fusionnés, mais rien n'entre ni ne sort par Lightning pour le moment. Le mint lui-même est actif et répond ; le nœud Lightning derrière lui n'est pas joignable depuis celui-ci.",
+  "mint.warnings.lnurlNoFunding.meta": "Minting et melting indisponibles",
+  "mint.warnings.also.noFunding": "Son nœud Lightning était également injoignable, il était donc impossible de faire du minting ou du melting."
+}

web/src/i18n/hi.json

@@ -0,0 +1,788 @@
+{
+  "site.name": "Cashumints.space",
+  "common.close": "बंद करें",
+  "common.cancel": "रद्द करें",
+  "common.done": "हो गया",
+  "common.back": "वापस",
+  "common.retry": "दोबारा प्रयास करें",
+  "common.connect": "कनेक्ट",
+  "common.copied": "प्रतिलिपि बनाई गई",
+  "common.copyFull": "पूरा {kind} कॉपी करें",
+  "common.previousPage": "पिछला पृष्ठ",
+  "common.nextPage": "अगला पृष्ठ",
+  "common.reviewPages": "समीक्षा पृष्ठ",
+  "time.never": "कभी नहीं",
+  "time.justNow": "अभी अभी",
+  "time.none": "-",
+  "time.unknownDate": "एक अज्ञात तारीख",
+  "time.ago.minute": "{n} मिनट पहले",
+  "time.ago.hour": "{n} घंटे पहले",
+  "time.ago.day": "{n} दिन पहले",
+  "time.ago.week": "{n} सप्ताह पहले",
+  "time.ago.month": "{n} महीने पहले",
+  "time.ago.year": "{n} वर्ष पहले",
+  "time.short.minute": "{n}मि",
+  "time.short.hour": "{n}घं",
+  "time.short.day": "{n}दि",
+  "time.short.week": "{n}स",
+  "time.short.month": "{n}माह",
+  "time.short.year": "{n}व",
+  "status.online": "ऑनलाइन",
+  "status.offline": "ऑफ़लाइन",
+  "status.degraded": "पहुँच से परे",
+  "status.unknown": "अभी तक जांचा नहीं गया",
+  "nav.skip": "सामग्री पर जाएं",
+  "nav.main": "मुख्य",
+  "nav.mints": "Cashu मिंट्स",
+  "nav.reviews": "समीक्षाएँ",
+  "nav.wallets": "बटुए",
+  "nav.about": "बारे में",
+  "nav.searchMints": "{n} मिंट्स में खोजें",
+  "lang.label": "भाषा",
+  "lang.switcher": "एक भाषा चुनें",
+  "footer.copyright": "© {year} Cashumints.space",
+  "footer.allMints": "सभी Cashu मिंट्स",
+  "footer.allReviews": "सभी समीक्षाएँ",
+  "footer.wallets": "बटुए",
+  "footer.about": "बारे में",
+  "footer.disclaimer": "अस्वीकरण",
+  "footer.terms": "शर्तें",
+  "footer.privacy": "गोपनीयता",
+  "footer.madeBy": "❤️ से निर्मित {azzamo} द्वारा · Cashu और NIP-87 द्वारा संचालित",
+  "footer.warning": "मिंट्स कस्टोडियल हैं। कोई मिंट आपके पैसों के साथ गायब हो सकता है।",
+  "footer.tagline": "ecash मिंट्स के लिए समुदाय की समीक्षाएँ, Nostr पर हस्ताक्षरित।",
+  "footer.col.explore": "एक्सप्लोर",
+  "footer.col.site": "साइट",
+  "footer.nav": "फ़ुटर",
+  "home.title": "Cashumints.space · एक ऐसा Cashu मिंट खोजें जिस पर आप भरोसा कर सकते हैं",
+  "home.description": "एक ऐसा Cashu मिंट खोजें जिस पर आप भरोसा कर सकें। {mints} मिंट्स {reviews} समुदाय समीक्षाओं के साथ अनुक्रमित, Nostr पर हस्ताक्षरित, साथ ही लाइव अपटाइम, समर्थित NUTs और मिंट सॉफ़्टवेयर।",
+  "home.hero.title": "Cashu मिंट खोजें",
+  "home.hero.titleEm": "आप भरोसा कर सकते हैं",
+  "home.hero.lede": "Nostr नेटवर्क पर हर मिंट, असली समुदाय समीक्षाओं के साथ। कोई गेटकीपर नहीं, सिर्फ हस्ताक्षरित समीक्षाएं जिन्हें आप स्वयं सत्यापित कर सकते हैं।",
+  "home.search.label": "नाम, डोमेन, या URL द्वारा मिंट्स खोजें",
+  "home.search.placeholder": "नाम, डोमेन से खोजें, या मिंट URL पेस्ट करें…",
+  "home.filters.mostReviewed": "सबसे अधिक समीक्षित",
+  "home.filters.highestRated": "सबसे अधिक रेटिंग प्राप्त",
+  "home.filters.recentlyActive": "हाल ही में सक्रिय",
+  "home.filters.websockets": "WebSockets का समर्थन करता है",
+  "home.top.title": "शीर्ष Cashu मिंट्स",
+  "home.top.sub": "समीक्षाओं और रेटिंग के अनुसार रैंक किया गया",
+  "home.top.all": "सभी {n} मिंट्स →",
+  "home.latest.title": "नवीनतम समीक्षाएँ",
+  "home.latest.sub": "Nostr नेटवर्क से प्रसारित",
+  "home.latest.prev": "पिछली समीक्षाएँ",
+  "home.latest.next": "और समीक्षाएँ",
+  "home.latest.all": "सभी समीक्षाएँ →",
+  "home.latest.empty": "अभी रिले से कोई समीक्षा नहीं पढ़ी जा सकी।  सीधे समीक्षाएँ पढ़ने और लिखने के लिए कोई भी मिंट पृष्ठ खोलें।",
+  "home.why.title": "इन समीक्षाओं पर भरोसा क्यों करें?",
+  "home.why.signed.title": "हस्ताक्षरित, प्रस्तुत नहीं",
+  "home.why.signed.body": "प्रत्येक समीक्षा एक {link} घटना है, जिसे इसके लेखक की Nostr कुंजी द्वारा हस्ताक्षरित किया गया है। यहाँ कुछ भी हम द्वारा संपादित, रैंक या हटाया नहीं गया है।",
+  "home.why.signed.link": "NIP-87",
+  "home.why.verify.title": "खुद सत्यापित करें",
+  "home.why.verify.body": "समीक्षाएँ हमारे डेटाबेस में नहीं, बल्कि सार्वजनिक Nostr रिले पर लाइव रहती हैं। किसी भी क्लाइंट को उन्हीं रिले पर निर्देशित करें और आप वही डेटा देखेंगे।",
+  "home.why.checked.title": "लगातार जांचा गया",
+  "home.why.checked.body": "हम हर मिंट पर अपटाइम, सॉफ़्टवेयर संस्करण, सीमाएँ और समर्थित NUTs की जाँच करते हैं, ताकि आपको जो विनिर्देश दिखते हैं वे वर्तमान हों, न कि स्वयं-रिपोर्ट किए गए।",
+  "home.cta.title": "क्या आप मिंट के बारे में सोच रहे हैं? पहले इसे पढ़ें।",
+  "home.cta.body": "एक मिंट आपके ecash को धारण करता है। sats डालने से पहले अन्य लोगों ने क्या पाया, पढ़ें, और जब आप स्वयं इसका उपयोग कर लें तो एक समीक्षा छोड़ें।",
+  "home.cta.explore": "सभी मिंट्स का अन्वेषण करें",
+  "home.cta.learn": "Cashu के बारे में जानें",
+  "pulse.mintsIndexed": "मिंट्स अनुक्रमित",
+  "pulse.reviewsOnNostr": "Nostr पर समीक्षाएँ",
+  "pulse.lastReview": "अंतिम समीक्षा",
+  "pulse.mintsOnline": "मिंट्स ऑनलाइन",
+  "pulse.indexer": "सूचीकरणकर्ता",
+  "pulse.connected": "जुड़ा हुआ",
+  "pulse.stale": "बासी",
+  "mints.title": "सभी Cashu मिंट्स · Cashumints.space",
+  "mints.description": "{total} Cashu मिंट्स से अनुक्रमित सभी Nostr नेटवर्क, {online} ऑनलाइन और {offline} ऑफ़लाइन, सामुदायिक रेटिंग, अपटाइम और मिंट सॉफ़्टवेयर के साथ। पूरी सूची खोजें और क्रमबद्ध करें।",
+  "mints.heading": "सभी Cashu मिंट्स",
+  "mints.lede": "Nostr नेटवर्क पर पाए गए प्रत्येक मिंट, उनमें से जो अब नहीं हैं, सहित। ऑफ़लाइन मिंट्स सूचीबद्ध रहते हैं ताकि आप उन्हें अभी भी ढूंढ और समीक्षा कर सकें।",
+  "mints.search.label": "नाम या डोमेन द्वारा मिंट्स खोजें",
+  "mints.search.placeholder": "नाम या डोमेन से खोजें…",
+  "mints.sort.label": "क्रमबद्ध करें मिंट्स",
+  "mints.sort.score": "कुल मिलाकर सर्वश्रेष्ठ",
+  "mints.sort.rating": "सबसे अधिक रेटिंग प्राप्त",
+  "mints.sort.reviews": "सबसे अधिक समीक्षित",
+  "mints.sort.recent": "हाल ही में समीक्षा की गई",
+  "mints.sort.seen": "हाल ही में ऑनलाइन देखा गया",
+  "mints.hideOffline": "ऑफ़लाइन छिपाएँ",
+  "mints.showing": "दिखा रहा है {total} मिंट्स ({online} ऑनलाइन, {offline} ऑफ़लाइन)",
+  "mints.showingFiltered": "{total} में से {shown} दिखा रहा है मिंट्स ({online} ऑनलाइन, {offline} ऑफ़लाइन)",
+  "mints.noResults": "मिंट्स से कोई मेल नहीं मिला। कोई डोमेन आज़माएँ, या मिंट URL पेस्ट करें।",
+  "mints.clearSearch": "खोज साफ़ करें",
+  "card.noRatings": "अभी तक कोई रेटिंग नहीं",
+  "card.reviews.one": "{n} समीक्षा",
+  "card.reviews.other": "{n} समीक्षाएँ",
+  "card.lastSeen": "अंतिम बार देखा गया {when}",
+  "card.neverSeen": "ऑनलाइन कभी नहीं देखा",
+  "card.reviewed": "समीक्षा की गई {when}",
+  "card.noReviews": "अभी तक कोई समीक्षा नहीं",
+  "mint.title": "{name} · Cashu मिंट समीक्षाएँ",
+  "mint.titleFedimint": "{name} · Fedimint फ़ेडरेशन की समीक्षाएँ",
+  "mint.titleLnurl": "{name} · LNURL mint की समीक्षाएँ",
+  "mint.breadcrumb": "ब्रेडक्रम्ब",
+  "mint.crumbMints": "Cashu मिंट्स",
+  "mint.copyUrl": "URL मिंट की प्रतिलिपि बनाएँ",
+  "mint.qrButton": "मिंट क्यूआर",
+  "mint.writeReview": "एक समीक्षा लिखें",
+  "mint.rankByScore": "#{rank} स्कोर द्वारा",
+  "mint.tagLightning": "Lightning",
+  "mint.summary": "मिंट सारांश",
+  "mint.rating.label": "सामुदायिक रेटिंग",
+  "mint.rating.none": "अभी तक कोई रेटिंग नहीं",
+  "mint.rating.reviews.one": "{n} समीक्षा",
+  "mint.rating.reviews.other": "{n} समीक्षाएँ",
+  "mint.rating.unrated.one": "{n} ने कोई रेटिंग नहीं दी",
+  "mint.rating.unrated.other": "{n} ने कोई रेटिंग नहीं दी",
+  "mint.activity.label": "गतिविधि",
+  "mint.activity.since": "पिछली समीक्षा के बाद से",
+  "mint.activity.noReviews": "अभी तक कोई समीक्षा नहीं",
+  "mint.activity.recent.one": "पिछले 90 दिनों में {n} समीक्षा",
+  "mint.activity.recent.other": "पिछले 90 दिनों में {n} समीक्षाएँ",
+  "mint.limits.label": "सीमाएँ",
+  "mint.limits.notPublished": "प्रकाशित नहीं",
+  "mint.limits.min": "मिन",
+  "mint.limits.max": "अधिकतम",
+  "mint.limits.mintRow": "मिंट",
+  "mint.limits.meltRow": "पिघलना",
+  "mint.limits.disabled": "अक्षम",
+  "mint.limits.range": "{min} से {max} {unit}",
+  "mint.limits.upTo": "{max} {unit} तक",
+  "mint.limits.from": "{min} से {unit} तक",
+  "mint.software.label": "मिंट सॉफ़्टवेयर",
+  "mint.software.unknown": "अज्ञात",
+  "mint.checked": "जाँचा गया {when}",
+  "mint.lastSeen": "अंतिम बार देखा गया {when}",
+  "mint.neverReached": "कभी नहीं पहुँचा",
+  "mint.uptime.checks": "पिछले {total} चेकों में से {ok} पहुँच योग्य हैं।",
+  "mint.uptime.percent": "{percent}% 30 दिनों में संपर्क किया जा सकता है",
+  "mint.uptime.description": "पिछले {total} जांचों में से {ok} सफल रहीं।",
+  "mint.operator.title": "ऑपरेटर की ओर से",
+  "mint.operator.motd": "दिन का संदेश",
+  "mint.operator.beta": "यह मिंट स्वयं को प्रयोगात्मक या बीटा अवस्था में बताता है। कुछ भी ऐसा संग्रहीत करने से पहले जो आप खो नहीं सकते, नीचे ऑपरेटर के अपने शब्द पढ़ें।",
+  "mint.nuts.title": "समर्थित NUTs",
+  "mint.nuts.noneOffline": "इस मिंट के लिए कोई NUT सूची कैश नहीं की गई, क्योंकि एक रिकॉर्ड होने से पहले यह ऑफ़लाइन हो गया।",
+  "mint.nuts.noneYet": "इस मिंट के लिए NUT सूची अभी तक कैश नहीं की गई है।",
+  "mint.nuts.supported": "ज्ञात {total} में से {n} समर्थित NUTs",
+  "mint.nuts.whatAre": "NUTs क्या हैं?",
+  "mint.nutRow.disabled": "अक्षम",
+  "mint.nutRow.notSupported": "समर्थित नहीं",
+  "mint.details.title": "मिंट विवरण",
+  "mint.details.pubkey": "Pubkey",
+  "mint.details.nostr": "Nostr",
+  "mint.details.email": "ईमेल",
+  "mint.details.serverTime": "सर्वर समय",
+  "mint.details.firstSeen": "पहली बार देखा गया",
+  "mint.details.terms": "शर्तें",
+  "mint.kind.identifier": "पहचानकर्ता",
+  "mint.kind.mintPubkey": "मिंट pubkey",
+  "mint.kind.nostrAddress": "Nostr पता",
+  "mint.kind.emailAddress": "ईमेल पता",
+  "mint.kind.npub": "npub",
+  "mint.disclaimer": "यह मिंट संरक्षक है: यह आपके पैसे रखता है, और यह कभी भी ऐसा करना बंद कर सकता है। रेटिंग्स समुदाय की राय होती हैं और ऑनलाइन होने का मतलब है कि वे पहुँच योग्य हैं, भरोसेमंद नहीं।",
+  "mint.disclaimerLink": "पूरा अस्वीकरण पढ़ें",
+  "mint.qr.title": "{name} को अपने वॉलेट में जोड़ें",
+  "mint.qr.note": "Cashu वॉलेट से इसे स्कैन करें ताकि मिंट जुड़ सके, या URL कॉपी करके पेस्ट करें।",
+  "mint.qr.warn": "मिंट जोड़ने का मतलब है कि आप अपनी धनराशि उस पर भरोसा कर रहे हैं।",
+  "mint.qr.whatMeans": "इसका क्या मतलब है",
+  "mint.qr.wallets": "वॉलेट जो Cashu को सपोर्ट करते हैं",
+  "mint.chip.frozen": "जमा हुआ",
+  "mint.chip.noWithdrawals": "कोई निकासी नहीं",
+  "mint.chip.meltOnly": "केवल पिघलाएँ",
+  "mint.warnings.dayCount.one": "{n} दिन",
+  "mint.warnings.dayCount.other": "{n} दिन",
+  "mint.warnings.gone.lead": "शायद चला गया।",
+  "mint.warnings.gone.body.since": "यह मिंट {date} ({days}) से अविश्वसनीय हो गया है। वहाँ रखे गए फंड को जोखिम में मानें और नए फंड न भेजें। नीचे दिए गए विवरण इसकी अंतिम ज्ञात स्थिति दिखाते हैं।",
+  "mint.warnings.gone.body.neverDated": "इस मिंट ने {month} में इसे देखना शुरू करने के बाद से एक भी जांच का जवाब नहीं दिया है। वहाँ रखे गए फंड को जोखिम में समझें, और नए फंड न भेजें। नीचे दिया गया कुछ भी Nostr की घोषणा से आया है, मिंट से नहीं।",
+  "mint.warnings.gone.body.never": "जब से हमने इसकी निगरानी शुरू की है, इस मिंट ने एक भी जांच का जवाब नहीं दिया है। वहाँ रखे गए फंड को जोखिम में समझें, और नए फंड न भेजें। नीचे दी गई कोई भी जानकारी Nostr की घोषणा से ली गई है, मिंट से नहीं।",
+  "mint.warnings.gone.meta.since": "{date} से ऑफ़लाइन",
+  "mint.warnings.gone.meta.never": "खोजे जाने के बाद से कभी भी पहुँच में नहीं आया",
+  "mint.warnings.meltDisabled.lead": "निकासी अक्षम हैं।",
+  "mint.warnings.meltDisabled.body.online": "इस मिंट में Lightning मेल्टिंग (NUT-05) बंद हैं: आप sats जमा कर सकते हैं, लेकिन आप उन्हें Lightning के माध्यम से नहीं निकाल सकते। जब तक मेल्टिंग वापस नहीं आ जाता, जमा न करें।",
+  "mint.warnings.meltDisabled.body.offline": "इस मिंट में Lightning मेल्टिंग (NUT-05) बंद थे: आप sats डाल सकते हैं, लेकिन आप उन्हें Lightning के माध्यम से नहीं निकाल सकते। जब तक मेल्टिंग वापस नहीं आ जाता, जमा न करें।",
+  "mint.warnings.meltDisabled.meta.online": "निकासी वर्तमान में अक्षम हैं।",
+  "mint.warnings.meltDisabled.meta.offline": "जब आखिरी बार देखा गया था, तब निकासी अक्षम थीं।",
+  "mint.warnings.frozen.lead": "मिंट जमे हुए।",
+  "mint.warnings.frozen.body.online": "मिंटिंग और मेल्टिंग दोनों अक्षम हैं। कोई भी sats Lightning के माध्यम से अंदर या बाहर नहीं जा सकता।",
+  "mint.warnings.frozen.body.offline": "मिंटिंग और मेल्टिंग दोनों अक्षम थे। कोई भी sats Lightning के माध्यम से अंदर या बाहर नहीं जा सकता।",
+  "mint.warnings.frozen.meta.online": "वर्तमान में स्थिर, न कुछ अंदर आता है न कुछ बाहर जाता है।",
+  "mint.warnings.frozen.meta.offline": "अंतिम बार देखा गया तो जमी हुई थी",
+  "mint.warnings.offlineLong.lead": "{days} के लिए ऑफ़लाइन, {date} से।",
+  "mint.warnings.offlineLong.body": "मिंट शायद अब उपलब्ध नहीं है। नीचे दी गई सभी जानकारी इसकी अंतिम ज्ञात स्थिति है, और समीक्षाएं अभी भी काम करती हैं।",
+  "mint.warnings.offlineLong.meta": "{date} से ऑफ़लाइन",
+  "mint.warnings.meltOnly.lead": "केवल पिघलाएँ।",
+  "mint.warnings.meltOnly.body.online": "नया मिंटिंग (NUT-04) अक्षम है: आप जमा नहीं कर सकते, लेकिन मौजूदा ecash अभी भी निकाला जा सकता है। इसका अक्सर मतलब होता है कि मिंट समाप्त होने वाला है, इसलिए यदि आपके पास इसका ecash है, तो मेल्टिंग को बाहर निकालने पर विचार करें।",
+  "mint.warnings.meltOnly.body.offline": "नया मिंटिंग (NUT-04) अक्षम कर दिया गया था: आप जमा नहीं कर सकते, लेकिन मौजूदा ecash अभी भी निकाला जा सकता है। इसका अक्सर मतलब होता है कि मिंट समाप्त होने वाला है, इसलिए यदि आपके पास इसका ecash है, तो मेल्टिंग को बाहर निकालने पर विचार करें।",
+  "mint.warnings.meltOnly.meta.online": "वर्तमान में केवल पिघलाएँ",
+  "mint.warnings.meltOnly.meta.offline": "केवल आखिरी बार दिखने पर पिघलें",
+  "mint.warnings.offline.lead": "{date} से ऑफ़लाइन।",
+  "mint.warnings.offline.body": "विवरण आखिरी बार तब ही पुष्टि किए गए थे। आप अभी भी समीक्षा लिख सकते हैं।",
+  "mint.warnings.offline.meta": "{date} से ऑफ़लाइन",
+  "mint.warnings.also.meltDisabled": "ऑफ़लाइन होने से पहले इसने निकासी को भी अक्षम कर दिया था।",
+  "mint.warnings.also.mintDisabled": "ऑफ़लाइन होने से पहले इसने नए मिंटिंग को भी अक्षम कर दिया था।",
+  "mint.warnings.also.offline": "यह {date} ({days}) से भी ऑफ़लाइन है।",
+  "nut.0": "संकेतन और मॉडल",
+  "nut.1": "मिंट सार्वजनिक कुंजी विनिमय",
+  "nut.2": "कीसेट्स और शुल्क",
+  "nut.3": "टोकन की अदला-बदली",
+  "nut.4": "मिंटिंग के माध्यम से Lightning",
+  "nut.5": "मेल्टिंग के माध्यम से Lightning",
+  "nut.6": "मिंट जानकारी",
+  "nut.7": "टोकन स्थिति जाँच",
+  "nut.8": "अधिक भुगतान किया गया Lightning शुल्क",
+  "nut.9": "हस्ताक्षर पुनर्स्थापित करें",
+  "nut.10": "व्यय की शर्तें",
+  "nut.11": "सार्वजनिक कुंजी को भुगतान करें",
+  "nut.12": "DLEQ प्रमाण",
+  "nut.13": "निर्धारित रहस्य",
+  "nut.14": "हैश किए गए टाइमलॉक अनुबंध",
+  "nut.15": "मल्टीपथ भुगतान",
+  "nut.16": "एनिमेटेड क्यूआर कोड",
+  "nut.17": "WebSocket सदस्यताएँ",
+  "nut.18": "भुगतान अनुरोध",
+  "nut.19": "कैश किए गए उत्तर",
+  "nut.20": "हस्ताक्षरित मिंट उद्धरण",
+  "nut.21": "स्पष्ट प्रमाणीकरण",
+  "nut.22": "अंध प्रमाणीकरण",
+  "nut.23": "BOLT11 भुगतान विधि",
+  "nut.24": "HTTP 402 भुगतान आवश्यक है",
+  "nut.25": "BOLT12 भुगतान विधि",
+  "reviews.title": "समीक्षाएँ",
+  "reviews.anon": "अज्ञात",
+  "reviews.anonTitle": "इस कुंजी के लिए कोई सार्वजनिक Nostr प्रोफ़ाइल नहीं मिली।",
+  "reviews.nip05Title": "NIP-05 पहचानकर्ता (इस साइट द्वारा सत्यापित नहीं)",
+  "reviews.filter.group": "समीक्षाएँ फ़िल्टर करें",
+  "reviews.filter.all": "सभी",
+  "reviews.filter.five": "5★",
+  "reviews.filter.critical": "आलोचनात्मक",
+  "reviews.filter.recent": "हाल का",
+  "reviews.filter.hideAnon": "अनाम छिपाएँ",
+  "reviews.anonHidden.other": "{total} समीक्षाओं में से {n} दिखा रहा है: गुमनाम छिपा हुआ।",
+  "reviews.allAnon.one": "यहाँ एकमात्र समीक्षा गुमनाम है।",
+  "reviews.allAnon.other": "यहाँ सभी {n} समीक्षाएँ गुमनाम हैं।",
+  "reviews.allAnonShow.one": "इसे दिखाओ",
+  "reviews.allAnonShow.other": "उन्हें दिखाओ",
+  "reviews.loading.one": "{n} की समीक्षा Nostr रिले से लोड हो रही है",
+  "reviews.loading.other": "Nostr रिले से {n} समीक्षाएँ लोड हो रही हैं",
+  "reviews.empty": "अभी तक कोई समीक्षा नहीं है। पहली समीक्षा लिखें।",
+  "reviews.emptyWritten": "यहाँ अभी तक कोई लिखित समीक्षा नहीं है। पहली समीक्षा लिखें।",
+  "reviews.emptyFilter": "इस फ़िल्टर से कोई समीक्षा मेल नहीं खाती।",
+  "reviews.rate.cashu": "इस मिंट को रेटिंग दें",
+  "reviews.rate.fedimint": "इस फ़ेडरेशन को रेटिंग दें",
+  "reviews.rate.lnurl": "इस मिंट को रेटिंग दें",
+  "reviews.noscript": "समीक्षाएँ Nostr पर साइन की जाती हैं और आपके ब्राउज़र में लोड होती हैं, इसलिए इस सूची के लिए JavaScript की आवश्यकता है। ऊपर दी गई रेटिंग और संख्याएँ स्वयं साइट से ली गई हैं।",
+  "reviews.relayError": "रिले तक नहीं पहुँच सका। समीक्षाएँ अधूरी हो सकती हैं।",
+  "reviews.srRating": "5 में से {rating}",
+  "reviews.srNoRating": "कोई रेटिंग नहीं दी गई",
+  "reviews.readMore": "और पढ़ें",
+  "reviews.readLess": "कम दिखाएँ",
+  "reviews.actions.copyNpub": "प्रति npub",
+  "reviews.actions.openNostr": "इस इवेंट को Nostr पर देखें",
+  "reviews.actions.copyLink": "इस समीक्षा का लिंक कॉपी करें",
+  "reviews.anonNote": "इस npub से पहली समीक्षा, कोई अन्य गतिविधि नहीं मिली।",
+  "reviews.published": "प्रकाशित",
+  "reviews.publishedPartial": "{total} रिलेज़ में से {accepted} पर प्रकाशित।",
+  "reviews.propagating": "Nostr रिले पर प्रकाशित किया जा रहा है",
+  "reviews.summary.line.one": "बिना टिप्पणी के {count} रेटिंग: {breakdown}",
+  "reviews.summary.line.other": "टिप्पणी के बिना रेटिंग: {count}; रेटिंग: {breakdown}",
+  "reviews.summary.lineDay.one": "{count} रेटिंग, {when} पर बिना टिप्पणी के: {breakdown}",
+  "reviews.summary.lineDay.other": "{count} रेटिंग्स बिना किसी टिप्पणी के {when} पर: {breakdown}",
+  "reviews.summary.showOne": "इसे दिखाओ",
+  "reviews.summary.showMany": "उन्हें दिखाओ",
+  "reviews.breakdown.5": "{n} पाँच सितारा",
+  "reviews.breakdown.4": "{n} चार सितारा",
+  "reviews.breakdown.3": "{n} तीन सितारा",
+  "reviews.breakdown.2": "{n} दो सितारा",
+  "reviews.breakdown.1": "{n} एक सितारा",
+  "reviews.breakdown.none": "{n} बिना रेटिंग के",
+  "reviews.dialog.title": "समीक्षा {name}",
+  "reviews.dialog.lede.cashu": "इस मिंट के बारे में अपना अनुभव साझा करें।",
+  "reviews.dialog.lede.fedimint": "इस फ़ेडरेशन के बारे में अपना अनुभव साझा करें।",
+  "reviews.dialog.lede.lnurl": "इस मिंट के बारे में अपना अनुभव साझा करें।",
+  "reviews.dialog.permanent": "सार्वजनिक Nostr रिले पर स्थायी रूप से प्रकाशित।",
+  "reviews.dialog.gate.title": "समीक्षा लिखने के लिए लॉग इन करें",
+  "reviews.dialog.gate.lead": "समीक्षाएँ आपकी Nostr कुंजी से हस्ताक्षरित होती हैं। कुंजी आपके हस्ताक्षरकर्ता में रहती है, यह साइट इसे कभी नहीं देखती।",
+  "reviews.dialog.ratingLegend": "आपकी रेटिंग",
+  "reviews.dialog.starsSr.one": "{n} सितारा",
+  "reviews.dialog.starsSr.other": "{n} सितारे",
+  "reviews.dialog.chooseRating": "एक रेटिंग चुनें",
+  "reviews.dialog.starLabel": "{n}: {phrase}",
+  "reviews.dialog.stars.1": "इससे बचें",
+  "reviews.dialog.stars.2": "समस्याएँ थीं",
+  "reviews.dialog.stars.3": "काम किया, कुछ शर्तों के साथ",
+  "reviews.dialog.stars.4": "अच्छा",
+  "reviews.dialog.stars.5": "बहुत बढ़िया काम करता है",
+  "reviews.dialog.bodyLabel": "दूसरों को और क्या जानना चाहिए?",
+  "reviews.dialog.charCount": "{n} / {max}",
+  "reviews.dialog.submit": "हस्ताक्षर करें और प्रकाशित करें",
+  "reviews.dialog.signing": "हस्ताक्षर…",
+  "reviews.dialog.publishing": "प्रकाशित हो रहा है…",
+  "reviews.dialog.publishingTo": "रिलेज़ पर प्रकाशित करना ({accepted}/{total})",
+  "reviews.dialog.waitingExtension": "आपके एक्सटेंशन का इंतज़ार",
+  "reviews.dialog.waitingSigner": "आपके हस्ताक्षरकर्ता की प्रतीक्षा",
+  "reviews.dialog.confirmClose": "इस समीक्षा को बंद करें? आपका मसौदा तब तक रखा जाता है जब तक आप साइट छोड़ते नहीं हैं।",
+  "reviews.dialog.why.login": "प्रकाशित करने के लिए लॉग इन करें",
+  "reviews.dialog.why.words": "कुछ शब्द लिखें",
+  "reviews.dialog.why.more.one": "{n} और वर्ण",
+  "reviews.dialog.why.more.other": "{n} और अक्षर",
+  "reviews.dialog.why.over.one": "सीमा से {n} अक्षर अधिक",
+  "reviews.dialog.why.over.other": "सीमा से {n} वर्ण अधिक",
+  "reviews.dialog.identity.needSigner": "प्रकाशित करने के लिए आपको Nostr हस्ताक्षरकर्ता की आवश्यकता है। आपकी कुंजी इसमें रहती है, यह साइट इसे कभी नहीं देखती।",
+  "reviews.dialog.identity.loginToPublish": "प्रकाशित करने के लिए लॉग इन करें",
+  "reviews.dialog.identity.switch": "स्विच",
+  "reviews.dialog.identity.extension": "अपने ब्राउज़र एक्सटेंशन के साथ साइन करना",
+  "reviews.dialog.identity.readingKey": "आपकी सार्वजनिक कुंजी पढ़ी जा रही है…",
+  "reviews.dialog.identity.willAsk": "आपके एक्सटेंशन से हस्ताक्षर करने के लिए कहा जाएगा।",
+  "reviews.dialog.error.noRelay": "कोई रिले समीक्षा स्वीकार नहीं कर रहा है। अपना कनेक्शन जांचें, फिर से प्रयास करें।",
+  "reviews.validate.rating": "1 से 5 सितारों में से एक रेटिंग चुनें।",
+  "reviews.validate.short": "समीक्षा उपयोगी हो, इसके लिए कम से कम {n} अक्षर लिखें।",
+  "reviews.validate.long": "समीक्षाएँ {n} वर्णों तक सीमित हैं।",
+  "feed.title": "नवीनतम मिंट और फेडरेशन समीक्षाएँ · Cashumints.space",
+  "feed.description": "हर मिंट, फ़ेडरेशन और LNURL मिंट समीक्षा प्रकाशित होते ही: {mints} Cashu मिंट, {federations} Fedimint फ़ेडरेशन और {lnurl} LNURL मिंट पर {reviews} समीक्षाएँ, Nostr पर हस्ताक्षरित और यहाँ नवीनतम पहले पढ़ने योग्य. पारिस्थितिकी, रेटिंग या नाम से छाँटें.",
+  "feed.heading": "नवीनतम समीक्षाएँ",
+  "feed.lede": "हर Cashu, मिंट और Fedimint संघ की हर समीक्षा, नवीनतम से शुरू होकर, Nostr रिले से सीधे पढ़ी जाती है। प्रत्येक समीक्षा अपने लेखक द्वारा हस्ताक्षरित होती है और हमारे डेटाबेस में नहीं, बल्कि रिले पर रहती है।",
+  "feed.label": "समीक्षाएँ",
+  "feed.showingBuild.one": "पिछली बिल्ड की सबसे हालिया समीक्षा दिखा रहा है",
+  "feed.showingBuild.other": "पिछली बिल्ड से {n} सबसे हालिया समीक्षाएँ दिखा रहा है",
+  "feed.noscript": "समीक्षाएँ Nostr पर साइन की जाती हैं और आपके ब्राउज़र में लोड होती हैं, इसलिए फ़िल्टरिंग और पूरी सूची के लिए JavaScript की आवश्यकता है। नीचे दी गई {n} समीक्षाएँ इस पेज के बनने के समय रिले से पढ़ी गई थीं।",
+  "feed.emptyBuild": "जब यह पेज बनाया गया था, तब रिले से कोई समीक्षा नहीं पढ़ी जा सकी।  यह सूची आपके ब्राउज़र में रिले से फिर से लोड होती है।",
+  "feed.foot": "समीक्षाएँ समुदाय की राय हैं, सत्यापित दावे नहीं।  पैसे के लिए मिंट पर भरोसा करने से पहले {link} पढ़ें।",
+  "feed.footLink": "अस्वीकरण",
+  "feed.showing": "{total} समीक्षाओं में से {shown} दिखाया जा रहा है",
+  "feed.showingMatching": "{matching} मिलान करने वाली समीक्षाओं में से {shown} दिखाया जा रहा है (कुल {total})",
+  "feed.emptyRelays": "रिले से कोई समीक्षा वापस नहीं आई। समीक्षाएँ पढ़ने और लिखने के लिए कोई भी मिंट पृष्ठ खोलें।",
+  "feed.emptyFilter": "इस फ़िल्टर से कोई समीक्षा मेल नहीं खाती। मिंट बॉक्स को साफ़ करें, या 'सभी' चुनें।",
+  "feed.relayError": "रिले तक नहीं पहुँच सका। पिछली बिल्ड की समीक्षाएँ दिखा रहा है।",
+  "feed.relayEmpty": "रिले से कोई समीक्षा वापस नहीं आई। पिछली बिल्ड की समीक्षाएँ दिखा रहा है।",
+  "feed.reading": "रिले पढ़ना…",
+  "login.open": "लॉग इन",
+  "login.title": "Nostr के साथ लॉग इन करें",
+  "login.note": "आपकी कुंजी आपके साइनर में रहती है। यह साइट इसे कभी नहीं देख सकती।",
+  "login.extension.name": "ब्राउज़र एक्सटेंशन",
+  "login.extension.desc": "Alby, nos2x या किसी अन्य NIP-07 एक्सटेंशन के साथ साइन करें",
+  "login.extension.none": "कोई एक्सटेंशन नहीं मिला",
+  "login.extension.getOne": "एक प्राप्त करें:",
+  "login.remote.name": "दूरस्थ हस्ताक्षरकर्ता",
+  "login.remote.desc": "साइनर ऐप से एक कोड स्कैन करें, या बंकर लिंक पेस्ट करें।",
+  "login.primal.name": "Primal",
+  "login.primal.desc": "अपने फोन पर Primal ऐप में लॉगिन को अनुमोदित करें।",
+  "login.paste.label": "या अपने हस्ताक्षरकर्ता द्वारा दिया गया कनेक्शन लिंक पेस्ट करें।",
+  "login.copyLink": "कनेक्शन लिंक की प्रतिलिपि करें",
+  "login.whatIsNostr": "Nostr क्या है?",
+  "login.connect.remote.title": "एक दूरस्थ हस्ताक्षरकर्ता को कनेक्ट करें",
+  "login.connect.remote.lead": "इसे अपने साइनर ऐप से स्कैन करें, या लिंक कॉपी करके वहाँ पेस्ट करें।",
+  "login.connect.remote.hint": "किसी भी NIP-46 हस्ताक्षरकर्ता के साथ काम करता है: nsec.app, Amber, Nostrify, आपका अपना बंकर।",
+  "login.connect.remote.open": "अपने साइनर ऐप में खोलें",
+  "login.connect.primal.title": "Primal से जुड़ें",
+  "login.connect.primal.lead": "अपने फोन पर Primal खोलें, इसकी सेटिंग्स में रिमोट साइनिंग खोजें, और इस कोड को स्कैन करें।",
+  "login.connect.primal.hint": "Primal अन्य ऐप्स के लिए NIP-46 पर हस्ताक्षर करता है, इसलिए यह वही कनेक्शन है जिसका कोई भी हस्ताक्षरकर्ता उपयोग करता है, और आपकी कुंजी Primal में रहती है। {link}",
+  "login.connect.primal.open": "Primal में खोलें",
+  "login.status.buildingLink": "एक कनेक्शन लिंक बनाना",
+  "login.status.waitingExtension": "आपके एक्सटेंशन का इंतज़ार",
+  "login.status.waitingSigner": "आपके हस्ताक्षरकर्ता की प्रतीक्षा",
+  "login.status.connecting": "आपके हस्ताक्षरकर्ता से कनेक्ट हो रहा है",
+  "login.status.connected": "जुड़ा हुआ",
+  "login.toast.loggedIn": "लॉग इन हो गए",
+  "login.toast.fetchingProfile": "आपकी Nostr प्रोफ़ाइल रिले से लाई जा रही है…",
+  "login.toast.profile": "प्रोफ़ाइल: {name}",
+  "login.toast.noProfile": "रिले पर कोई प्रोफ़ाइल नहीं मिली",
+  "login.method.extension": "विस्तार",
+  "login.method.remote": "दूरस्थ",
+  "login.method.primal": "Primal",
+  "login.account": "आपका Nostr खाता",
+  "login.copyNpub": "अपना पूरा npub कॉपी करें",
+  "login.logout": "लॉग आउट करें",
+  "signer.status.waitingExtension": "आपके एक्सटेंशन का इंतज़ार",
+  "signer.status.signed": "हस्ताक्षरित",
+  "signer.status.reconnecting": "अपने हस्ताक्षरकर्ता से फिर से जुड़ना",
+  "signer.status.approveWindow": "आपके हस्ताक्षरकर्ता को इसे अपनी अलग विंडो में स्वीकृत करने की आवश्यकता है।",
+  "signer.status.waitingSigner": "आपके हस्ताक्षरकर्ता की प्रतीक्षा",
+  "signer.status.stillWaiting": "अभी भी आपके हस्ताक्षरकर्ता के जवाब का इंतजार कर रहा हूँ।",
+  "signer.status.connected": "जुड़ा हुआ",
+  "signer.error.noExtension": "हस्ताक्षर विस्तार नहीं मिला। Alby या nos2x इंस्टॉल करें, फिर इस पृष्ठ को पुनः लोड करें।",
+  "signer.error.privateKey": "यह एक निजी कुंजी की तरह दिखता है, कनेक्शन लिंक नहीं। यह साइट कभी भी कुंजी नहीं लेती। अपने साइनर द्वारा दिए गए bunker:// लिंक को पेस्ट करें।",
+  "signer.error.badLink": "यह उस कनेक्शन लिंक को नहीं है जिसे यह साइट समझती है। अपने साइनर से bunker:// लिंक पेस्ट करें।",
+  "signer.error.noAnswer": "आपके साइनर ने उत्तर नहीं दिया। यह बंद हो सकता है, या इसका रिले काम नहीं कर रहा है। इसे खोलें और फिर से प्रयास करें।",
+  "signer.error.timeout": "आपके हस्ताक्षरकर्ता ने समय पर उत्तर नहीं दिया। इसे खोलें, जांचें कि यह अभी भी जुड़ा हुआ है, फिर से प्रयास करें।",
+  "signer.error.cancelled": "कनेक्शन रद्द हो गया।",
+  "signer.error.declined": "हस्ताक्षर अनुरोध अस्वीकार कर दिया गया",
+  "notfound.title": "पृष्ठ नहीं मिला · Cashumints.space",
+  "notfound.description": "उस पृष्ठ का Cashumints.space पर अस्तित्व नहीं है।",
+  "notfound.heading": "यह पृष्ठ मौजूद नहीं है",
+  "notfound.lede": "यह स्थानांतरित हो चुका हो सकता है, या मिंट अभी तक अनुक्रमित नहीं हुआ है। नाम या डोमेन के अनुसार मिंट खोजें, या मिंट URL पेस्ट करें।",
+  "notfound.browse": "सभी मिंट्स ब्राउज़ करें",
+  "notfound.home": "घर जाओ",
+  "notfound.loading": "लोड हो रहा है {host}",
+  "notfound.fb.rating": "रेटिंग",
+  "notfound.fb.reviews": "समीक्षाएँ",
+  "notfound.fb.software": "सॉफ़्टवेयर",
+  "notfound.fb.lastOnline": "अंतिम ऑनलाइन",
+  "notfound.fb.note": "यह mint साइट के पिछले बिल्ड के बाद इंडेक्स हुआ था, इसलिए यह लाइव API से बना सारांश है और नीचे इसकी समीक्षाएँ हैं। पूरा पेज अगले बिल्ड पर दिखेगा।",
+  "notfound.resolve.checking": "पहली बार: इस mint की जाँच अभी हो रही है।",
+  "notfound.resolve.failed": "यह mint जोड़ा नहीं जा सका",
+  "notfound.resolve.failedFedimint": "यह फ़ेडरेशन जोड़ा नहीं जा सका",
+  "notfound.resolve.retry": "दूसरा पता आज़माएँ",
+  "notfound.resolve.switch": "इसे {kind} mint के रूप में खोलें",
+  "notfound.resolve.fedimint": "फ़ेडरेशन के पेज के पते में उसका invite code नहीं होता, इसलिए सिर्फ़ लिंक से इसे खोजा नहीं जा सकता। invite code चिपकाएँ, यह जुड़ जाएगा।",
+  "notfound.resolve.ambiguous": "सिर्फ़ लिंक से यह पता निकाला नहीं जा सकता। mint का पूरा URL चिपकाएँ, यह जुड़ जाएगा।",
+  "wallets.title": "Cashu वॉलेट्स · Cashumints.space",
+  "wallets.description": "Cashu वॉलेट जो यहाँ सूचीबद्ध मिंट्स के साथ मोबाइल, वेब, ब्राउज़र और कमांड लाइन पर काम करते हैं, और प्रत्येक किस काम में अच्छा है।",
+  "wallets.heading": "बटुए",
+  "wallets.lede": "आपको इनमें से किसी भी मिंट्स से ecash रखने के लिए एक वॉलेट की आवश्यकता है। अधिकांश वॉलेट एक साथ कई मिंट्स से संवाद करते हैं, इसलिए आप पहले वाले से बंधे नहीं रहते जो आप आज़माते हैं।",
+  "wallets.note": "यह सूची संपूर्ण नहीं है और यह कोई अनुशंसा नहीं है। Cashu परियोजना {link} पर एक व्यापक अनुक्रमणिका रखती है। एक वॉलेट चाबियाँ रखता है, एक मिंट पैसे रखता है: यह तय करने से पहले मिंट समीक्षाएँ पढ़ें कि आपका sats कहाँ रहता है।",
+  "wallets.platform.android": "Android",
+  "wallets.platform.ios": "iOS",
+  "wallets.platform.web": "वेब",
+  "wallets.platform.extension": "ब्राउज़र एक्सटेंशन",
+  "wallets.platform.cli": "CLI",
+  "wallets.platform.python": "Python",
+  "wallets.item.minibits": "मोबाइल ecash वॉलेट अपने स्वयं के मिंट, Lightning पते और Nostr संपर्कों के साथ।",
+  "wallets.item.nutstash": "ब्राउज़र वॉलेट जो एक साथ कई मिंट्स को संभालता है और कच्चे टोकन आयात और निर्यात करता है।",
+  "wallets.item.enuts": "मल्टीमिंट बैलेंस पर केंद्रित मोबाइल वॉलेट और ecash से Nostr पर ecash भेजने पर ध्यान केंद्रित।",
+  "wallets.item.cashume": "Cashu परियोजना का वेब वॉलेट। पूरी तरह से ब्राउज़र में चलता है, PWA के रूप में इंस्टॉल किया जा सकता है।",
+  "wallets.item.boardwalk": "Lightning पतों के आसपास निर्मित वेब वॉलेट और लिंक के माध्यम से ecash भेजना।",
+  "wallets.item.coinos": "Lightning वॉलेट और पॉइंट ऑफ़ सेल जो अपने स्वयं के Cashu मिंट को भी चलाता है।",
+  "wallets.item.oxchat": "Nostr मैसेंजर जिसमें ecash वॉलेट अंतर्निर्मित है, चैट के अंदर sats भेजने के लिए।",
+  "wallets.item.nutshell": "संदर्भ कार्यान्वयन। कमांड लाइन पर एक वॉलेट के रूप में और मिंट सॉफ़्टवेयर के रूप में चलता है।",
+  "about.title": "लगभग Cashumints.space के बारे में",
+  "about.description": "Cashu क्या है, मिंट वास्तव में क्या धारण करता है, NIP-87 क्या है, और यह साइट मिंट्स को कैसे इंडेक्स करती है और Nostr रिले से समीक्षाएँ कैसे पढ़ती है।",
+  "about.heading": "बारे में",
+  "about.lede": "Cashumints.space नेटवर्क पर हमें जो भी Cashu मिंट मिलते हैं, उनकी सूची Nostr में दी गई है और यह दिखाता है कि लोग उनके बारे में क्या कहते हैं। इसे Azzamo ने बनाया है।",
+  "about.cashu.title": "Cashu क्या है",
+  "about.cashu.p1": "Cashu ecash का Bitcoin के लिए एक प्रोटोकॉल है। एक मिंट उन sats द्वारा समर्थित ब्लाइंडेड टोकन जारी करता है जिन्हें वह धारण करता है, और ये टोकन लोगों के बीच इस तरह चलते हैं कि मिंट यह नहीं जान पाता कि किसने क्या किसे भेजा। गोपनीयता वास्तविक है और यही मुख्य बिंदु है: टोकन खाते नहीं हैं, और मिंट उस टोकन को, जिसे उसने हस्ताक्षरित किया है, वापस आने वाले टोकन से जोड़ नहीं सकता।",
+  "about.cashu.p2": "आप प्रोटोकॉल और इसकी विशिष्टताओं को {link} पर पढ़ सकते हैं। विशिष्टताओं को स्वयं NUTs कहा जाता है, और यही वह स्रोत है जहाँ से प्रत्येक मिंट पृष्ठ पर NUT संख्याएँ आती हैं।",
+  "about.mints.title": "मिंट क्या है, और इसका समझौता",
+  "about.mints.p1": "एक मिंट संरक्षक है। जब आप मिंट ecash करते हैं, तो आप sats उस व्यक्ति को सौंप रहे हैं जो उस सर्वर को चलाता है, और आप उन पर भरोसा कर रहे हैं कि वे टोकन का सम्मान करेंगे जब आप उन्हें वापस पिघलाएंगे। कोई धोखाधड़ी-प्रूफ नहीं, कोई एस्क्रो नहीं और कोई सहारा नहीं। एक मिंट ऑपरेटर शेष राशि लेकर गायब हो सकता है, और मिंट्स हो चुका है।",
+  "about.mints.p2": "यही कारण है कि यहाँ समीक्षाएँ मौजूद हैं। यह साइट कभी भी आपको यह नहीं बताती कि मिंट सुरक्षित है। मिंट पेज पर स्थिति {code} कहती है, \"ट्रस्टेड\" नहीं, और इसका मतलब केवल यह है कि सर्वर ने हमारी पिछली पूछताछ का जवाब दिया था। ecash बैलेंस को कोट की जेब में रखे नकद की तरह समझें: खर्च करने के लिए ठीक, बचत के लिए गलत।",
+  "about.nip87.title": "NIP-87 क्या है",
+  "about.nip87.p1": "NIP-87 Nostr सम्मेलन है जो ecash मिंट्स की घोषणा और सिफारिश करने के लिए है। यहां दो प्रकार की घटनाएं मायने रखती हैं:",
+  "about.nip87.li1": "{code} मिंट की घोषणा करता है। मिंट URL {tag} टैग में है। इस तरह साइट मिंट्स को खोजती है जिसे उसने कभी नहीं देखा।",
+  "about.nip87.li2": "{code} एक समीक्षा है। इसमें रेटिंग और समीक्षा का पाठ होता है, और यह {utag} टैग (मिंट URL) और {dtag} टैग (मिंट की अपनी सार्वजनिक कुंजी) के साथ उस मिंट की ओर इशारा करता है, जिसके बारे में यह है।",
+  "about.nip87.p2": "हर समीक्षा इसके लेखक की Nostr कुंजी से हस्ताक्षरित होती है। हम कभी भी किसी समीक्षा को \"सत्यापित\" नहीं कहते, क्योंकि किसी ने भी इसकी पुष्टि नहीं की है: यह हस्ताक्षरित है, जो एक अलग और अधिक उपयोगी दावा है। इसका मतलब है कि आप जांच सकते हैं कि इसे किसने लिखा है और यह कि इसे बदला नहीं गया है। इसका यह मतलब नहीं है कि लेखक ईमानदार है या कभी मिंट का उपयोग किया है।",
+  "about.how.title": "यह साइट कैसे काम करती है",
+  "about.how.p1": "दो लूप और एक नियम हैं। नियम यह है कि मिंट अपनी मेटाडेटा का मालिक है और Nostr समीक्षाओं का मालिक है, इसलिए यह साइट किसी को भी प्राधिकरण के रूप में संग्रहीत नहीं करती।",
+  "about.how.li1": "{strong} हर दस मिनट में हर ज्ञात मिंट से {code} के लिए पूछता है और जो कुछ भी वह कहता है उसे रिकॉर्ड करता है: नाम, विवरण, संस्करण, समर्थित NUTs, सीमाएँ, संपर्क विवरण। यह यह भी रिकॉर्ड करता है कि क्या मिंट ने बिल्कुल भी उत्तर दिया, जिससे अपटाइम प्राप्त होता है।",
+  "about.how.li1Label": "जांच लूप",
+  "about.how.li2": "{strong} हर घंटे Nostr रिले से जुड़ता है, मिंट घोषणाएं और समीक्षाएं पढ़ता है, और किसी भी मिंट जिसे उसने पहले नहीं देखा होता, उसे जोड़ता है।",
+  "about.how.li2Label": "खोज चक्र",
+  "about.how.p2": "महत्वपूर्ण हिस्सा यह है कि जब कोई मिंट जवाब देना बंद कर देता है तो क्या होता है। इसकी कैश की गई मेटाडेटा कभी भी असफल जांच द्वारा ओवरराइट नहीं होती, इसलिए एक निष्क्रिय मिंट अपना पूरा पेज रखता है: इसकी विशिष्टताएँ, इसका इतिहास और इसकी समीक्षाएँ, एक बैनर के साथ जो बताता है कि यह कब बंद हुआ। इस साइट का पिछला संस्करण इसके बजाय एक त्रुटि पृष्ठ दिखाता था, जिसका मतलब था कि जिन मिंट्स लोगों के बारे में लोगों को सबसे ज़्यादा एक-दूसरे को चेतावनी देनी होती थी, वे ही लोग थे जिनकी समीक्षा नहीं की जा सकती थी। यही पुनर्निर्माण का मुख्य कारण था।",
+  "about.how.p3": "समीक्षा पाठ कभी भी हमारी ओर से संग्रहीत नहीं किया जाता। जब आप मिंट पृष्ठ खोलते हैं, तो आपका ब्राउज़र सीधे रिले से बात करता है और स्वयं समीक्षाएँ पढ़ता है, और जब आप कोई समीक्षा लिखते हैं तो वह आपके अपने Nostr एक्सटेंशन द्वारा हस्ताक्षरित होकर सीधे उन रिले को भेज दी जाती है। हम केवल पृष्ठों को रैंक और क्रमबद्ध करने के लिए एक गिनती रखते हैं, और कुछ नहीं। यहाँ कुछ भी, उन समीक्षाओं सहित जिन्हें हम नहीं चाहते, हमारे द्वारा संपादित या हटाया नहीं जा सकता।",
+  "about.relays.title": "रिले पढ़ते हैं",
+  "about.relays.p1": "ये वे रिले हैं जिनका उपयोग इंडेक्सर और आपका ब्राउज़र दोनों करते हैं:",
+  "about.relays.p2": "किसी भी Nostr क्लाइंट को उन्हीं रिलेज़ पर पॉइंट करें और आप वही घटनाएँ देखेंगे। यही पूरा वादा है: यहाँ कुछ भी केवल इसलिए सत्य नहीं है क्योंकि हम कहते हैं।",
+  "about.nuts.title": "NUTs क्या हैं?",
+  "about.nuts.p1": "NUTs संख्यांकित Cashu विनिर्देश हैं, जैसे Bitcoin के लिए BIPs। एक मिंट यह विज्ञापन करता है कि वह किन विनिर्देशों को लागू करता है, और इससे आपको पता चलता है कि वह वास्तव में क्या कर सकता है: NUT-04 और NUT-05 हैं मिंटिंग और मेल्टिंग Lightning पर (इनके बिना एक मिंट का ज्यादा उपयोग नहीं है), NUT-07 वॉलेट को यह जांचने की अनुमति देता है कि क्या कोई टोकन पहले ही खर्च हो चुका है, NUT-17 वॉलेट्स को पोलिंग के बजाय WebSockets पर लाइव अपडेट देता है, और NUT-20 वॉलेट को यह साबित करने की अनुमति देता है कि मिंट उद्धरण वास्तव में उसे जारी किया गया था। पूरी सूची {link} पर है।",
+  "about.numbers.title": "अभी",
+  "about.numbers.p1": "{mints} मिंट्स अनुक्रमित, {online} उनमें से उत्तर दे रहे, {reviews} उपरोक्त रिले से समीक्षाएँ गिनी गईं।",
+  "about.source.title": "स्रोत और श्रेय",
+  "about.source.p1": "साइट {github} पर ओपन सोर्स है। इसे {azzamo} द्वारा बनाया और चलाया जाता है। यदि मिंट पृष्ठ में कुछ गलत है, तो इसे स्रोत पर ठीक करें: मिंट मेटाडेटा मिंट के अपने {code} से आता है, और समीक्षाएं Nostr से आती हैं।",
+  "terms.title": "उपयोग की शर्तें · Cashumints.space",
+  "terms.description": "Cashumints.space के उपयोग की शर्तें: यह साइट क्या है, यह क्या नहीं करती, और किसके लिए कौन जिम्मेदार है। कोई खाते नहीं, कोई वारंटी नहीं, किसी भी मिंट से कोई संबद्धता नहीं।",
+  "terms.heading": "उपयोग की शर्तें",
+  "terms.lede": "केवल सार्वजनिक डेटा को अनुक्रमित करने वाली साइट के लिए सरल शर्तें।   अंतिम अपडेट {date}।",
+  "terms.what.title": "यह साइट क्या है",
+  "terms.what.p1": "Cashumints.space सार्वजनिक रूप से उपलब्ध डेटा का एक सूचकांक है जो Cashu मिंट्स के बारे में है। दो प्रकार के डेटा, दोनों कहीं और से:",
+  "terms.what.li1": "मिंट मेटाडेटा, प्रत्येक मिंट के अपने {code} एंडपॉइंट से पढ़ा गया: नाम, विवरण, सॉफ़्टवेयर संस्करण, समर्थित NUTs, संपर्क विवरण और कि क्या मिंट ने जब हमने पिछली बार पूछा था तब उत्तर दिया था।",
+  "terms.what.li2": "समीक्षाएँ, सार्वजनिक Nostr रिले से पढ़ी गई। ये NIP-87 घटनाएँ हैं जिन्हें उनके लेखकों ने रिले पर प्रकाशित किया है, जिन्हें कोई भी पूछताछ कर सकता है।",
+  "terms.what.p2": "हम उस डेटा को एकत्रित करते हैं, उसे सामान्यीकृत करते हैं, रैंक करते हैं और दिखाते हैं। हम इसे नहीं बनाते।",
+  "terms.noAccounts.title": "न कोई खाते, न कोई वारंटी",
+  "terms.noAccounts.p1": "साइन अप करने के लिए कुछ भी नहीं है। साइट को जैसा है वैसा ही प्रदान किया जाता है, किसी भी प्रकार की कोई गारंटी नहीं: न कि डेटा सटीक है, न कि यह वर्तमान है, न कि साइट उपलब्ध रहेगी। मिंट डेटा मिनटों या घंटों पुराना हो सकता है, एक मिंट हमारी पिछली जाँच के बाद बदल सकता है, और एक रिले उत्तर देने में विफल हो सकता है, ऐसी स्थिति में आप जो देख रहे हैं वह वास्तव में मौजूद से कम है।",
+  "terms.noAccounts.p2": "इसे अपने जोखिम पर उपयोग करें। इस साइट का उपयोग करने या यहाँ पढ़ी गई किसी भी बात पर भरोसा करने से होने वाले किसी भी नुकसान के लिए हम उत्तरदायी नहीं हैं। Cashu मिंट का उपयोग करने के विशिष्ट जोखिमों के लिए {link} देखें।",
+  "terms.noAccounts.link": "अस्वीकरण",
+  "terms.noCustody.title": "हम आपके पैसे नहीं रखते।",
+  "terms.noCustody.p1": "यह साइट कभी भी धन की हिरासत नहीं लेती। इसके पास कोई वॉलेट नहीं है, यह ecash को छूती नहीं है, और यह कुछ भी स्थानांतरित, जमा या पुनर्प्राप्त नहीं कर सकती। यदि आपको मिंट के साथ कोई समस्या है, तो मिंट ऑपरेटर ही एकमात्र पक्ष है जो आपकी मदद कर सकता है, और हम आपकी ओर से उनसे संपर्क नहीं कर सकते।",
+  "terms.noCustody.p2": "हम यहाँ सूचीबद्ध किसी भी मिंट से संबद्ध नहीं हैं, और कोई भी मिंट इसकी सूची, इसकी रैंक या इसकी रेटिंग के लिए भुगतान नहीं करता है। मिंट्स सार्वजनिक Nostr घोषणाओं से खोजे जाते हैं और सार्वजनिक समीक्षा डेटा पर एक एल्गोरिदम द्वारा रैंक किए जाते हैं।",
+  "terms.reviews.title": "समीक्षाएँ दूसरों के शब्द हैं।",
+  "terms.reviews.p1": "समीक्षाएँ उपयोगकर्ता-निर्मित सामग्री हैं जिन्हें उनके लेखकों द्वारा सार्वजनिक Nostr रिले पर प्रकाशित किया जाता है। हम उन्हें प्रदर्शित करते हैं, हम उनका नियंत्रण नहीं करते। हमने उन्हें नहीं लिखा, हम उन्हें संपादित नहीं कर सकते, और हम उन्हें उन रिले से हटा नहीं सकते जो उन्हें धारण करते हैं: वे एक ऐसे नेटवर्क पर हस्ताक्षरित घटनाएँ हैं जिसका हम स्वामित्व नहीं रखते।",
+  "terms.reviews.p2": "एक समीक्षा किसी व्यक्ति का अनुभव है, न कि कोई सत्यापित तथ्य। यदि आप कोई समीक्षा प्रकाशित करते हैं, तो आप उसमें कही गई बातों के लिए जिम्मेदार हैं। कुछ भी गैरकानूनी प्रकाशित न करें, और ध्यान रखें कि जो कुछ भी आप प्रकाशित करते हैं वह सार्वजनिक और स्थायी होता है (देखें {link})।",
+  "terms.reviews.link": "गोपनीयता पृष्ठ",
+  "terms.reviews.p3": "हम इस साइट पर किसी विशिष्ट समीक्षा को दिखाना बंद कर सकते हैं, और हम अवैध सामग्री के लिए ऐसा करेंगे। इससे वह केवल इन पृष्ठों से ही हट जाती है। यह घटना रिले पर बनी रहती है और कोई भी अन्य Nostr क्लाइंट इसे अभी भी पढ़ सकता है।",
+  "terms.links.title": "अन्य साइटों के लिंक",
+  "terms.links.p1": "मिंट यूआरएल, वॉलेट लिंक, ऑपरेटर संपर्क और इस साइट से बाहर जाने वाले अन्य सभी लिंक डेटा का हिस्सा होने के कारण यहां मौजूद हैं। एक लिंक समर्थन का संकेत नहीं है और हम यह जांचते नहीं हैं कि दूसरी ओर क्या है।",
+  "terms.changes.title": "परिवर्तन",
+  "terms.changes.p1": "ये शर्तें बदल सकती हैं। शीर्ष पर दिनांक बताता है कि इन्हें आखिरी बार कब बदला गया था। यह साइट ओपन सोर्स है, इसलिए इस पृष्ठ में की गई हर परिवर्तन कमेिट इतिहास में दर्ज है।",
+  "terms.contact.title": "संपर्क",
+  "terms.contact.p1": "समस्याएँ और हटाने के अनुरोध {github} पर दर्ज करना सबसे अच्छा है। यह साइट {azzamo} द्वारा संचालित है।",
+  "privacy.title": "गोपनीयता · Cashumints.space",
+  "privacy.description": "Cashumints.space पर गोपनीयता: कोई खाते नहीं, कोई ट्रैकिंग कुकीज़ नहीं, कोई एनालिटिक्स नहीं। localStorage का उपयोग प्रोफ़ाइल कैशिंग के लिए किया जाता है और कुछ भी कहीं नहीं भेजा जाता। समीक्षाएँ आपके अपने ब्राउज़र में हस्ताक्षरित होती हैं।",
+  "privacy.heading": "गोपनीयता",
+  "privacy.lede": "हम उतना ही कम डेटा एकत्र करते हैं जितना एक वेबसाइट कर सकती है।   अंतिम अपडेट {date}।",
+  "privacy.noAccounts.title": "कोई खाते नहीं",
+  "privacy.noAccounts.p1": "इस साइट पर कोई साइन-अप, कोई लॉगिन और कोई प्रोफ़ाइल नहीं है। यहाँ कुछ भी आपसे यह नहीं पूछता कि आप कौन हैं, और कोई उपयोगकर्ता रिकॉर्ड लीक होने के लिए मौजूद ही नहीं है क्योंकि यहाँ कोई उपयोगकर्ता ही नहीं हैं।",
+  "privacy.noTracking.title": "कोई ट्रैकिंग कुकीज़ नहीं, कोई एनालिटिक्स नहीं",
+  "privacy.noTracking.p1": "यह साइट ट्रैकिंग के लिए कोई कुकीज़ नहीं सेट करती। कोई एनालिटिक्स स्क्रिप्ट नहीं है, कोई टैग मैनेजर नहीं है, कोई पिक्सेल नहीं है, कोई सत्र रिकॉर्डिंग नहीं है और कोई विज्ञापन नेटवर्क नहीं है। पेज पर कुछ भी आपके व्यवहार की जानकारी हमें या किसी और को नहीं भेजता।",
+  "privacy.logs.title": "सर्वर लॉग्स",
+  "privacy.logs.p1": "वेब सर्वर मानक एक्सेस लॉग रखता है, जो कि कोई भी वेब सर्वर डिफ़ॉल्ट रूप से करता है। एक लॉग लाइन में आपका आईपी पता, समय, जिस पेज के लिए आपने अनुरोध किया, प्रतिक्रिया स्थिति, और आपका ब्राउज़र जो यूज़र एजेंट और रेफ़रर भेजता है, रिकॉर्ड होता है। ये लॉग त्रुटियों को डीबग करने और दुरुपयोग का पता लगाने के लिए होते हैं। इन्हें किसी अन्य चीज़ से नहीं जोड़ा जाता और न ही इन्हें बेचा या साझा किया जाता है।",
+  "privacy.logs.operatorLabel": "ऑपरेटर नोट:",
+  "privacy.logs.operator": "यदि आप इस साइट को चलाते हैं, तो यहाँ अपनी वास्तविक प्रतिधारण अवधि बताएं। README में तैनाती nginx का उपयोग करती है, इसके डिफ़ॉल्ट एक्सेस लॉग के साथ और जो भी रोटेशन आपकी वितरण प्रदान करती है (Debian और Ubuntu पर, जो logrotate है, दैनिक, 14 दिन तक रखती है)। पुष्टि करें कि आपका सर्वर क्या करता है और इस पैराग्राफ़ को उस संख्या से बदलें।",
+  "privacy.storage.title": "आपके ब्राउज़र में क्या संग्रहीत है",
+  "privacy.storage.p1": "यह साइट localStorage का उपयोग ठीक दो चीज़ों के लिए करती है, जो दोनों आपके डिवाइस पर ही रहती हैं और कभी भी कहीं भेजी नहीं जातीं:",
+  "privacy.storage.li1": "आपने जिन समीक्षकों की समीक्षाएँ देखी हैं, उनके प्रोफ़ाइल मेटाडेटा (प्रकार 0 घटनाएँ: नाम, अवतार, NIP-05 पते) का Nostr कैश। यह प्रत्येक पृष्ठ पर पुनः क्वेरी करने की आवश्यकता को बचाता है। प्रविष्टियाँ समाप्त हो जाती हैं, और कैश सीमित होता है तथा सबसे पुराने आइटम पहले निष्कासित किए जाते हैं।",
+  "privacy.storage.li2": "इंटरफ़ेस प्राथमिकताएँ, ताकि साइट अगली बार भी उसी तरह व्यवहार करे।",
+  "privacy.storage.p2": "अपने ब्राउज़र का साइट डेटा साफ़ करने से दोनों हट जाते हैं। कुछ भी टूटता नहीं है, प्रोफ़ाइल लुकअप बस फिर से चल जाते हैं।",
+  "privacy.thirdParties.title": "आपका ब्राउज़र किससे बात करता है",
+  "privacy.thirdParties.p1": "एक पेज लोड करने पर आपका ब्राउज़र इस साइट के अलावा कुछ अन्य स्थानों से भी जुड़ता है। इसी तरह कोई ऐसी साइट जिसमें सर्वर-साइड ट्रैकिंग नहीं है, फिर भी लाइव डेटा पढ़ती है:",
+  "privacy.thirdParties.li1Label": "सार्वजनिक Nostr रिले करता है",
+  "privacy.thirdParties.li1": "{strong}, WebSocket से अधिक, समीक्षाएँ और समीक्षक प्रोफाइल पढ़ने के लिए।  रिले आपकी आईपी और आपने जो अनुरोध किया है, उसे देखता है, जैसे कोई भी सर्वर जिससे आप कनेक्ट होते हैं।  रिले {link} पर सूचीबद्ध हैं।",
+  "privacy.thirdParties.li1Link": "हमारे बारे में पृष्ठ",
+  "privacy.thirdParties.li2Label": "समीक्षक अवतार चित्र",
+  "privacy.thirdParties.li2": "{strong}, समीक्षक की प्रोफ़ाइल जहाँ भी इंगित करती है, वहाँ से लोड किया गया। ये बिना रेफरर नीति के भेजे जाते हैं, ताकि होस्ट को यह पता न चले कि आप किस पेज पर थे।",
+  "privacy.publishing.title": "समीक्षा प्रकाशित करना",
+  "privacy.publishing.p1": "समीक्षा लिखना आपके ब्राउज़र में होता है, हमारे सर्वर पर नहीं। इस घटना को आपके NIP-07 एक्सटेंशन (Alby, nos2x या समान) द्वारा हस्ताक्षरित किया जाता है और आपके ब्राउज़र से सीधे रिलेज़ तक प्रसारित किया जाता है। आपकी निजी कुंजी कभी भी एक्सटेंशन से बाहर नहीं जाती और यह साइट इसे कभी नहीं देखती। हम कस्टम कुंजी प्रबंधन नहीं बनाते हैं और हम कभी भी कुंजी या सीड वाक्यांश नहीं मांगते हैं।",
+  "privacy.permanent.title": "आप जो कुछ भी Nostr पर प्रकाशित करते हैं, वह सार्वजनिक और स्थायी है।",
+  "privacy.permanent.p1": "यह वह हिस्सा है जिसे दो बार पढ़ना चाहिए। एक समीक्षा सार्वजनिक रिले पर एक हस्ताक्षरित घटना है। एक बार यह जारी हो जाने के बाद, यह वापस नहीं ली जा सकती:",
+  "privacy.permanent.li1": "कोई भी इसे अब और बाद में किसी भी Nostr क्लाइंट का उपयोग करके पढ़ सकता है। यह \"Cashumints.space पर सार्वजनिक\" नहीं है, यह नेटवर्क पर सार्वजनिक है।",
+  "privacy.permanent.li2": "यह स्थायी रूप से आपकी Nostr सार्वजनिक कुंजी से जुड़ा हुआ है, साथ ही उस कुंजी द्वारा अब तक प्रकाशित की गई सभी चीज़ों के साथ।",
+  "privacy.permanent.li3": "इसे हटाना एक अनुरोध है, आदेश नहीं। आप एक हटाने की घटना प्रकाशित कर सकते हैं और कुछ रिले इसका सम्मान करेंगे, लेकिन कोई भी रिले इसे अनदेखा कर सकता है और जिसने भी पहले ही इस घटना की प्रतिलिपि बना ली है, उसके पास यह अभी भी मौजूद है। प्रकाशित समीक्षा को स्थायी मानिए।",
+  "privacy.permanent.li4": "हम इसे आपके लिए हटा नहीं सकते। हम इसे यहाँ दिखाना बंद कर सकते हैं; इससे रिले पर कुछ भी नहीं बदलता।",
+  "privacy.permanent.p2": "यदि आप अपनी मुख्य पहचान से जुड़े बिना मिंट की समीक्षा करना चाहते हैं, तो Nostr की एक अलग कुंजी का उपयोग करें। ध्यान दें कि कोई अन्य गतिविधि न होने वाली कुंजी को कठोर समीक्षाओं में इस रूप में दिखाया जाता है, क्योंकि एक बिल्कुल नई कुंजी द्वारा एक सितारा समीक्षा लिखना एक ऐसा पैटर्न है जिसे पाठक देखना चाहते हैं।",
+  "privacy.contact.title": "प्रश्न",
+  "privacy.contact.p1": "यह साइट ओपन सोर्स है: यदि आप उपरोक्त में से किसी को भी जांचना चाहते हैं, तो {github} पर कोड पढ़ें। प्रश्न और सुधार वहाँ एक इश्यू में भेजे जा सकते हैं।",
+  "disclaimer.title": "अस्वीकरण · Cashumints.space",
+  "disclaimer.description": "Cashu मिंट का उपयोग करने से पहले क्या जानना चाहिए: मिंट्स संरक्षक हैं, मिंट आपका पैसा लेकर गायब हो सकता है, समीक्षाएँ व्यक्तिगत राय होती हैं और ऑनलाइन माध्यम पहुँच योग्य होते हैं, भरोसेमंद नहीं।",
+  "disclaimer.heading": "अस्वीकरण",
+  "disclaimer.lede": "मिंट में पैसा डालने से पहले इसे पढ़ें।   अंतिम अपडेट {date}।",
+  "disclaimer.callout": "एक Cashu मिंट आपके पैसे आपके लिए रखता है। अगर यह गायब हो जाता है, तो आपका ecash चला जाता है, और अपील करने के लिए कोई नहीं होता। केवल वही रखें जिसे आप खोने का जोखिम उठा सकते हैं।",
+  "disclaimer.custodial.title": "मिंट्स अभिरक्षा में हैं",
+  "disclaimer.custodial.p1": "जब आप मिंट ecash करते हैं, तो आप bitcoin मिंट ऑपरेटर को देते हैं और टोकन वापस प्राप्त करते हैं। वे टोकन उस ऑपरेटर पर एक दावा हैं। वे bitcoin आपके पास नहीं होते, और ऑपरेटर ही यह तय करता है कि उन्हें मान्य किया जाए या नहीं।",
+  "disclaimer.custodial.p2": "इसका मतलब है कि हर मिंट में समान जोखिम होते हैं: ऑपरेटर गायब हो सकता है, उसे बंद करने के लिए मजबूर किया जा सकता है, किसी बग या हैक के कारण फंड खो सकते हैं, या वह बस सर्वर बंद कर सकता है। कोई जमा बीमा नहीं है, कोई चार्जबैक नहीं है, कोई सहायता लाइन नहीं है और कोई कानूनी सहारा नहीं है जिस पर भरोसा किया जा सके। यह इस साइट पर उच्चतम रेटिंग वाले मिंट के बारे में भी सच है।",
+  "disclaimer.custodial.p3": "Cashu को छोटी-छोटी रकमों को जल्दी से घुमाने के लिए डिज़ाइन किया गया है। इसे इसी तरह इस्तेमाल करें: जो आप खर्च करने वाले हैं, वही इसमें रखें, अपनी बचत नहीं, और सब कुछ एक ही जगह पार्क करने के बजाय मिंट्स में फैला दें।",
+  "disclaimer.reviews.title": "समीक्षाएँ राय हैं, सत्यापित दावे नहीं।",
+  "disclaimer.reviews.p1": "यहाँ की हर समीक्षा Nostr पर किसी व्यक्ति द्वारा लिखी गई है और उनकी कुंजी से हस्ताक्षरित है। हस्ताक्षरित का मतलब है कि हम आपको बता सकते हैं कि किस कुंजी ने इसे लिखा है। इसका यह मतलब नहीं है कि समीक्षा सत्य है, कि लेखक ने मिंट का उपयोग किया, या कि लेखक ऑपरेटर नहीं है, कोई प्रतिस्पर्धी नहीं है, या एक ही व्यक्ति दस कुंजियों का उपयोग नहीं कर रहा है।",
+  "disclaimer.reviews.p2": "हम समीक्षकों की पुष्टि नहीं करते, और हम उन समीक्षाओं को संपादित या हटाते नहीं हैं जिनसे हम असहमत हैं। कुछ समीक्षाएँ पढ़ें, देखें कि वे वास्तव में क्या कहती हैं, और तीन समीक्षाओं वाली मिंट को तीन सौ समीक्षाओं वाली की तुलना में अलग तरह से तौलें।",
+  "disclaimer.status.title": "ऑनलाइन का मतलब पहुँच योग्य है, भरोसेमंद नहीं।",
+  "disclaimer.status.p1": "हम हर मिंट की नियमित रूप से जाँच करते हैं और दिखाते हैं कि क्या उसने उत्तर दिया। हरे रंग की स्थिति का यही मतलब है: सर्वर ने प्रतिक्रिया दी। इससे यह नहीं पता चलता कि ऑपरेटर आर्थिक रूप से सक्षम है, ईमानदार है, या कल आपके टोकन का सम्मान करने का इरादा रखता है।",
+  "disclaimer.status.p2": "एक मिंट तब तक ऑनलाइन रह सकता है जब तक कि वह ऑनलाइन न हो। अपटाइम इतिहास, समर्थित NUTs और सॉफ़्टवेयर संस्करण आपको यह बताते हैं कि एक मिंट कैसे चलाया जाता है, लेकिन इनमें से कोई भी आपके पैसे के लिए कोई वादा नहीं है।",
+  "disclaimer.ranking.title": "रैंकिंग कैसे काम करती है, और इसका क्या मतलब नहीं है",
+  "disclaimer.ranking.p1": "मिंट्स को सार्वजनिक समीक्षा डेटा (रेटिंग, समीक्षाओं की संख्या और हालिया गतिविधि) के आधार पर एक एल्गोरिदम द्वारा क्रमबद्ध किया जाता है, जिसमें ऑनलाइन मिंट्स डिफ़ॉल्ट रूप से ऑफ़लाइन से आगे होता है। विवरण ओपन सोर्स कोड में हैं।",
+  "disclaimer.ranking.p2": "किसी को भी प्लेसमेंट के लिए भुगतान नहीं किया जाता। इस साइट पर कोई प्रायोजित स्लॉट नहीं है, कोई प्रचारित लिस्टिंग नहीं है और मिंट के साथ कोई व्यवस्था नहीं है। उच्च रैंक का मतलब है कि एल्गोरिदम को सार्वजनिक डेटा पसंद आया, और बस इतना ही। यह कोई सिफारिश नहीं है और यह कोई सुरक्षा रेटिंग नहीं है।",
+  "disclaimer.notAdvice.title": "यह वित्तीय सलाह नहीं है।",
+  "disclaimer.notAdvice.p1": "इस साइट पर कुछ भी वित्तीय, निवेश, कानूनी या कर संबंधी सलाह नहीं है। हम आपकी स्थिति नहीं जानते और हम आपको कोई सलाह नहीं दे रहे हैं। मिंट का उपयोग करना और यह चुनना कि कौन सा है, आपका निर्णय है।",
+  "disclaimer.dyor.title": "अपनी खुद की रिसर्च करें",
+  "disclaimer.dyor.li1": "ऑपरेटर की जानकारी देखें। सार्वजनिक प्रतिष्ठा खोने का जोखिम उठाने वाले किसी व्यक्ति द्वारा संचालित मिंट और एक अनाम URL में बड़ा अंतर है।",
+  "disclaimer.dyor.li2": "मिंट की अपनी शर्तें और उसका MOTD पढ़ें। एक मिंट जो खुद को टेस्ट या बीटा कहता है, तो इसका मतलब वही है।",
+  "disclaimer.dyor.li3": "छोटी शुरुआत करें। मिंट थोड़ी सी लें, उसे खर्च करें, फिर उसे पिघलाकर वापस निकालें, और इससे पहले कि आप इस पर और भरोसा करें, देखें कि क्या होता है।",
+  "disclaimer.dyor.li4": "सीमाओं पर ध्यान दें। कम अधिकतम सीमा अक्सर एक सावधान ऑपरेटर का संकेत होती है, और उच्च अधिकतम सीमा सुरक्षित ऑपरेटर का संकेत नहीं होती।",
+  "disclaimer.dyor.li5": "अपने टोकन का बैकअप रखें, और याद रखें कि टोकन एक धारक संपत्ति है: जो कोई भी इसे रखता है, वह इसे खर्च कर सकता है।",
+  "disclaimer.site.title": "साइट के बारे में",
+  "disclaimer.site.p1": "यहाँ का डेटा गलत या पुराना हो सकता है। मिंट्स को एक निर्धारित समय-सारणी के अनुसार जांचा जाता है, रिले कभी-कभी उत्तर नहीं देते, और आप जो पेज पढ़ रहे हैं वह अतीत में किसी समय बनाया गया था। साइट को बिना किसी वारंटी के \"जैसा है\" प्रदान की जाती है। {link} देखें।",
+  "disclaimer.site.link": "उपयोग की शर्तें",
+  "disclaimer.updated": "20 अगस्त 2026",
+  "login.getPrimal": "Primal प्राप्त करें",
+  "reviews.dialog.identity.extensionGone": "आपका ब्राउज़र एक्सटेंशन प्रतिक्रिया नहीं दे रहा है। फिर से लॉग इन करें, या रिमोट साइनर का उपयोग करें।",
+  "seo.orgDescription": "Cashu मिंट्स की एक निर्देशिका, जिसमें प्रत्येक मिंट से लाइव स्थिति और Nostr पर हस्ताक्षरित सामुदायिक समीक्षाएँ शामिल हैं।",
+  "seo.ogImageAlt": "Cashumints.space: एक ऐसा Cashu मिंट खोजें जिस पर आप भरोसा कर सकें।",
+  "seo.mint.title.one": "{name} समीक्षाएँ: {rating} से {n} समीक्षा रेटिंग | Cashumints.space",
+  "seo.mint.title.other": "{name} समीक्षाएँ: {rating} रेटिंग {n} समीक्षाओं से | Cashumints.space",
+  "seo.mint.titleOffline.one": "{name}: {n} दिन के लिए ऑफ़लाइन | Cashumints.space",
+  "seo.mint.titleOffline.other": "{name}: {n} दिनों से ऑफ़लाइन | Cashumints.space",
+  "seo.mint.titleNoReviews": "{name}: Cashu मिंट जानकारी और समीक्षाएँ | Cashumints.space",
+  "seo.fedimint.titleNoReviews": "{name}: Fedimint फेडरेशन जानकारी और समीक्षाएँ | Cashumints.space",
+  "seo.desc.fallback": "{name} ({domain}) के लिए सामुदायिक समीक्षाएँ।",
+  "seo.desc.fallbackDomain": "Cashu मिंट के लिए {domain} पर सामुदायिक समीक्षाएँ।",
+  "seo.desc.rated.one": "{n} पर हस्ताक्षरित समीक्षा से {rating}/5 रेट किया गया Nostr।",
+  "seo.desc.rated.other": "{n} हस्ताक्षरित समीक्षाओं से {rating}/5 रेट किया गया Nostr।",
+  "seo.desc.noReviews": "अभी तक कोई समीक्षा नहीं।",
+  "seo.desc.status": "{status}.",
+  "seo.desc.statusLimits": "{status}, सीमाएँ {limits}।",
+  "seo.desc.fedModules": "{status}. मॉड्यूल: {modules}.",
+  "seo.desc.fedModulesNetwork": "{status}. मॉड्यूल: {modules} पर {network}।",
+  "seo.mint.ogAlt.one": "{name}: {rating} सितारे {n} समीक्षा से Cashumints.space पर",
+  "seo.mint.ogAlt.other": "{name}: {rating} सितारे {n} समीक्षाओं से Cashumints.space पर",
+  "seo.mint.ogAltNoReviews": "{name} पर Cashumints.space",
+  "nav.home": "होम",
+  "mint.more.title": "और मिंट्स",
+  "mint.more.all": "सभी मिंट्स देखें",
+  "nav.fedimints": "Fedimints",
+  "status.announced": "केवल घोषित",
+  "card.unnamedFederation": "अनाम संघ",
+  "card.notChecked": "कभी जांचा नहीं",
+  "fedimints.title": "सभी Fedimint संघ · Cashumints.space",
+  "fedimints.description": "{total} Fedimint सभी संघों की घोषणा Nostr नेटवर्क पर: {online} बाहरी जांच द्वारा पुष्टि किए गए, {announced} घोषित लेकिन कभी पुष्टि नहीं हुए। प्रत्येक के लिए सामुदायिक रेटिंग, मॉड्यूल और निमंत्रण कोड।",
+  "fedimints.heading": "सभी महासंघ",
+  "fedimints.lede": "Fedimint संघ की घोषणा Nostr नेटवर्क पर की गई। एक संघ का अपना कोई सार्वजनिक स्थिति एंडपॉइंट नहीं होता, इसलिए इनमें से कुछ की चलने की पुष्टि बाहरी जांच द्वारा की गई है और बाकी को ठीक वैसे ही सूचीबद्ध किया गया है जैसे उनकी घोषणा की गई थी।",
+  "fedimints.search.label": "नाम या आईडी से फ़ेडरेशन खोजें",
+  "fedimints.search.placeholder": "नाम या फेडरेशन आईडी से खोजें…",
+  "fedimints.sort.label": "संघों को क्रमबद्ध करें",
+  "fedimints.hideOffline": "ऑफ़लाइन छिपाएँ",
+  "fedimints.showing": "{total} संघ दिखाए जा रहे हैं ({online} पुष्टि किए गए, {announced} केवल घोषित)",
+  "fedimints.showingFiltered": "{total} संघों में से {shown} दिखाया जा रहा है ({online} पुष्टि किए गए, {announced} केवल घोषित)",
+  "fedimints.announcedNote.one": "इनमें से एक की घोषणा Nostr पर की गई थी और तब से यह चल रहा है, इसकी कोई पुष्टि नहीं हुई है। इसे ऑनलाइन या ऑफ़लाइन के बजाय 'घोषित' के रूप में सूचीबद्ध किया गया है, क्योंकि दोनों में से कोई भी सही नहीं होगा।",
+  "fedimints.announcedNote.other": "इनमें से {n} की घोषणा Nostr पर की गई थी और तब से यह पुष्टि नहीं हुई है कि वे चालू हैं। इन्हें ऑनलाइन या ऑफ़लाइन के बजाय 'घोषित' के रूप में सूचीबद्ध किया गया है, क्योंकि इनमें से कोई भी स्थिति सत्य नहीं है।",
+  "fedimints.noResults": "कोई फेडरेशन मैच नहीं मिला। कोई नाम आज़माएँ, या फेडरेशन आईडी पेस्ट करें।",
+  "fedimints.emptyIndex": "इस साइट के अनुसार रिले पर अभी तक कोई महासंघ घोषित नहीं किए गए हैं। घोषणाएँ आते ही सूची अपने आप भर जाती है।",
+  "fedimint.crumb": "फेडिमिंट्स",
+  "fedimint.breadcrumb": "ब्रेडक्रम्ब",
+  "fedimint.unnamed": "अनाम संघ",
+  "fedimint.idLabel": "संघ",
+  "fedimint.kind.federationId": "संघ आईडी",
+  "fedimint.moduleCount.one": "{n} मॉड्यूल",
+  "fedimint.moduleCount.other": "{n} मॉड्यूल",
+  "fedimint.copyInvite": "आमंत्रण कोड कॉपी करें",
+  "fedimint.confirmed.label": "पुष्टि",
+  "fedimint.confirmed.never": "कभी नहीं",
+  "fedimint.confirmed.by": "{source} द्वारा",
+  "fedimint.confirmed.unattributed": "अंतिम जाँच",
+  "fedimint.announcedOn": "घोषित {when}",
+  "fedimint.announcedUnknown": "कोई घोषणा तिथि नहीं",
+  "fedimint.modules.title": "मॉड्यूल",
+  "fedimint.modules.none": "इस महासंघ की घोषणा में कोई मॉड्यूल सूचीबद्ध नहीं हैं।",
+  "fedimint.modules.note": "मॉड्यूल वे भाग हैं जिन्हें एक परिसंघ संचालित करता है। घोषणा में यह बताया गया है कि कौन-कौन से मौजूद हैं, लेकिन इस बारे में कुछ नहीं कहा गया है कि उनमें से कोई जमा स्वीकार कर रहा है या नहीं।",
+  "fedimint.modules.notListed": "सूचीबद्ध नहीं",
+  "fedimint.invite.title": "आमंत्रण कोड",
+  "fedimint.invite.count.one": "{n} कोड",
+  "fedimint.invite.count.other": "{n} कोड",
+  "fedimint.invite.note": "इसको Fedimint वॉलेट में पेस्ट करके जुड़ें। इसमें फेडरेशन आईडी और इसके संरक्षकों के पते शामिल हैं, और इसे साझा करने के लिए बनाया गया है।",
+  "fedimint.invite.kind": "निमंत्रण कोड",
+  "fedimint.invite.qr": "क्यूआर",
+  "fedimint.invite.qrCaption": "{name} में शामिल होने के लिए स्कैन करें",
+  "fedimint.details.federationId": "फेडरेशन आईडी",
+  "fedimint.details.network": "नेटवर्क",
+  "fedimint.details.announcedBy": "द्वारा घोषित",
+  "fedimint.details.announced": "घोषित",
+  "fedimint.more.title": "अधिक महासंघ",
+  "fedimint.more.all": "सभी महासंघ देखें",
+  "fedimint.disclaimer": "एक संघ में शामिल होने का मतलब है अपने पैसे की हिफाजत करने वालों पर भरोसा करना। रेटिंग्स समुदाय की राय होती हैं, और पुष्टि किया गया संचालन केवल यह दर्शाता है कि वे संपर्क में हैं, न कि भरोसेमंद।",
+  "fedimint.module.lightning": "Lightning",
+  "fedimint.module.mint": "Ecash मिंट",
+  "fedimint.module.wallet": "ऑन-चेन वॉलेट",
+  "fedimint.module.meta": "मेटाडेटा",
+  "fedimint.module.stability_pool": "स्थिरता पूल",
+  "fedimint.module.multi_sig_stability_pool": "स्थिरता पूल (मल्टीसिग)",
+  "fedimint.module.fedi-social": "सामाजिक पुनर्प्राप्ति",
+  "fedimint.network.mainnet": "Bitcoin mainnet",
+  "fedimint.network.signet": "Signet",
+  "fedimint.network.testnet": "Testnet",
+  "fedimint.network.testnet4": "Testnet4",
+  "fedimint.network.regtest": "Regtest",
+  "feed.ecosystem.group": "पारिस्थितिकी तंत्र",
+  "feed.ecosystem.all": "सभी",
+  "feed.ecosystem.cashu": "Cashu",
+  "feed.ecosystem.fedimint": "Fedimint",
+  "feed.filterBySubject": "मिंट या फेडरेशन द्वारा फ़िल्टर करें",
+  "feed.anySubject": "कोई भी मिंट या फेडरेशन",
+  "feed.clearSubject": "नाम फ़िल्टर साफ़ करें",
+  "home.topFedimints.title": "शीर्ष फेडिमिंट्स",
+  "home.topFedimints.sub": "समीक्षाओं और रेटिंग के अनुसार रैंक किया गया",
+  "home.topFedimints.all": "सभी {n} संघ →",
+  "reviews.validate.subject": "इस समीक्षा को इंगित करने के लिए कुछ भी नहीं है।",
+  "mint.warnings.fedimintOffline.lead": "ऑफ़लाइन रिपोर्ट किया गया।",
+  "mint.warnings.fedimintOffline.body.since": "इस संघ तक आखिरी बार चेक {date} ({days} पहले) पर पहुँचा था। तब से इसके संरक्षकों ने कोई उत्तर नहीं दिया है। वहाँ रखे गए धन को जोखिम में समझें, और नए धन को इसमें शामिल न करें।",
+  "mint.warnings.fedimintOffline.body.never": "इस संघ की कोई भी जांच कभी तक नहीं पहुँच पाई, और सबसे हालिया जांच असफल रही। वहाँ रखे गए धन को जोखिम में मानिए, और नए धन को इसमें शामिल न करें।",
+  "mint.warnings.fedimintOffline.meta.since": "{date} से ऑफ़लाइन रिपोर्ट किया गया",
+  "mint.warnings.fedimintOffline.meta.never": "ऑफ़लाइन रिपोर्ट किया गया, एक बार भी नहीं पहुँचा।",
+  "mint.warnings.neverConfirmed.lead": "घोषित, कभी पुष्टि नहीं हुई।",
+  "mint.warnings.neverConfirmed.body.reviewed": "इस संघ की घोषणा Nostr पर {date}, {days} पहले की गई थी, और तब से यह चल रहा है इसकी कोई पुष्टि नहीं हुई है। नीचे दिए गए रिव्यू ही इस पेज पर जीवन का एकमात्र संकेत हैं; बाकी सब कुछ घोषणा से आया है।",
+  "mint.warnings.neverConfirmed.body.quiet": "इस संघ की घोषणा Nostr पर {date}, {days} पहले की गई थी, तब से इसके चालू होने की कोई पुष्टि नहीं हुई है, और हाल ही में किसी ने इसकी समीक्षा नहीं की है। नीचे दी गई सभी जानकारी घोषणा से ली गई है।",
+  "mint.warnings.neverConfirmed.meta": "घोषित {date}, कभी पुष्टि नहीं हुई",
+  "footer.allFedimints": "सभी महासंघ",
+  "reviews.dialog.bodyPlaceholder.cashu": "मिंटिंग, मेल्टिंग और सपोर्ट का हिसाब कैसे निकला? विशिष्ट रूप से बताएं।",
+  "reviews.dialog.bodyPlaceholder.fedimint": "जॉइनिंग, Lightning भुगतान और सपोर्ट का काम कैसे हुआ? विशिष्ट रूप से बताएं।",
+  "fedimint.details.title": "संघ का विवरण",
+  "nav.lnurlMints": "LNURL मिंट",
+  "footer.allLnurlMints": "सभी LNURL मिंट",
+  "lnurlMints.title": "LNURL मिंट: lnurlcash वाहक नोट मिंट, समीक्षा सहित | Cashumints.space",
+  "lnurlMints.description": "Nostr नेटवर्क से अनुक्रमित सभी {total} LNURL मिंट: {online} ऑनलाइन, {offline} ऑफ़लाइन. हर एक के लिए समुदाय की रेटिंग, निकासी सीमाएँ और सुविधाएँ.",
+  "lnurlMints.heading": "LNURL मिंट",
+  "lnurlMints.lede": "इस साइट को ज्ञात हर LNURL मिंट. एक LNURL मिंट lnurlcash वाहक नोट जारी करता है: लाइटनिंग नोट जिन्हें आप एक रहस्य की तरह रखते हैं, और जिन्हें घुमाया, बाँटा, जोड़ा या वापस लाइटनिंग भुगतान में पिघलाया जा सकता है. हर एक की HTTPS पर कुछ मिनटों के अंतराल पर जाँच होती है.",
+  "lnurlMints.search.label": "LNURL मिंट खोजें",
+  "lnurlMints.search.placeholder": "नाम या पते से खोजें…",
+  "lnurlMints.sort.label": "LNURL मिंट क्रमबद्ध करें",
+  "lnurlMints.hideOffline": "ऑफ़लाइन छिपाएँ",
+  "lnurlMints.showing": "{total} LNURL मिंट दिखाए जा रहे हैं ({online} ऑनलाइन, {offline} ऑफ़लाइन)",
+  "lnurlMints.showingFiltered": "{total} में से {shown} LNURL मिंट दिखाए जा रहे हैं ({online} ऑनलाइन, {offline} ऑफ़लाइन)",
+  "lnurlMints.noResults": "कोई LNURL मिंट मेल नहीं खाता.",
+  "lnurlMints.emptyIndex": "अभी तक कोई LNURL मिंट अनुक्रमित नहीं है.",
+  "lnurl.crumb": "LNURL मिंट",
+  "lnurl.breadcrumb": "ब्रेडक्रम्ब",
+  "lnurl.copyAddress": "पता कॉपी करें",
+  "lnurl.more.title": "और LNURL मिंट",
+  "lnurl.more.all": "सभी LNURL मिंट →",
+  "lnurl.disclaimer": "एक LNURL मिंट आपके sats रखता है जबकि आप उसके नोट रखते हैं, इसलिए उसका उपयोग करने का मतलब है उसके संचालक पर भरोसा करना. रेटिंग समुदाय की राय हैं, और ऑनलाइन का मतलब पहुँच योग्य है, भरोसेमंद नहीं.",
+  "lnurl.features.title": "सुविधाएँ",
+  "lnurl.features.none": "इस मिंट ने घोषित नहीं किया कि वह क्या समर्थन करता है.",
+  "lnurl.features.note": "सुविधाएँ वही हैं जो मिंट के संचालक ने Nostr पर घोषित कीं. जहाँ यह साइट HTTPS पर किसी की जाँच कर सकती है, वहाँ करती है, और बताती है जब कोई घोषित चीज़ अभी उपलब्ध नहीं है.",
+  "lnurl.features.notListed": "घोषित नहीं",
+  "lnurl.features.unavailable": "अनुपलब्ध",
+  "lnurl.feature.mint": "लाइटनिंग से मिंट (LUD-06)",
+  "lnurl.feature.melt": "लाइटनिंग में पिघलाना",
+  "lnurl.feature.notes": "नोट घुमाना / बाँटना / जोड़ना",
+  "lnurl.feature.lud16": "लाइटनिंग पता",
+  "lnurl.feature.lud21": "भुगतान सत्यापन (LUD-21)",
+  "lnurl.feature.signed-notes": "हस्ताक्षरित नोट (ऑफ़लाइन सत्यापन)",
+  "lnurl.feature.onion": "Tor पता",
+  "lnurl.feature.rotate": "नोट घुमाएँ",
+  "lnurl.feature.split": "नोट बाँटें",
+  "lnurl.feature.merge": "नोट जोड़ें",
+  "lnurl.feature.lud06": "LUD-06 payRequest",
+  "lnurl.feature.lud03": "LUD-03 withdrawRequest",
+  "lnurl.limits.label": "निकासी सीमाएँ",
+  "lnurl.limits.notPublished": "प्रकाशित नहीं",
+  "lnurl.limits.withdrawRow": "निकासी",
+  "lnurl.limits.disabled": "बंद",
+  "lnurl.limits.sats.one": "{n} sat",
+  "lnurl.limits.sats.other": "{n} sats",
+  "lnurl.details.title": "मिंट विवरण",
+  "lnurl.details.address": "लाइटनिंग पता",
+  "lnurl.details.mintPubkey": "मिंट की सार्वजनिक कुंजी",
+  "lnurl.details.onion": "Tor पता",
+  "lnurl.details.fee": "मिंट शुल्क",
+  "lnurl.details.node": "नोड",
+  "lnurl.details.capacity": "घोषित क्षमता",
+  "lnurl.kind.lightningAddress": "लाइटनिंग पता",
+  "lnurl.kind.mintPubkey": "मिंट की सार्वजनिक कुंजी",
+  "lnurl.kind.onionAddress": "Tor पता",
+  "lnurl.confirmed.label": "अंतिम पुष्टि",
+  "lnurl.confirmed.when": "{when} पुष्ट",
+  "lnurl.fee.base.one": "{n} sat",
+  "lnurl.fee.base.other": "{n} sats",
+  "lnurl.fee.percent": "{percent}%",
+  "home.topLnurl.title": "शीर्ष LNURL मिंट",
+  "home.topLnurl.sub": "समीक्षाओं और रेटिंग के अनुसार",
+  "home.topLnurl.all": "सभी {n} LNURL मिंट →",
+  "feed.ecosystem.lnurl": "LNURL",
+  "reviews.dialog.bodyPlaceholder.lnurl": "मिंट करना, पिघलाना और नोट घुमाना कैसा रहा? विशिष्ट रहें.",
+  "reviews.byUrl.open": "समीक्षा लिखें",
+  "reviews.byUrl.title": "समीक्षा लिखें",
+  "reviews.byUrl.lede": "पता चिपकाएँ। अगर यह साइट उसे अभी तक नहीं जानती, तो उसे अभी जाँचकर जोड़ लिया जाएगा।",
+  "reviews.byUrl.label.cashu": "mint का URL",
+  "reviews.byUrl.label.fedimint": "फ़ेडरेशन का invite code",
+  "reviews.byUrl.label.lnurl": "LNURL mint का URL",
+  "reviews.byUrl.placeholder.cashu": "mint.example.com",
+  "reviews.byUrl.placeholder.fedimint": "fed11…",
+  "reviews.byUrl.placeholder.lnurl": "mint.example.com",
+  "reviews.byUrl.check": "यह पता जाँचें",
+  "reviews.byUrl.checking": "जाँच रहे हैं…",
+  "reviews.byUrl.back": "दूसरा पता इस्तेमाल करें",
+  "reviews.byUrl.existing": "पहले से सूची में",
+  "reviews.byUrl.indexed": "अभी जोड़ा गया",
+  "reviews.byUrl.confirmClose": "बंद करें? आपने जो पता लिखा है वह सहेजा नहीं जाएगा।",
+  "reviews.byUrl.detected": "उस पते ने {kind} mint की तरह जवाब दिया।",
+  "reviews.byUrl.switchTo": "इसे {kind} mint के रूप में समीक्षा करें",
+  "reviews.byUrl.error.empty": "पहले कोई पता लिखें।",
+  "reviews.byUrl.error.badUrl": "यह mint के URL जैसा नहीं लगता।",
+  "reviews.byUrl.error.badInvite": "यह Fedimint का invite code नहीं है। कोड fed11 से शुरू होते हैं।",
+  "reviews.byUrl.error.badInput": "यह साइट उस पते की जाँच नहीं कर सकती।",
+  "reviews.byUrl.error.blocked": "यह सार्वजनिक पता नहीं है, इसलिए इसकी जाँच नहीं हो सकती।",
+  "reviews.byUrl.error.notAMint": "उस पते ने जवाब तो दिया, पर इस तरह के mint के रूप में नहीं।",
+  "reviews.byUrl.error.wrongType": "उस पते ने जवाब दिया, पर किसी और तरह के mint के रूप में।",
+  "reviews.byUrl.error.unverifiable": "उस पते पर कुछ भी जवाब नहीं आया, और Nostr पर भी अभी उसका कोई निशान नहीं है।",
+  "reviews.byUrl.error.rateLimited.one": "एक ही कनेक्शन से बहुत सारी जाँचें हो चुकी हैं। लगभग {n} मिनट बाद फिर कोशिश करें।",
+  "reviews.byUrl.error.rateLimited.other": "एक ही कनेक्शन से बहुत सारी जाँचें हो चुकी हैं। लगभग {n} मिनट बाद फिर कोशिश करें।",
+  "reviews.byUrl.error.network": "इंडेक्स तक नहीं पहुँच सके। अपना कनेक्शन जाँचकर फिर कोशिश करें।",
+  "seo.lnurl.titleNoReviews": "{name}: LNURL मिंट जानकारी और समीक्षाएँ | Cashumints.space",
+  "seo.desc.statusWithdraw": "{status}, निकासी {min}–{max} sat.",
+  "mint.chip.noFunding": "मिंट / मेल्ट बंद",
+  "mint.warnings.lnurlWithdrawalsDisabled.lead": "निकासी बंद है.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.online": "यह मिंट अधिकतम निकासी शून्य घोषित करता है, इसलिए इसके जारी किए किसी भी नोट को किसी चीज़ के बदले भुनाया नहीं जा सकता. जब तक यह न बदले, यहाँ मिंट न करें.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.offline": "अंतिम बार संपर्क होने पर इस मिंट ने अधिकतम निकासी शून्य घोषित की थी, इसलिए इसके जारी किए किसी भी नोट को किसी चीज़ के बदले भुनाया नहीं जा सकता था. जब तक यह न बदले, यहाँ मिंट न करें.",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.online": "निकासी फ़िलहाल बंद है",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.offline": "अंतिम बार देखे जाने पर निकासी बंद थी",
+  "mint.warnings.lnurlInvalid.lead": "एंडपॉइंट जवाब दे रहा है पर अमान्य है.",
+  "mint.warnings.lnurlInvalid.body": "होस्ट जवाब देता है, पर ऐसी मिंट घोषणा के साथ नहीं जिसे यह साइट पढ़ सके, इसलिए निकासी शायद काम न करे. नीचे जो है वह अंतिम पढ़ी जा सकी स्थिति है, और समीक्षाएँ अब भी काम करती हैं.",
+  "mint.warnings.lnurlInvalid.meta": "जवाब देता है, पर वैध मिंट घोषणा के साथ नहीं",
+  "mint.warnings.lnurlNoFunding.lead": "मिंट और मेल्ट अनुपलब्ध.",
+  "mint.warnings.lnurlNoFunding.body": "मौजूदा नोट अब भी घुमाए, बाँटे या जोड़े जा सकते हैं, पर अभी लाइटनिंग से कुछ भी अंदर या बाहर नहीं जा रहा. मिंट खुद चालू है और जवाब दे रहा है; उसके पीछे का लाइटनिंग नोड उससे पहुँच में नहीं है.",
+  "mint.warnings.lnurlNoFunding.meta": "मिंट और मेल्ट अनुपलब्ध",
+  "mint.warnings.also.noFunding": "इसका लाइटनिंग नोड भी पहुँच से बाहर था, इसलिए कुछ भी मिंट या मेल्ट नहीं किया जा सकता था."
+}

web/src/i18n/id.json

@@ -0,0 +1,788 @@
+{
+  "site.name": "Cashumints.space",
+  "common.close": "Tutup",
+  "common.cancel": "Batal",
+  "common.done": "Selesai",
+  "common.back": "Mundur",
+  "common.retry": "Coba lagi",
+  "common.connect": "Sambung",
+  "common.copied": "Disalin",
+  "common.copyFull": "Salin lengkap {kind}",
+  "common.previousPage": "Halaman sebelumnya",
+  "common.nextPage": "Halaman berikutnya",
+  "common.reviewPages": "Halaman Ulasan",
+  "time.never": "tidak pernah",
+  "time.justNow": "hanya sekarang",
+  "time.none": "-",
+  "time.unknownDate": "tanggal yang tidak diketahui",
+  "time.ago.minute": "{n}m yang lalu",
+  "time.ago.hour": "{n}h yang lalu",
+  "time.ago.day": "{n}d yang lalu",
+  "time.ago.week": "{n}w yang lalu",
+  "time.ago.month": "{n}mo yang lalu",
+  "time.ago.year": "{n}y yang lalu",
+  "time.short.minute": "{n}m",
+  "time.short.hour": "{n}h",
+  "time.short.day": "{n}d",
+  "time.short.week": "{n}w",
+  "time.short.month": "{n}mo",
+  "time.short.year": "{n}y",
+  "status.online": "Daring",
+  "status.offline": "Luring",
+  "status.degraded": "Tak bisa dihubungi",
+  "status.unknown": "Belum diperiksa",
+  "nav.skip": "Lewati ke isi",
+  "nav.main": "Utama",
+  "nav.mints": "Mint Cashu",
+  "nav.reviews": "Ulasan",
+  "nav.wallets": "Dompet",
+  "nav.about": "Tentang",
+  "nav.searchMints": "Cari di {n} mint",
+  "lang.label": "Bahasa",
+  "lang.switcher": "Pilih sebuah bahasa",
+  "footer.copyright": "© {year} Cashumints.space",
+  "footer.allMints": "Semua mint Cashu",
+  "footer.allReviews": "Semua ulasan",
+  "footer.wallets": "Dompet",
+  "footer.about": "Tentang",
+  "footer.disclaimer": "Penafian",
+  "footer.terms": "Ketentuan",
+  "footer.privacy": "Privasi",
+  "footer.madeBy": "Dibuat dengan ❤️ oleh {azzamo} · Ditenagai oleh Cashu dan NIP-87",
+  "footer.warning": "Mint bersifat kustodial. Sebuah mint bisa menghilang bersama uangmu.",
+  "footer.tagline": "Ulasan komunitas untuk mint ecash, ditandatangani di Nostr.",
+  "footer.col.explore": "Jelajahi",
+  "footer.col.site": "Situs",
+  "footer.nav": "Footer",
+  "home.title": "Cashumints.space · Temukan mint Cashu yang bisa kamu percaya",
+  "home.description": "Temukan mint Cashu yang dapat Anda percaya. {mints} mint diindeks dengan {reviews} ulasan komunitas yang ditandatangani di Nostr, beserta waktu aktif langsung, NUT yang didukung, dan perangkat lunak mint.",
+  "home.hero.title": "Temukan mint Cashu",
+  "home.hero.titleEm": "Anda dapat percaya",
+  "home.hero.lede": "Setiap mint pada jaringan Nostr, dengan ulasan komunitas yang nyata. Tidak ada penjaga gerbang, hanya menandatangani ulasan Anda dapat memverifikasi diri sendiri.",
+  "home.search.label": "Cari mint dengan nama, domain, atau URL",
+  "home.search.placeholder": "Cari berdasarkan nama, domain, atau tempel URL mint…",
+  "home.filters.mostReviewed": "Kebanyakan ditinjau",
+  "home.filters.highestRated": "Rating tertinggi",
+  "home.filters.recentlyActive": "Baru-baru ini aktif",
+  "home.filters.websockets": "Mendukung Soket Web",
+  "home.top.title": "Mint Cashu teratas",
+  "home.top.sub": "peringkat dengan ulasan dan peringkat",
+  "home.top.all": "Semua {n} Mints",
+  "home.latest.title": "Ulasan Terbaru",
+  "home.latest.sub": "langsung dari jaringan Nostr",
+  "home.latest.prev": "Ulasan sebelumnya",
+  "home.latest.next": "Lebih banyak ulasan",
+  "home.latest.all": "Semua ulasan (ulasan).",
+  "home.latest.empty": "Tidak ada ulasan yang bisa dibaca dari relay sekarang. Buka setiap halaman mint untuk membaca dan menulis ulasan secara langsung.",
+  "home.why.title": "Mengapa mempercayai ulasan ini?",
+  "home.why.signed.title": "Ditandatangani, tidak dimasukkan",
+  "home.why.signed.body": "Setiap ulasan adalah acara {link} yang ditandatangani oleh kunci Nostr penulisnya. Tidak ada yang diedit, peringkat, atau dihapus oleh kami.",
+  "home.why.signed.link": "NIP-87",
+  "home.why.verify.title": "Verifikasi sendiri",
+  "home.why.verify.body": "Ulasan hidup di masyarakat Nostr relay, bukan database kami. Tunjukkan setiap klien pada relay yang sama dan Anda akan melihat data yang sama.",
+  "home.why.checked.title": "Diperiksa terus-menerus",
+  "home.why.checked.body": "Kami menyelidiki setiap mint untuk uptime, versi perangkat lunak, batas, dan didukung NUTS, sehingga spesifikasi yang Anda lihat adalah saat ini, tidak diri-dilaporkan.",
+  "home.cta.title": "Berpikir tentang mint? Baca dulu.",
+  "home.cta.body": "Sebuah mint memegang ecash Anda. Baca apa yang orang lain temukan sebelum kau memasukkan sats, dan tinggalkan ulasan ketika kau menggunakannya sendiri.",
+  "home.cta.explore": "Jelajahi semua mint",
+  "home.cta.learn": "Pelajari tentang Cashu",
+  "pulse.mintsIndexed": "mint diindeks",
+  "pulse.reviewsOnNostr": "ulasan pada Nostr",
+  "pulse.lastReview": "ulasan terakhir",
+  "pulse.mintsOnline": "mint online",
+  "pulse.indexer": "pengindeks",
+  "pulse.connected": "tersambung",
+  "pulse.stale": "basi",
+  "mints.title": "Semua mint Cashu · Cashumints.space",
+  "mints.description": "Semua {total} mint Cashu yang diindeks dari jaringan Nostr, {online} online dan {offline} offline, dengan peringkat komunitas, waktu aktif, dan perangkat lunak mint. Cari dan urutkan daftar lengkapnya.",
+  "mints.heading": "Semua mint Cashu",
+  "mints.lede": "Setiap mint yang ditemukan di jaringan Nostr, termasuk yang sudah tidak ada. Mint yang offline tetap terdaftar sehingga kamu masih bisa menemukan dan mengulasnya.",
+  "mints.search.label": "Cari mint dengan nama atau domain",
+  "mints.search.placeholder": "Cari dengan nama atau domain...",
+  "mints.sort.label": "Urutkan mint",
+  "mints.sort.score": "Keseluruhan terbaik",
+  "mints.sort.rating": "Rating tertinggi",
+  "mints.sort.reviews": "Kebanyakan ditinjau",
+  "mints.sort.recent": "Baru-baru ini ditinjau",
+  "mints.sort.seen": "Baru-baru ini terlihat online",
+  "mints.hideOffline": "Sembunyikan luring",
+  "mints.showing": "Menampilkan {total} mint ({online} online, {offline} offline)",
+  "mints.showingFiltered": "Menampilkan mint {shown} dari {total} ({online} daring, {offline} offline)",
+  "mints.noResults": "Tidak ada mint yang cocok. Coba sebuah domain, atau tempel URL mint.",
+  "mints.clearSearch": "Bersihkan pencarian",
+  "card.noRatings": "Belum ada peringkat",
+  "card.reviews.one": "{n} ulasan",
+  "card.reviews.other": "{n} ulasan",
+  "card.lastSeen": "terakhir terlihat {when}",
+  "card.neverSeen": "tidak pernah terlihat online",
+  "card.reviewed": "diulas {when}",
+  "card.noReviews": "belum ada ulasan",
+  "mint.title": "{name} · ulasan mint Cashu",
+  "mint.titleFedimint": "{name} · Ulasan federasi Fedimint",
+  "mint.titleLnurl": "{name} · Ulasan mint LNURL",
+  "mint.breadcrumb": "Breadcrumb",
+  "mint.crumbMints": "Mint Cashu",
+  "mint.copyUrl": "Salin URL mint",
+  "mint.qrButton": "Mint QR",
+  "mint.writeReview": "Tulis suatu ulasan",
+  "mint.rankByScore": "#{rank} berdasarkan skor",
+  "mint.tagLightning": "Lightning",
+  "mint.summary": "Ringkasan mint",
+  "mint.rating.label": "Rating komunitas",
+  "mint.rating.none": "Belum ada peringkat",
+  "mint.rating.reviews.one": "{n} ulasan",
+  "mint.rating.reviews.other": "{n} ulasan",
+  "mint.rating.unrated.one": "{n} tidak meninggalkan rating",
+  "mint.rating.unrated.other": "{n} tidak meninggalkan rating",
+  "mint.activity.label": "Aktivitas",
+  "mint.activity.since": "sejak ulasan terakhir",
+  "mint.activity.noReviews": "belum ada ulasan",
+  "mint.activity.recent.one": "{n} ulasan dalam 90 hari terakhir",
+  "mint.activity.recent.other": "{n} ulasan dalam 90 hari terakhir",
+  "mint.limits.label": "Batas",
+  "mint.limits.notPublished": "tidak diterbitkan",
+  "mint.limits.min": "min",
+  "mint.limits.max": "max",
+  "mint.limits.mintRow": "mint",
+  "mint.limits.meltRow": "melt",
+  "mint.limits.disabled": "dinonaktifkan",
+  "mint.limits.range": "{min} ke {max} {unit}",
+  "mint.limits.upTo": "hingga {max} {unit}",
+  "mint.limits.from": "dari {min} {unit}",
+  "mint.software.label": "Perangkat lunak mint",
+  "mint.software.unknown": "tidak diketahui",
+  "mint.checked": "diperiksa {when}",
+  "mint.lastSeen": "terakhir terlihat {when}",
+  "mint.neverReached": "tidak pernah dicapai",
+  "mint.uptime.checks": "{ok} dari pemeriksaan {total} terakhir yang dapat dicapai",
+  "mint.uptime.percent": "{percent}% dapat dicapai lebih dari 30 hari",
+  "mint.uptime.description": "{ok} dari pemeriksaan {total} terakhir berhasil",
+  "mint.operator.title": "Dari operator",
+  "mint.operator.motd": "Pesan hari ini",
+  "mint.operator.beta": "Mint ini menggambarkan dirinya sebagai percobaan atau dalam beta. Baca kata-kata operator sendiri di bawah ini sebelum menyimpan apa pun yang Anda tidak dapat kehilangan.",
+  "mint.nuts.title": "NUTs yang didukung",
+  "mint.nuts.noneOffline": "Tidak ada daftar NUT cached untuk mint ini, itu pergi offline sebelum salah satu direkam.",
+  "mint.nuts.noneYet": "Belum ada daftar NUT yang di-cache untuk mint ini.",
+  "mint.nuts.supported": "{n} dari {total} NUTs yang dikenal didukung",
+  "mint.nuts.whatAre": "apa itu NUTs?",
+  "mint.nutRow.disabled": "dinonaktifkan",
+  "mint.nutRow.notSupported": "tidak didukung",
+  "mint.details.title": "Rincian mint",
+  "mint.details.pubkey": "Pubkey",
+  "mint.details.nostr": "Nostr",
+  "mint.details.email": "Surel",
+  "mint.details.serverTime": "Waktu server",
+  "mint.details.firstSeen": "Pertama terlihat",
+  "mint.details.terms": "Ketentuan",
+  "mint.kind.identifier": "pengidentifikasi",
+  "mint.kind.mintPubkey": "mint pubkey",
+  "mint.kind.nostrAddress": "Alamat Nostr",
+  "mint.kind.emailAddress": "alamat email",
+  "mint.kind.npub": "npub",
+  "mint.disclaimer": "Mint ini kustodian: ia memegang uang Anda, dan dapat berhenti melakukannya setiap saat. Rating adalah pendapat masyarakat dan online berarti terjangkau, tidak dapat dipercaya.",
+  "mint.disclaimerLink": "Baca pengungkapan penuh",
+  "mint.qr.title": "Tambahkan {name} ke dompet Anda",
+  "mint.qr.note": "Pindai ini dengan dompet Cashu untuk menambahkan mint, atau salin URL dan tempelkan.",
+  "mint.qr.warn": "Menambahkan mint berarti percaya dengan uang Anda.",
+  "mint.qr.whatMeans": "Apa artinya",
+  "mint.qr.wallets": "Dompet yang mendukung Cashu",
+  "mint.chip.frozen": "Beku",
+  "mint.chip.noWithdrawals": "Tidak ada penarikan",
+  "mint.chip.meltOnly": "Hanya Melt",
+  "mint.warnings.dayCount.one": "Hari {n}",
+  "mint.warnings.dayCount.other": "{n} hari",
+  "mint.warnings.gone.lead": "Sepertinya sudah pergi.",
+  "mint.warnings.gone.body.since": "Mint ini tak bisa dihubungi sejak {date} ({days}). Perlakukan dana yang diselenggarakan di sana sebagai risiko, dan tidak mengirim dana baru. Rincian di bawah ini menunjukkan keadaan terakhir yang diketahui.",
+  "mint.warnings.gone.body.neverDated": "Mint ini belum menjawab satu cek sejak kami mulai menonton di {month}. Perlakukan dana yang diselenggarakan di sana sebagai risiko, dan tidak mengirim dana baru. Apa pun di bawah ini berasal dari pengumuman Nostr, bukan dari mint.",
+  "mint.warnings.gone.body.never": "Mint ini belum menjawab satu cek sejak kami mulai menonton itu. Perlakukan dana yang diselenggarakan di sana sebagai risiko, dan tidak mengirim dana baru. Apa pun di bawah ini berasal dari pengumuman Nostr, bukan dari mint.",
+  "mint.warnings.gone.meta.since": "Offline sejak {date}",
+  "mint.warnings.gone.meta.never": "Tidak pernah bisa dihubungi sejak ditemukan",
+  "mint.warnings.meltDisabled.lead": "Withdrawal dinonaktifkan.",
+  "mint.warnings.meltDisabled.body.online": "Mint ini telah lelehan Lightning (NUT-05) dimatikan: Anda dapat menempatkan SAT di, tetapi Anda tidak dapat menarik mereka melalui Lightning. Jangan deposito sampai mencair kembali.",
+  "mint.warnings.meltDisabled.body.offline": "Mint ini telah Lightning mencair (NUT-05) dimatikan: Anda dapat menempatkan SAT di, tetapi Anda tidak dapat menarik mereka melalui Lightning. Jangan deposito sampai mencair kembali.",
+  "mint.warnings.meltDisabled.meta.online": "withdrawal saat ini tidak aktif",
+  "mint.warnings.meltDisabled.meta.offline": "withdrawals dimatikan ketika terakhir terlihat",
+  "mint.warnings.frozen.lead": "Mint beku.",
+  "mint.warnings.frozen.body.online": "Minting dan melting keduanya dinonaktifkan. Tidak ada sats yang bisa masuk atau keluar lewat Lightning.",
+  "mint.warnings.frozen.body.offline": "Minting dan melting keduanya dinonaktifkan. Tidak ada sats yang bisa masuk atau keluar lewat Lightning.",
+  "mint.warnings.frozen.meta.online": "Saat ini membeku, tidak ada yang bergerak masuk atau keluar",
+  "mint.warnings.frozen.meta.offline": "Membeku ketika terakhir terlihat",
+  "mint.warnings.offlineLong.lead": "Offline untuk {days}, sejak {date}.",
+  "mint.warnings.offlineLong.body": "Mint mungkin hilang. Segala sesuatu di bawah ini adalah negara yang terakhir diketahui, dan ulasan masih bekerja.",
+  "mint.warnings.offlineLong.meta": "Offline sejak {date}",
+  "mint.warnings.meltOnly.lead": "Melt saja.",
+  "mint.warnings.meltOnly.body.online": "Minting baru (NUT-04) dinonaktifkan: Anda tidak dapat menyimpan, tapi ecash yang ada masih dapat ditarik. Ini sering berarti mint yang berliku ke bawah, jadi jika Anda memegang ecash nya, mempertimbangkan mencair.",
+  "mint.warnings.meltOnly.body.offline": "Minting baru (NUT-04) dinonaktifkan: Anda tidak dapat menyimpan, tapi ecash yang ada masih dapat ditarik. Ini sering berarti mint yang berliku ke bawah, jadi jika Anda memegang ecash nya, mempertimbangkan mencair.",
+  "mint.warnings.meltOnly.meta.online": "Saat ini hanya mencair",
+  "mint.warnings.meltOnly.meta.offline": "Melt hanya ketika terakhir terlihat",
+  "mint.warnings.offline.lead": "Offline sejak {date}.",
+  "mint.warnings.offline.body": "Rincian terakhir dikonfirmasi kemudian. Kau masih bisa menulis ulasan.",
+  "mint.warnings.offline.meta": "Offline sejak {date}",
+  "mint.warnings.also.meltDisabled": "Sebelum offline, juga ada penarikan yang dinonaktifkan.",
+  "mint.warnings.also.mintDisabled": "Sebelum offline itu juga dinonaktifkan baru minting.",
+  "mint.warnings.also.offline": "Ini juga telah offline sejak {date} ({days}).",
+  "nut.0": "Notasi dan model",
+  "nut.1": "Pertukaran kunci publik Mint",
+  "nut.2": "Tombol dan biaya",
+  "nut.3": "Bertukar token",
+  "nut.4": "Minting lewat Lightning",
+  "nut.5": "Penarikan melalui Lightning",
+  "nut.6": "Informasi Mint",
+  "nut.7": "Cek keadaan Token",
+  "nut.8": "Biaya Lightning yang kelebihan bayar",
+  "nut.9": "Kembalikan tanda tangan",
+  "nut.10": "Kondisi pemborosan",
+  "nut.11": "Bayar ke kunci publik",
+  "nut.12": "Bukti DLEQ",
+  "nut.13": "Rahasia deterministik",
+  "nut.14": "Kontrak timelock hashed",
+  "nut.15": "Pembayaran multipath",
+  "nut.16": "Kode QR animasi",
+  "nut.17": "Subscriptions WebSocket",
+  "nut.18": "Permintaan pembayaran",
+  "nut.19": "Respon cached",
+  "nut.20": "Kutipan mint tertanda",
+  "nut.21": "Bersihkan otentikasi",
+  "nut.22": "Otentikasi buta",
+  "nut.23": "Metode pembayaran BOLT11",
+  "nut.24": "Pembayaran HTTP 402 diperlukan",
+  "nut.25": "Metode pembayaran BOLT12",
+  "reviews.title": "Ulasan",
+  "reviews.anon": "Anon",
+  "reviews.anonTitle": "Tak ada profil publik Nostr yang ditemukan untuk kunci ini",
+  "reviews.nip05Title": "Identifier NIP-05 (tidak diverifikasi oleh situs ini)",
+  "reviews.filter.group": "Penyaring ulasan",
+  "reviews.filter.all": "Semua",
+  "reviews.filter.five": "5★",
+  "reviews.filter.critical": "Kritis",
+  "reviews.filter.recent": "Terkini",
+  "reviews.filter.hideAnon": "Sembunyikan Anon",
+  "reviews.anonHidden.other": "Menampilkan {n} dari {total} ulasan: ulasan anonim disembunyikan.",
+  "reviews.allAnon.one": "Satu-satunya ulasan di sini adalah anon.",
+  "reviews.allAnon.other": "Semua ulasan {n} di sini adalah anon.",
+  "reviews.allAnonShow.one": "Tampilkan",
+  "reviews.allAnonShow.other": "Tunjukkan pada mereka.",
+  "reviews.loading.one": "Memuat {n} ulasan dari relay Nostr",
+  "reviews.loading.other": "Memuat {n} ulasan dari relay Nostr",
+  "reviews.empty": "Belum ada ulasan. Jadilah orang pertama yang menulis.",
+  "reviews.emptyWritten": "Belum ada ulasan tertulis di sini. Jadilah orang pertama yang menulis.",
+  "reviews.emptyFilter": "Tidak ada ulasan yang cocok dengan filter ini.",
+  "reviews.rate.cashu": "Beri rating mint ini",
+  "reviews.rate.fedimint": "Beri rating federasi ini",
+  "reviews.rate.lnurl": "Beri rating mint ini",
+  "reviews.noscript": "Ulasan ditandatangani pada Nostr dan muat dalam peramban Anda, jadi daftar ini membutuhkan JavaScript. Rating dan jumlah di atas berasal dari situs itu sendiri.",
+  "reviews.relayError": "Tidak bisa mencapai relay. Ulasan mungkin tidak lengkap.",
+  "reviews.srRating": "{rating} dari 5",
+  "reviews.srNoRating": "Tak ada peringkat yang diberikan",
+  "reviews.readMore": "Baca lagi.",
+  "reviews.readLess": "Tampilkan kurang",
+  "reviews.actions.copyNpub": "Salin npub",
+  "reviews.actions.openNostr": "Tilik acara ini pada Nostr",
+  "reviews.actions.copyLink": "Salin taut ke ulasan ini",
+  "reviews.anonNote": "Ulasan pertama dari npub ini, tidak ada aktivitas lain ditemukan",
+  "reviews.published": "Diterbitkan.",
+  "reviews.publishedPartial": "Diterbitkan ke {accepted} dari {total} relay.",
+  "reviews.propagating": "Mempublikasikan ke relay Nostr",
+  "reviews.summary.line.one": "Rating {count} tanpa komentar: {breakdown}",
+  "reviews.summary.line.other": "Rating {count} tanpa komentar: {breakdown}",
+  "reviews.summary.lineDay.one": "{count} rating tanpa komentar di {when}: {breakdown}",
+  "reviews.summary.lineDay.other": "{count} peringkat tanpa komentar tentang {when}: {breakdown}",
+  "reviews.summary.showOne": "Tampilkan",
+  "reviews.summary.showMany": "Tunjukkan pada mereka.",
+  "reviews.breakdown.5": "Bintang 5 {n}",
+  "reviews.breakdown.4": "{n} empat bintang",
+  "reviews.breakdown.3": "{n} tiga bintang",
+  "reviews.breakdown.2": "{n} dua bintang",
+  "reviews.breakdown.1": "{n} satu bintang",
+  "reviews.breakdown.none": "{n} tanpa rating",
+  "reviews.dialog.title": "Ulasan {name}",
+  "reviews.dialog.lede.cashu": "Bagikan pengalaman Anda dengan mint ini.",
+  "reviews.dialog.lede.fedimint": "Bagikan pengalaman Anda dengan federasi ini.",
+  "reviews.dialog.lede.lnurl": "Bagikan pengalaman Anda dengan mint ini.",
+  "reviews.dialog.permanent": "Diterbitkan secara permanen ke relay Nostr publik.",
+  "reviews.dialog.gate.title": "Masuk untuk menulis ulasan",
+  "reviews.dialog.gate.lead": "Ulasan ditandatangani dengan kunci Nostr Anda. Kunci tetap di penandatangan Anda, situs ini tidak pernah melihatnya.",
+  "reviews.dialog.ratingLegend": "Rating Anda",
+  "reviews.dialog.starsSr.one": "Bintang {n}",
+  "reviews.dialog.starsSr.other": "Bintang {n}",
+  "reviews.dialog.chooseRating": "Pilih sebuah rating",
+  "reviews.dialog.starLabel": "{n}: {phrase}",
+  "reviews.dialog.stars.1": "Menghindarinya",
+  "reviews.dialog.stars.2": "memiliki masalah",
+  "reviews.dialog.stars.3": "berfungsi, dengan catatan",
+  "reviews.dialog.stars.4": "baik",
+  "reviews.dialog.stars.5": "Kerja bagus.",
+  "reviews.dialog.bodyLabel": "Apa yang harus orang lain tahu?",
+  "reviews.dialog.charCount": "{n} / {max}",
+  "reviews.dialog.submit": "Tandatangani dan terbitkan",
+  "reviews.dialog.signing": "Tanda tangan...",
+  "reviews.dialog.publishing": "Penerbitan...",
+  "reviews.dialog.publishingTo": "Penerbitan ke relay ({accepted} / {total})",
+  "reviews.dialog.waitingExtension": "Menunggu ekstensi Anda",
+  "reviews.dialog.waitingSigner": "Menunggu penandamu",
+  "reviews.dialog.confirmClose": "Tutup ulasan ini? Draf Anda disimpan sampai Anda meninggalkan situs.",
+  "reviews.dialog.why.login": "Log masuk untuk mempublikasikan",
+  "reviews.dialog.why.words": "Tulis beberapa kata",
+  "reviews.dialog.why.more.one": "{n} lebih banyak karakter",
+  "reviews.dialog.why.more.other": "{n} lebih banyak karakter",
+  "reviews.dialog.why.over.one": "{n} karakter di atas batas",
+  "reviews.dialog.why.over.other": "{n} karakter di atas batas",
+  "reviews.dialog.identity.needSigner": "Anda perlu penandatangan Nostr untuk mempublikasikan. Kunci Anda tetap di dalamnya, situs ini tidak pernah melihatnya.",
+  "reviews.dialog.identity.loginToPublish": "Log masuk untuk mempublikasikan",
+  "reviews.dialog.identity.switch": "Tukar",
+  "reviews.dialog.identity.extension": "Menandatangani dengan ekstensi peramban Anda",
+  "reviews.dialog.identity.readingKey": "Membaca kunci publikmu...",
+  "reviews.dialog.identity.willAsk": "Ekstensi Anda akan diminta untuk menandatangani",
+  "reviews.dialog.error.noRelay": "Tidak ada relay diterima ulasan. Periksa koneksimu, lalu coba lagi.",
+  "reviews.validate.rating": "Pilih peringkat 1 sampai 5 bintang.",
+  "reviews.validate.short": "Tulis setidaknya karakter {n} sehingga ulasan berguna.",
+  "reviews.validate.long": "Ulasan terbatas pada karakter {n}.",
+  "feed.title": "Ulasan mint dan federasi terbaru · Cashumints.space",
+  "feed.description": "Setiap ulasan mint, federasi, dan mint LNURL begitu dipublikasikan: {reviews} ulasan atas {mints} mint Cashu, {federations} federasi Fedimint, dan {lnurl} mint LNURL, ditandatangani di Nostr dan dapat dibaca di sini mulai dari yang terbaru. Saring berdasarkan ekosistem, penilaian, atau nama.",
+  "feed.heading": "Ulasan Terbaru",
+  "feed.lede": "Setiap ulasan dari setiap Cushu mint dan Fedimint federation, terbaru pertama, membaca langsung dari relays Nostr. Masing-masing ditandatangani oleh penulis dan tinggal di relay, tidak dalam database kami.",
+  "feed.label": "Ulasan",
+  "feed.showingBuild.one": "Menampilkan ulasan terbaru dari bangunan terakhir",
+  "feed.showingBuild.other": "Menampilkan {n} ulasan terbaru dari bangunan terakhir",
+  "feed.noscript": "Ulasan ditandatangani pada Nostr dan muat dalam peramban Anda, jadi penyaringan dan daftar lengkap membutuhkan JavaScript. Ulasan {n} di bawah ini dibaca dari relay ketika halaman ini dibangun.",
+  "feed.emptyBuild": "Tidak ada ulasan yang dapat dibaca dari relay ketika halaman ini dibangun. Daftar dimuat ulang dari relay dalam browser Anda.",
+  "feed.foot": "Ulasan adalah pendapat masyarakat, tidak diverifikasi klaim. Baca {link} sebelum Anda mempercayai mint dengan uang.",
+  "feed.footLink": "displaimer",
+  "feed.showing": "Menampilkan ulasan {shown} dari {total}",
+  "feed.showingMatching": "Menampilkan {shown} dari {matching} pencocokan ulasan ({total} secara total)",
+  "feed.emptyRelays": "Tidak ada ulasan yang kembali dari relay. Buka setiap halaman mint untuk membaca dan menulis ulasan di sana.",
+  "feed.emptyFilter": "Tidak ada ulasan yang cocok dengan filter ini. Bersihkan kotak mint, atau coba All.",
+  "feed.relayError": "Tidak bisa mencapai relay. Menampilkan ulasan dari bangunan terakhir.",
+  "feed.relayEmpty": "Tidak ada ulasan yang kembali dari relay. Menampilkan ulasan dari bangunan terakhir.",
+  "feed.reading": "Membaca relay...",
+  "login.open": "Masuk",
+  "login.title": "Log in dengan Nostr",
+  "login.note": "Kunci Anda tetap di signer Anda. Situs ini tidak pernah bisa melihatnya.",
+  "login.extension.name": "Ekstensi peramban",
+  "login.extension.desc": "Tanda tangani dengan Alby, nos2x atau ekstensi NIP-07 lainnya",
+  "login.extension.none": "Ekstensi tak ditemukan",
+  "login.extension.getOne": "Dapatkan satu:",
+  "login.remote.name": "Penandatangan jarak jauh",
+  "login.remote.desc": "Pindai kode dengan aplikasi signer, atau paste sebuah link bunker",
+  "login.primal.name": "Primal",
+  "login.primal.desc": "Atur log masuk pada aplikasi Primal pada ponsel Anda",
+  "login.paste.label": "Atau paste link koneksi signer Anda memberi Anda",
+  "login.copyLink": "Salin taut sambungan",
+  "login.whatIsNostr": "Apa itu Nostr?",
+  "login.connect.remote.title": "Hubungkan suatu penandatangan remote",
+  "login.connect.remote.lead": "Pindai ini dengan aplikasi signer Anda, atau salin link dan paste di sana.",
+  "login.connect.remote.hint": "Bekerja dengan penandatanganan NIP-46: nsec.app, Amber, Nostrify, bunker Anda sendiri.",
+  "login.connect.remote.open": "Buka di aplikasi signer Anda",
+  "login.connect.primal.title": "Hubungkan dengan Primal",
+  "login.connect.primal.lead": "Buka Primal di ponsel Anda, temukan penandatanganan jarak jauh di pengaturan, dan pindai kode ini.",
+  "login.connect.primal.hint": "Tanda-tanda utama bagi aplikasi lain melalui NIP-46, jadi ini adalah koneksi yang sama yang digunakan penandatangan, dan kunci Anda tetap di Primal. {link}",
+  "login.connect.primal.open": "Buka di Primal",
+  "login.status.buildingLink": "Membangun link koneksi",
+  "login.status.waitingExtension": "Menunggu ekstensi Anda",
+  "login.status.waitingSigner": "Menunggu penandamu",
+  "login.status.connecting": "Menyambung ke penandatangan Anda",
+  "login.status.connected": "Terhubung",
+  "login.toast.loggedIn": "Berhasil masuk",
+  "login.toast.fetchingProfile": "Mengambil profil Nostr Anda dari relay…",
+  "login.toast.profile": "Profil: {name}",
+  "login.toast.noProfile": "Tidak ada profil yang ditemukan di relay",
+  "login.method.extension": "Ekstensi",
+  "login.method.remote": "Jauh",
+  "login.method.primal": "Primal",
+  "login.account": "Akun Nostr Anda",
+  "login.copyNpub": "Salin npub lengkap Anda",
+  "login.logout": "Keluar",
+  "signer.status.waitingExtension": "Menunggu ekstensi Anda",
+  "signer.status.signed": "Ditandatangani",
+  "signer.status.reconnecting": "Menyambung kembali ke penandatangan Anda",
+  "signer.status.approveWindow": "Penandatangan Anda membutuhkan Anda untuk menyetujui ini di jendela sendiri",
+  "signer.status.waitingSigner": "Menunggu penandamu",
+  "signer.status.stillWaiting": "Masih menunggu penandamu menjawab.",
+  "signer.status.connected": "Terhubung",
+  "signer.error.noExtension": "Tidak ditemukan ekstensi penandatanganan. Pasang Alby atau nos2x, lalu isi ulang halaman ini.",
+  "signer.error.privateKey": "Yang terlihat seperti kunci pribadi, bukan link koneksi. Situs ini tidak pernah mengambil kunci. Tempel bunker: / / link signer Anda memberi Anda.",
+  "signer.error.badLink": "Itu bukan link koneksi situs ini mengerti. Paste bunker: / / link dari signer Anda.",
+  "signer.error.noAnswer": "Signer Anda tidak menjawab. Mungkin ditutup, atau relay nya mungkin turun. Buka dan coba lagi.",
+  "signer.error.timeout": "Penandamu tidak menjawab tepat waktu. Buka, periksa masih terhubung, lalu coba lagi.",
+  "signer.error.cancelled": "Koneksi dibatalkan.",
+  "signer.error.declined": "Permintaan tanda tangan ditolak",
+  "notfound.title": "Halaman tidak ditemukan · Cashumints.space",
+  "notfound.description": "Halaman itu tidak ada di angkasa Cashumints.space.",
+  "notfound.heading": "Halaman ini tidak ada",
+  "notfound.lede": "Ini mungkin telah pindah, atau mint mungkin belum diindeks. Cari sebuah mint dengan nama atau domain, atau paste sebuah URL mint.",
+  "notfound.browse": "Jelajahi semua mint",
+  "notfound.home": "Pulanglah.",
+  "notfound.loading": "Memuat {host}",
+  "notfound.fb.rating": "Rating",
+  "notfound.fb.reviews": "Ulasan",
+  "notfound.fb.software": "Perangkat Lunak",
+  "notfound.fb.lastOnline": "Online terakhir",
+  "notfound.fb.note": "Mint ini diindeks setelah situs terakhir dibangun, jadi ini ringkasan dari API langsung, dengan ulasannya di bawah. Halaman lengkapnya muncul pada pembangunan berikutnya.",
+  "notfound.resolve.checking": "Kunjungan pertama: mint ini sedang diperiksa.",
+  "notfound.resolve.failed": "Mint ini tidak bisa ditambahkan",
+  "notfound.resolve.failedFedimint": "Federasi ini tidak bisa ditambahkan",
+  "notfound.resolve.retry": "Coba alamat lain",
+  "notfound.resolve.switch": "Buka sebagai mint {kind}",
+  "notfound.resolve.fedimint": "Alamat halaman sebuah federasi tidak memuat kode undangannya, jadi yang ini tidak bisa dicari hanya dari tautannya. Tempel kode undangannya dan federasi itu ditambahkan.",
+  "notfound.resolve.ambiguous": "Alamat ini tidak bisa disimpulkan hanya dari tautannya. Tempel URL lengkap mint itu dan mint itu ditambahkan.",
+  "wallets.title": "Dompet Cashu · Cashumints.space",
+  "wallets.description": "Dompet Cashu yang bekerja dengan mint yang terdaftar di sini, di ponsel, web, peramban, dan baris perintah, beserta keunggulan masing-masing.",
+  "wallets.heading": "Dompet",
+  "wallets.lede": "Kamu butuh dompet untuk menyimpan ecash dari salah satu mint ini. Kebanyakan dompet bicara dengan beberapa mint sekaligus, jadi kamu tidak terikat pada yang pertama kamu coba.",
+  "wallets.note": "Daftar ini tidak melelahkan dan bukan dukungan. Proyek Cashu menyimpan indeks yang lebih luas di {link}. Dompet memegang kunci, mint memegang uang: membaca ulasan mint sebelum Anda memilih di mana Anda sats hidup.",
+  "wallets.platform.android": "Android",
+  "wallets.platform.ios": "iOS",
+  "wallets.platform.web": "Web",
+  "wallets.platform.extension": "Ekstensi peramban",
+  "wallets.platform.cli": "CLI",
+  "wallets.platform.python": "Python",
+  "wallets.item.minibits": "Dompet ecash Mobile dengan mint sendiri, Lightning alamat dukungan dan Nostr kontak.",
+  "wallets.item.nutstash": "Dompet peramban yang menangani beberapa mint sekaligus serta mengimpor dan mengekspor token mentah.",
+  "wallets.item.enuts": "Dompet mobil difokuskan pada saldo multimint dan mengirim e cash atas Nostr.",
+  "wallets.item.cashume": "Referensi dompet web dari proyek Cashu. Berjalan sepenuhnya dalam browser, dipasang sebagai PWA.",
+  "wallets.item.boardwalk": "Dompet web yang dibangun di sekitar alamat Lightning dan mengirim e-cash melalui link.",
+  "wallets.item.coinos": "Dompet petir dan titik penjualan yang juga menjalankan sendiri mint Cashu.",
+  "wallets.item.oxchat": "Messenger Nostr dengan dompet ecash bawaan, untuk mengirim sats di dalam obrolan.",
+  "wallets.item.nutshell": "Referensi implementasi. Berjalan sebagai dompet di baris perintah dan sebagai perangkat lunak mint.",
+  "about.title": "Tentang Cashumints.space",
+  "about.description": "Apa itu Cashu, apa yang sebenarnya dipegang sebuah mint, apa itu NIP-87, dan bagaimana situs ini mengindeks mint dan membaca ulasan dari relay Nostr.",
+  "about.heading": "Tentang",
+  "about.lede": "Cashumints.space daftar setiap mint Cashu kita dapat menemukan pada jaringan Nostr dan menunjukkan apa yang orang katakan tentang mereka. Ini dibuat oleh Azzamo.",
+  "about.cashu.title": "Apa itu Cashu?",
+  "about.cashu.p1": "Cashu adalah protokol untuk Bitcoin. Sebuah isu mint buta token didukung oleh sats itu memegang, dan tanda-tanda bergerak antara orang tanpa pembelajaran mint yang dikirim apa kepada siapa. privasi itu nyata dan itu adalah titik: token bukan rekening, dan mint tidak dapat menghubungkan token itu ditandatangani ke token yang datang kembali.",
+  "about.cashu.p2": "Anda dapat membaca protokol dan spesifikasinya di {link}. Spesifikasi sendiri disebut NUTS, yang mana angka NUT pada setiap halaman mint berasal.",
+  "about.mints.title": "Apa mint adalah, dan tradeoff",
+  "about.mints.p1": "Mint bersifat kustodial. Saat kamu minting ecash, kamu menyerahkan sats kepada siapa pun yang menjalankan server itu, dan kamu percaya mereka akan menghormati token itu saat kamu melt kembali. Tidak ada bukti penipuan, tidak ada escrow, dan tidak ada jalan banding. Operator mint bisa menghilang bersama saldonya, dan itu sudah pernah terjadi.",
+  "about.mints.p2": "Itulah mengapa ulasan ada di sini. Situs ini tidak pernah memberitahu Anda mint aman. Status pada halaman mint mengatakan {code}, bukan \"dipercaya\", dan itu hanya berarti server menjawab ketika kita terakhir bertanya. Perlakukan keseimbangan ecash seperti uang tunai dalam saku mantel: baik untuk pengeluaran, salah untuk tabungan.",
+  "about.nip87.title": "Apa itu NIP-87?",
+  "about.nip87.p1": "NIP-87 adalah konvensi Nostr untuk mengumumkan dan merekomendasikan cash mint. Dua peristiwa jenis materi di sini:",
+  "about.nip87.li1": "{code} mengumumkan sebuah mint. URL mint ada di tag {tag}. Beginilah situs ini menemukan mint yang belum pernah dilihatnya.",
+  "about.nip87.li2": "{code} adalah ulasan. Ini membawa peringkat dan teks tinjauan, dan poin pada mint itu adalah tentang dengan tag {utag} (URL mint) dan tag {dtag} (mint sendiri kunci publik).",
+  "about.nip87.p2": "Setiap ulasan ditandatangani oleh kunci Nostr penulisnya. Kami tidak pernah menyebut ulasan \"diverifikasi\", karena tidak ada yang diverifikasi: itu ditandatangani, yang merupakan klaim yang berbeda dan lebih berguna. Ini berarti Anda dapat memeriksa siapa yang menulis itu dan bahwa itu tidak berubah. Ini tidak berarti penulis adalah jujur atau pernah digunakan mint.",
+  "about.how.title": "Bagaimana situs ini bekerja",
+  "about.how.p1": "Ada dua putaran dan satu aturan. Aturannya adalah bahwa mint memiliki metadata dan Nostr memiliki ulasan, sehingga situs ini menyimpan baik sebagai otoritas.",
+  "about.how.li1": "{strong} meminta setiap mint yang diketahui untuk {code} setiap sepuluh menit dan mencatat apa yang tertulis: nama, deskripsi, versi, didukung NUTS, batas, rincian kontak. Ini juga mencatat apakah mint menjawab sama sekali, yang mana adalah di mana uptime berasal.",
+  "about.how.li1Label": "Siklus pemeriksaan",
+  "about.how.li2": "{strong} terhubung ke Nostr relays setiap jam, membaca pengumuman mint dan ulasan, dan menambahkan setiap mint itu belum terlihat sebelumnya.",
+  "about.how.li2Label": "Siklus penemuan",
+  "about.how.p2": "Bagian yang penting adalah apa yang terjadi ketika mint berhenti menjawab. Metadata cached nya tidak pernah ditimpa oleh probe gagal, sehingga mint mati terus halaman penuh: spesifikasi, sejarah dan tinjauan, dengan spanduk mengatakan ketika pergi gelap. Versi sebelumnya dari situs ini menunjukkan halaman kesalahan, yang berarti orang-orang mint yang paling diperlukan untuk memperingatkan satu sama lain tentang adalah orang-orang yang tidak dapat ditinjau. Itu adalah alasan utama untuk membangun kembali.",
+  "about.how.p3": "Teks Ulasan tidak pernah disimpan di pihak kita. Ketika Anda membuka halaman mint presentasi browser Anda ke relay secara langsung dan membaca ulasan itu sendiri, dan ketika Anda menulis satu itu ditandatangani oleh ekstensi Nostr Anda sendiri dan dikirim langsung ke relay tersebut. Kami terus menghitung sehingga halaman dapat peringkat dan diurutkan, tidak lebih. Tidak ada di sini yang dapat disunting atau dihapus oleh kami, termasuk ulasan yang tidak kami miliki.",
+  "about.relays.title": "Relay kita baca",
+  "about.relays.p1": "Ini adalah relay pengindexer dan peramban Anda berdua menggunakan:",
+  "about.relays.p2": "Tunjukkan setiap klien Nostr pada relay yang sama dan Anda akan melihat peristiwa yang sama. Itu adalah seluruh janji: tidak ada di sini hanya benar karena kita mengatakan begitu.",
+  "about.nuts.title": "Apa itu NUTS?",
+  "about.nuts.p1": "NUTs adalah spesifikasi Cashu yang bernomor, seperti BIP untuk Bitcoin. Sebuah mint mengumumkan mana saja yang diterapkannya, dan itu memberitahumu apa yang sebenarnya bisa dilakukannya: NUT-04 dan NUT-05 adalah minting dan melting lewat Lightning (tanpa keduanya sebuah mint tidak banyak gunanya), NUT-07 memungkinkan dompet memeriksa apakah sebuah token sudah terpakai, NUT-17 memberi dompet pembaruan langsung lewat WebSockets alih-alih polling, dan NUT-20 memungkinkan dompet membuktikan bahwa sebuah mint quote memang diterbitkan untuknya. Daftar lengkapnya ada di {link}.",
+  "about.numbers.title": "Sekarang",
+  "about.numbers.p1": "{mints} mint diindeks, {online} dari mereka menjawab, {reviews} ulasan dihitung dari relay di atas.",
+  "about.source.title": "Sumber dan kredit",
+  "about.source.p1": "Situs ini open source di {github}. Dibangun dan dijalankan oleh {azzamo}. Jika halaman mint memiliki sesuatu yang salah di atasnya, memperbaikinya di sumber: metadata mint berasal dari mint sendiri {code}, dan ulasan berasal dari Nostr.",
+  "terms.title": "Ketentuan penggunaan · Cashumints.space",
+  "terms.description": "Hukuman penggunaan bagi Cashumints.space: apa situs ini, apa yang tidak dilakukan, dan siapa yang bertanggung jawab untuk apa. Tidak ada rekening, tidak ada jaminan, tidak ada afiliasi dengan mint.",
+  "terms.heading": "Kalimat penggunaan",
+  "terms.lede": "Istilah sederhana untuk situs yang hanya mengindeks data publik. Terakhir diperbarui {date}.",
+  "terms.what.title": "Apa situs ini",
+  "terms.what.p1": "Cashumints.space adalah sebuah indeks data publik yang tersedia tentang mints Cashu. Dua jenis data, baik dari tempat lain:",
+  "terms.what.li1": "Metadata Mint, dibaca dari masing-masing mint 's sendiri {code} titik akhir: nama, deskripsi, versi perangkat lunak, didukung NUTS, rincian kontak dan apakah mint menjawab ketika kita terakhir bertanya.",
+  "terms.what.li2": "Ulasan, dibaca dari relay Nostr publik. Ini adalah NIP-87 peristiwa yang diterbitkan oleh penulis mereka untuk menyampaikan siapa pun dapat query.",
+  "terms.what.p2": "Kami mengumpulkan data itu, menormalkannya, meningkatkannya dan menunjukkannya. Kami tidak menciptakannya.",
+  "terms.noAccounts.title": "Tidak ada rekening, tidak ada surat perintah",
+  "terms.noAccounts.p1": "Tidak ada yang mendaftar untuk. Situs ini disediakan seperti itu, tanpa garansi apapun: bukan bahwa data akurat, bukan bahwa itu saat ini, bukan bahwa situs akan tersedia. Data mint bisa menjadi menit atau jam tua, mint dapat berubah setelah kami terakhir memeriksa, dan relay dapat gagal menjawab, dalam hal ini Anda melihat kurang dari ada.",
+  "terms.noAccounts.p2": "Gunakan dengan resiko sendiri. Kami tidak bertanggung jawab atas kerugian apapun yang mengikuti dari menggunakan situs ini atau mengandalkan apa pun yang Anda baca di sini. Lihat {link} untuk risiko tertentu menggunakan mint Cashu.",
+  "terms.noAccounts.link": "displaimer",
+  "terms.noCustody.title": "Kami tidak memegang uang Anda",
+  "terms.noCustody.p1": "Situs ini tidak pernah mengambil hak asuh dana. Tidak memiliki dompet, tidak menyentuh e-cash, dan tidak bisa bergerak, membeku atau memulihkan apa pun. Jika Anda memiliki masalah dengan mint, operator mint adalah satu-satunya pihak yang dapat membantu Anda, dan kami tidak dapat menghubungi mereka atas nama Anda.",
+  "terms.noCustody.p2": "Kami tidak berafiliasi dengan setiap mint tercantum di sini, dan tidak ada mint membayar untuk daftar, peringkat atau ratingnya. Mints ditemukan dari publik Nostr pengumuman dan peringkat oleh algoritma atas data tinjauan publik.",
+  "terms.reviews.title": "Ulasan kata-kata orang lain",
+  "terms.reviews.p1": "Ulasan konten yang dihasilkan diterbitkan ke publik Nostr relay oleh penulis mereka. Kita menampilkannya, kita tidak mengendalikan mereka. Kami tidak menulis mereka, kami tidak dapat mengeditnya, dan kami tidak dapat menghapus mereka dari relay yang menahan mereka: mereka ditandatangani peristiwa pada jaringan yang tidak kita miliki.",
+  "terms.reviews.p2": "Ulasan adalah pengalaman seseorang, bukan fakta yang terverifikasi. Jika Anda menerbitkannya, Anda bertanggung jawab atas isinya. Jangan menerbitkan apa pun yang melanggar hukum, dan ingat bahwa apa yang Anda terbitkan bersifat publik dan permanen (lihat {link}).",
+  "terms.reviews.link": "halaman privasi",
+  "terms.reviews.p3": "Kita dapat berhenti menunjukkan ulasan spesifik di situs ini, dan kita akan melakukannya untuk konten yang melanggar hukum. Yang menghapus dari halaman ini saja. Acara ini tetap pada relay dan klien Nostr lainnya masih bisa membacanya.",
+  "terms.links.title": "Taut ke situs lain",
+  "terms.links.p1": "URL Mint, link dompet, operator kontak dan segala sesuatu yang menunjukkan off situs ini ada karena mereka adalah bagian dari data. Sebuah hubungan bukanlah dukungan dan kami tidak memeriksa apa yang ada di ujung lainnya.",
+  "terms.changes.title": "Perubahan",
+  "terms.changes.p1": "Istilah ini bisa berubah. Tanggal di atas mengatakan ketika mereka terakhir melakukannya. Situs ini open source, jadi setiap perubahan pada halaman ini ada dalam sejarah komit.",
+  "terms.contact.title": "Kontak",
+  "terms.contact.p1": "Masalah dan permintaan pengambilalihan paling baik diajukan pada {github}. Situs ini dijalankan oleh {azzamo}.",
+  "privacy.title": "Privasi · Cashumints.space",
+  "privacy.description": "Privasi pada Cashumints.space: tidak ada akun, tidak ada cookie pelacakan, tidak ada analitik. localStorage digunakan untuk caching profile dan tidak ada yang dikirim di mana saja. Ulasan ditandatangani dalam browser Anda sendiri.",
+  "privacy.heading": "Privasi",
+  "privacy.lede": "Kami mengumpulkan sesedikit situs web bisa. Terakhir diperbarui {date}.",
+  "privacy.noAccounts.title": "Tidak ada akun",
+  "privacy.noAccounts.p1": "Tidak ada tanda tangan, tidak ada login dan tidak ada profil. Tidak ada di situs ini yang menanyakan siapa Anda, dan tidak ada catatan pengguna yang bocor karena tidak ada pengguna.",
+  "privacy.noTracking.title": "Tidak ada kue pelacak, tidak ada analitis",
+  "privacy.noTracking.p1": "Situs ini tidak menetapkan cookie untuk pelacakan. Tidak ada skrip analitik, tidak ada manajer tag, tidak ada pixel, tidak ada rekaman sesi dan tidak ada jaringan iklan. Tidak ada di halaman laporan perilaku Anda kepada kami atau orang lain.",
+  "privacy.logs.title": "Log server",
+  "privacy.logs.p1": "Server web menyimpan log akses standar, yang merupakan apa yang dilakukan server web secara baku. Baris log mencatat alamat IP Anda, waktu, halaman yang Anda minta, status respons, dan agen pengguna dan referensi peramban Anda dikirim. Log ada pada kesalahan debug dan penyalahgunaan spot. Dan tidaklah sama antara yang lain dengan yang lain. Dan tidaklah sama antara mereka dengan orang-orang yang menjual dan tidak (pula) sama.",
+  "privacy.logs.operatorLabel": "Catatan Operator:",
+  "privacy.logs.operator": "Jika Anda menjalankan situs ini, negara retensi nyata Anda di sini. Penugasan dalam README menggunakan nginx dengan log akses baku dan rotasi apapun kapal distribusi Anda (pada Debian dan Ubuntu yang logrotasi, setiap hari, menjaga 14 hari). Konfirmasi apa yang server Anda lakukan dan ganti paragraf ini dengan nomor.",
+  "privacy.storage.title": "Apa yang tersimpan dalam peramban Anda",
+  "privacy.storage.p1": "Situs ini menggunakan LocalStorage untuk persis dua hal, yang keduanya tinggal di perangkat Anda dan tidak pernah dikirim ke mana saja:",
+  "privacy.storage.li1": "Sebuah singgahan metadata profil Nostr (jenis 0 kejadian: nama, avatar, alamat NIP-05) untuk peninjau-peninjau yang tinjauan-ulasan yang telah Anda lihat. Ini menyimpan re-query relay di setiap halaman. Entri berakhir, dan cache adalah capped dan diusir tertua pertama.",
+  "privacy.storage.li2": "Pilihan antar muka, sehingga situs berperilaku dengan cara yang sama waktu berikutnya.",
+  "privacy.storage.p2": "Membersihkan data situs browser Anda menghapus keduanya. Tidak ada yang rusak, pencarian profil hanya berjalan lagi.",
+  "privacy.thirdParties.title": "Apa pembicaraan browser Anda untuk",
+  "privacy.thirdParties.p1": "Memuat halaman yang menghubungkan peramban Anda ke beberapa tempat selain situs ini. Itulah bagaimana sebuah situs tanpa pelacakan sisi server- masih membaca data langsung:",
+  "privacy.thirdParties.li1Label": "Relay Nostr publik",
+  "privacy.thirdParties.li1": "{strong}, melalui WebSocket, untuk membaca ulasan dan profil peninjau. Relay melihat IP Anda dan apa yang Anda minta, sebagai server apapun yang Anda koneksi lakukan. Relay terdaftar di {link}.",
+  "privacy.thirdParties.li1Link": "tentang halaman",
+  "privacy.thirdParties.li2Label": "Gambar avatar Peninjau",
+  "privacy.thirdParties.li2": "{strong}, dimuat dari mana pun titik profil peninjau. Ini dikirim dengan kebijakan referensi no-, sehingga host tidak belajar yang halaman Anda berada di.",
+  "privacy.publishing.title": "Menerbitkan suatu ulasan",
+  "privacy.publishing.p1": "Menulis ulasan terjadi di browser Anda, bukan di server kami. Acara ini ditandatangani oleh ekstensi NIP-07 Anda (Alby, nos2x atau serupa) dan disiarkan dari browser Anda langsung ke relay. Kunci pribadi Anda tidak pernah meninggalkan ekstensi dan situs ini tidak pernah melihatnya. Kami tidak membangun manajemen kunci kustom dan kami tidak pernah meminta kunci atau frasa benih.",
+  "privacy.permanent.title": "Apa pun yang Anda mempublikasikan untuk Nostr adalah publik dan permanen",
+  "privacy.permanent.p1": "Ini adalah bagian yang layak dibaca dua kali. Ulasan adalah acara yang ditandatangani pada relay publik. Setelah itu keluar, itu keluar:",
+  "privacy.permanent.li1": "Siapapun bisa membacanya, sekarang dan nanti, menggunakan klien Nostr. Hal ini tidak \"publik pada Cashumints.space\", itu adalah publik pada jaringan.",
+  "privacy.permanent.li2": "Hal ini terkait permanen dengan kunci publik Nostr Anda, bersama segala sesuatu yang lain yang kunci pernah diterbitkan.",
+  "privacy.permanent.li3": "Menghapus itu adalah permintaan, bukan perintah. Anda dapat menerbitkan sebuah peristiwa penghapusan dan beberapa relay akan menghormatinya, tetapi relay bebas untuk mengabaikannya dan siapa pun yang sudah menyalin acara itu masih memilikinya. Perlakukan ulasan yang diterbitkan sebagai permanen.",
+  "privacy.permanent.li4": "Kami tak bisa menghapusnya untukmu. Kita bisa berhenti menunjukkannya di sini; itu tidak mengubah apa-apa pada relay.",
+  "privacy.permanent.p2": "Jika Anda ingin meninjau mint tanpa yang terikat dengan identitas utama Anda, menggunakan kunci Nostr terpisah. Perhatikan bahwa kunci tanpa aktivitas lain ditampilkan seperti pada ulasan kasar, karena kunci baru yang menulis tinjauan satu bintang adalah pembaca pola yang layak untuk dilihat.",
+  "privacy.contact.title": "Pertanyaan",
+  "privacy.contact.p1": "Situs ini terbuka: jika Anda ingin memeriksa salah satu di atas, baca kode di {github}. Pertanyaan dan koreksi dapat pergi dalam masalah di sana.",
+  "disclaimer.title": "Penafian · Cashumints.space",
+  "disclaimer.description": "Yang perlu diketahui sebelum kamu memakai mint Cashu: mint bersifat kustodial, sebuah mint bisa menghilang bersama uangmu, ulasan adalah pendapat, dan online berarti bisa dihubungi, bukan bisa dipercaya.",
+  "disclaimer.heading": "Discoverer",
+  "disclaimer.lede": "Baca ini sebelum Anda menempatkan uang dalam mint. Terakhir diperbarui {date}.",
+  "disclaimer.callout": "Sebuah mint Cashu memegang uang Anda untuk Anda. Jika itu menghilang, ecash Anda hilang, dan tidak ada orang untuk menarik. Simpan hanya apa yang Anda mampu untuk kehilangan.",
+  "disclaimer.custodial.title": "Mints adalah kustodian",
+  "disclaimer.custodial.p1": "Ketika Anda mint ecash, Anda tangan bitcoin ke operator mint dan mendapatkan token kembali. Token itu adalah klaim pada operator itu. Mereka bukan bitcoin yang Anda pegang, dan operator adalah orang yang memutuskan apakah untuk menghormati mereka.",
+  "disclaimer.custodial.p2": "Itu berarti setiap mint membawa risiko yang sama: operator dapat lenyap, dapat dipaksa untuk berhenti, dapat kehilangan dana melalui bug atau hack, atau hanya dapat mematikan server. Tidak ada asuransi deposit, tidak ada chargeback, tidak ada garis dukungan dan tidak ada jalur hukum yang layak diandalkan. Ini benar dari peringkat tertinggi mint di situs ini.",
+  "disclaimer.custodial.p3": "Cashu dirancang untuk jumlah kecil yang bergerak cepat. Pakai seperti itu: simpan yang akan segera kamu belanjakan, bukan tabunganmu, dan sebarkan ke beberapa mint alih-alih menaruh semuanya di satu tempat.",
+  "disclaimer.reviews.title": "Ulasan adalah pendapat, tidak diverifikasi klaim",
+  "disclaimer.reviews.p1": "Setiap ulasan di sini ditulis oleh seseorang di Nostr dan ditandatangani dengan kunci mereka. Ditandatangani berarti kita dapat memberitahu Anda kunci mana yang menulisnya. Ini tidak berarti ulasan benar, bahwa penulis menggunakan mint, atau bahwa penulis bukan operator, pesaing, atau satu orang dengan sepuluh kunci.",
+  "disclaimer.reviews.p2": "Kami tidak memverifikasi peninjau, dan kami tidak mengedit atau menghapus ulasan kita tidak setuju dengan. Baca beberapa, lihat apa yang sebenarnya mereka katakan, dan menimbang mint dengan tiga ulasan berbeda dari satu dengan tiga ratus.",
+  "disclaimer.status.title": "Online berarti dapat dicapai, tidak dapat dipercaya",
+  "disclaimer.status.p1": "Kami memeriksa setiap mint teratur dan menunjukkan apakah itu menjawab. Itu semua berarti status hijau: server menjawab. Ini mengatakan apa-apa tentang apakah operator adalah pelarut, jujur, atau masih berniat untuk menghormati token Anda besok.",
+  "disclaimer.status.p2": "Mint A bisa online sampai saat ini tidak. Uptime sejarah, didukung NUTS dan versi perangkat lunak memberitahu Anda sesuatu tentang bagaimana mint dijalankan, tapi tidak satupun dari mereka adalah janji tentang uang Anda.",
+  "disclaimer.ranking.title": "Bagaimana peringkat bekerja, dan apa itu tidak berarti",
+  "disclaimer.ranking.p1": "Mint diurutkan oleh sebuah algoritma atas data ulasan publik: rating, jumlah ulasan, dan aktivitas terbaru, dengan mint yang online di depan yang offline secara bawaan. Rinciannya ada di kode sumber terbuka.",
+  "disclaimer.ranking.p2": "Tidak ada yang membayar untuk penempatan. Tidak ada slot yang disponsori, tidak ada daftar promosi dan tidak ada pengaturan dengan setiap mint di situs ini. Peringkat tinggi berarti algoritma menyukai data publik, dan tidak lebih. Ini bukan rekomendasi dan bukan rating keamanan.",
+  "disclaimer.notAdvice.title": "Ini bukan saran keuangan.",
+  "disclaimer.notAdvice.p1": "Tidak ada di situs ini adalah keuangan, investasi, hukum atau nasihat pajak. Kami tidak tahu situasi Anda dan kami tidak menyarankan Anda. Menggunakan mint, dan memilih yang mana, adalah keputusanmu.",
+  "disclaimer.dyor.title": "Apakah penelitian Anda sendiri",
+  "disclaimer.dyor.li1": "Cari operator. Sebuah mint dijalankan oleh seseorang dengan reputasi publik kehilangan adalah proposisi yang berbeda dari URL anonim.",
+  "disclaimer.dyor.li2": "Baca istilah mint sendiri dan MOTD nya. Sebuah mint yang menyebut dirinya tes atau beta berarti itu.",
+  "disclaimer.dyor.li3": "Mulai dari kecil. Mint sedikit, belanjakan, melt kembali, dan lihat apa yang terjadi sebelum kamu memercayakan lebih banyak.",
+  "disclaimer.dyor.li4": "Perhatikan batasnya. Maksimum rendah sering merupakan tanda dari operator yang hati-hati, dan yang tinggi bukanlah tanda dari yang aman.",
+  "disclaimer.dyor.li5": "Dan kerjakanlah (amal yang baik) untuk dirimu, dan ketahuilah bahwa sesungguhnya tanda (Allah) itulah yang memberi (pahala) kepadanya.",
+  "disclaimer.site.title": "Tentang situs itu sendiri",
+  "disclaimer.site.p1": "Data di sini bisa salah atau keluar dari tanggal. Mints yang diperiksa pada jadwal, relay kadang-kadang gagal menjawab, dan halaman yang Anda baca dibangun di beberapa titik di masa lalu. Situs ini disediakan seperti itu, tanpa garansi. Lihat {link}.",
+  "disclaimer.site.link": "istilah penggunaan",
+  "disclaimer.updated": "20 Agustus 2026",
+  "login.getPrimal": "Dapatkan Primal",
+  "reviews.dialog.identity.extensionGone": "Ekstensi peramban Anda tidak menjawab. Masuk lagi, atau gunakan penandatangan jarak jauh.",
+  "seo.orgDescription": "Direktori mint Cashu, dengan status langsung dari tiap mint dan ulasan komunitas yang ditandatangani di Nostr.",
+  "seo.ogImageAlt": "Cashumints.space: temukan mint Cashu yang bisa kamu percaya.",
+  "seo.mint.title.one": "Ulasan {name}: dinilai {rating} dari {n} ulasan | Cashumints.space",
+  "seo.mint.title.other": "Ulasan {name}: dinilai {rating} dari {n} ulasan | Cashumints.space",
+  "seo.mint.titleOffline.one": "{name}: offline selama {n} hari | Cashumints.space",
+  "seo.mint.titleOffline.other": "{name}: offline selama {n} hari | Cashumints.space",
+  "seo.mint.titleNoReviews": "{name}: info dan ulasan mint Cashu | Cashumints.space",
+  "seo.fedimint.titleNoReviews": "{name}: info dan ulasan federasi Fedimint | Cashumints.space",
+  "seo.desc.fallback": "Ulasan komunitas untuk {name} ({domain}).",
+  "seo.desc.fallbackDomain": "Ulasan komunitas untuk mint Cashu di {domain}.",
+  "seo.desc.rated.one": "Dinilai {rating}/5 dari {n} ulasan Nostr yang ditandatangani.",
+  "seo.desc.rated.other": "Dinilai {rating}/5 dari {n} ulasan Nostr yang ditandatangani.",
+  "seo.desc.noReviews": "Belum ada ulasan.",
+  "seo.desc.status": "{status}.",
+  "seo.desc.statusLimits": "{status}, batas {limits}.",
+  "seo.desc.fedModules": "{status}. Modul: {modules}.",
+  "seo.desc.fedModulesNetwork": "{status}. Modul: {modules} pada {network}.",
+  "seo.mint.ogAlt.one": "{name}: {rating} bintang dari {n} ulasan di Cashumints.space",
+  "seo.mint.ogAlt.other": "{name}: {rating} bintang dari {n} ulasan pada Cashumints.space",
+  "seo.mint.ogAltNoReviews": "{name} di Cashumints.space",
+  "nav.home": "Beranda",
+  "mint.more.title": "Mint lainnya",
+  "mint.more.all": "Lihat semua mint",
+  "nav.fedimints": "Fedimints",
+  "status.announced": "Hanya diumumkan",
+  "card.unnamedFederation": "Federasi Tanpa Nama",
+  "card.notChecked": "tak pernah diperiksa",
+  "fedimints.title": "Semua federasi Fedimint · Cashumints.space",
+  "fedimints.description": "Semua {total} Fedimint federasi mengumumkan pada jaringan Nostr: {online} dikonfirmasi dijalankan oleh pemeriksaan luar, {announced} mengumumkan dan tidak pernah dikonfirmasi. Rating komunitas, modul dan kode undangan untuk masing-masing.",
+  "fedimints.heading": "Semua federasi",
+  "fedimints.lede": "Setiap federasi Fedimint mengumumkan pada jaringan Nostr. Sebuah federasi tidak memiliki status publik akhir sendiri, sehingga beberapa dari ini dikonfirmasi berjalan oleh cek luar dan sisanya terdaftar persis seperti yang diumumkan.",
+  "fedimints.search.label": "Cari federasi berdasarkan nama atau id",
+  "fedimints.search.placeholder": "Cari dengan nama atau id federasi...",
+  "fedimints.sort.label": "Urutkan federasi",
+  "fedimints.hideOffline": "Sembunyikan luring",
+  "fedimints.showing": "Menampilkan {total} federasi ({online} dikonfirmasi, {announced} hanya mengumumkan)",
+  "fedimints.showingFiltered": "Menampilkan {shown} dari {total} federasi ({online} dikonfirmasi, {announced} hanya mengumumkan)",
+  "fedimints.announcedNote.one": "Salah satu dari ini diumumkan pada Nostr dan tidak ada yang dikonfirmasi sejak itu berjalan. Hal ini terdaftar sebagai diumumkan daripada sebagai online atau offline, karena keduanya tidak akan benar.",
+  "fedimints.announcedNote.other": "{n} dari ini diumumkan pada Nostr dan tidak ada yang dikonfirmasi sejak bahwa mereka sedang berlari. Mereka terdaftar sebagai mengumumkan daripada sebagai online atau offline, karena keduanya tidak akan benar.",
+  "fedimints.noResults": "Tidak ada federasi yang cocok. Coba nama, atau paste ID federasi.",
+  "fedimints.emptyIndex": "Tidak ada federasi telah diumumkan pada relay situs ini membaca. Daftar itu mengisi dirinya sendiri sebagai pengumuman tiba.",
+  "fedimint.crumb": "Fedimints",
+  "fedimint.breadcrumb": "Breadcrumb",
+  "fedimint.unnamed": "Federasi Tanpa Nama",
+  "fedimint.idLabel": "Federasi",
+  "fedimint.kind.federationId": "Id federasi",
+  "fedimint.moduleCount.one": "Modul {n}",
+  "fedimint.moduleCount.other": "Modul {n}",
+  "fedimint.copyInvite": "Salin kode undangan",
+  "fedimint.confirmed.label": "Dikonfirmasi",
+  "fedimint.confirmed.never": "Tidak pernah",
+  "fedimint.confirmed.by": "oleh {source}",
+  "fedimint.confirmed.unattributed": "pemeriksaan terakhir",
+  "fedimint.announcedOn": "mengumumkan {when}",
+  "fedimint.announcedUnknown": "tidak ada tanggal pengumuman",
+  "fedimint.modules.title": "Modul",
+  "fedimint.modules.none": "Pengumuman federasi ini tidak ada daftar modul.",
+  "fedimint.modules.note": "Modules adalah bagian-bagian yang menjalankan federasi. Pengumuman mengatakan yang hadir, dan tidak tentang apakah salah satu dari mereka menerima deposito.",
+  "fedimint.modules.notListed": "tidak terdaftar",
+  "fedimint.invite.title": "Undang kode",
+  "fedimint.invite.count.one": "Kode {n}",
+  "fedimint.invite.count.other": "Kode {n}",
+  "fedimint.invite.note": "Tempelkan ini ke dalam dompet Fedimint untuk bergabung. Ini membawa ID federasi dan alamat penjaganya, dan itu dimaksudkan untuk dibagi.",
+  "fedimint.invite.kind": "kode invite",
+  "fedimint.invite.qr": "QR",
+  "fedimint.invite.qrCaption": "Pindai untuk bergabung dengan {name}",
+  "fedimint.details.federationId": "id Federasi",
+  "fedimint.details.network": "Jaringan",
+  "fedimint.details.announcedBy": "Diumumkan oleh",
+  "fedimint.details.announced": "Diumumkan",
+  "fedimint.more.title": "Federasi lagi",
+  "fedimint.more.all": "Lihat semua federasi",
+  "fedimint.disclaimer": "Bergabung dengan federasi berarti mempercayai penjaganya dengan uangmu. Rating adalah pendapat masyarakat, dan dikonfirmasi berjalan berarti dapat dicapai, tidak dapat dipercaya.",
+  "fedimint.module.lightning": "Lightning",
+  "fedimint.module.mint": "Ecash mint",
+  "fedimint.module.wallet": "Dompet On- chain",
+  "fedimint.module.meta": "Metadata",
+  "fedimint.module.stability_pool": "Kolam Stabilitas",
+  "fedimint.module.multi_sig_stability_pool": "Kolam Stabilitas (multisig)",
+  "fedimint.module.fedi-social": "Pemulihan sosial",
+  "fedimint.network.mainnet": "Bitcoin mainnet",
+  "fedimint.network.signet": "Signet",
+  "fedimint.network.testnet": "Testnet",
+  "fedimint.network.testnet4": "Testnet4",
+  "fedimint.network.regtest": "Regtest",
+  "feed.ecosystem.group": "Ekosistem",
+  "feed.ecosystem.all": "Semua",
+  "feed.ecosystem.cashu": "Cashu",
+  "feed.ecosystem.fedimint": "Fedimint",
+  "feed.filterBySubject": "Filter oleh mint atau federasi",
+  "feed.anySubject": "Setiap mint atau federasi",
+  "feed.clearSubject": "Bersihkan penyaring nama",
+  "home.topFedimints.title": "Fedimints Top",
+  "home.topFedimints.sub": "peringkat dengan ulasan dan peringkat",
+  "home.topFedimints.all": "Semua federasi {n}",
+  "reviews.validate.subject": "Tidak ada yang perlu titik ulasan ini.",
+  "mint.warnings.fedimintOffline.lead": "Dilaporkan offline.",
+  "mint.warnings.fedimintOffline.body.since": "Cek terakhir yang mencapai federasi ini adalah {date} ({days} yang lalu). Para penjaganya tidak menjawab sejak itu. Perlakukan dana yang diselenggarakan di sana sebagai risiko, dan tidak bergabung dengan dana baru.",
+  "mint.warnings.fedimintOffline.body.never": "Tidak ada cek federasi ini yang pernah mencapai itu, dan yang terbaru gagal. Perlakukan dana yang diselenggarakan di sana sebagai risiko, dan tidak bergabung dengan dana baru.",
+  "mint.warnings.fedimintOffline.meta.since": "Dilaporkan offline sejak {date}",
+  "mint.warnings.fedimintOffline.meta.never": "Dilaporkan offline, tidak pernah sekali dicapai",
+  "mint.warnings.neverConfirmed.lead": "Diumumkan, tidak pernah dikonfirmasi.",
+  "mint.warnings.neverConfirmed.body.reviewed": "federasi ini diumumkan pada Nostr di {date}, {days} yang lalu, dan tidak ada yang dikonfirmasi sejak itu bahwa itu berjalan. Ulasan di bawah ini adalah satu-satunya tanda kehidupan di halaman ini; segala sesuatu yang lain datang dari pengumuman.",
+  "mint.warnings.neverConfirmed.body.quiet": "federasi ini diumumkan pada Nostr di {date}, {days} yang lalu, tidak ada yang mengkonfirmasi sejak itu bahwa itu berjalan, dan tidak ada yang melihatnya baru-baru ini. Segala sesuatu di bawah ini berasal dari pengumuman.",
+  "mint.warnings.neverConfirmed.meta": "Diumumkan {date}, tidak pernah dikonfirmasi",
+  "footer.allFedimints": "Semua federasi",
+  "reviews.dialog.bodyPlaceholder.cashu": "Bagaimana pengalaman minting, melting, dan dukungannya? Ceritakan yang spesifik.",
+  "reviews.dialog.bodyPlaceholder.fedimint": "Bagaimana pengalaman bergabung, pembayaran Lightning, dan dukungannya? Ceritakan yang spesifik.",
+  "fedimint.details.title": "Rincian Federasi",
+  "nav.lnurlMints": "Mint LNURL",
+  "footer.allLnurlMints": "Semua mint LNURL",
+  "lnurlMints.title": "Mint LNURL: mint nota atas unjuk lnurlcash, dengan ulasan | Cashumints.space",
+  "lnurlMints.description": "Seluruh {total} mint LNURL yang diindeks dari jaringan Nostr: {online} daring, {offline} luring. Penilaian komunitas, batas penarikan, dan fitur untuk masing-masing.",
+  "lnurlMints.heading": "Mint LNURL",
+  "lnurlMints.lede": "Setiap mint LNURL yang diketahui situs ini. Mint LNURL menerbitkan nota atas unjuk lnurlcash: nota Lightning yang Anda simpan sebagai rahasia, dan dapat diputar, dipecah, digabung, atau dilebur kembali menjadi pembayaran Lightning. Masing-masing diperiksa lewat HTTPS setiap beberapa menit.",
+  "lnurlMints.search.label": "Cari mint LNURL",
+  "lnurlMints.search.placeholder": "Cari berdasarkan nama atau alamat…",
+  "lnurlMints.sort.label": "Urutkan mint LNURL berdasarkan",
+  "lnurlMints.hideOffline": "Sembunyikan yang luring",
+  "lnurlMints.showing": "Menampilkan {total} mint LNURL ({online} daring, {offline} luring)",
+  "lnurlMints.showingFiltered": "Menampilkan {shown} dari {total} mint LNURL ({online} daring, {offline} luring)",
+  "lnurlMints.noResults": "Tidak ada mint LNURL yang cocok.",
+  "lnurlMints.emptyIndex": "Belum ada mint LNURL yang diindeks.",
+  "lnurl.crumb": "Mint LNURL",
+  "lnurl.breadcrumb": "Remah roti",
+  "lnurl.copyAddress": "Salin alamat",
+  "lnurl.more.title": "Mint LNURL lainnya",
+  "lnurl.more.all": "Semua mint LNURL →",
+  "lnurl.disclaimer": "Mint LNURL menyimpan sats Anda sementara Anda memegang notanya, jadi memakainya berarti memercayai operatornya. Penilaian adalah pendapat komunitas, dan daring berarti dapat dijangkau, bukan tepercaya.",
+  "lnurl.features.title": "Fitur",
+  "lnurl.features.none": "Mint ini belum mengumumkan apa yang didukungnya.",
+  "lnurl.features.note": "Fitur adalah apa yang diumumkan operator mint di Nostr. Bila situs ini dapat memeriksanya lewat HTTPS, ia melakukannya, dan memberi tahu bila sesuatu yang diumumkan sedang tidak tersedia.",
+  "lnurl.features.notListed": "tidak diumumkan",
+  "lnurl.features.unavailable": "tidak tersedia",
+  "lnurl.feature.mint": "Mint lewat Lightning (LUD-06)",
+  "lnurl.feature.melt": "Lebur ke Lightning",
+  "lnurl.feature.notes": "Putar / pecah / gabung nota",
+  "lnurl.feature.lud16": "Alamat Lightning",
+  "lnurl.feature.lud21": "Verifikasi pembayaran (LUD-21)",
+  "lnurl.feature.signed-notes": "Nota bertanda tangan (verifikasi luring)",
+  "lnurl.feature.onion": "Alamat Tor",
+  "lnurl.feature.rotate": "Putar sebuah nota",
+  "lnurl.feature.split": "Pecah sebuah nota",
+  "lnurl.feature.merge": "Gabungkan nota",
+  "lnurl.feature.lud06": "LUD-06 payRequest",
+  "lnurl.feature.lud03": "LUD-03 withdrawRequest",
+  "lnurl.limits.label": "Batas penarikan",
+  "lnurl.limits.notPublished": "tidak dipublikasikan",
+  "lnurl.limits.withdrawRow": "Penarikan",
+  "lnurl.limits.disabled": "dinonaktifkan",
+  "lnurl.limits.sats.one": "{n} sat",
+  "lnurl.limits.sats.other": "{n} sat",
+  "lnurl.details.title": "Detail mint",
+  "lnurl.details.address": "Alamat Lightning",
+  "lnurl.details.mintPubkey": "Kunci publik mint",
+  "lnurl.details.onion": "Alamat Tor",
+  "lnurl.details.fee": "Biaya mint",
+  "lnurl.details.node": "Node",
+  "lnurl.details.capacity": "Kapasitas yang diumumkan",
+  "lnurl.kind.lightningAddress": "alamat Lightning",
+  "lnurl.kind.mintPubkey": "kunci publik mint",
+  "lnurl.kind.onionAddress": "alamat Tor",
+  "lnurl.confirmed.label": "Terakhir dikonfirmasi",
+  "lnurl.confirmed.when": "dikonfirmasi {when}",
+  "lnurl.fee.base.one": "{n} sat",
+  "lnurl.fee.base.other": "{n} sat",
+  "lnurl.fee.percent": "{percent}%",
+  "home.topLnurl.title": "Mint LNURL teratas",
+  "home.topLnurl.sub": "diperingkat berdasarkan ulasan dan penilaian",
+  "home.topLnurl.all": "Semua {n} mint LNURL →",
+  "feed.ecosystem.lnurl": "LNURL",
+  "reviews.dialog.bodyPlaceholder.lnurl": "Bagaimana pengalaman mint, lebur, dan memutar nota? Jelaskan secara spesifik.",
+  "reviews.byUrl.open": "Tulis ulasan",
+  "reviews.byUrl.title": "Tulis ulasan",
+  "reviews.byUrl.lede": "Tempel alamatnya. Kalau situs ini belum mengenalnya, alamat itu diperiksa dan ditambahkan sekarang.",
+  "reviews.byUrl.label.cashu": "URL mint",
+  "reviews.byUrl.label.fedimint": "Kode undangan federasi",
+  "reviews.byUrl.label.lnurl": "URL mint LNURL",
+  "reviews.byUrl.placeholder.cashu": "mint.example.com",
+  "reviews.byUrl.placeholder.fedimint": "fed11…",
+  "reviews.byUrl.placeholder.lnurl": "mint.example.com",
+  "reviews.byUrl.check": "Periksa alamat ini",
+  "reviews.byUrl.checking": "Memeriksa…",
+  "reviews.byUrl.back": "Pakai alamat lain",
+  "reviews.byUrl.existing": "Sudah terdaftar",
+  "reviews.byUrl.indexed": "Baru ditambahkan",
+  "reviews.byUrl.confirmClose": "Tutup? Alamat yang kamu ketik tidak disimpan.",
+  "reviews.byUrl.detected": "Alamat itu menjawab sebagai mint {kind}.",
+  "reviews.byUrl.switchTo": "Ulas sebagai mint {kind}",
+  "reviews.byUrl.error.empty": "Isi alamatnya dulu.",
+  "reviews.byUrl.error.badUrl": "Itu tidak terlihat seperti URL mint.",
+  "reviews.byUrl.error.badInvite": "Itu bukan kode undangan Fedimint. Kode dimulai dengan fed11.",
+  "reviews.byUrl.error.badInput": "Situs ini tidak bisa memeriksa alamat itu.",
+  "reviews.byUrl.error.blocked": "Itu bukan alamat publik, jadi tidak bisa diperiksa.",
+  "reviews.byUrl.error.notAMint": "Alamat itu menjawab, tetapi bukan sebagai mint jenis ini.",
+  "reviews.byUrl.error.wrongType": "Alamat itu menjawab, tetapi sebagai mint jenis lain.",
+  "reviews.byUrl.error.unverifiable": "Tidak ada yang menjawab di alamat itu, dan jejaknya belum ada di Nostr.",
+  "reviews.byUrl.error.rateLimited.one": "Terlalu banyak pemeriksaan dari satu koneksi. Coba lagi sekitar {n} menit lagi.",
+  "reviews.byUrl.error.rateLimited.other": "Terlalu banyak pemeriksaan dari satu koneksi. Coba lagi sekitar {n} menit lagi.",
+  "reviews.byUrl.error.network": "Indeks tidak dapat dihubungi. Periksa koneksimu, lalu coba lagi.",
+  "seo.lnurl.titleNoReviews": "{name}: info dan ulasan mint LNURL | Cashumints.space",
+  "seo.desc.statusWithdraw": "{status}, penarikan {min}–{max} sat.",
+  "mint.chip.noFunding": "Tanpa mint / lebur",
+  "mint.warnings.lnurlWithdrawalsDisabled.lead": "Penarikan dinonaktifkan.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.online": "Mint ini mengumumkan penarikan maksimum nol, sehingga tidak ada nota yang diterbitkannya dapat ditukar dengan apa pun. Jangan melakukan mint di sini sampai hal itu berubah.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.offline": "Saat terakhir dapat dihubungi, mint ini mengumumkan penarikan maksimum nol, sehingga tidak ada nota yang diterbitkannya dapat ditukar dengan apa pun. Jangan melakukan mint di sini sampai hal itu berubah.",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.online": "Penarikan sedang dinonaktifkan",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.offline": "Penarikan dinonaktifkan saat terakhir terlihat",
+  "mint.warnings.lnurlInvalid.lead": "Endpoint merespons tetapi tidak valid.",
+  "mint.warnings.lnurlInvalid.body": "Host merespons, tetapi bukan dengan pengumuman mint yang dapat dibaca situs ini, jadi penarikan mungkin tidak berfungsi. Semua di bawah ini adalah keadaan terakhir yang berhasil dibaca, dan ulasan tetap berfungsi.",
+  "mint.warnings.lnurlInvalid.meta": "Merespons, tetapi bukan dengan pengumuman mint yang valid",
+  "mint.warnings.lnurlNoFunding.lead": "Mint dan lebur tidak tersedia.",
+  "mint.warnings.lnurlNoFunding.body": "Nota yang ada masih dapat diputar, dipecah, atau digabung, tetapi saat ini tidak ada yang masuk atau keluar lewat Lightning. Mint-nya sendiri hidup dan merespons; node Lightning di belakangnya tidak dapat dijangkau dari sana.",
+  "mint.warnings.lnurlNoFunding.meta": "Mint dan lebur tidak tersedia",
+  "mint.warnings.also.noFunding": "Node Lightning-nya juga tidak dapat dijangkau, sehingga tidak ada yang bisa di-mint atau dilebur."
+}

web/src/i18n/index.ts

@@ -2,14 +2,40 @@
  * Build-time i18n entry point. Imported from .astro frontmatter, never from an island.
  *
  * Every catalog is imported statically here, which is exactly what we want at build
- * time (one process renders all three locales) and exactly what we do not want in the
+ * time (one process renders every locale) and exactly what we do not want in the
  * browser. Islands import `./client` instead, which reads the one locale the page
  * already carries. Nothing in this file reaches a bundle: Astro frontmatter runs on the
  * build machine only.
+ *
+ * Every locale in `LOCALES` needs a line in both places below. A locale listed in the
+ * table with no catalog here does not fail: it silently renders English under its own
+ * `lang` and URL prefix, which is worse than failing. `test/i18n-wiring.test.mjs`
+ * fails instead.
  */
 import en from './en.json';
 import es from './es.json';
 import nl from './nl.json';
+import zh from './zh.json';
+import hi from './hi.json';
+import ar from './ar.json';
+import fr from './fr.json';
+import pt from './pt.json';
+import it from './it.json';
+import tr from './tr.json';
+import pl from './pl.json';
+import uk from './uk.json';
+import ro from './ro.json';
+import el from './el.json';
+import cs from './cs.json';
+import sv from './sv.json';
+import da from './da.json';
+import id from './id.json';
+import ur from './ur.json';
+import ru from './ru.json';
+import de from './de.json';
+import ja from './ja.json';
+import areg from './ar-eg.json';
+import vi from './vi.json';
 
 import { CLIENT_NAMESPACES, DEFAULT_LOCALE, LOCALE_CODES, isLocale, type Locale } from './config.js';
 import { createTranslator, type Catalog, type Translator } from './translate.js';
@@ -22,6 +48,27 @@ const CATALOGS: Record<string, Catalog> = {
   en: en as Catalog,
   es: es as Catalog,
   nl: nl as Catalog,
+  zh: zh as Catalog,
+  hi: hi as Catalog,
+  ar: ar as Catalog,
+  fr: fr as Catalog,
+  pt: pt as Catalog,
+  it: it as Catalog,
+  tr: tr as Catalog,
+  pl: pl as Catalog,
+  uk: uk as Catalog,
+  ro: ro as Catalog,
+  el: el as Catalog,
+  cs: cs as Catalog,
+  sv: sv as Catalog,
+  da: da as Catalog,
+  id: id as Catalog,
+  ur: ur as Catalog,
+  ru: ru as Catalog,
+  de: de as Catalog,
+  ja: ja as Catalog,
+  'ar-eg': areg as Catalog,
+  vi: vi as Catalog,
 };
 
 /** The English catalog, which is what every other locale falls back to key by key. */
@@ -74,13 +121,22 @@ export function missingKeys(): Record<string, string[]> {
  * key that survives is resolved: a key this locale is missing arrives already filled
  * with the English string, so the browser needs no fallback catalog and ships exactly
  * one language.
+ *
+ * `extra` is for a namespace exactly one page's islands need. The home page's grids
+ * hydrate and have to rewrite their own "All 56 mints →" links, which live under
+ * `home.` — a namespace worth about 2KB that every other page, including 1,300 mint
+ * pages, has no use for. Passed per page through `Base.astro`'s `clientNamespaces`
+ * prop, it is inlined where it is read and nowhere else. `check-i18n.mjs` does not know
+ * about this, so a key reached this way must still be in a namespace the checker
+ * accepts, or listed in `CLIENT_NAMESPACES` — see the note there.
  */
-export function clientCatalog(locale: Locale): Catalog {
+export function clientCatalog(locale: Locale, extra: readonly string[] = []): Catalog {
   const catalog = catalogFor(locale);
+  const allowed = new Set<string>([...CLIENT_NAMESPACES, ...extra]);
   const out: Catalog = {};
   for (const key of Object.keys(BASE_CATALOG)) {
     const namespace = key.split('.')[0] ?? '';
-    if (!(CLIENT_NAMESPACES as readonly string[]).includes(namespace)) continue;
+    if (!allowed.has(namespace)) continue;
     out[key] = catalog[key] ?? BASE_CATALOG[key]!;
   }
   return out;

web/src/i18n/it.json

@@ -0,0 +1,788 @@
+{
+  "site.name": "Cashumints.space",
+  "common.close": "Chiudi",
+  "common.cancel": "Annulla",
+  "common.done": "Fatto",
+  "common.back": "Indietro",
+  "common.retry": "Reazione",
+  "common.connect": "Collegamento",
+  "common.copied": "Copie",
+  "common.copyFull": "Copia completa {kind}",
+  "common.previousPage": "Pagina precedente",
+  "common.nextPage": "Pagina successiva",
+  "common.reviewPages": "Pagine di revisione",
+  "time.never": "mai",
+  "time.justNow": "ora",
+  "time.none": "- No.",
+  "time.unknownDate": "una data sconosciuta",
+  "time.ago.minute": "{n}#",
+  "time.ago.hour": "{n}#",
+  "time.ago.day": "{n}#",
+  "time.ago.week": "{n}#",
+  "time.ago.month": "{n}#",
+  "time.ago.year": "{n}#",
+  "time.short.minute": "{n}m",
+  "time.short.hour": "{n}h",
+  "time.short.day": "{n}D",
+  "time.short.week": "{n}#",
+  "time.short.month": "{n}mo",
+  "time.short.year": "{n}#",
+  "status.online": "Online",
+  "status.offline": "Offline",
+  "status.degraded": "Non raggiungibile",
+  "status.unknown": "Non ancora controllato",
+  "nav.skip": "Salta al contenuto",
+  "nav.main": "Principali",
+  "nav.mints": "Mint Cashu",
+  "nav.reviews": "Recensioni",
+  "nav.wallets": "Portafogli",
+  "nav.about": "Informazioni",
+  "nav.searchMints": "Cerca tra {n} mint",
+  "lang.label": "Lingua",
+  "lang.switcher": "Scegli una lingua",
+  "footer.copyright": "© {year} Cashumints.space",
+  "footer.allMints": "Tutti i mint Cashu",
+  "footer.allReviews": "Tutte le recensioni",
+  "footer.wallets": "Portafogli",
+  "footer.about": "Informazioni",
+  "footer.disclaimer": "Avvertenza",
+  "footer.terms": "Termini",
+  "footer.privacy": "Privacy",
+  "footer.madeBy": "Realizzato con ❤️ da {azzamo} · Basato su Cashu e NIP-87",
+  "footer.warning": "I mint sono custodiali. Un mint può sparire con i tuoi soldi.",
+  "footer.tagline": "Recensioni della comunità sui mint ecash, firmate su Nostr.",
+  "footer.col.explore": "Esplora",
+  "footer.col.site": "Sito",
+  "footer.nav": "Piè di pagina",
+  "home.title": "Cashumints.space · Trova un mint Cashu di cui fidarti",
+  "home.description": "Trova un mint Cashu di cui fidarti. {mints} mint indicizzati con {reviews} recensioni della comunità firmate su Nostr, oltre a disponibilità in tempo reale, NUTs supportati e software del mint.",
+  "home.hero.title": "Trova un mint Cashu",
+  "home.hero.titleEm": "tu puoi fidarti",
+  "home.hero.lede": "Ogni mint sulla rete Nostr, con recensioni comuni reali. Nessun portiere, appena firmato recensioni è possibile verificare se stessi.",
+  "home.search.label": "Cerca mints per nome, dominio o URL",
+  "home.search.placeholder": "Cerca per nome, dominio o incolla un mint URL...",
+  "home.filters.mostReviewed": "Più recensito",
+  "home.filters.highestRated": "Più alto nominale",
+  "home.filters.recentlyActive": "Recentemente attivo",
+  "home.filters.websockets": "Supporta WebSockets",
+  "home.top.title": "Top Cashu mints",
+  "home.top.sub": "classificato per recensioni e valutazioni",
+  "home.top.all": "Tutti {n} mints →",
+  "home.latest.title": "Ultime recensioni",
+  "home.latest.sub": "dal vivo dalla rete Nostr",
+  "home.latest.prev": "Precedente recensioni",
+  "home.latest.next": "Altre recensioni",
+  "home.latest.all": "Tutte le recensioni →",
+  "home.latest.empty": "Nessuna recensione potrebbe essere letta dai relè proprio ora. Apri qualsiasi pagina mint per leggere e scrivere recensioni direttamente.",
+  "home.why.title": "Perché fidarsi di queste recensioni?",
+  "home.why.signed.title": "Firmato, non presentato",
+  "home.why.signed.body": "Ogni recensione è un evento {link} firmato dal suo autore Nostr chiave. Nulla qui è modificato, classificato o rimosso da noi.",
+  "home.why.signed.link": "NIP-87",
+  "home.why.verify.title": "Verificatelo voi stessi",
+  "home.why.verify.body": "Le recensioni vivono su relè pubbliche Nostr, non il nostro database. Punta qualsiasi client alle stesse relè e vedrai gli stessi dati.",
+  "home.why.checked.title": "Controllato continuamente",
+  "home.why.checked.body": "Noi sonda ogni mint per uptime, versione del software, limiti e supportato NUTs, quindi le specifiche che vedete sono attuali, non auto-riportate.",
+  "home.cta.title": "Stai pensando a un mint? Leggilo prima.",
+  "home.cta.body": "Un mint tiene il tuo ecash. Leggi quello che altre persone hanno trovato prima di mettere sats in, e lasciare una recensione quando si ha usato uno stesso.",
+  "home.cta.explore": "Esplora tutto mints",
+  "home.cta.learn": "Scopri di Cashu",
+  "pulse.mintsIndexed": "mints indicizzato",
+  "pulse.reviewsOnNostr": "recensioni su Nostr",
+  "pulse.lastReview": "ultima recensione",
+  "pulse.mintsOnline": "mints online",
+  "pulse.indexer": "Indice",
+  "pulse.connected": "collegato",
+  "pulse.stale": "Stallo.",
+  "mints.title": "Tutti Cashu mints · Cashumints.space",
+  "mints.description": "Tutti {total} Cashu mints indicizzato dalla rete Nostr, {online} online e {offline} offline, con valutazioni della comunità, uptime e mint software. Cerca e ordina la lista completa.",
+  "mints.heading": "Tutti i mint Cashu",
+  "mints.lede": "Ogni mint scoperto sulla rete Nostr, compresi quelli che sono andati. Offline mints rimanere elencato in modo da poter ancora trovare e rivederli.",
+  "mints.search.label": "Cerca mints per nome o dominio",
+  "mints.search.placeholder": "Ricerca per nome o dominio...",
+  "mints.sort.label": "Ordinare mints",
+  "mints.sort.score": "Migliore in generale",
+  "mints.sort.rating": "Più alto nominale",
+  "mints.sort.reviews": "Più recensito",
+  "mints.sort.recent": "Recentemente recensito",
+  "mints.sort.seen": "Recentemente visto online",
+  "mints.hideOffline": "Nascondi offline",
+  "mints.showing": "Mostrando {total} mints ({online} online, {offline} offline)",
+  "mints.showingFiltered": "Mostrando {shown} di {total} mints ({online} online, {offline} offline)",
+  "mints.noResults": "No. mints Corrisponde. Prova un dominio o incolla un mint URL.",
+  "mints.clearSearch": "Cancella la ricerca",
+  "card.noRatings": "Nessuna valutazione",
+  "card.reviews.one": "{n} recensione",
+  "card.reviews.other": "{n} recensioni",
+  "card.lastSeen": "Ultimo accesso {when}",
+  "card.neverSeen": "mai visto online",
+  "card.reviewed": "recensione {when}",
+  "card.noReviews": "nessuna recensione",
+  "mint.title": "{name} · Cashu mint recensioni",
+  "mint.titleFedimint": "{name} · Recensioni della federazione Fedimint",
+  "mint.titleLnurl": "{name} · Recensioni del mint LNURL",
+  "mint.breadcrumb": "Percorso di navigazione",
+  "mint.crumbMints": "Cashu mints",
+  "mint.copyUrl": "Copia URL mint",
+  "mint.qrButton": "Mint QR",
+  "mint.writeReview": "Scrivi una recensione",
+  "mint.rankByScore": "#{rank} by score",
+  "mint.tagLightning": "Lightning",
+  "mint.summary": "Mint Sintesi",
+  "mint.rating.label": "Valutazione comunitaria",
+  "mint.rating.none": "Nessuna valutazione",
+  "mint.rating.reviews.one": "{n} recensione",
+  "mint.rating.reviews.other": "{n} recensioni",
+  "mint.rating.unrated.one": "{n} non ha lasciato nessuna valutazione",
+  "mint.rating.unrated.other": "{n} non ha lasciato nessuna valutazione",
+  "mint.activity.label": "Attività",
+  "mint.activity.since": "dall'ultima recensione",
+  "mint.activity.noReviews": "nessuna recensione",
+  "mint.activity.recent.one": "{n} recensione negli ultimi 90 giorni",
+  "mint.activity.recent.other": "{n} recensioni negli ultimi 90 giorni",
+  "mint.limits.label": "Limiti",
+  "mint.limits.notPublished": "non pubblicato",
+  "mint.limits.min": "min min min",
+  "mint.limits.max": "massimo",
+  "mint.limits.mintRow": "mint",
+  "mint.limits.meltRow": "fusione",
+  "mint.limits.disabled": "disabili",
+  "mint.limits.range": "{min} a {max} {unit}",
+  "mint.limits.upTo": "fino a {max} {unit}",
+  "mint.limits.from": "da {min} {unit}",
+  "mint.software.label": "Software Mint",
+  "mint.software.unknown": "sconosciuto",
+  "mint.checked": "controllato {when}",
+  "mint.lastSeen": "Ultimo accesso {when}",
+  "mint.neverReached": "mai raggiunto",
+  "mint.uptime.checks": "{ok} dell'ultimo {total} verifica raggiungibile",
+  "mint.uptime.percent": "{percent}% raggiungibile in 30 giorni",
+  "mint.uptime.description": "{ok} dell'ultimo {total} i controlli sono riusciti",
+  "mint.operator.title": "Dall'operatore",
+  "mint.operator.motd": "Messaggio del giorno",
+  "mint.operator.beta": "Questo mint si descrive come sperimentale o in beta. Leggi le parole dell'operatore qui sotto prima di memorizzare qualsiasi cosa non si può perdere.",
+  "mint.nuts.title": "Supportato NUTs",
+  "mint.nuts.noneOffline": "Nessun elenco NUT memorizzato in cache per questo mint, è andato offline prima di essere registrato.",
+  "mint.nuts.noneYet": "Nessun elenco NUT memorizzato per questo mint ancora.",
+  "mint.nuts.supported": "{n} di {total} noto NUTs supportato",
+  "mint.nuts.whatAre": "che cosa sono NUTs?",
+  "mint.nutRow.disabled": "disabili",
+  "mint.nutRow.notSupported": "non supportato",
+  "mint.details.title": "Mint dettagli",
+  "mint.details.pubkey": "Pubkey",
+  "mint.details.nostr": "Nostr",
+  "mint.details.email": "Email",
+  "mint.details.serverTime": "Ora del server",
+  "mint.details.firstSeen": "Prima vista",
+  "mint.details.terms": "Termini",
+  "mint.kind.identifier": "identificatore",
+  "mint.kind.mintPubkey": "mint pubkey",
+  "mint.kind.nostrAddress": "Nostr indirizzo",
+  "mint.kind.emailAddress": "indirizzo email",
+  "mint.kind.npub": "npub",
+  "mint.disclaimer": "Questo mint è custode: tiene i vostri soldi, e può smettere di farlo in qualsiasi momento. Le valutazioni sono opinioni comuni e mezzi online raggiungibili, non affidabili.",
+  "mint.disclaimerLink": "Leggi l'avvertenza completa",
+  "mint.qr.title": "Aggiungi {name} al tuo portafoglio",
+  "mint.qr.note": "Scansiona questo con un portafoglio Cashu per aggiungere il mint, o copiare l'URL e incollarlo.",
+  "mint.qr.warn": "Aggiungere un mint significa fidarsi con i vostri soldi.",
+  "mint.qr.whatMeans": "Che cosa significa",
+  "mint.qr.wallets": "Portafogli che sostengono Cashu",
+  "mint.chip.frozen": "congelato",
+  "mint.chip.noWithdrawals": "Nessun prelievo",
+  "mint.chip.meltOnly": "Melt solo",
+  "mint.warnings.dayCount.one": "{n} giorno",
+  "mint.warnings.dayCount.other": "{n} giorni",
+  "mint.warnings.gone.lead": "Se n'e' andata.",
+  "mint.warnings.gone.body.since": "Questo mint è irraggiungibile da {date} ({days}). Trattare fondi detenuti lì come a rischio, e non inviare nuovi fondi. I dettagli qui sotto mostrano il suo ultimo stato conosciuto.",
+  "mint.warnings.gone.body.neverDated": "Questo mint non ha risposto a un singolo assegno da quando abbiamo iniziato a guardarlo in {month}. Trattare fondi detenuti lì come a rischio, e non inviare nuovi fondi. Qualsiasi cosa di seguito proveniva dall'annuncio Nostr, non dal mint.",
+  "mint.warnings.gone.body.never": "Questo mint non ha risposto a un singolo assegno da quando abbiamo iniziato a guardarlo. Trattare fondi detenuti lì come a rischio, e non inviare nuovi fondi. Qualsiasi cosa di seguito proveniva dall'annuncio Nostr, non dal mint.",
+  "mint.warnings.gone.meta.since": "Offline da {date}",
+  "mint.warnings.gone.meta.never": "Non è mai raggiungibile da quando è stato scoperto",
+  "mint.warnings.meltDisabled.lead": "Ritiro disattivato.",
+  "mint.warnings.meltDisabled.body.online": "Questo mint ha Lightning melting (NUT-05) spento: si può mettere sats in, ma non si può ritirare via Lightning. Non depositare fino a quando melting è tornato.",
+  "mint.warnings.meltDisabled.body.offline": "Questo mint aveva Lightning melting (NUT-05) spento: si può mettere sats in, ma non si può ritirare via Lightning. Non depositare fino a quando melting è tornato.",
+  "mint.warnings.meltDisabled.meta.online": "Prelievi attualmente disabilitati",
+  "mint.warnings.meltDisabled.meta.offline": "I prelievi sono stati disabilitati all'ultima vista",
+  "mint.warnings.frozen.lead": "Mint congelato.",
+  "mint.warnings.frozen.body.online": "Entrambi minting e melting sono disabilitati. No sats può muoversi dentro o fuori tramite Lightning.",
+  "mint.warnings.frozen.body.offline": "Entrambi minting e melting sono stati disabilitati. No sats può muoversi dentro o fuori tramite Lightning.",
+  "mint.warnings.frozen.meta.online": "Attualmente congelato, nulla si muove dentro o fuori",
+  "mint.warnings.frozen.meta.offline": "congelato quando l'ultimo visto",
+  "mint.warnings.offlineLong.lead": "Offline per {days}, dal {date}.",
+  "mint.warnings.offlineLong.body": "Il mint potrebbe essere scomparso. Tutto ciò che segue è il suo ultimo stato noto e le recensioni continuano a funzionare.",
+  "mint.warnings.offlineLong.meta": "Offline da {date}",
+  "mint.warnings.meltOnly.lead": "Basta.",
+  "mint.warnings.meltOnly.body.online": "Il nuovo minting (NUT-04) è disabilitato: non è possibile depositare, ma ecash esistente può ancora essere ritirato. Questo significa spesso che un mint si sta abbassando, quindi se si tiene il suo ecash, considerare melting fuori.",
+  "mint.warnings.meltOnly.body.offline": "Nuovo minting (NUT-04) è stato disabilitato: non è possibile depositare, ma ecash esistente può ancora essere ritirato. Questo significa spesso che un mint si sta abbassando, quindi se si tiene il suo ecash, considerare melting fuori.",
+  "mint.warnings.meltOnly.meta.online": "Attualmente si scioglie solo",
+  "mint.warnings.meltOnly.meta.offline": "Melt solo quando l'ultima volta visto",
+  "mint.warnings.offline.lead": "Offline da {date}.",
+  "mint.warnings.offline.body": "I dettagli sono stati confermati l'ultima volta. Puoi ancora scrivere una recensione.",
+  "mint.warnings.offline.meta": "Offline da {date}",
+  "mint.warnings.also.meltDisabled": "Prima di andare offline aveva anche disabilitato i prelievi.",
+  "mint.warnings.also.mintDisabled": "Prima di andare offline aveva anche disabilitato nuovo minting.",
+  "mint.warnings.also.offline": "E 'anche offline da {date} ({days}).",
+  "nut.0": "Notazione e modelli",
+  "nut.1": "Mint scambio chiave pubblica",
+  "nut.2": "Tastiere e tasse",
+  "nut.3": "Token di salto",
+  "nut.4": "Minting via Lightning",
+  "nut.5": "Melting via Lightning",
+  "nut.6": "Mint informazioni",
+  "nut.7": "Controllo dello stato di Token",
+  "nut.8": "Sovrapagato Lightning tasse",
+  "nut.9": "Ripristinare le firme",
+  "nut.10": "Condizioni di spesa",
+  "nut.11": "Pagamento alla chiave pubblica",
+  "nut.12": "DLEQ prove",
+  "nut.13": "Segreti deterministici",
+  "nut.14": "Contratti di tempo libero",
+  "nut.15": "Pagamenti multipath",
+  "nut.16": "Codici animati QR",
+  "nut.17": "WebSocket sottoscrizioni",
+  "nut.18": "Richieste di pagamento",
+  "nut.19": "Risposte in attesa",
+  "nut.20": "Firmato mint citazioni",
+  "nut.21": "Cancella l'autenticazione",
+  "nut.22": "Autenticazione cinta",
+  "nut.23": "BOLT11 metodo di pagamento",
+  "nut.24": "HTTP 402 pagamento richiesto",
+  "nut.25": "BOLT12 metodo di pagamento",
+  "reviews.title": "Recensioni",
+  "reviews.anon": "Anon",
+  "reviews.anonTitle": "Nessun profilo pubblico Nostr trovato per questa chiave",
+  "reviews.nip05Title": "NIP-05 identificatore (non verificato da questo sito)",
+  "reviews.filter.group": "Filtra le recensioni",
+  "reviews.filter.all": "Tutti",
+  "reviews.filter.five": "5★",
+  "reviews.filter.critical": "Critica",
+  "reviews.filter.recent": "Recenti",
+  "reviews.filter.hideAnon": "Nascondere",
+  "reviews.anonHidden.other": "Mostrando {n} di {total} recensioni: anon nascosto.",
+  "reviews.allAnon.one": "L'unica recensione qui è anon.",
+  "reviews.allAnon.other": "Tutte le recensioni {n} qui sono anon.",
+  "reviews.allAnonShow.one": "Mostralo.",
+  "reviews.allAnonShow.other": "Mostra loro",
+  "reviews.loading.one": "Caricamento {n} recensione da Nostr relays",
+  "reviews.loading.other": "Caricamento {n} recensioni da Nostr relays",
+  "reviews.empty": "Ancora nessuna recensione. Sii il primo a scriverne uno.",
+  "reviews.emptyWritten": "Nessuna recensione scritta qui. Sii il primo a scriverne uno.",
+  "reviews.emptyFilter": "Nessuna recensione corrisponde a questo filtro.",
+  "reviews.rate.cashu": "Valuta questo mint",
+  "reviews.rate.fedimint": "Valuta questa federazione",
+  "reviews.rate.lnurl": "Valuta questo mint",
+  "reviews.noscript": "Le recensioni sono firmate su Nostr e caricare nel browser, quindi questa lista ha bisogno di JavaScript. La valutazione e conta sopra provengono dal sito stesso.",
+  "reviews.relayError": "Non poteva raggiungere il relè. Le recensioni possono essere incomplete.",
+  "reviews.srRating": "{rating} su 5",
+  "reviews.srNoRating": "Nessuna valutazione data",
+  "reviews.readMore": "Leggi tutto",
+  "reviews.readLess": "Mostra meno",
+  "reviews.actions.copyNpub": "Copia npub",
+  "reviews.actions.openNostr": "Vedi questo evento su Nostr",
+  "reviews.actions.copyLink": "Copia link a questa recensione",
+  "reviews.anonNote": "Prima recensione da questo npub, nessun'altra attività trovata",
+  "reviews.published": "Pubblicato.",
+  "reviews.publishedPartial": "Pubblicato in {accepted} di {total} relè.",
+  "reviews.propagating": "Pubblicazione sui relay Nostr",
+  "reviews.summary.line.one": "{count} valutazione senza un commento: {breakdown}",
+  "reviews.summary.line.other": "{count} valutazioni senza un commento: {breakdown}",
+  "reviews.summary.lineDay.one": "{count} valutazione senza un commento su {when}: {breakdown}",
+  "reviews.summary.lineDay.other": "{count} valutazioni senza un commento su {when}: {breakdown}",
+  "reviews.summary.showOne": "Mostralo.",
+  "reviews.summary.showMany": "Mostra loro",
+  "reviews.breakdown.5": "{n} 5 stelle",
+  "reviews.breakdown.4": "{n} quattro stelle",
+  "reviews.breakdown.3": "{n} tre stelle",
+  "reviews.breakdown.2": "{n} due stelle",
+  "reviews.breakdown.1": "{n} una stella",
+  "reviews.breakdown.none": "{n} senza classificazione",
+  "reviews.dialog.title": "Recensione {name}",
+  "reviews.dialog.lede.cashu": "Racconta la tua esperienza con questo mint.",
+  "reviews.dialog.lede.fedimint": "Racconta la tua esperienza con questa federazione.",
+  "reviews.dialog.lede.lnurl": "Racconta la tua esperienza con questo mint.",
+  "reviews.dialog.permanent": "Pubblicato in modo permanente su relay Nostr pubblici.",
+  "reviews.dialog.gate.title": "Accedi per scrivere una recensione",
+  "reviews.dialog.gate.lead": "Le recensioni sono firmate con la tua chiave Nostr. Resta nel tuo signer, questo sito non la vede mai.",
+  "reviews.dialog.ratingLegend": "La tua valutazione",
+  "reviews.dialog.starsSr.one": "{n} stella stella",
+  "reviews.dialog.starsSr.other": "{n} stelle",
+  "reviews.dialog.chooseRating": "Scegli una valutazione",
+  "reviews.dialog.starLabel": "{n}: {phrase}",
+  "reviews.dialog.stars.1": "evitarlo",
+  "reviews.dialog.stars.2": "aveva problemi",
+  "reviews.dialog.stars.3": "lavorato, con caveats",
+  "reviews.dialog.stars.4": "Bene.",
+  "reviews.dialog.stars.5": "opere grandi",
+  "reviews.dialog.bodyLabel": "Cosa dovrebbero sapere gli altri?",
+  "reviews.dialog.charCount": "{n} / {max}",
+  "reviews.dialog.submit": "Firma e pubblicazione",
+  "reviews.dialog.signing": "Firmare...",
+  "reviews.dialog.publishing": "Pubblicazione...",
+  "reviews.dialog.publishingTo": "Pubblicazione a relè ({accepted}/{total})",
+  "reviews.dialog.waitingExtension": "Attendere l'estensione",
+  "reviews.dialog.waitingSigner": "Aspettando il tuo firmatario",
+  "reviews.dialog.confirmClose": "Chiudi questa recensione? La tua bozza viene mantenuta fino a quando non esci dal sito.",
+  "reviews.dialog.why.login": "Accedi per pubblicare",
+  "reviews.dialog.why.words": "Scrivi qualche parola",
+  "reviews.dialog.why.more.one": "{n} più carattere",
+  "reviews.dialog.why.more.other": "{n} più caratteri",
+  "reviews.dialog.why.over.one": "{n} carattere oltre il limite",
+  "reviews.dialog.why.over.other": "{n} caratteri oltre il limite",
+  "reviews.dialog.identity.needSigner": "Hai bisogno di un cartello Nostr da pubblicare. La vostra chiave rimane in esso, questo sito non lo vede mai.",
+  "reviews.dialog.identity.loginToPublish": "Accedi per pubblicare",
+  "reviews.dialog.identity.switch": "Interruttore",
+  "reviews.dialog.identity.extension": "Accedi con l'estensione del tuo browser",
+  "reviews.dialog.identity.readingKey": "Leggere la chiave pubblica...",
+  "reviews.dialog.identity.willAsk": "La vostra estensione sarà chiesto di firmare",
+  "reviews.dialog.error.noRelay": "Nessun relè ha accettato la recensione. Controlla la tua connessione, poi riprova.",
+  "reviews.validate.rating": "Scegli una valutazione da 1 a 5 stelle.",
+  "reviews.validate.short": "Scrivi almeno {n} caratteri in modo che la recensione sia utile.",
+  "reviews.validate.long": "Le recensioni sono limitate ai caratteri {n}.",
+  "feed.title": "Ultimi mint e recensioni federazioni · Cashumints.space",
+  "feed.description": "Ogni recensione di mint, federazione e mint LNURL appena viene pubblicata: {reviews} recensioni su {mints} mint Cashu, {federations} federazioni Fedimint e {lnurl} mint LNURL, firmate su Nostr e leggibili qui dalla più recente. Filtra per ecosistema, valutazione o nome.",
+  "feed.heading": "Ultime recensioni",
+  "feed.lede": "Ogni recensione di ogni Cashu mint e Fedimint federazione, prima nuova, leggere dal vivo dai relè Nostr. Ognuno è firmato dal suo autore e vive sui relè, non nel nostro database.",
+  "feed.label": "Recensioni",
+  "feed.showingBuild.one": "Mostrando la recensione più recente dall'ultima costruzione",
+  "feed.showingBuild.other": "Mostrando le {n} più recenti recensioni dall'ultima costruzione",
+  "feed.noscript": "Le recensioni sono firmate su Nostr e caricate nel vostro browser, quindi filtraggio e l'elenco completo devono JavaScript. Le recensioni {n} qui sotto sono state lette dai relè quando questa pagina è stata costruita.",
+  "feed.emptyBuild": "Nessuna recensione potrebbe essere letto dai relè quando questa pagina è stata costruita. La lista si ricarica dai relè nel tuo browser.",
+  "feed.foot": "Le recensioni sono opinioni della comunità, affermazioni non verificate. Leggi il {link} prima di fidarti di un mint con i soldi.",
+  "feed.footLink": "avvertenza",
+  "feed.showing": "Mostrando {shown} di {total} recensioni",
+  "feed.showingMatching": "Mostrando {shown} di {matching} recensioni corrispondenti ({total} in totale)",
+  "feed.emptyRelays": "Nessuna recensione è tornata dai relè. Apri qualsiasi pagina mint per leggere e scrivere recensioni lì.",
+  "feed.emptyFilter": "Nessuna recensione corrisponde a questo filtro. Cancellare la casella mint, o provare Tutti.",
+  "feed.relayError": "Non poteva raggiungere i relè. Mostrando le recensioni dall'ultima costruzione.",
+  "feed.relayEmpty": "Nessuna recensione è tornata dai relè. Mostrando le recensioni dall'ultima costruzione.",
+  "feed.reading": "Leggendo i relè...",
+  "login.open": "Accedi",
+  "login.title": "Accedi con Nostr",
+  "login.note": "La tua chiave rimane nel tuo firmatario. Questo sito non può mai vederlo.",
+  "login.extension.name": "Estensione del browser",
+  "login.extension.desc": "Segnale con Alby, nos2x o un'altra estensione NIP-07",
+  "login.extension.none": "Nessuna estensione trovata",
+  "login.extension.getOne": "Prendine uno:",
+  "login.remote.name": "Registratore remoto",
+  "login.remote.desc": "Scansione di un codice con un'app firmatrice, o incolla un link bunker",
+  "login.primal.name": "Primal",
+  "login.primal.desc": "Approva il login nell'app Primal sul tuo telefono",
+  "login.paste.label": "O incollare il link di connessione che il tuo firmatario ti ha dato",
+  "login.copyLink": "Copia il collegamento",
+  "login.whatIsNostr": "Che cosa è Nostr?",
+  "login.connect.remote.title": "Collegare un segnale remoto",
+  "login.connect.remote.lead": "Scansiona questo con la tua app firma, o copia il link e incollalo lì.",
+  "login.connect.remote.hint": "Funziona con qualsiasi segno NIP-46: nsec.app, Amber, Nostrify, il tuo bunker.",
+  "login.connect.remote.open": "Apri la tua app firmatrice",
+  "login.connect.primal.title": "Collegare con Primal",
+  "login.connect.primal.lead": "Aprire Primal sul telefono, trovare la firma remota nelle sue impostazioni e la scansione di questo codice.",
+  "login.connect.primal.hint": "Primal segni per altre applicazioni NIP-46, quindi questa è la stessa connessione che ogni firmatario utilizza, e la vostra chiave rimane dentro Primal. {link}",
+  "login.connect.primal.open": "Aprire in Primal",
+  "login.status.buildingLink": "Costruire un collegamento",
+  "login.status.waitingExtension": "Attendere l'estensione",
+  "login.status.waitingSigner": "Aspettando il tuo firmatario",
+  "login.status.connecting": "Collegamento al tuo firmatario",
+  "login.status.connected": "Collegato",
+  "login.toast.loggedIn": "Accesso effettuato",
+  "login.toast.fetchingProfile": "Recupero del tuo profilo Nostr dalle relè…",
+  "login.toast.profile": "Profilo: {name}",
+  "login.toast.noProfile": "Nessun profilo trovato sulle relè",
+  "login.method.extension": "Estensione",
+  "login.method.remote": "Telecomando",
+  "login.method.primal": "Primal",
+  "login.account": "Il tuo account Nostr",
+  "login.copyNpub": "Ricevuto npub",
+  "login.logout": "Accedi",
+  "signer.status.waitingExtension": "Attendere l'estensione",
+  "signer.status.signed": "Firmato",
+  "signer.status.reconnecting": "Ricollegamento al tuo firmatario",
+  "signer.status.approveWindow": "Il vostro firmatario ha bisogno di approvare questo nella sua finestra",
+  "signer.status.waitingSigner": "Aspettando il tuo firmatario",
+  "signer.status.stillWaiting": "Stai ancora aspettando che il tuo firmatario risponda",
+  "signer.status.connected": "Collegato",
+  "signer.error.noExtension": "Nessuna estensione di firma trovata. Installare Alby o nos2x, quindi ricaricare questa pagina.",
+  "signer.error.privateKey": "Sembra una chiave privata, non un collegamento. Questo sito non prende mai una chiave. Incolla il link bunker:// che ti ha dato il firmatario.",
+  "signer.error.badLink": "Questo non è un collegamento che questo sito comprende. Incolla il link bunker:// dal tuo firmatario.",
+  "signer.error.noAnswer": "Il suo firmatario non ha risposto. Può essere chiuso, o il suo relè può essere giù. Aprila e riprova.",
+  "signer.error.timeout": "Il suo firmatario non ha risposto in tempo. Aprilo, controlla che sia ancora collegato, poi riprova.",
+  "signer.error.cancelled": "Connessione annullata.",
+  "signer.error.declined": "La richiesta di firma è stata rifiutata",
+  "notfound.title": "Pagina non trovata Cashumints.space",
+  "notfound.description": "Quella pagina non esiste su Cashumints.space.",
+  "notfound.heading": "Questa pagina non esiste",
+  "notfound.lede": "Potrebbe essersi spostato, o il mint potrebbe non essere ancora indicizzato. Cercare un mint per nome o per dominio, o incollare un mint URL.",
+  "notfound.browse": "Sfoglia tutti mints",
+  "notfound.home": "Vai a casa.",
+  "notfound.loading": "Caricamento {host}",
+  "notfound.fb.rating": "Valutazione",
+  "notfound.fb.reviews": "Recensioni",
+  "notfound.fb.software": "Software software",
+  "notfound.fb.lastOnline": "Ultimo online",
+  "notfound.fb.note": "Questo mint è stato indicizzato dopo l’ultima build del sito, quindi questo è un riepilogo dall’API dal vivo, con le recensioni sotto. La pagina completa compare alla prossima build.",
+  "notfound.resolve.checking": "Prima visita: sto controllando questo mint adesso.",
+  "notfound.resolve.failed": "Non è stato possibile aggiungere questo mint",
+  "notfound.resolve.failedFedimint": "Non è stato possibile aggiungere questa federazione",
+  "notfound.resolve.retry": "Prova un altro indirizzo",
+  "notfound.resolve.switch": "Aprilo come mint {kind}",
+  "notfound.resolve.fedimint": "L’indirizzo della pagina di una federazione non contiene il suo codice di invito, quindi non si può risalire a questa dal solo link. Incolla il codice di invito e verrà aggiunta.",
+  "notfound.resolve.ambiguous": "Questo indirizzo non si può ricavare dal solo link. Incolla l’URL completo del mint e verrà aggiunto.",
+  "wallets.title": "Cashu portafogli · Cashumints.space",
+  "wallets.description": "Cashu portafogli che funzionano con il mints elencati qui, attraverso mobile, web, browser e la riga di comando, con quello che ognuno è buono a.",
+  "wallets.heading": "Portafogli",
+  "wallets.lede": "Hai bisogno di un portafogli per tenere ecash da uno di questi mints. La maggior parte dei portafogli parlano con diversi mints subito, quindi non sei legato al primo che provi.",
+  "wallets.note": "Questa lista non è esaustiva e non è un'approvazione. Il progetto Cashu mantiene un indice più ampio a {link}. Un portafoglio contiene le chiavi, un mint detiene il denaro: leggere le recensioni mint prima di scegliere dove il vostro sats live.",
+  "wallets.platform.android": "Android",
+  "wallets.platform.ios": "iOS",
+  "wallets.platform.web": "Web",
+  "wallets.platform.extension": "Estensione del browser",
+  "wallets.platform.cli": "CLI",
+  "wallets.platform.python": "Python",
+  "wallets.item.minibits": "Mobile ecash portafoglio con il proprio mint, Lightning supporto indirizzo e Nostr contatti.",
+  "wallets.item.nutstash": "Browser portafoglio che gestisce più mints contemporaneamente e importa e esporta token grezzi.",
+  "wallets.item.enuts": "Portafoglio mobile focalizzato su bilancia multimint e inviando ecash su Nostr.",
+  "wallets.item.cashume": "Portafogli web di riferimento dal progetto Cashu. Funziona interamente nel browser, installabile come PWA.",
+  "wallets.item.boardwalk": "Portafogli web costruito intorno Lightning indirizzi e l'invio ecash dal link.",
+  "wallets.item.coinos": "Lightning portafoglio e punto vendita che gestisce anche il proprio Cashu mint.",
+  "wallets.item.oxchat": "Nostr messenger con un portafoglio ecash costruito in, per l'invio sats dentro chat.",
+  "wallets.item.nutshell": "L'implementazione di riferimento. Esegue come un portafoglio sulla riga di comando e come mint software.",
+  "about.title": "A proposito di Cashumints.space",
+  "about.description": "Ciò che Cashu è, che un mint effettivamente detiene, che NIP-87 è, e come questo sito indici mints e legge recensioni da Nostr relè.",
+  "about.heading": "Informazioni",
+  "about.lede": "Cashumints.space elenca ogni Cashu mint possiamo trovare sulla rete Nostr e mostra ciò che la gente dice di loro. È fatto da Azzamo.",
+  "about.cashu.title": "Cosa? Cashu è",
+  "about.cashu.p1": "Cashu è un protocollo ecash per Bitcoin. Un mint problemi accecati gettoni supportati da sats che detiene, e quei gettoni si muovono tra le persone senza l'apprendimento mint che ha inviato cosa a chi. La privacy è reale ed è il punto: i token non sono account, e il mint non può collegare il token firmato al token che ritorna.",
+  "about.cashu.p2": "È possibile leggere il protocollo e le sue specifiche a {link}. Le specifiche stesse sono chiamate NUTs, che è dove i numeri NUT su ogni pagina mint provengono da.",
+  "about.mints.title": "Che cosa è un mint e il tradeoff",
+  "about.mints.p1": "Un mint è custode. Quando si mint ecash si sta consegnando sats a chiunque esegue quel server, e si sta fidando di loro per onorare i gettoni quando li sciogliere. Non ci sono prove di frode, nessun impegno e nessun ricorso. Un operatore mint può sparire con l'equilibrio, e mints hanno.",
+  "about.mints.p2": "Ecco perché esistono le recensioni qui. Questo sito non ti dice mai un mint è sicuro. Lo stato su una pagina mint dice {code}, non \"trusted\", e significa solo che il server ha risposto quando abbiamo chiesto l'ultima volta. Trattare ecash bilancia come il denaro in una tasca del cappotto: fine per la spesa, sbagliato per il risparmio.",
+  "about.nip87.title": "Cosa? NIP-87 è",
+  "about.nip87.p1": "NIP-87 è la convenzione Nostr per annunciare e raccomandare ecash mints. Qui ci sono due tipi di eventi:",
+  "about.nip87.li1": "{code} annuncia un mint. mint L'URL è nel {tag} tag. Questo è il modo in cui il sito scopre mints non ha mai visto.",
+  "about.nip87.li2": "{code} è una recensione. Porta la valutazione e il testo di revisione, e punti al mint si tratta di {utag} (Il Parlamento approva il progetto) mint URL) e un {dtag} (Il Parlamento approva il progetto) mint's propria chiave pubblica).",
+  "about.nip87.p2": "Ogni recensione è firmata dal suo autore Nostr chiave. Non chiamiamo mai una recensione \"verificata\", perché nessuno l'ha verificata: è firmata, che è una rivendicazione diversa e più utile. Significa che puoi controllare chi l'ha scritto e che non è stato modificato. Non significa che l'autore sia onesto o mai usato il mint.",
+  "about.how.title": "Come funziona questo sito",
+  "about.how.p1": "Ci sono due loop e una regola. La regola è che il mint possiede i suoi metadati e Nostr possiede le recensioni, quindi questo sito non memorizza né come autorità.",
+  "about.how.li1": "{strong} chiede ogni nota mint per {code} ogni dieci minuti e registra ciò che dice: nome, descrizione, versione, supportato NUTs, limiti, contatti. Si registra anche se la risposta mint a tutti, che è da dove arriva l'uptime.",
+  "about.how.li1Label": "L'anello della sonda",
+  "about.how.li2": "{strong} si collega a Nostr relè ogni ora, legge annunci e recensioni mint e aggiunge qualsiasi mint non ha visto prima.",
+  "about.how.li2Label": "Il ciclo di scoperta",
+  "about.how.p2": "La parte importante è ciò che accade quando un mint smette di rispondere. I suoi metadati cache non sono mai sovrascritti da una sonda fallita, quindi un morto mint mantiene la sua pagina completa: le sue specifiche, la sua storia e le sue recensioni, con un banner che dice quando è andato buio. La versione precedente di questo sito mostrava invece una pagina di errore, che significava il mints persone più necessarie per avvertire l'un l'altro erano quelli che non potevano essere esaminati. Questa era la ragione principale per la ricostruzione.",
+  "about.how.p3": "Il testo di revisione non è mai memorizzato sul nostro lato. Quando si apre una pagina mint il browser parla direttamente ai relè e legge le recensioni stesse, e quando si scrive uno è firmato dal proprio Nostr estensione e inviato dritto a quei relè. Teniamo un conteggio in modo che le pagine possano essere classificate e ordinate, niente di più. Nulla qui può essere modificato o cancellato da noi, comprese le recensioni che preferiremmo non avere.",
+  "about.relays.title": "Relè che leggiamo",
+  "about.relays.p1": "Questi sono i relè l'indicizzatore e il browser entrambi utilizzano:",
+  "about.relays.p2": "Punta qualsiasi client Nostr presso gli stessi relè e vedrai gli stessi eventi. Questa è l'intera promessa: niente qui è vero solo perché lo diciamo noi.",
+  "about.nuts.title": "Che cosa sono NUTs?",
+  "about.nuts.p1": "NUTs sono le specifiche Cashu numerate, come BIPs per Bitcoin. A mint pubblicizza quali sono quelli che implementa, e che ti dice cosa può effettivamente fare: NUT-04 e NUT-05 sono minting e melting sopra Lightning (senza di loro un mint non è molto uso), NUT-07 permette un controllo del portafoglio se un token è stato già speso, NUT-17 dà portafogli aggiornamenti in diretta su WebSockets Invece di inquinare, e NUT-20 permette un portafoglio dimostrare che un preventivo mint è stato effettivamente rilasciato a esso. L'elenco completo è a {link}.",
+  "about.numbers.title": "Adesso.",
+  "about.numbers.p1": "{mints} mints indicizzato, {online} di loro rispondendo, {reviews} recensioni contate dai relè sopra.",
+  "about.source.title": "Fonte e credito",
+  "about.source.p1": "Il sito è open source a {github}. È costruito e gestito da {azzamo}. Se una pagina mint ha qualcosa che non va, fissala alla fonte: mint metadati proviene dal mint proprio {code}, e le recensioni provengono da Nostr.",
+  "terms.title": "Condizioni d'uso · Cashumints.space",
+  "terms.description": "Termini d'uso per Cashumints.space: che cosa il sito è, che cosa non fa, e chi è responsabile per cosa. Nessun conto, nessuna garanzia, nessuna affiliazione con qualsiasi mint.",
+  "terms.heading": "Condizioni d'uso",
+  "terms.lede": "Termini per un sito che indicizza solo i dati pubblici. Ultimo aggiornamento {date}.",
+  "terms.what.title": "Che cosa questo sito è",
+  "terms.what.p1": "Cashumints.space è un indice di dati pubblicamente disponibili su Cashu mints. Due tipi di dati, entrambi da qualche altra parte:",
+  "terms.what.li1": "Mint metadati, letti da ciascun mint proprio {code} endpoint: nome, descrizione, versione software, supportato NUTs, dettagli di contatto e se il mint ha risposto all'ultima domanda.",
+  "terms.what.li2": "Recensioni, letto da pubblico Nostr relè. Questi sono eventi NIP-87 pubblicati dai loro autori per relays chiunque può query.",
+  "terms.what.p2": "Raccogliamo quei dati, lo normalizziamo, lo rango e lo mostriamo. Non lo creiamo.",
+  "terms.noAccounts.title": "Nessun account, nessuna garanzia",
+  "terms.noAccounts.p1": "Non c'e' niente per cui iscriversi. Il sito è fornito come è, senza alcuna garanzia di alcun tipo: non che i dati siano accurati, non che sia corrente, non che il sito sarà disponibile. Mint i dati possono essere minuti o ore, un mint può cambiare dopo che abbiamo controllato l'ultima volta, e un relè può non rispondere, in questo caso si sta vedendo meno che esiste.",
+  "terms.noAccounts.p2": "Usalo a tuo rischio. Non siamo responsabili per qualsiasi perdita che segue dall'utilizzo di questo sito o affidandoci a qualsiasi cosa leggete qui. Vedere il {link} per i rischi specifici di utilizzare un Cashu mint.",
+  "terms.noAccounts.link": "avvertenza",
+  "terms.noCustody.title": "Non teniamo i tuoi soldi",
+  "terms.noCustody.p1": "Questo sito non prende mai la custodia dei fondi. Non ha portafoglio, non tocca ecash, e non può muoversi, congelare o recuperare nulla. Se avete un problema con un mint, l'operatore mint è l'unico che può aiutarvi, e non possiamo contattarli per vostro conto.",
+  "terms.noCustody.p2": "Non siamo affiliati con alcun mint elencati qui, e nessun mint paga per la sua lista, il suo grado o la sua valutazione. Mints sono scoperti da annunci pubblici Nostr e ordinati da un algoritmo sui dati di recensione pubblica.",
+  "terms.reviews.title": "Le recensioni sono parole di altre persone",
+  "terms.reviews.p1": "Le recensioni sono contenuti generati dall'utente pubblicati in relè pubbliche Nostr dai loro autori. Li mostriamo, non li controlliamo. Non li abbiamo scritti, non possiamo modificarli, e non possiamo eliminarli dai relè che li tengono: sono eventi firmati su una rete che non possediamo.",
+  "terms.reviews.p2": "Una recensione è l'esperienza di una persona, non un fatto verificato. Se ne pubblichi uno, sei responsabile di quello che dice. Non pubblicare nulla di illegale, e essere consapevoli che ciò che pubblichi è pubblico e permanente (vedi {link}).",
+  "terms.reviews.link": "pagina della privacy",
+  "terms.reviews.p3": "Possiamo smettere di mostrare una recensione specifica su questo sito, e lo faremo per i contenuti che è illegale. Questo lo rimuove solo da queste pagine. L'evento rimane sui relè e qualsiasi altro client Nostr può ancora leggerlo.",
+  "terms.links.title": "Link ad altri siti",
+  "terms.links.p1": "Mint URL, link portafogli, contatti operatore e tutto il resto che punti fuori questo sito sono lì perché fanno parte dei dati. Un link non è un'approvazione e non vet ciò che è sull'altra estremità.",
+  "terms.changes.title": "Cambiamenti",
+  "terms.changes.p1": "Questi termini possono cambiare. La data in cima dice quando l'ultima volta. Il sito è open source, quindi ogni cambiamento a questa pagina è nella storia del commit.",
+  "terms.contact.title": "Contatto",
+  "terms.contact.p1": "I problemi e le richieste di rimozione sono meglio archiviati su {github}. Il sito è gestito da {azzamo}.",
+  "privacy.title": "Privacy · Cashumints.space",
+  "privacy.description": "Privacy su Cashumints.space: nessun account, nessun cookie di tracciamento, nessuna analisi. localStorage è usato per il caching del profilo e nulla viene inviato ovunque. Le recensioni sono firmate nel proprio browser.",
+  "privacy.heading": "Privacy",
+  "privacy.lede": "Raccogliamo poco quanto un sito web può. Ultimo aggiornamento {date}.",
+  "privacy.noAccounts.title": "Nessun account",
+  "privacy.noAccounts.p1": "Non c'è alcuna registrazione, nessun login e nessun profilo. Niente su questo sito ti chiede chi sei, e non c'è alcun record utente da perdere perché non ci sono utenti.",
+  "privacy.noTracking.title": "Nessun cookie di tracciamento, nessuna analisi",
+  "privacy.noTracking.p1": "Il sito non imposta cookie per il monitoraggio. Non esiste uno script di analisi, nessun tag manager, nessun pixel, nessuna registrazione di sessione e nessuna rete pubblicitaria. Niente sulla pagina riporta il tuo comportamento a noi o a chiunque altro.",
+  "privacy.logs.title": "log del server",
+  "privacy.logs.p1": "Il server web mantiene registri di accesso standard, che è ciò che qualsiasi server web fa per impostazione predefinita. Una riga di registro registra l'indirizzo IP, l'ora, la pagina richiesta, lo stato di risposta, e l'agente utente e il referrer del browser inviato. I registri esistono per debug errori e spot abusi. Non sono uniti a nient'altro e non sono venduti o condivisi.",
+  "privacy.logs.operatorLabel": "Nota operatore:",
+  "privacy.logs.operator": "se si esegue questo sito, indicare la vostra vera ritenzione qui. La distribuzione nel README utilizza nginx con il suo log di accesso predefinito e qualsiasi rotazione delle navi di distribuzione (su Debian e Ubuntu che è logrotate, ogni giorno, mantenendo 14 giorni). Confermare ciò che il server fa e sostituire questo paragrafo con il numero.",
+  "privacy.storage.title": "Cosa viene memorizzato nel browser",
+  "privacy.storage.p1": "Il sito utilizza localStorage per esattamente due cose, entrambe rimangono sul dispositivo e non vengono mai inviate da nessuna parte:",
+  "privacy.storage.li1": "Una cache di metadati di profilo Nostr (kind 0 eventi: nomi, avatar, NIP-05 indirizzi) per i recensori le cui recensioni hai guardato. Questo consente di salvare i relè di acquisizione in ogni pagina. Le voci scadono, e la cache è bloccata e sfrattata prima più vecchia.",
+  "privacy.storage.li2": "Preferenze di interfaccia, quindi il sito si comporta allo stesso modo la prossima volta.",
+  "privacy.storage.p2": "Cancellare i dati del sito del browser rimuove entrambi. Niente si rompe, le ricerche sul profilo funzionano di nuovo.",
+  "privacy.thirdParties.title": "Cosa parla il tuo browser",
+  "privacy.thirdParties.p1": "Caricamento di una pagina collega il browser ad alcuni luoghi oltre a questo sito. Questo è il modo in cui un sito senza monitoraggio lato server legge ancora i dati dal vivo:",
+  "privacy.thirdParties.li1Label": "Pubblico Nostr relè",
+  "privacy.thirdParties.li1": "{strong}, sopra WebSocket, per leggere recensioni e profili di recensore. Il relè vede il tuo IP e quello che hai chiesto, come qualsiasi server a cui ti colleghi. I relè sono elencati sul {link}.",
+  "privacy.thirdParties.li1Link": "sulla pagina",
+  "privacy.thirdParties.li2Label": "Recensione di immagini avatar",
+  "privacy.thirdParties.li2": "{strong}, caricato da dove il profilo del recensore punta. Questi vengono inviati con una politica no-referrer, quindi l'host non impara quale pagina eri.",
+  "privacy.publishing.title": "Pubblicare una recensione",
+  "privacy.publishing.p1": "Scrivere una recensione avviene nel tuo browser, non sul nostro server. L'evento è firmato dall'estensione NIP-07 (Alby, nos2x o simile) e trasmesso dal browser direttamente ai relè. La vostra chiave privata non lascia mai l'estensione e questo sito non lo vede mai. Non costruiamo una gestione personalizzata delle chiavi e non chiediamo mai una chiave o una frase di seme.",
+  "privacy.permanent.title": "Tutto ciò che pubblichi a Nostr è pubblico e permanente",
+  "privacy.permanent.p1": "Questa è la parte che vale la pena leggere due volte. Una recensione è un evento firmato sui relè pubblici. Una volta che è fuori, è fuori:",
+  "privacy.permanent.li1": "Chiunque può leggerlo, ora e poi, utilizzando qualsiasi client Nostr. Non è \"pubblico su Cashumints.space\", è pubblico sulla rete.",
+  "privacy.permanent.li2": "È permanentemente collegato al tuo Nostr chiave pubblica, accanto a tutto il resto che chiave ha mai pubblicato.",
+  "privacy.permanent.li3": "Cancellarlo è una richiesta, non un comando. È possibile pubblicare un evento di cancellazione e alcuni relè lo onorerà, ma un relè è libero di ignorarlo e chiunque abbia già copiato l'evento lo ha ancora. Trattare una recensione pubblicata come permanente.",
+  "privacy.permanent.li4": "Non possiamo cancellarlo per voi. Possiamo smettere di mostrarlo qui, che non cambia nulla sui relè.",
+  "privacy.permanent.p2": "Se si desidera rivedere un mint senza che sia legato alla vostra identità principale, utilizzare un Nostr separato chiave. Si noti che una chiave con nessun'altra attività è mostrata come tale su recensioni dure, perché una nuova chiave che scrive una recensione di una stella è un lettore di pattern merita di vedere.",
+  "privacy.contact.title": "Domande",
+  "privacy.contact.p1": "Il sito è open source: se si desidera controllare uno qualsiasi dei suddetti, leggere il codice a {github}. Le domande e le correzioni possono andare in un problema lì.",
+  "disclaimer.title": "Avvertenza · Cashumints.space",
+  "disclaimer.description": "Cosa sapere prima di utilizzare un Cashu mint: mints sono custode, un mint può scomparire con i vostri soldi, le recensioni sono opinioni e mezzi online raggiungibili, non affidabili.",
+  "disclaimer.heading": "Avvertenza",
+  "disclaimer.lede": "Leggi questo prima di mettere soldi in un mint. Ultimo aggiornamento {date}.",
+  "disclaimer.callout": "Un Cashu mint tiene i tuoi soldi per te. Se scompare, il tuo ecash è andato, e non c'è nessuno a cui appellarsi. Tieni solo quello che puoi permetterti di perdere.",
+  "disclaimer.custodial.title": "Mints sono custodi",
+  "disclaimer.custodial.p1": "Quando si mint ecash, si passa bitcoin all'operatore mint e tornare indietro i gettoni. Quei token sono un reclamo su quell'operatore. Non sono bitcoin che si tiene, e l'operatore è quello che decide se onorarli.",
+  "disclaimer.custodial.p2": "Ciò significa che ogni mint comporta gli stessi rischi: l'operatore può sparire, può essere costretto a fermarsi, può perdere i fondi attraverso un bug o un hack, o può semplicemente spegnere il server. Non vi è alcuna assicurazione di deposito, nessun chargeback, nessuna linea di supporto e nessun ricorso legale vale la pena contare su. Questo è vero del più alto nominale mint su questo sito.",
+  "disclaimer.custodial.p3": "Cashu è progettato per piccole quantità in movimento rapidamente. Usalo in questo modo: tieni quello che stai per spendere, non i tuoi risparmi, e diffonda su mints piuttosto che parcheggiare tutto in uno.",
+  "disclaimer.reviews.title": "Le recensioni sono opinioni, affermazioni non verificate",
+  "disclaimer.reviews.p1": "Ogni recensione qui è stata scritta da qualcuno su Nostr e firmato con la loro chiave. Firmato significa che possiamo dirvi quale chiave l'ha scritta. Non significa che la recensione è vera, che l'autore ha usato il mint, o che l'autore non è l'operatore, un concorrente, o una persona con dieci chiavi.",
+  "disclaimer.reviews.p2": "Non verifichiamo i recensori, e non modifichiamo o rimuoviamo le recensioni con cui non siamo d'accordo. Leggi alcuni, guarda quello che dicono, e pesa un mint con tre recensioni in modo diverso da uno con trecento.",
+  "disclaimer.status.title": "Online significa raggiungibile, non affidabile",
+  "disclaimer.status.p1": "Controlliamo ogni mint regolarmente e mostriamo se ha risposto. Questo è tutto uno stato verde significa: il server ha risposto. Non dice nulla se l'operatore è solvente, onesto, o ancora intende onorare i vostri gettoni domani.",
+  "disclaimer.status.p2": "Un mint può essere online fino al momento in cui non lo è. La cronologia dei tempi, supportata NUTs e la versione del software vi dicono qualcosa su come viene eseguito un mint, ma nessuno di loro è una promessa circa i vostri soldi.",
+  "disclaimer.ranking.title": "Come funziona la classifica, e che cosa non significa",
+  "disclaimer.ranking.p1": "Mints sono ordinati da un algoritmo su dati di revisione pubblica: valutazione, numero di recensioni e attività recente, con online mints prima di quelli offline per impostazione predefinita. I dettagli sono nel codice sorgente aperto.",
+  "disclaimer.ranking.p2": "Nessuno paga per il collocamento. Non c'è slot sponsorizzato, nessun elenco promosso e nessun accordo con qualsiasi mint su questo sito. Un alto grado significa che l'algoritmo ha apprezzato i dati pubblici, e niente di più. Non è una raccomandazione e non è una valutazione di sicurezza.",
+  "disclaimer.notAdvice.title": "Questo non è un consiglio finanziario",
+  "disclaimer.notAdvice.p1": "Nulla su questo sito è finanziario, investimento, consulenza legale o fiscale. Non conosciamo la vostra situazione e non vi consigliamo. Usando un mint, e scegliendo quale, è la tua decisione.",
+  "disclaimer.dyor.title": "Fai la tua ricerca",
+  "disclaimer.dyor.li1": "Guarda l'operatore. Un mint gestito da qualcuno con una reputazione pubblica da perdere è una proposta diversa da un URL anonimo.",
+  "disclaimer.dyor.li2": "Leggi i termini propri di mint e i suoi MOTD. Un mint che si chiama un test o una beta significa.",
+  "disclaimer.dyor.li3": "Iniziare piccolo. Mint un po', spenderlo, scioglierlo e vedere cosa succede prima di fidarsi di più.",
+  "disclaimer.dyor.li4": "Guarda i limiti. Un basso massimo è spesso un segno di un operatore attento, e uno alto non è un segno di uno sicuro.",
+  "disclaimer.dyor.li5": "Mantenete i vostri gettoni appoggiati, e ricordate che un gettone è una risorsa portante: chiunque lo trattiene può spenderla.",
+  "disclaimer.site.title": "Informazioni sul sito stesso",
+  "disclaimer.site.p1": "I dati qui possono essere sbagliati o fuori data. Mints sono probed su un programma, relè a volte non riescono a rispondere, e una pagina che stai leggendo è stata costruita ad un certo punto in passato. Il sito è fornito come è, senza garanzia. Vedi il {link}.",
+  "disclaimer.site.link": "termini di utilizzo",
+  "disclaimer.updated": "20 agosto 2026",
+  "login.getPrimal": "Vai! Primal",
+  "reviews.dialog.identity.extensionGone": "L'estensione del tuo browser non risponde. Accedere di nuovo, o utilizzare un segnalatore remoto.",
+  "seo.orgDescription": "Una directory di Cashu mints, con stato live da ogni mint e recensioni della comunità firmate su Nostr.",
+  "seo.ogImageAlt": "Cashumints.space: trovare un Cashu mint si può fidare.",
+  "seo.mint.title.one": "{name} recensioni: valutato {rating} da {n} recensione | Cashumints.space",
+  "seo.mint.title.other": "{name} recensioni: valutato {rating} da {n} recensioni | Cashumints.space",
+  "seo.mint.titleOffline.one": "{name}: offline per {n} day | Cashumints.space",
+  "seo.mint.titleOffline.other": "{name}: offline per {n} days | Cashumints.space",
+  "seo.mint.titleNoReviews": "{name}: Cashu mint info e recensioni | Cashumints.space",
+  "seo.fedimint.titleNoReviews": "{name}: Fedimint federazione informazioni e recensioni | Cashumints.space",
+  "seo.desc.fallback": "Recensioni comunitarie per {name} ({domain}).",
+  "seo.desc.fallbackDomain": "Rivista comunitaria per il Cashu mint a {domain}.",
+  "seo.desc.rated.one": "Voto {rating}/5 da {n} firmato Nostr recensione.",
+  "seo.desc.rated.other": "Voto {rating}/5 da {n} firmato Nostr recensioni.",
+  "seo.desc.noReviews": "Ancora nessuna recensione.",
+  "seo.desc.status": "{status}.",
+  "seo.desc.statusLimits": "{status}, limiti {limits}.",
+  "seo.desc.fedModules": "{status}. Moduli: {modules}.",
+  "seo.desc.fedModulesNetwork": "{status}. Moduli: {modules} su {network}.",
+  "seo.mint.ogAlt.one": "{name}: {rating} stelle da {n} recensione su Cashumints.space",
+  "seo.mint.ogAlt.other": "{name}: {rating} stelle da {n} recensioni su Cashumints.space",
+  "seo.mint.ogAltNoReviews": "{name} su Cashumints.space",
+  "nav.home": "Home",
+  "mint.more.title": "Altro mints",
+  "mint.more.all": "Vedi tutto mints",
+  "nav.fedimints": "Fedimints",
+  "status.announced": "Annunciato solo",
+  "card.unnamedFederation": "federazione non nominata",
+  "card.notChecked": "mai controllato",
+  "fedimints.title": "Tutti Fedimint federazioni · Cashumints.space",
+  "fedimints.description": "Tutte le federazioni {total} Fedimint annunciate sulla rete Nostr: {online} confermate in esecuzione da un controllo esterno, {announced} annunciato e mai confermato. Punteggi comunitari, moduli e codici di invito per ciascuno.",
+  "fedimints.heading": "Tutte le federazioni",
+  "fedimints.lede": "Ogni federazione Fedimint annunciata sulla rete Nostr. Una federazione non ha alcun punto finale di stato pubblico, quindi alcuni di questi sono confermati in esecuzione da un controllo esterno e il resto sono elencati esattamente come sono stati annunciati.",
+  "fedimints.search.label": "Federazioni di ricerca per nome o id",
+  "fedimints.search.placeholder": "Ricerca per nome o federazione id...",
+  "fedimints.sort.label": "Ordinare federazioni",
+  "fedimints.hideOffline": "Nascondi offline",
+  "fedimints.showing": "Mostrando {total} federazioni ({online} confermato, {announced} annunciato solo)",
+  "fedimints.showingFiltered": "Mostrando {shown} di {total} federazioni ({online} confermato, {announced} annunciato solo)",
+  "fedimints.announcedNote.one": "Uno di questi è stato annunciato su Nostr e nulla ha confermato dal momento che è in esecuzione. È elencato come annunciato piuttosto che come online o offline, perché né sarebbe vero.",
+  "fedimints.announcedNote.other": "{n} di questi sono stati annunciati su Nostr e nulla ha confermato dal momento che stanno correndo. Sono elencati come annunciato piuttosto che come online o offline, perché né sarebbe vero.",
+  "fedimints.noResults": "Nessuna federazione corrisponde. Prova un nome, o incolla un ID federazione.",
+  "fedimints.emptyIndex": "Non sono state annunciate federazioni sui relè che questo sito legge. La lista si riempie di annunci.",
+  "fedimint.crumb": "Fediminti",
+  "fedimint.breadcrumb": "Percorso di navigazione",
+  "fedimint.unnamed": "federazione non nominata",
+  "fedimint.idLabel": "Federazione",
+  "fedimint.kind.federationId": "Federazione",
+  "fedimint.moduleCount.one": "Modulo {n}",
+  "fedimint.moduleCount.other": "Moduli {n}",
+  "fedimint.copyInvite": "Copia codice invito",
+  "fedimint.confirmed.label": "Confermato",
+  "fedimint.confirmed.never": "Mai",
+  "fedimint.confirmed.by": "da {source}",
+  "fedimint.confirmed.unattributed": "Ultimo controllo",
+  "fedimint.announcedOn": "annunciato {when}",
+  "fedimint.announcedUnknown": "nessuna data di annuncio",
+  "fedimint.modules.title": "Moduli",
+  "fedimint.modules.none": "L'annuncio di questa federazione non elenca moduli.",
+  "fedimint.modules.note": "I moduli sono le parti che una federazione gestisce. L'annuncio dice che sono presenti, e nulla circa se uno di loro accetta depositi.",
+  "fedimint.modules.notListed": "non elencato",
+  "fedimint.invite.title": "Codice invito",
+  "fedimint.invite.count.one": "{n} codice",
+  "fedimint.invite.count.other": "{n} codici",
+  "fedimint.invite.note": "Incolla questo in un portafoglio Fedimint per unirsi. Porta l'ID federazione e gli indirizzi dei suoi guardiani, ed è destinato a essere condiviso.",
+  "fedimint.invite.kind": "invito codice",
+  "fedimint.invite.qr": "QR",
+  "fedimint.invite.qrCaption": "Scansione per aderire {name}",
+  "fedimint.details.federationId": "Federazione id",
+  "fedimint.details.network": "Rete di rete",
+  "fedimint.details.announcedBy": "Annunciato da",
+  "fedimint.details.announced": "Annunciato",
+  "fedimint.more.title": "Altre federazioni",
+  "fedimint.more.all": "Vedi tutte le federazioni",
+  "fedimint.disclaimer": "Unire una federazione significa fidarsi dei suoi guardiani con i vostri soldi. Le valutazioni sono opinioni della comunità, e confermata in esecuzione significa raggiungibile, non affidabile.",
+  "fedimint.module.lightning": "Lightning",
+  "fedimint.module.mint": "Ecash mint",
+  "fedimint.module.wallet": "Portafoglio on-chain",
+  "fedimint.module.meta": "Metadati",
+  "fedimint.module.stability_pool": "Piscina per disabili",
+  "fedimint.module.multi_sig_stability_pool": "Piscina di stabilità (multisig)",
+  "fedimint.module.fedi-social": "Recupero sociale",
+  "fedimint.network.mainnet": "Bitcoin mainnet",
+  "fedimint.network.signet": "Signet",
+  "fedimint.network.testnet": "Testnet",
+  "fedimint.network.testnet4": "Testnet4",
+  "fedimint.network.regtest": "Regtest",
+  "feed.ecosystem.group": "Ecosistema",
+  "feed.ecosystem.all": "Tutti",
+  "feed.ecosystem.cashu": "Cashu",
+  "feed.ecosystem.fedimint": "Fedimint",
+  "feed.filterBySubject": "Filtra per mint o federazione",
+  "feed.anySubject": "Qualsiasi mint o federazione",
+  "feed.clearSubject": "Cancellare il filtro nome",
+  "home.topFedimints.title": "I migliori Fedimint",
+  "home.topFedimints.sub": "classificato per recensioni e valutazioni",
+  "home.topFedimints.all": "Tutte le federazioni {n} →",
+  "reviews.validate.subject": "Non c'è nulla a cui puntare questa recensione.",
+  "mint.warnings.fedimintOffline.lead": "Segnalato offline.",
+  "mint.warnings.fedimintOffline.body.since": "L'ultimo controllo che ha raggiunto questa federazione era su {date} ({days} fa). I suoi guardiani non hanno risposto da allora. Trattare fondi detenuti lì come a rischio, e non unirsi a esso con nuovi fondi.",
+  "mint.warnings.fedimintOffline.body.never": "Nessun controllo di questa federazione è mai arrivato, e quello più recente è fallito. Trattare fondi detenuti lì come a rischio, e non unirsi a esso con nuovi fondi.",
+  "mint.warnings.fedimintOffline.meta.since": "Segnalato offline da {date}",
+  "mint.warnings.fedimintOffline.meta.never": "Segnalato offline, mai raggiunto",
+  "mint.warnings.neverConfirmed.lead": "Annunciato, mai confermato.",
+  "mint.warnings.neverConfirmed.body.reviewed": "Questa federazione è stata annunciata su Nostr su {date}, {days} fa, e nulla ha confermato da allora che è in esecuzione. Le recensioni qui sotto sono l'unico segno di vita in questa pagina; tutto il resto è venuto dall'annuncio.",
+  "mint.warnings.neverConfirmed.body.quiet": "Questa federazione è stata annunciata su Nostr su {date}, {days} fa, nulla ha confermato da allora che è in esecuzione, e nessuno l'ha recensito recentemente. Tutto il sotto è venuto dall'annuncio.",
+  "mint.warnings.neverConfirmed.meta": "Annunciato {date}, mai confermato",
+  "footer.allFedimints": "Tutte le federazioni",
+  "reviews.dialog.bodyPlaceholder.cashu": "Come ha funzionato minting, melting e supporto? Sii specifico.",
+  "reviews.dialog.bodyPlaceholder.fedimint": "Come si è unito, Lightning pagamenti e supporto funziona? Sii specifico.",
+  "fedimint.details.title": "Dettagli della Federazione",
+  "nav.lnurlMints": "Mint LNURL",
+  "footer.allLnurlMints": "Tutti i mint LNURL",
+  "lnurlMints.title": "Mint LNURL: mint di banconote al portatore lnurlcash, con recensioni | Cashumints.space",
+  "lnurlMints.description": "Tutti i {total} mint LNURL indicizzati dalla rete Nostr: {online} online, {offline} offline. Valutazioni della comunità, limiti di prelievo e funzionalità di ciascuno.",
+  "lnurlMints.heading": "Mint LNURL",
+  "lnurlMints.lede": "Ogni mint LNURL che questo sito conosce. Un mint LNURL emette banconote al portatore lnurlcash: banconote Lightning che conservi come un segreto e che si possono ruotare, dividere, unire o rifondere in un pagamento Lightning. Ognuno viene controllato via HTTPS ogni pochi minuti.",
+  "lnurlMints.search.label": "Cerca mint LNURL",
+  "lnurlMints.search.placeholder": "Cerca per nome o indirizzo…",
+  "lnurlMints.sort.label": "Ordina i mint LNURL per",
+  "lnurlMints.hideOffline": "Nascondi offline",
+  "lnurlMints.showing": "Mostrati {total} mint LNURL ({online} online, {offline} offline)",
+  "lnurlMints.showingFiltered": "Mostrati {shown} di {total} mint LNURL ({online} online, {offline} offline)",
+  "lnurlMints.noResults": "Nessun mint LNURL corrisponde.",
+  "lnurlMints.emptyIndex": "Non ci sono ancora mint LNURL indicizzati.",
+  "lnurl.crumb": "Mint LNURL",
+  "lnurl.breadcrumb": "Percorso di navigazione",
+  "lnurl.copyAddress": "Copia indirizzo",
+  "lnurl.more.title": "Altri mint LNURL",
+  "lnurl.more.all": "Tutti i mint LNURL →",
+  "lnurl.disclaimer": "Un mint LNURL custodisce i tuoi sat mentre tu custodisci le sue banconote, quindi usarne uno significa fidarsi del suo operatore. Le valutazioni sono opinioni della comunità, e online significa raggiungibile, non affidabile.",
+  "lnurl.features.title": "Funzionalità",
+  "lnurl.features.none": "Questo mint non ha annunciato cosa supporta.",
+  "lnurl.features.note": "Le funzionalità sono ciò che l'operatore del mint ha annunciato su Nostr. Dove questo sito può verificarne una via HTTPS lo fa, e segnala quando qualcosa di annunciato non è disponibile in questo momento.",
+  "lnurl.features.notListed": "non annunciato",
+  "lnurl.features.unavailable": "non disponibile",
+  "lnurl.feature.mint": "Minting via Lightning (LUD-06)",
+  "lnurl.feature.melt": "Melting verso Lightning",
+  "lnurl.feature.notes": "Ruota / dividi / unisci banconote",
+  "lnurl.feature.lud16": "Indirizzo Lightning",
+  "lnurl.feature.lud21": "Verifica del pagamento (LUD-21)",
+  "lnurl.feature.signed-notes": "Banconote firmate (verifica offline)",
+  "lnurl.feature.onion": "Indirizzo Tor",
+  "lnurl.feature.rotate": "Ruota una banconota",
+  "lnurl.feature.split": "Dividi una banconota",
+  "lnurl.feature.merge": "Unisci banconote",
+  "lnurl.feature.lud06": "payRequest LUD-06",
+  "lnurl.feature.lud03": "withdrawRequest LUD-03",
+  "lnurl.limits.label": "Limiti di prelievo",
+  "lnurl.limits.notPublished": "non pubblicato",
+  "lnurl.limits.withdrawRow": "Prelievo",
+  "lnurl.limits.disabled": "disattivato",
+  "lnurl.limits.sats.one": "{n} sat",
+  "lnurl.limits.sats.other": "{n} sat",
+  "lnurl.details.title": "Dettagli del mint",
+  "lnurl.details.address": "Indirizzo Lightning",
+  "lnurl.details.mintPubkey": "Chiave pubblica del mint",
+  "lnurl.details.onion": "Indirizzo Tor",
+  "lnurl.details.fee": "Commissione di minting",
+  "lnurl.details.node": "Nodo",
+  "lnurl.details.capacity": "Capacità annunciata",
+  "lnurl.kind.lightningAddress": "indirizzo Lightning",
+  "lnurl.kind.mintPubkey": "chiave pubblica del mint",
+  "lnurl.kind.onionAddress": "indirizzo Tor",
+  "lnurl.confirmed.label": "Ultima conferma",
+  "lnurl.confirmed.when": "confermato {when}",
+  "lnurl.fee.base.one": "{n} sat",
+  "lnurl.fee.base.other": "{n} sat",
+  "lnurl.fee.percent": "{percent}%",
+  "home.topLnurl.title": "Migliori mint LNURL",
+  "home.topLnurl.sub": "ordinati per recensioni e valutazione",
+  "home.topLnurl.all": "Tutti i {n} mint LNURL →",
+  "feed.ecosystem.lnurl": "LNURL",
+  "reviews.dialog.bodyPlaceholder.lnurl": "Come sono andati minting, melting e la rotazione delle banconote? Sii concreto.",
+  "reviews.byUrl.open": "Scrivi una recensione",
+  "reviews.byUrl.title": "Scrivi una recensione",
+  "reviews.byUrl.lede": "Incolla l’indirizzo. Se questo sito non lo conosce ancora, viene controllato e aggiunto ora.",
+  "reviews.byUrl.label.cashu": "URL del mint",
+  "reviews.byUrl.label.fedimint": "Codice di invito della federazione",
+  "reviews.byUrl.label.lnurl": "URL del mint LNURL",
+  "reviews.byUrl.placeholder.cashu": "mint.example.com",
+  "reviews.byUrl.placeholder.fedimint": "fed11…",
+  "reviews.byUrl.placeholder.lnurl": "mint.example.com",
+  "reviews.byUrl.check": "Controlla questo indirizzo",
+  "reviews.byUrl.checking": "Controllo in corso…",
+  "reviews.byUrl.back": "Usa un altro indirizzo",
+  "reviews.byUrl.existing": "Già elencato",
+  "reviews.byUrl.indexed": "Appena aggiunto",
+  "reviews.byUrl.confirmClose": "Chiudere? L’indirizzo digitato non viene conservato.",
+  "reviews.byUrl.detected": "Quell’indirizzo ha risposto come un mint {kind}.",
+  "reviews.byUrl.switchTo": "Recensiscilo come mint {kind}",
+  "reviews.byUrl.error.empty": "Inserisci prima un indirizzo.",
+  "reviews.byUrl.error.badUrl": "Non sembra l’URL di un mint.",
+  "reviews.byUrl.error.badInvite": "Non è un codice di invito Fedimint. I codici iniziano con fed11.",
+  "reviews.byUrl.error.badInput": "Questo sito non può controllare quell’indirizzo.",
+  "reviews.byUrl.error.blocked": "Non è un indirizzo pubblico, quindi non può essere controllato.",
+  "reviews.byUrl.error.notAMint": "Quell’indirizzo ha risposto, ma non come un mint di questo tipo.",
+  "reviews.byUrl.error.wrongType": "Quell’indirizzo ha risposto, ma come un mint di un altro tipo.",
+  "reviews.byUrl.error.unverifiable": "A quell’indirizzo non ha risposto nulla, e su Nostr non c’è ancora traccia.",
+  "reviews.byUrl.error.rateLimited.one": "Sono molti controlli da una sola connessione. Riprova tra circa {n} minuto.",
+  "reviews.byUrl.error.rateLimited.other": "Sono molti controlli da una sola connessione. Riprova tra circa {n} minuti.",
+  "reviews.byUrl.error.network": "Non è stato possibile raggiungere l’indice. Controlla la connessione e riprova.",
+  "seo.lnurl.titleNoReviews": "{name}: informazioni e recensioni del mint LNURL | Cashumints.space",
+  "seo.desc.statusWithdraw": "{status}, prelievo {min}–{max} sat.",
+  "mint.chip.noFunding": "Né mint né melt",
+  "mint.warnings.lnurlWithdrawalsDisabled.lead": "Prelievi disattivati.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.online": "Questo mint dichiara un prelievo massimo pari a zero, quindi nessuna banconota che emette può essere riscossa per qualcosa. Non fare minting qui finché non cambia.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.offline": "Questo mint dichiarava un prelievo massimo pari a zero l'ultima volta che è stato raggiunto, quindi nessuna banconota che emetteva poteva essere riscossa per qualcosa. Non fare minting qui finché non cambia.",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.online": "Prelievi attualmente disattivati",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.offline": "I prelievi erano disattivati all'ultimo contatto",
+  "mint.warnings.lnurlInvalid.lead": "L'endpoint risponde ma non è valido.",
+  "mint.warnings.lnurlInvalid.body": "L'host risponde, ma non con un annuncio di mint che questo sito sappia leggere, quindi i prelievi potrebbero non funzionare. Quello che segue è l'ultimo stato leggibile, e le recensioni funzionano ancora.",
+  "mint.warnings.lnurlInvalid.meta": "Risponde, ma non con un annuncio di mint valido",
+  "mint.warnings.lnurlNoFunding.lead": "Minting e melting non disponibili.",
+  "mint.warnings.lnurlNoFunding.body": "Le banconote esistenti si possono ancora ruotare, dividere o unire, ma al momento nulla entra o esce via Lightning. Il mint è attivo e risponde; il nodo Lightning che sta dietro non è raggiungibile da lì.",
+  "mint.warnings.lnurlNoFunding.meta": "Minting e melting non disponibili",
+  "mint.warnings.also.noFunding": "Anche il suo nodo Lightning era irraggiungibile, quindi non si poteva fare né minting né melting."
+}

web/src/i18n/ja.json

@@ -0,0 +1,788 @@
+{
+  "site.name": "Cashumints.space",
+  "common.close": "ふりがな",
+  "common.cancel": "キャンセル",
+  "common.done": "ログイン",
+  "common.back": "バックナンバー",
+  "common.retry": "リトリート",
+  "common.connect": "ログイン",
+  "common.copied": "コピッド",
+  "common.copyFull": "コピーフル {kind}",
+  "common.previousPage": "前のページ",
+  "common.nextPage": "次のページ",
+  "common.reviewPages": "レビューページ",
+  "time.never": "決してない",
+  "time.justNow": "ただ今",
+  "time.none": "・",
+  "time.unknownDate": "未知の日付",
+  "time.ago.minute": "{n}m 前に",
+  "time.ago.hour": "{n}h 前に",
+  "time.ago.day": "{n}d 前に",
+  "time.ago.week": "{n}w 前に",
+  "time.ago.month": "{n}mo 前に",
+  "time.ago.year": "{n}y 前に",
+  "time.short.minute": "{n}メートル",
+  "time.short.hour": "{n}hの",
+  "time.short.day": "{n}dの",
+  "time.short.week": "{n}ワット",
+  "time.short.month": "{n}モ",
+  "time.short.year": "{n}yの",
+  "status.online": "オンライン",
+  "status.offline": "オフライン",
+  "status.degraded": "到達不能",
+  "status.unknown": "未確認",
+  "nav.skip": "コンテンツへスキップ",
+  "nav.main": "メインページ",
+  "nav.mints": "Cashu ミント",
+  "nav.reviews": "レビュー",
+  "nav.wallets": "ウォレット",
+  "nav.about": "サイトについて",
+  "nav.searchMints": "{n} 件のミントを検索",
+  "lang.label": "言語",
+  "lang.switcher": "言語を選択",
+  "footer.copyright": "© {year} Cashumints.space",
+  "footer.allMints": "すべての Cashu ミント",
+  "footer.allReviews": "すべてのレビュー",
+  "footer.wallets": "ウォレット",
+  "footer.about": "サイトについて",
+  "footer.disclaimer": "免責事項",
+  "footer.terms": "利用規約",
+  "footer.privacy": "プライバシー",
+  "footer.madeBy": "{azzamo} が ❤️ を込めて制作 · Cashu と NIP-87 で動作",
+  "footer.warning": "ミントはカストディアル（資金を預かる）です。ミントがあなたのお金ごと消えることがあります。",
+  "footer.tagline": "ecash ミントに対するコミュニティのレビュー。Nostr で署名されています。",
+  "footer.col.explore": "探す",
+  "footer.col.site": "サイト",
+  "footer.nav": "フッター",
+  "home.title": "Cashumints.space · 信頼できる Cashu ミントを見つける",
+  "home.description": "信頼できる Cashu ミントを見つけましょう。{mints} 件のミントを収録し、Nostr で署名された {reviews} 件のコミュニティレビュー、稼働状況、対応 NUTs、ミントソフトウェアの情報を掲載しています。",
+  "home.hero.title": "Cashu ミントを探す",
+  "home.hero.titleEm": "信頼できます",
+  "home.hero.lede": "コミュニティレビューを実践するNostrネットワーク上ですべてのミント。 ゲートキーパーは、あなたが自分で確認できるレビューを署名しました。",
+  "home.search.label": "名前、ドメイン、URLでミントを検索",
+  "home.search.placeholder": "名前、ドメインで検索するか、ミントURLを貼り付けます。",
+  "home.filters.mostReviewed": "ほとんどのレビュー",
+  "home.filters.highestRated": "最高評価",
+  "home.filters.recentlyActive": "最近の活動",
+  "home.filters.websockets": "WebSocketをサポート",
+  "home.top.title": "人気の Cashu ミント",
+  "home.top.sub": "レビューと評価でランク付け",
+  "home.top.all": "すべて {n} 分 →",
+  "home.latest.title": "最新のレビュー",
+  "home.latest.sub": "Nostrネットワークからライブ",
+  "home.latest.prev": "前のレビュー",
+  "home.latest.next": "その他のレビュー",
+  "home.latest.all": "すべてのレビュー →",
+  "home.latest.empty": "リレーからのレビューが読み込まれることができません。 直接レビューを読み書きするために、任意のミントページを開きます。",
+  "home.why.title": "なぜこれらのレビューを信頼しますか?",
+  "home.why.signed.title": "署名、提出されていない",
+  "home.why.signed.body": "すべてのレビューは、著者のNostrキーによって署名された{link}イベントです。 ここに編集、ランク付け、または削除されたものはありません。",
+  "home.why.signed.link": "NIP-87の特長",
+  "home.why.verify.title": "自分で確認する",
+  "home.why.verify.body": "レビューは、私たちのデータベースではなく、公のNostrリレーに住んでいます。 同じリレーで任意のクライアントをポイントし、同じデータが表示されます。",
+  "home.why.checked.title": "絶えず点検される",
+  "home.why.checked.body": "稼働時間、ソフトウェアバージョン、制限、および対応するNUT毎のミントをプローブします。そのため、自分で報告されていない仕様が表示されます。",
+  "home.cta.title": "ミントについて考える まずはお読みください。",
+  "home.cta.body": "ミントはecashを保持します。 あなたが座る前に、他の人が見つけたものを読んで、あなたは1自分自身を使用していたときにレビューを残します。",
+  "home.cta.explore": "すべてのミントを見る",
+  "home.cta.learn": "Cashuについて知る",
+  "pulse.mintsIndexed": "mints インデックス",
+  "pulse.reviewsOnNostr": "Nostrのレビュー",
+  "pulse.lastReview": "最終レビュー",
+  "pulse.mintsOnline": "オンラインミント",
+  "pulse.indexer": "インデックス",
+  "pulse.connected": "コネクティッド",
+  "pulse.stale": "ストール",
+  "mints.title": "すべての Cashu ミント · Cashumints.space",
+  "mints.description": "すべて {total} Cashu は、Nostr のネットワーク、{online} オンラインおよび {offline} オフラインでインデックス化され、コミュニティの評価、稼働時間、ミント ソフトウェア。 完全なリストを検索してソートします。",
+  "mints.heading": "すべての Cashu ミント",
+  "mints.lede": "ノストラネットワークで発見されたミントは、消えているものを含む。 オフラインのミントはリストされているので、まだそれらを見つけ、確認することができます。",
+  "mints.search.label": "名前またはドメインでミントを検索",
+  "mints.search.placeholder": "名前やドメインで検索",
+  "mints.sort.label": "ソートミント",
+  "mints.sort.score": "最高の全体",
+  "mints.sort.rating": "最高評価",
+  "mints.sort.reviews": "ほとんどのレビュー",
+  "mints.sort.recent": "最近レビュー",
+  "mints.sort.seen": "最近オンラインで見た",
+  "mints.hideOffline": "オフラインで隠す",
+  "mints.showing": "見る {total} mints ({online} オンライン, {offline} オフライン)",
+  "mints.showingFiltered": "見る {shown} の {total} ミント ({online} オンライン、{offline} オフライン)",
+  "mints.noResults": "マッチしません。 ドメインを試すか、ミントのURLを貼り付けます。",
+  "mints.clearSearch": "検索をクリアする",
+  "card.noRatings": "評価はまだありません",
+  "card.reviews.one": "{n} レビュー",
+  "card.reviews.other": "スコア {n} レビュー",
+  "card.lastSeen": "最後の見ました {when}",
+  "card.neverSeen": "オンラインで見たことがない",
+  "card.reviewed": "レビュー {when}",
+  "card.noReviews": "レビューはまだありません",
+  "mint.title": "{name} · Cashuミントレビュー",
+  "mint.titleFedimint": "{name} · Fedimint フェデレーションのレビュー",
+  "mint.titleLnurl": "{name} · LNURL mint のレビュー",
+  "mint.breadcrumb": "パン粉",
+  "mint.crumbMints": "キャッシュミント",
+  "mint.copyUrl": "ミントURLをコピーする",
+  "mint.qrButton": "ミントQR",
+  "mint.writeReview": "レビューを書く",
+  "mint.rankByScore": "#{rank} スコアで",
+  "mint.tagLightning": "ライトニング",
+  "mint.summary": "ミントサマリー",
+  "mint.rating.label": "コミュニティの評価",
+  "mint.rating.none": "評価はまだありません",
+  "mint.rating.reviews.one": "{n} レビュー",
+  "mint.rating.reviews.other": "スコア {n} レビュー",
+  "mint.rating.unrated.one": "{n} 左の評価",
+  "mint.rating.unrated.other": "{n} 左の評価",
+  "mint.activity.label": "活動内容",
+  "mint.activity.since": "最後のレビュー以来",
+  "mint.activity.noReviews": "レビューはまだありません",
+  "mint.activity.recent.one": "{n} レビュー に 最後の 90 日",
+  "mint.activity.recent.other": "最後の90日間の{n}レビュー",
+  "mint.limits.label": "制限事項",
+  "mint.limits.notPublished": "未公開",
+  "mint.limits.min": "ツイート",
+  "mint.limits.max": "マックス",
+  "mint.limits.mintRow": "ミント",
+  "mint.limits.meltRow": "ログイン",
+  "mint.limits.disabled": "バリアフリー",
+  "mint.limits.range": "{min} へ {max} {unit}",
+  "mint.limits.upTo": "まで {max} {unit}",
+  "mint.limits.from": "から {min} {unit}",
+  "mint.software.label": "ミントソフトウェア",
+  "mint.software.unknown": "インフォメーション",
+  "mint.checked": "チェック {when}",
+  "mint.lastSeen": "最後の見ました {when}",
+  "mint.neverReached": "決して到達しません",
+  "mint.uptime.checks": "{ok} の 最後の {total} チェック 到達可能",
+  "mint.uptime.percent": "{percent}% 30日以上到達可能",
+  "mint.uptime.description": "{ok} の最後の {total} チェックの成功",
+  "mint.operator.title": "オペレータから",
+  "mint.operator.motd": "当日のメッセージ",
+  "mint.operator.beta": "このミントは実験的かベータとしてそれ自身を記述します。 あなたが失うことができないものを格納する前に、オペレータの独自の言葉を読んでください。",
+  "mint.nuts.title": "NUT対応",
+  "mint.nuts.noneOffline": "NUTリストは、このミントのためにキャッシュされず、記録される前にオフラインに行ってきました。",
+  "mint.nuts.noneYet": "NUT リストがまだこの mint にキャッシュされていない。",
+  "mint.nuts.supported": "{n} の {total} は NUT を支えました",
+  "mint.nuts.whatAre": "NUTとは?",
+  "mint.nutRow.disabled": "バリアフリー",
+  "mint.nutRow.notSupported": "サポートされていない",
+  "mint.details.title": "ミントの細部",
+  "mint.details.pubkey": "パブキー",
+  "mint.details.nostr": "ノストール",
+  "mint.details.email": "電子メール",
+  "mint.details.serverTime": "サーバー時間",
+  "mint.details.firstSeen": "初めて見た",
+  "mint.details.terms": "利用規約",
+  "mint.kind.identifier": "識別子",
+  "mint.kind.mintPubkey": "ミントパブキー",
+  "mint.kind.nostrAddress": "ノストアドレス",
+  "mint.kind.emailAddress": "メールアドレス",
+  "mint.kind.npub": "ログイン",
+  "mint.disclaimer": "このミントはカストディアルです:それはあなたのお金を保持し、それはいつでもそうすることを止めることができます。 格付けは、コミュニティの意見であり、オンラインは、信頼できるものではありません。",
+  "mint.disclaimerLink": "完全な免責事項を読む",
+  "mint.qr.title": "ウォレットに{name}を追加",
+  "mint.qr.note": "これをキャッシュウォレットでスキャンして、ミントを追加したり、URLをコピーして貼り付けます。",
+  "mint.qr.warn": "ミントを追加すると、お金でそれを信頼することを意味します。",
+  "mint.qr.whatMeans": "つまり、",
+  "mint.qr.wallets": "Cashuをサポートするウォレット",
+  "mint.chip.frozen": "冷凍庫",
+  "mint.chip.noWithdrawals": "出金なし",
+  "mint.chip.meltOnly": "メルトだけ",
+  "mint.warnings.dayCount.one": "{n} 日",
+  "mint.warnings.dayCount.other": "{n} 日",
+  "mint.warnings.gone.lead": "同様に消える。",
+  "mint.warnings.gone.body.since": "{date} ({days})以来、このミントは到達できませんでした。 リスクとして保有する資金を扱い、新たな資金を送らないでください。 以下は、最後の既知の状態を示します。",
+  "mint.warnings.gone.body.neverDated": "{month}で見始めるので、このミントは単一のチェックに答えていませんでした。 リスクとして保有する資金を扱い、新たな資金を送らないでください。 以下のものは、ミントからではなく、ノストラの発表から来た。",
+  "mint.warnings.gone.body.never": "見始めてから、ひとつのチェックに答えなかったミント。 リスクとして保有する資金を扱い、新たな資金を送金しません。 以下のものは、ミントからではなく、ノストラの発表から来た。",
+  "mint.warnings.gone.meta.since": "{date}以来のオフライン",
+  "mint.warnings.gone.meta.never": "発見されたので、決して到達できません",
+  "mint.warnings.meltDisabled.lead": "引き出しが無効になっています。",
+  "mint.warnings.meltDisabled.body.online": "このミントはライトニングメルト(NUT-05)がオフになっている:あなたはsatsを入れることができますが、Lightningを介してそれらを引き出すことはできません。 溶けるまで入金しないでください。",
+  "mint.warnings.meltDisabled.body.offline": "このミントはライトニングメルト(NUT-05)がオフになりました:あなたは座って置くことができますが、あなたはLightningを介してそれらを撤回することはできません。 溶けるまで入金しないでください。",
+  "mint.warnings.meltDisabled.meta.online": "現在無効になっています",
+  "mint.warnings.meltDisabled.meta.offline": "過去に見られたときの引き出しは無効になりました",
+  "mint.warnings.frozen.lead": "ミント凍結。",
+  "mint.warnings.frozen.body.online": "ミンチと溶融の両方が無効になっています。 土はライトニングで動かすことはできません。",
+  "mint.warnings.frozen.body.offline": "ミンチと溶融の両方が無効になりました。 土はライトニングで動かすことはできません。",
+  "mint.warnings.frozen.meta.online": "現在凍結、何も動きません",
+  "mint.warnings.frozen.meta.offline": "最後の見られたとき凍らせて下さい",
+  "mint.warnings.offlineLong.lead": "{date}年以来、{days}のためのオフライン。",
+  "mint.warnings.offlineLong.body": "ミントは消える可能性があります。 以下は、その最後の既知の状態であり、レビューはまだ機能しています。",
+  "mint.warnings.offlineLong.meta": "{date}以来のオフライン",
+  "mint.warnings.meltOnly.lead": "メルトだけ。",
+  "mint.warnings.meltOnly.body.online": "新規マイニング(NUT-04)は無効です。入金できませんが、既存のキャッシュはまだ撤退できます。 これは多くの場合、ミントが巻いていることを意味します。そのため、湿疹を保持している場合は、溶融を検討してください。",
+  "mint.warnings.meltOnly.body.offline": "新採掘(NUT-04)は無効になっています。入金できませんが、既存の発疹は引き出すことができます。 これは多くの場合、ミントが巻いていることを意味します。そのため、湿疹を保持している場合は、溶融を検討してください。",
+  "mint.warnings.meltOnly.meta.online": "現在、メルトのみ",
+  "mint.warnings.meltOnly.meta.offline": "最後に見たときだけ溶ける",
+  "mint.warnings.offline.lead": "{date}年以来のオフライン。",
+  "mint.warnings.offline.body": "詳細は最終確認です。 レビューを書くことができます。",
+  "mint.warnings.offline.meta": "{date}以来のオフライン",
+  "mint.warnings.also.meltDisabled": "オフラインに行く前に、無効な出金もありました。",
+  "mint.warnings.also.mintDisabled": "オフラインに行く前に、新しいミニストも無効になりました。",
+  "mint.warnings.also.offline": "{date} ({days})以来、オフラインでもあります。",
+  "nut.0": "ノテーションとモデル",
+  "nut.1": "秘密鍵交換",
+  "nut.2": "キーセットと手数料",
+  "nut.3": "スワッピングトークン",
+  "nut.4": "ライトニングによるミンチ",
+  "nut.5": "ライトニングによる溶ける",
+  "nut.6": "ミント情報",
+  "nut.7": "トークンの状態チェック",
+  "nut.8": "過払いされた避雷料",
+  "nut.9": "署名を復元する",
+  "nut.10": "利用条件",
+  "nut.11": "公開鍵の支払い",
+  "nut.12": "DLEQの証拠",
+  "nut.13": "決定的な秘密",
+  "nut.14": "ハッシュタイムロック契約",
+  "nut.15": "マルチパス決済",
+  "nut.16": "QRコード",
+  "nut.17": "WebSocketサブスクリプション",
+  "nut.18": "支払いリクエスト",
+  "nut.19": "キャッシュされた応答",
+  "nut.20": "署名されたミントの引用符",
+  "nut.21": "明確な認証",
+  "nut.22": "盲目の認証",
+  "nut.23": "BOLT11の支払方法",
+  "nut.24": "HTTP 402 支払い必須",
+  "nut.25": "BOLT12の支払方法",
+  "reviews.title": "レビュー",
+  "reviews.anon": "アノン",
+  "reviews.anonTitle": "このキーの公開Nostrプロファイルが見つかりません",
+  "reviews.nip05Title": "NIP-05 識別子 (このサイトでは検証されていません)",
+  "reviews.filter.group": "フィルターレビュー",
+  "reviews.filter.all": "すべて",
+  "reviews.filter.five": "5★5",
+  "reviews.filter.critical": "クリティカル",
+  "reviews.filter.recent": "最近の投稿",
+  "reviews.filter.hideAnon": "アノンを隠す",
+  "reviews.anonHidden.other": "見る {n} の {total} レビュー: anon hidden.",
+  "reviews.allAnon.one": "ここで唯一のレビューはアノンです。",
+  "reviews.allAnon.other": "{n} 件のレビューはこちら aon.",
+  "reviews.allAnonShow.one": "それを表示する",
+  "reviews.allAnonShow.other": "それらを表示",
+  "reviews.loading.one": "Nostrリレーから{n}のレビューを読み込む",
+  "reviews.loading.other": "Nostrリレーから{n}のレビューを読み込む",
+  "reviews.empty": "レビューはありません。 まずは書いてください。",
+  "reviews.emptyWritten": "まだレビューはありません。 まずは書いてください。",
+  "reviews.emptyFilter": "このフィルタに一致するレビューはありません。",
+  "reviews.rate.cashu": "この mint を評価する",
+  "reviews.rate.fedimint": "このフェデレーションを評価する",
+  "reviews.rate.lnurl": "この mint を評価する",
+  "reviews.noscript": "レビューはNostrに署名され、ブラウザに読み込まれるので、このリストにはJavaScriptが必要です。 上記の評価とカウントは、サイト自体から来ています。",
+  "reviews.relayError": "リレーに到達できませんでした。 レビューは不完全かもしれません。",
+  "reviews.srRating": "{rating} から 5",
+  "reviews.srNoRating": "評価なし",
+  "reviews.readMore": "もっと読む",
+  "reviews.readLess": "少ないショー",
+  "reviews.actions.copyNpub": "コピーnpub",
+  "reviews.actions.openNostr": "Nostrでこのイベントを見る",
+  "reviews.actions.copyLink": "このレビューへのリンクをコピーする",
+  "reviews.anonNote": "このnpubからの最初のレビュー、他の活動が見つかりません",
+  "reviews.published": "掲載情報",
+  "reviews.publishedPartial": "に公開 {accepted} の {total} リレー.",
+  "reviews.propagating": "Nostrリレーに公開中",
+  "reviews.summary.line.one": "{count} コメントのない評価: {breakdown}",
+  "reviews.summary.line.other": "{count} コメントのない評価: {breakdown}",
+  "reviews.summary.lineDay.one": "{count} 評価なし にコメント {when}: {breakdown}",
+  "reviews.summary.lineDay.other": "{count} 件のコメントのない評価: {when}: {breakdown}",
+  "reviews.summary.showOne": "それを表示する",
+  "reviews.summary.showMany": "それらを表示",
+  "reviews.breakdown.5": "{n} 5つ星ホテル",
+  "reviews.breakdown.4": "{n} 4つ星ホテル",
+  "reviews.breakdown.3": "{n} 3つ星ホテル",
+  "reviews.breakdown.2": "{n} 2つ星ホテル",
+  "reviews.breakdown.1": "{n} ワンスター",
+  "reviews.breakdown.none": "{n} なしの評価",
+  "reviews.dialog.title": "レビュー {name}",
+  "reviews.dialog.lede.cashu": "この mint での体験を共有してください。",
+  "reviews.dialog.lede.fedimint": "このフェデレーションでの体験を共有してください。",
+  "reviews.dialog.lede.lnurl": "この mint での体験を共有してください。",
+  "reviews.dialog.permanent": "公開 Nostr リレーに恒久的に公開されます。",
+  "reviews.dialog.gate.title": "レビューを書くにはログインしてください",
+  "reviews.dialog.gate.lead": "レビューはあなたの Nostr 鍵で署名されます。鍵は署名アプリの中にとどまり、このサイトが見ることはありません。",
+  "reviews.dialog.ratingLegend": "あなたの評価",
+  "reviews.dialog.starsSr.one": "{n} スター",
+  "reviews.dialog.starsSr.other": "{n} つ星ホテル",
+  "reviews.dialog.chooseRating": "評価を選ぶ",
+  "reviews.dialog.starLabel": "{n}:{phrase}",
+  "reviews.dialog.stars.1": "それを避ける",
+  "reviews.dialog.stars.2": "問題があった",
+  "reviews.dialog.stars.3": "働いた, 洞窟で",
+  "reviews.dialog.stars.4": "お問い合わせ",
+  "reviews.dialog.stars.5": "素晴らしい作品",
+  "reviews.dialog.bodyLabel": "他の人が知っているべきことは何ですか?",
+  "reviews.dialog.charCount": "{n} / {max}",
+  "reviews.dialog.submit": "サインと出版",
+  "reviews.dialog.signing": "サインイン",
+  "reviews.dialog.publishing": "出版...",
+  "reviews.dialog.publishingTo": "リレーへの公開 ({accepted}/{total})",
+  "reviews.dialog.waitingExtension": "延長待ち",
+  "reviews.dialog.waitingSigner": "あなたの署名者を待っています",
+  "reviews.dialog.confirmClose": "このレビューを閉じる? サイトを離れるまで、あなたのドラフトは保持されます。",
+  "reviews.dialog.why.login": "ログインして公開する",
+  "reviews.dialog.why.words": "いくつかの単語を書く",
+  "reviews.dialog.why.more.one": "{n} キャラクター",
+  "reviews.dialog.why.more.other": "{n} より多くの文字",
+  "reviews.dialog.why.over.one": "限界の上の{n}の特性",
+  "reviews.dialog.why.over.other": "限界を超える{n}文字",
+  "reviews.dialog.identity.needSigner": "Nostr の署名者を公開する必要があります。 あなたの鍵は、その中にとどまります。このサイトは決して見ません。",
+  "reviews.dialog.identity.loginToPublish": "ログインして公開する",
+  "reviews.dialog.identity.switch": "スイッチ",
+  "reviews.dialog.identity.extension": "ブラウザの拡張機能に署名する",
+  "reviews.dialog.identity.readingKey": "公開鍵の読み込み",
+  "reviews.dialog.identity.willAsk": "延長は署名を求められます",
+  "reviews.dialog.error.noRelay": "リレーはレビューを受け付けていません。 接続を確認してもう一度お試しください。",
+  "reviews.validate.rating": "1から5星までの格付けを選択します。",
+  "reviews.validate.short": "少なくとも{n}文字を書くと、レビューが便利です。",
+  "reviews.validate.long": "レビューは{n}文字に制限されています。",
+  "feed.title": "最新のミントとフェデレーションのレビュー · Cashumints.space",
+  "feed.description": "ミント、フェデレーション、LNURL ミントのレビューを公開され次第すべて掲載：{mints} 件の Cashu ミント、{federations} 件の Fedimint フェデレーション、{lnurl} 件の LNURL ミントにわたる {reviews} 件のレビューを、Nostr 上で署名された新しい順に読めます。エコシステム、評価、名前で絞り込めます。",
+  "feed.heading": "最新のレビュー",
+  "feed.lede": "すべての Cashu mint と Fedimint のフェデレーションのすべてのレビューは、Nostr リレーからライブを最初に読みます。 それぞれがその著者によって署名され、私たちのデータベースではなく、リレーに住んでいます。",
+  "feed.label": "レビュー",
+  "feed.showingBuild.one": "最終ビルドから最新のレビューを表示",
+  "feed.showingBuild.other": "最後のビルドから{n}最新のレビューを表示",
+  "feed.noscript": "レビューはNostrに署名され、ブラウザに読み込まれるので、フィルタリングとフルリストにはJavaScriptが必要です。 {n}のレビューは、このページが構築されたときにリレーから読み込まれました。",
+  "feed.emptyBuild": "このページが構築されたときに、リレーからのレビューが読み取れません。 リストは、ブラウザのリレーからリロードします。",
+  "feed.foot": "レビューはコミュニティの意見であり、検証されていない主張です。 あなたがお金でミントを信頼する前に{link}を読んでください。",
+  "feed.footLink": "免責事項",
+  "feed.showing": "見る {shown} の {total} レビュー",
+  "feed.showingMatching": "見る {shown} の {matching} 一致するレビュー ({total} の合計)",
+  "feed.emptyRelays": "リレーからのレビューが返らない mint ページを開き、レビューを読み書きします。",
+  "feed.emptyFilter": "このフィルタに一致するレビューはありません。 ミントボックスをクリアするか、すべてを試してください。",
+  "feed.relayError": "リレーに到達できませんでした。 最後のビルドからのレビューを表示します。",
+  "feed.relayEmpty": "リレーからのレビューが返らない 最後のビルドからのレビューを表示します。",
+  "feed.reading": "リレーを読む...",
+  "login.open": "ログイン",
+  "login.title": "Nostrでログイン",
+  "login.note": "あなたのキーは、あなたの署名者に滞在します。 このサイトでは、決して見られません。",
+  "login.extension.name": "ブラウザ拡張",
+  "login.extension.desc": "Alby、nos2x、または別のNIP-07拡張子で署名する",
+  "login.extension.none": "延長が見つかりません",
+  "login.extension.getOne": "1 つを得る:",
+  "login.remote.name": "リモートサイダー",
+  "login.remote.desc": "署名アプリでコードをスキャンしたり、二段のリンクを貼り付ける",
+  "login.primal.name": "プリマル",
+  "login.primal.desc": "お使いの携帯電話のプリマルアプリでログイン承認",
+  "login.paste.label": "またはあなたのサイダーがあなたに与えた接続リンクを貼り付ける",
+  "login.copyLink": "接続リンクをコピーする",
+  "login.whatIsNostr": "Nostrとは?",
+  "login.connect.remote.title": "リモート・サイダーを接続して下さい",
+  "login.connect.remote.lead": "署名アプリでこれをスキャンするか、リンクをコピーして貼り付けます。",
+  "login.connect.remote.hint": "NIP-46 の署名者と連携: nsec.app、Amber、Nostrify、独自のバンカー。",
+  "login.connect.remote.open": "サインインアプリで開く",
+  "login.connect.primal.title": "Primalとつながる",
+  "login.connect.primal.lead": "お使いの携帯電話でPrimalを開き、その設定でリモート署名を見つけて、このコードをスキャンします。",
+  "login.connect.primal.hint": "NIP-46上の他のアプリのプライマルサインは、これは、任意のサイダーが使用するのと同じ接続であり、あなたのキーはプリマルにとどまります。 {link}の特長",
+  "login.connect.primal.open": "プリマルで開く",
+  "login.status.buildingLink": "接続リンクの構築",
+  "login.status.waitingExtension": "延長待ち",
+  "login.status.waitingSigner": "あなたの署名者を待っています",
+  "login.status.connecting": "署名者への接続",
+  "login.status.connected": "コネクテッド",
+  "login.toast.loggedIn": "ログインしました",
+  "login.toast.fetchingProfile": "リレーから Nostr プロフィールを取得しています…",
+  "login.toast.profile": "プロフィール: {name}",
+  "login.toast.noProfile": "リレーにプロフィールが見つかりませんでした",
+  "login.method.extension": "エクステンション",
+  "login.method.remote": "リモート",
+  "login.method.primal": "プリマル",
+  "login.account": "Nostrアカウント",
+  "login.copyNpub": "フルnpubをコピーする",
+  "login.logout": "ログイン",
+  "signer.status.waitingExtension": "延長待ち",
+  "signer.status.signed": "サインイン",
+  "signer.status.reconnecting": "署名者への再接続",
+  "signer.status.approveWindow": "署名者は、自分のウィンドウでこれを承認する必要があります",
+  "signer.status.waitingSigner": "あなたの署名者を待っています",
+  "signer.status.stillWaiting": "それでもあなたの署名者が答えるのを待っています",
+  "signer.status.connected": "コネクテッド",
+  "signer.error.noExtension": "署名の延長が見つかりません。 Alby または nos2x をインストールし、このページをリロードします。",
+  "signer.error.privateKey": "これは、接続リンクではなく、プライベートキーのように見えます。 このサイトでは、キーをとりません。 署名者をリンクするbunker://を貼り付けます。",
+  "signer.error.badLink": "本サイトが理解しているリンクではありません。 署名者からBunker://リンクを貼り付けます。",
+  "signer.error.noAnswer": "サイダーは答えませんでした。 閉鎖、またはそのリレーがダウンすることがあります。 それを開いたり、再度試みて下さい。",
+  "signer.error.timeout": "サイダーは時間内に答えませんでした。 開くと、まだ接続されていることを確認してください。",
+  "signer.error.cancelled": "接続解除",
+  "signer.error.declined": "署名が拒否されました",
+  "notfound.title": "ページが見つかりません · Cashumints.space",
+  "notfound.description": "そのページは Cashumints.space にありません。",
+  "notfound.heading": "このページは存在しない",
+  "notfound.lede": "移動しているか、まだミントがインデックス化されていない可能性があります。 名前またはドメインでミントを検索するか、ミントURLを貼り付けます。",
+  "notfound.browse": "すべてのミントを見る",
+  "notfound.home": "ホーム",
+  "notfound.loading": "ローディング {host}",
+  "notfound.fb.rating": "評価",
+  "notfound.fb.reviews": "レビュー",
+  "notfound.fb.software": "ソフトウェア",
+  "notfound.fb.lastOnline": "最新オンライン",
+  "notfound.fb.note": "この mint はサイトの最終ビルド後にインデックスされたため、これはライブ API からの要約で、下にレビューがあります。完全なページは次回のビルドで表示されます。",
+  "notfound.resolve.checking": "初めての訪問です。この mint を今確認しています。",
+  "notfound.resolve.failed": "この mint は追加できませんでした",
+  "notfound.resolve.failedFedimint": "このフェデレーションは追加できませんでした",
+  "notfound.resolve.retry": "別のアドレスを試す",
+  "notfound.resolve.switch": "{kind} の mint として開く",
+  "notfound.resolve.fedimint": "フェデレーションのページアドレスには invite code が含まれないため、リンクだけでは見つけられません。invite code を貼り付ければ追加されます。",
+  "notfound.resolve.ambiguous": "このアドレスはリンクだけからは特定できません。mint の完全な URL を貼り付ければ追加されます。",
+  "wallets.title": "Cashu ウォレット · Cashumints.space",
+  "wallets.description": "モバイル、ウェブ、ブラウザ、コマンドラインで、ここにリストされているミントで動作するキャッシュウォレットは、それぞれが得意です。",
+  "wallets.heading": "ウォレット",
+  "wallets.lede": "これらのミントからecashを保持するウォレットが必要です。 ほとんどの財布は、一度に複数のミントに話しますので、最初に試してみることに気付きません。",
+  "wallets.note": "このリストは網羅的ではありません。 Cashuプロジェクトは、{link}でより広範なインデックスを保持しています。 財布は鍵を保持します。, ミントはお金を保持します。: あなたのサットが住んでいる場所を選ぶ前にミントのレビューを読みます.",
+  "wallets.platform.android": "アンドロイド",
+  "wallets.platform.ios": "iOS版",
+  "wallets.platform.web": "サイトマップ",
+  "wallets.platform.extension": "ブラウザ拡張",
+  "wallets.platform.cli": "お問い合わせ",
+  "wallets.platform.python": "トピックス",
+  "wallets.item.minibits": "モバイル ecash ウォレットは、独自のミント、Lightning アドレスのサポート、Nostr の連絡先を持ちます。",
+  "wallets.item.nutstash": "複数のミントを一度に処理し、生トークンをインポートおよびエクスポートするブラウザウォレット。",
+  "wallets.item.enuts": "モバイルウォレットは、マルチミント残高に焦点を当て、ノスト上にecashを送信。",
+  "wallets.item.cashume": "CashuプロジェクトからWebウォレットを参照。 PWAとしてインストール可能なブラウザで完全に実行します。",
+  "wallets.item.boardwalk": "Lightningアドレスの周りに構築されたWebウォレットとリンクによるecashの送信。",
+  "wallets.item.coinos": "また、独自のCashuミントを実行する財布と販売のポイントをLightning.",
+  "wallets.item.oxchat": "ノスト・メッセンジャーは、チャット内でsatsを送信します。",
+  "wallets.item.nutshell": "リファレンス実装。 コマンドラインとミントソフトウェアでウォレットとして実行します。",
+  "about.title": "Cashumints.space について",
+  "about.description": "Cashuは、実際に保持するミント、NIP-87が何であるか、そしてこのサイトがNostrリレーからミントをインデックス化し、レビューを読み込む方法です。",
+  "about.heading": "お問い合わせ",
+  "about.lede": "Cashumints.spaceは、Nostrネットワークで見つけることができるすべてのCashuミントをリストし、人々がそれらについて言うことを示します。 Azzamoで作っています。",
+  "about.cashu.title": "キャッシュとは",
+  "about.cashu.p1": "CashuはBitcoinのecashプロトコルです。 トークンが残っていると、そのトークンは誰に送られたミント学習なしで人々の間で移動します。 プライバシーは本物であり、それはポイントです。トークンはアカウントではありません。また、マイナスはトークンに署名したトークンを振り返ることはできません。",
+  "about.cashu.p2": "{link}でプロトコルとその仕様を読み込むことができます。 仕様自体はNUTと呼ばれ、すべてのミントページのNUT番号がどこから来るかです。",
+  "about.mints.title": "ミントとは、トレードオフ",
+  "about.mints.p1": "ミントはカストディアルです。 ecashを省略すると、サーバーを誰が実行しているかに座っていて、それらを解凍したときにトークンを調達するために信頼しています。 不正防止、エスクローなし、リコースはありません。 ミント演算子はバランスで消え、ミントは持っている。",
+  "about.mints.p2": "ここまでのレビューが残っているのはまさにその理由です。 このサイトでは、ミントが安全であることを決して伝えません。 mint ページのステータスは {code} で、「信頼」ではなく、最後に尋ねたときにサーバーの回答のみを意味します。 コートポケットに現金のようなecash残高を扱います:支出のために罰金、節約のために間違っています。",
+  "about.nip87.title": "NIP-87とは",
+  "about.nip87.p1": "NIP-87は、発音と発疹ミントの推奨のためのNostr条約です。 2つのイベントの種類はこちら:",
+  "about.nip87.li1": "{code} ミントを発表 mint URL は {tag} タグにあります。 このサイトが見たことのないミントを発見する方法です。",
+  "about.nip87.li2": "{code} レビューです。 評価とレビューのテキストを運び、ミントのポイントは、{utag} タグ (ミント URL) と {dtag} タグ (ミントの公開キー) です。",
+  "about.nip87.p2": "すべてのレビューは、著者のNostrキーによって署名されます。 誰もそれを検証していないので、私たちは「検証済み」というレビューを呼び出すことはありません。それは署名され、これは異なるより有用な主張です。 誰が書いたのか確認でき、変更されていないかが確認できます。 著者が正直であるか、あるいはミントを使用するという意味ではありません。",
+  "about.how.title": "このサイトについて",
+  "about.how.p1": "2つのループと1つのルールがあります。 ルールは、ミントがメタデータを所有し、ノストはレビューを所有しているため、このサイトは権限として保存されません。",
+  "about.how.li1": "{strong}は、10分ごとに{code}の既知のミントを尋ね、それが言うものを記録します:名前、説明、バージョン、サポートNUT、制限、連絡先の詳細。 また、ミントがすべてで答えたかどうかを記録します。これは、稼働時間が来る場所です。",
+  "about.how.li1Label": "プローブループ",
+  "about.how.li2": "{strong}は、毎時ノストリレーに接続し、ミントの発表とレビューを読み、それが前に見ていないミントを追加します。",
+  "about.how.li2Label": "発見ループ",
+  "about.how.p2": "重要な部分は、ミントが応答を停止したときに起こることです。 そのキャッシュされたメタデータは、失敗したプローブによって決して上書きされないため、デッドミントは、そのスペック、その歴史、そしてそのレビューを完全に保持し、それが暗くなったとき、バナーが言っている。 このサイトの以前のバージョンは、代わりにエラーページを示しました, これは、ほとんどの人がお互いに警告するために必要なミントは、レビューできないものでした. 再建の主な理由でした。",
+  "about.how.p3": "テキストは、私たちの側には保存されません。 ミントページを開くと、ブラウザは直接リレーに話して、レビュー自体を読みます。そして、あなたが書いたとき、それはあなた自身のNostr拡張によって署名され、それらのリレーにまっすぐ送信されます。 ページをランク付けしてソートできるので、数を続けてください。 ここで編集したり、削除したりすることはできません。",
+  "about.relays.title": "読み込まれるリレー",
+  "about.relays.p1": "これらは、両方の使用インデックスとブラウザを中継します。",
+  "about.relays.p2": "同じリレーでNostrクライアントをポイントし、同じイベントが表示されます。 つまり、約束全体です。ここでしか真実ではありません。",
+  "about.nuts.title": "NUTとは?",
+  "about.nuts.p1": "NUTはBitcoinのBIPのような多数のCashuの指定です。 NUT-04 と NUT-05 は、実装しているもの、実際に何ができるかを教えてくれるミントの広告です。NUT-04 と NUT-05 は、Lightning を縮小して溶かします(ミントがあまり使用されていません)、NUT-07 は、トークンが既に使用していたかどうかをウォレットにチェックします。NUT-17 は、ウォレットはポーリングの代わりに WebSockets をライブアップデートし、NUT-20 では、ウォレットはミントの引用符を実際に発行しました。 完全なリストは{link}にあります。",
+  "about.numbers.title": "今すぐ登録",
+  "about.numbers.p1": "{mints} mints インデックス, {online} 回答の, {reviews} 上記リレーからカウントされたレビュー.",
+  "about.source.title": "ソースとクレジット",
+  "about.source.p1": "本サイトは{github}に公開されています。 {azzamo}でビルドして実行します。 ミントページが間違っている場合は、ソースで修正してください。ミントメタデータは、ミント独自の{code}から来て、レビューはノストから来ます。",
+  "terms.title": "利用規約 · Cashumints.space",
+  "terms.description": "Cashumints.space の利用規約：このサイトが何であり、何をしないのか、誰が何に責任を負うのか。アカウントなし、保証なし、いかなるミントとも無関係です。",
+  "terms.heading": "利用規約",
+  "terms.lede": "パブリックデータだけをインデックス化するサイトのための明白な条件。 最近更新された{date}。",
+  "terms.what.title": "このサイトについて",
+  "terms.what.p1": "Cashumints.space は、Cashu mints に関する公開利用可能なデータのインデックスです。 別の場所から2種類のデータ:",
+  "terms.what.li1": "ミントメタデータ, 各ミントの独自の{code}エンドポイントから読みます:名前, 説明, ソフトウェアバージョン, サポートされているNUT, 連絡先の詳細と、最後に尋ねたときにミントが答えるかどうか.",
+  "terms.what.li2": "レビュー, パブリックノストラリレーから読みます. これらはNIP-87イベントの著者が誰に問い合わせることができるかを中継するために公開されています。",
+  "terms.what.p2": "データを収集し、それを正規化し、それをランク付けして表示します。 作りません。",
+  "terms.noAccounts.title": "口座なし、保証なし",
+  "terms.noAccounts.p1": "サインアップすることができません。 本サイトは、いかなる種類の保証も一切行いません。そのデータが正確であることではなく、サイトが利用できなくなるわけではありません。 ミントデータは、チェックしたあとにミントが変更でき、リレーが応答に失敗する可能性があるので、その場合よりも少ないことがわかります。",
+  "terms.noAccounts.p2": "ご自身の責任でご使用ください。 当ウェブサイトのご利用や、ご利用者様のご了承のほど、下記の損失について、一切の責任を負いません。 キャッシュミントを使用する特定のリスクについては、{link}を参照してください。",
+  "terms.noAccounts.link": "免責事項",
+  "terms.noCustody.title": "私たちはあなたのお金を持っていません",
+  "terms.noCustody.p1": "このサイトでは、資金の保管は一切行いません。 ウォレットがないため、ecashに触れず、何も動かしたり、フリーズしたり、回復したりすることはできません。 mint に問題がある場合、mint 演算子はあなたを助けることができる唯一のパーティーであり、代わりにそれらに連絡することはできません。",
+  "terms.noCustody.p2": "ここに記載されているミントと提携しておらず、そのリスト、ランク、またはその評価にミントペイはありません。 公開Nostrの発表からミントが発見され、公開レビューデータの上にアルゴリズムによってランク付けされます。",
+  "terms.reviews.title": "レビューは他の人の言葉です",
+  "terms.reviews.p1": "レビューは、著者が公開するNostrリレーに公開されたユーザー生成コンテンツです。 それらを表示し、それらを制御しません。 それらを書いていなかったので、それらを編集することはできません。それらを保持するリレーからそれらを削除することはできません。彼らは私たちが所有していないネットワーク上のイベントを署名しています。",
+  "terms.reviews.p2": "レビューは、検証済みの事実ではなく、1人の経験です。 もし公開したら、その旨について責任を負います。 不法なものを公開しないようにし、公開が公開され、永続的であることを認識してください({link})。",
+  "terms.reviews.link": "プライバシーポリシー",
+  "terms.reviews.p3": "当サイトでは特定のレビューを中止し、不当な内容について行います。 これらのページのみから削除します。 イベントはリレーにとどまり、他のNostrクライアントはそれをまだ読むことができます。",
+  "terms.links.title": "他のサイトへのリンク",
+  "terms.links.p1": "ミントのURL、ウォレットのリンク、オペレータの連絡先、そしてこのサイトをポイントする他のすべてがデータの一部であるため、そこにあります。 リンクは支持ではありませんし、もう一方の端にあるものをベットしません。",
+  "terms.changes.title": "変更点",
+  "terms.changes.p1": "これらの条件は変更できます。 一番上の日付は、最後にした時に言います。 本サイトはオープンソースなので、このページへの変更はすべてコミット履歴です。",
+  "terms.contact.title": "お問い合わせ",
+  "terms.contact.p1": "{github} で発行と買収の要求が最適です。 このサイトは、{azzamo} が運営しています。",
+  "privacy.title": "プライバシー · Cashumints.space",
+  "privacy.description": "Cashumints.spaceのプライバシー:アカウントなし、トラッキングクッキーなし、分析なし。 localStorage は、プロファイルキャッシュに使用され、どこにも送信されません。 レビューは、あなた自身のブラウザで署名されます。",
+  "privacy.heading": "プロフィール",
+  "privacy.lede": "弊社では、ウェブサイトが出来る限り少しだけ収集しております。 最近更新された{date}。",
+  "privacy.noAccounts.title": "アカウントなし",
+  "privacy.noAccounts.p1": "サインアップ、ログインなし、プロフィールはありません。 当サイトでは、利用者が誰であるかを尋ねておらず、利用者がいないため、漏れるユーザーレコードはありません。",
+  "privacy.noTracking.title": "追跡クッキーなし、分析なし",
+  "privacy.noTracking.p1": "本サイトは、トラッキングのためのクッキーを設定していません。 分析スクリプト、タグマネージャ、ピクセルなし、セッション録画なし、広告ネットワークなしはありません。 このページでは、行動を他の人に報告するものではありません。",
+  "privacy.logs.title": "サーバーログ",
+  "privacy.logs.p1": "ウェブサーバーは標準アクセスログを保持します。これは、任意のWebサーバーがデフォルトで動作するものです。 ログラインは、IPアドレス、時間、要求したページ、応答ステータス、およびユーザーのエージェントとブラウザが送信したレファラーを記録します。 ログはエラーをデバッグし、不正をスポット化するために存在します。 これらは、他のものに結合されていないし、販売または共有されていない。",
+  "privacy.logs.operatorLabel": "オペレータノート:",
+  "privacy.logs.operator": "このサイトを運営している場合は、ここにあなたの本当の保持を述べてください。 README のデプロイメントは、デフォルトのアクセスログで nginx を使用しており、ディストリビューションシップを回転させるもの(Debian と Ubuntu では、毎日 14 日間保存されます)。 サーバが何であるかを確認し、この段落を番号に置き換えます。",
+  "privacy.storage.title": "ブラウザに保存されているもの",
+  "privacy.storage.p1": "このサイトでは、ローカルストレージを使用して、デバイスに滞在し、どこにでも送信されることはありません。",
+  "privacy.storage.li1": "Nostr プロファイルメタデータのキャッシュ (種類 0 イベント: 名前, アバター, NIP-05 アドレス) あなたが見てきたレビュー担当者のための. このページでは、各ページのリキューリングリレーを保存します。 有効期限が切れ、キャッシュが捕捉され、最も古いキャッシュが最初に現れます。",
+  "privacy.storage.li2": "インターフェイスの設定なので、サイトは次回と同じ方法で動作します。",
+  "privacy.storage.p2": "ブラウザのサイトデータを消去すると、どちらも削除されます。 何も壊れない、プロファイルの外観は再び実行します。",
+  "privacy.thirdParties.title": "ブラウザが何を語るのか",
+  "privacy.thirdParties.p1": "このページをロードすると、ブラウザがこのサイト以外にいくつかの場所に接続されます。 つまり、サーバー側のトラッキングがまだライブデータを読み込みていないサイトです。",
+  "privacy.thirdParties.li1Label": "パブリックノストラリレー",
+  "privacy.thirdParties.li1": "{strong}、WebSocketを経由して、レビューやレビューを読んでください。 リレーは、接続する任意のサーバーとして、IP と尋ねたものを参照してください。 リレーは{link}にリストされています。",
+  "privacy.thirdParties.li1Link": "サイトマップ",
+  "privacy.thirdParties.li2Label": "投稿者 アバター画像",
+  "privacy.thirdParties.li2": "{strong}, 審査官のプロファイルポイントから読み込まれた. これらはノーレファラーポリシーで送信されるため、どのページにあるかをホストは学習しません。",
+  "privacy.publishing.title": "レビュー投稿",
+  "privacy.publishing.p1": "ブラウザでのレビューを書くと、サーバーではなくブラウザで行われます。 イベントは、お使いのNIP-07拡張子(Alby、nos2x または類似)によって署名され、お使いのブラウザから直接リレーに放送されます。 あなたの秘密鍵は、拡張機能を残しず、このサイトは決して見ていない。 カスタムキー管理は構築せず、キーやシードフレーズは問いません。",
+  "privacy.permanent.title": "ノストに公開するものは、一般と永続的です",
+  "privacy.permanent.p1": "2回読む価値のある部分です。 公開リレーのサイン会です。 それが出てから、それは出ます:",
+  "privacy.permanent.li1": "誰でも、Nostr クライアントを使用して、現在、以降に読み込むことができます。 「Cashumints.spaceの公開」ではなく、ネットワーク上で公開しています。",
+  "privacy.permanent.li2": "永続的にあなたのNostrの公開鍵にリンクされています, キーがこれまでに公開されている他のすべてと一緒に.",
+  "privacy.permanent.li3": "コマンドではなく、リクエストは削除されます。 削除されたイベントを公開し、いくつかのリレーはそれを奨励することができますが、リレーはそれを無視し、既にイベントをコピーした人は無料です。 公開されたレビューを永続的に扱う。",
+  "privacy.permanent.li4": "削除できません。 リレーに何も変更しないため、ここに表示を停止することができます。",
+  "privacy.permanent.p2": "自分のアイデンティティに縛られたことなしでミントを見直したい場合は、別のNostrキーを使用します。 一方のスターレビューを書いているブランドの新しいキーはパターンリーダーが見るのに値するパターンリーダーであるため、他の活動がないキーは、過酷なレビューのように示されていることに注意してください。",
+  "privacy.contact.title": "お問い合わせ",
+  "privacy.contact.p1": "サイトはオープンソースです。上記のいずれかをチェックしたい場合は、{github}でコードを読みます。 質問や修正は問題に遭う可能性があります。",
+  "disclaimer.title": "免責事項 · Cashumints.space",
+  "disclaimer.description": "あなたはカシューミントを使用する前に知っておくべきこと:ミントはcustodialです、ミントはあなたのお金で消えることができます、レビューは意見であり、オンラインでは信頼できるものではありません。",
+  "disclaimer.heading": "免責事項",
+  "disclaimer.lede": "あなたがミントにお金を入れる前にこれを読んでください。 最近更新された{date}。",
+  "disclaimer.callout": "キャッシュミントは、あなたのお金を保持します。 消えてしまうと、ecashがなくなって、誰にもアピールできない。 失くする余裕を持たせるだけを保ちましょう。",
+  "disclaimer.custodial.title": "ミントはカストディアル",
+  "disclaimer.custodial.p1": "ecashをmintすると、ビットコインをmint演算子に渡し、トークンを取り戻します。 これらのトークンは、その演算子のクレームです。 彼らはあなたが保持するビットコインではなく、オペレータは、それらを砥石で研ぐかどうかを決定するものです。",
+  "disclaimer.custodial.p2": "つまり、すべてのミントは同じリスクを運びます: オペレータは消えることができます, 停止するために説得することができます, バグやハックを介して資金を失うことができます, または単にサーバーをオフにすることができます. 預金保険、チャージバックなし、サポートラインなし、カウントする価値のある法的条件はありません。 このサイトでは最高評価のミントの真髄です。",
+  "disclaimer.custodial.p3": "カシューは、移動量が少ないように設計されています。 このように使います:あなたが費やすために何であるかを保持し、あなたの節約ではなく、そして1つのすべてのものを駐車するのではなく、ミントを渡って広がる。",
+  "disclaimer.reviews.title": "レビューは意見です, 確認されていないクレーム",
+  "disclaimer.reviews.p1": "ここにすべてのレビューは、Nostrの誰かによって書かれ、鍵に署名しました。 署名された手段は、どのキーが書いたかを伝えることができます。 レビューは真実ではなく、著者がミントを使用したこと、または著者がオペレータ、競合他社、または10キーを持つ1人ではないことを意味するものではありません。",
+  "disclaimer.reviews.p2": "審査者を検証せず、解約したレビューを編集または削除しません。 数を読みます, 彼らが実際に言うものを見て, そして、三百と異なる3レビューとミントを秤量.",
+  "disclaimer.status.title": "オンラインは、信頼できる、信頼できる意味しません到達可能を意味します",
+  "disclaimer.status.p1": "定期的にチェックを行い、回答したかどうかをお伝えします。 つまり、サーバが応答する全ての緑色のステータスを意味します。 オペレータが溶媒、正直、またはまだ明日にあなたのトークンを砥石で研ぐつもりであるかどうかについて何も言う。",
+  "disclaimer.status.p2": "ミントは、それがない瞬間までオンラインにすることができます。 稼働時間履歴、NUTとソフトウェアバージョンをサポートし、ミントの実行方法について何かを伝えますが、それらのどれもあなたのお金の約束です。",
+  "disclaimer.ranking.title": "ランキングの仕組みや意味がないもの",
+  "disclaimer.ranking.p1": "ミントは、パブリックレビューデータ上にあるアルゴリズムで注文されます。評価、レビュー数、最近の活動数、オフラインのミントをデフォルトでオンラインで mints します。 詳細はオープンソースのコードです。",
+  "disclaimer.ranking.p2": "誰も配置のために支払うべきではないです。 当サイトでは、スポンサースロット、プロモーションリスト、その他一切の議事録はありません。 高いランクは、パブリックデータのようなアルゴリズムを意味し、さらには何もない。 推奨ではなく、安全評価ではありません。",
+  "disclaimer.notAdvice.title": "金融アドバイスではありません",
+  "disclaimer.notAdvice.p1": "当サイトでは、金融、投資、法律、税務に関するアドバイスはありません。 私たちはあなたの状況を知りませんし、私たちはあなたをお勧めしません。 ミントを使用して、誰を選ぶか、あなたの決定です。",
+  "disclaimer.dyor.title": "あなた自身の研究を行う",
+  "disclaimer.dyor.li1": "オペレータを調べます。 失うために公的な評判を持つ人によって実行ミントは、匿名のURLから異なる提案です。",
+  "disclaimer.dyor.li2": "ミント独自の用語とMOTDを読みます。 テストやベータを呼ぶミントはそれを意味します。",
+  "disclaimer.dyor.li3": "小さじスタート 少し分かち、それを消費し、それを溶かし、あなたがそれをもっと信頼する前に何が起こるかを見てください。",
+  "disclaimer.dyor.li4": "限界を見る 低い最大は、多くの場合、慎重なオペレータの兆候であり、高い人は安全なものの兆候ではありません。",
+  "disclaimer.dyor.li5": "トークンをバックアップし、トークンがベアラーアセットであることを覚えておいてください。トークンを保有する人は、それを費やすことができます。",
+  "disclaimer.site.title": "サイト自体について",
+  "disclaimer.site.p1": "ここにデータが間違っているか、日付が切れる可能性があります。 ミンツはスケジュールでプローブされ、リレーは時々答えに失敗し、あなたが読んだページは過去にいくつかの点で構築されました。 本サイトは、いかなる保証もいたしません。 見る {link}.",
+  "disclaimer.site.link": "利用規約",
+  "disclaimer.updated": "20 8月 2026",
+  "login.getPrimal": "プリマルをゲット",
+  "reviews.dialog.identity.extensionGone": "ブラウザの拡張は応答しません。 再度ログインするか、リモート・サイダーを使用して下さい。",
+  "seo.orgDescription": "ノストラに署名された各ミントとコミュニティレビューからライブステータスを持つキャッシュミントのディレクトリ。",
+  "seo.ogImageAlt": "Cashumints.space: 信用できるCashuミントを見つけます。",
+  "seo.mint.title.one": "{name}のレビュー評価・口コミ{rating} から {n} レビュー | Cashumints.space",
+  "seo.mint.title.other": "{n} {name}のレビュー評価・口コミ{rating}   Cashumints.space",
+  "seo.mint.titleOffline.one": "{name}: オフラインで {n} 日 | Cashumints.space",
+  "seo.mint.titleOffline.other": "{name}: オフラインで {n} 日間 | Cashumints.space",
+  "seo.mint.titleNoReviews": "{name}: Cashu ミントの情報とレビュー | Cashumints.space",
+  "seo.fedimint.titleNoReviews": "{name}: Fedimint フェデレーションの情報とレビュー | Cashumints.space",
+  "seo.desc.fallback": "コミュニティのレビュー {name} ({domain}).",
+  "seo.desc.fallbackDomain": "{domain}のキャッシュミントのコミュニティレビュー。",
+  "seo.desc.rated.one": "評価{rating}/5から{n}はノストラのレビューを署名しました。",
+  "seo.desc.rated.other": "評価される{rating}/5から{n}はノストラのレビューを署名しました。",
+  "seo.desc.noReviews": "レビューはありません。",
+  "seo.desc.status": "{status}。",
+  "seo.desc.statusLimits": "{status}、限界{limits}。",
+  "seo.desc.fedModules": "{status}. モジュール: {modules}.",
+  "seo.desc.fedModulesNetwork": "{status}. モジュール: {modules} に {network}.",
+  "seo.mint.ogAlt.one": "{name}: {rating} 星の {n} Cashumints.space のレビュー",
+  "seo.mint.ogAlt.other": "{n} {name}: {rating} 星から Cashumints.space",
+  "seo.mint.ogAltNoReviews": "{name} に Cashumints.space",
+  "nav.home": "ホーム",
+  "mint.more.title": "もっとミント",
+  "mint.more.all": "すべてのミントを見る",
+  "nav.fedimints": "Fedimints",
+  "status.announced": "開催概要",
+  "card.unnamedFederation": "名称変更",
+  "card.notChecked": "決してチェックしない",
+  "fedimints.title": "すべての Fedimint フェデレーション · Cashumints.space",
+  "fedimints.description": "すべて {total} Nostrネットワークで発表されたFedimintのフェデレーション: {online} 外部チェックで実行を確認, {announced} 発表し、確認しませんでした. コミュニティの評価、モジュール、各コードを招待します。",
+  "fedimints.heading": "すべてのフェデレーション",
+  "fedimints.lede": "ノスト・ネットワークにFedimintのフェデレーションが発表されました。 フェデレーションは、自身のパブリックなステータスのエンドポイントがないため、外部チェックで実行されていることが確認されており、発表した時点で、残りは正確にリストされています。",
+  "fedimints.search.label": "名前またはidでフェデレーションを検索する",
+  "fedimints.search.placeholder": "名前またはフェデレーションIDで検索...",
+  "fedimints.sort.label": "ソート フェデレーション",
+  "fedimints.hideOffline": "オフラインで隠す",
+  "fedimints.showing": "表示 {total} のフェデレーション ({online} 確認済み, {announced} 発表のみ)",
+  "fedimints.showingFiltered": "{shown} の {total} のフェデレーション ({online} 確認済み、{announced} は発表しました)",
+  "fedimints.announcedNote.one": "これら1つは、Norstrで発表され、それが実行されているので、何も確認されていませんでした。 オンラインやオフラインではなく、正式に表示されているので、",
+  "fedimints.announcedNote.other": "これらの{n}はノストに発表され、彼らが実行されているので、何も確認されていませんでした。 オンラインやオフラインではなく、真のものではないため、発表としてリストされています。",
+  "fedimints.noResults": "フェデレーションの一致無し。 名前を試し、またはフェデレーションIDを貼り付けます。",
+  "fedimints.emptyIndex": "このサイトが読み込まれるリレーでフェデレーションが発表されていない。 リストは、アナウンスが到着するように、それ自体を満たします。",
+  "fedimint.crumb": "フィードバック",
+  "fedimint.breadcrumb": "パン粉",
+  "fedimint.unnamed": "名称変更",
+  "fedimint.idLabel": "カテゴリー",
+  "fedimint.kind.federationId": "フェデレーションID",
+  "fedimint.moduleCount.one": "{n}モジュール",
+  "fedimint.moduleCount.other": "{n} モジュール",
+  "fedimint.copyInvite": "招待コードをコピーする",
+  "fedimint.confirmed.label": "確認済み",
+  "fedimint.confirmed.never": "決して",
+  "fedimint.confirmed.by": "によって {source}",
+  "fedimint.confirmed.unattributed": "最後のチェック",
+  "fedimint.announcedOn": "発表 {when}",
+  "fedimint.announcedUnknown": "発表日なし",
+  "fedimint.modules.title": "モジュール",
+  "fedimint.modules.none": "このフェデレーションのアナウンスはモジュールをリストしません。",
+  "fedimint.modules.note": "モジュールは、フェデレーションが実行される部分です。 発表は、提示され、それらのいずれかが預金を受け入れるかどうかについて何も言う。",
+  "fedimint.modules.notListed": "リストされていない",
+  "fedimint.invite.title": "招待コード",
+  "fedimint.invite.count.one": "{n} コード",
+  "fedimint.invite.count.other": "{n} コード",
+  "fedimint.invite.note": "これをFedimintウォレットにコピーして参加してください。 それは連盟IDとその保護者の住所を運び、それは共有されることを意味します。",
+  "fedimint.invite.kind": "招待コード",
+  "fedimint.invite.qr": "QRコード",
+  "fedimint.invite.qrCaption": "{name}に参加するスキャン",
+  "fedimint.details.federationId": "フェデレーションID",
+  "fedimint.details.network": "ネットワーク",
+  "fedimint.details.announcedBy": "お知らせ",
+  "fedimint.details.announced": "リリース",
+  "fedimint.more.title": "より多くのフェデレーション",
+  "fedimint.more.all": "すべてのフェデレーションを見る",
+  "fedimint.disclaimer": "連盟に参加すると、あなたのお金で守護者を信頼することを意味します。 格付けはコミュニティの意見であり、信頼されるべきではなく、到達可能な実行方法を確認しました。",
+  "fedimint.module.lightning": "ライトニング",
+  "fedimint.module.mint": "Ecash ミント",
+  "fedimint.module.wallet": "オンチェーンウォレット",
+  "fedimint.module.meta": "メタデータ",
+  "fedimint.module.stability_pool": "安定性プール",
+  "fedimint.module.multi_sig_stability_pool": "安定性プール(マルチシグ)",
+  "fedimint.module.fedi-social": "社会回復",
+  "fedimint.network.mainnet": "ビットコインメインネット",
+  "fedimint.network.signet": "ログイン",
+  "fedimint.network.testnet": "テストネット",
+  "fedimint.network.testnet4": "テストネット4",
+  "fedimint.network.regtest": "参加登録",
+  "feed.ecosystem.group": "エコシステム",
+  "feed.ecosystem.all": "すべて",
+  "feed.ecosystem.cashu": "ログイン",
+  "feed.ecosystem.fedimint": "フィードバック",
+  "feed.filterBySubject": "ミントまたはフェデレーションによるフィルタ",
+  "feed.anySubject": "任意のミントまたはフェデレーション",
+  "feed.clearSubject": "名前フィルターをクリアする",
+  "home.topFedimints.title": "トップFedimints",
+  "home.topFedimints.sub": "レビューと評価でランク付け",
+  "home.topFedimints.all": "すべて {n} 連盟 →",
+  "reviews.validate.subject": "このレビューを指摘するものではありません。",
+  "mint.warnings.fedimintOffline.lead": "オフラインで報告",
+  "mint.warnings.fedimintOffline.body.since": "このフェデレーションに達した最後のチェックは{date}にありました ({days} 前に). 守護者たちはそれ以来の答えをしていませんでした。 リスクとして保持されている資金を扱い、新しい資金で参加しないでください。",
+  "mint.warnings.fedimintOffline.body.never": "このフェデレーションのチェックがなかったので、最近は失敗しました。 リスクとして保持されている資金を扱い、新しい資金で参加しないでください。",
+  "mint.warnings.fedimintOffline.meta.since": "{date}以来、オフラインで報告",
+  "mint.warnings.fedimintOffline.meta.never": "オフラインで報告され、一度に到達したことがない",
+  "mint.warnings.neverConfirmed.lead": "決して確認しないで下さい。",
+  "mint.warnings.neverConfirmed.body.reviewed": "このフェデレーションは{date}、{days}年前にノストで発表され、それが実行されているので何も確認されていませんでした。 以下のレビューは、このページの人生の唯一の兆候です。他のすべてが発表から来ています。",
+  "mint.warnings.neverConfirmed.body.quiet": "このフェデレーションは、{date}、{days}の上のノストに発表されました。その後、それが実行されていることを確認し、誰も最近それを見直していませんでした。 発表から来られたことすべて。",
+  "mint.warnings.neverConfirmed.meta": "{date}を発表",
+  "footer.allFedimints": "すべてのフェデレーション",
+  "reviews.dialog.bodyPlaceholder.cashu": "鉱山、溶融、サポートはどのように機能しましたか? 具体的に。",
+  "reviews.dialog.bodyPlaceholder.fedimint": "参加方法、支払いのLightning、サポートはどのように機能しますか? 具体的に。",
+  "fedimint.details.title": "フェデレーションの詳細",
+  "nav.lnurlMints": "LNURL ミント",
+  "footer.allLnurlMints": "すべての LNURL ミント",
+  "lnurlMints.title": "LNURL ミント：lnurlcash 無記名ノートのミント評価 | Cashumints.space",
+  "lnurlMints.description": "Nostr ネットワークから索引した {total} 件の LNURL ミント：オンライン {online} 件、オフライン {offline} 件。各ミントのコミュニティ評価、出金上限、機能を掲載。",
+  "lnurlMints.heading": "LNURL ミント",
+  "lnurlMints.lede": "このサイトが把握しているすべての LNURL ミント。LNURL ミントは lnurlcash 無記名ノートを発行します。シークレットとして保持する Lightning のノートで、ローテーション・分割・統合、あるいは Lightning 支払いへメルトして戻すことができます。各ミントは数分ごとに HTTPS で確認しています。",
+  "lnurlMints.search.label": "LNURL ミントを検索",
+  "lnurlMints.search.placeholder": "名前またはアドレスで検索…",
+  "lnurlMints.sort.label": "LNURL ミントの並び順",
+  "lnurlMints.hideOffline": "オフラインを隠す",
+  "lnurlMints.showing": "{total} 件の LNURL ミントを表示中（オンライン {online} 件、オフライン {offline} 件）",
+  "lnurlMints.showingFiltered": "{total} 件中 {shown} 件の LNURL ミントを表示中（オンライン {online} 件、オフライン {offline} 件）",
+  "lnurlMints.noResults": "該当する LNURL ミントはありません。",
+  "lnurlMints.emptyIndex": "まだ LNURL ミントは索引されていません。",
+  "lnurl.crumb": "LNURL ミント",
+  "lnurl.breadcrumb": "パンくずリスト",
+  "lnurl.copyAddress": "アドレスをコピー",
+  "lnurl.more.title": "他の LNURL ミント",
+  "lnurl.more.all": "すべての LNURL ミント →",
+  "lnurl.disclaimer": "LNURL ミントはあなたの sats を預かり、あなたはそのノートを持ちます。つまり利用は運営者を信頼するということです。評価はコミュニティの意見であり、オンラインは到達可能という意味で、信頼できるという意味ではありません。",
+  "lnurl.features.title": "機能",
+  "lnurl.features.none": "このミントは対応機能を告知していません。",
+  "lnurl.features.note": "機能はミントの運営者が Nostr で告知した内容です。HTTPS で確認できるものは確認し、告知された機能が現在利用できない場合はその旨を表示します。",
+  "lnurl.features.notListed": "未告知",
+  "lnurl.features.unavailable": "利用不可",
+  "lnurl.feature.mint": "Lightning でミント（LUD-06）",
+  "lnurl.feature.melt": "Lightning へメルト",
+  "lnurl.feature.notes": "ノートのローテーション / 分割 / 統合",
+  "lnurl.feature.lud16": "Lightning アドレス",
+  "lnurl.feature.lud21": "支払い検証（LUD-21）",
+  "lnurl.feature.signed-notes": "署名付きノート（オフライン検証）",
+  "lnurl.feature.onion": "Tor アドレス",
+  "lnurl.feature.rotate": "ノートをローテーション",
+  "lnurl.feature.split": "ノートを分割",
+  "lnurl.feature.merge": "ノートを統合",
+  "lnurl.feature.lud06": "LUD-06 payRequest",
+  "lnurl.feature.lud03": "LUD-03 withdrawRequest",
+  "lnurl.limits.label": "出金上限",
+  "lnurl.limits.notPublished": "未公開",
+  "lnurl.limits.withdrawRow": "出金",
+  "lnurl.limits.disabled": "無効",
+  "lnurl.limits.sats.one": "{n} sat",
+  "lnurl.limits.sats.other": "{n} sats",
+  "lnurl.details.title": "ミントの詳細",
+  "lnurl.details.address": "Lightning アドレス",
+  "lnurl.details.mintPubkey": "ミントの公開鍵",
+  "lnurl.details.onion": "Tor アドレス",
+  "lnurl.details.fee": "ミント手数料",
+  "lnurl.details.node": "ノード",
+  "lnurl.details.capacity": "告知済みキャパシティ",
+  "lnurl.kind.lightningAddress": "Lightning アドレス",
+  "lnurl.kind.mintPubkey": "ミントの公開鍵",
+  "lnurl.kind.onionAddress": "Tor アドレス",
+  "lnurl.confirmed.label": "最終確認",
+  "lnurl.confirmed.when": "{when}に確認",
+  "lnurl.fee.base.one": "{n} sat",
+  "lnurl.fee.base.other": "{n} sats",
+  "lnurl.fee.percent": "{percent}%",
+  "home.topLnurl.title": "人気の LNURL ミント",
+  "home.topLnurl.sub": "レビュー数と評価で順位付け",
+  "home.topLnurl.all": "全 {n} 件の LNURL ミント →",
+  "feed.ecosystem.lnurl": "LNURL",
+  "reviews.dialog.bodyPlaceholder.lnurl": "ミント、メルト、ノートのローテーションはどうでしたか？具体的にどうぞ。",
+  "reviews.byUrl.open": "レビューを書く",
+  "reviews.byUrl.title": "レビューを書く",
+  "reviews.byUrl.lede": "アドレスを貼り付けてください。このサイトがまだ知らないアドレスなら、今すぐ確認して追加します。",
+  "reviews.byUrl.label.cashu": "mint の URL",
+  "reviews.byUrl.label.fedimint": "フェデレーションの invite code",
+  "reviews.byUrl.label.lnurl": "LNURL mint の URL",
+  "reviews.byUrl.placeholder.cashu": "mint.example.com",
+  "reviews.byUrl.placeholder.fedimint": "fed11…",
+  "reviews.byUrl.placeholder.lnurl": "mint.example.com",
+  "reviews.byUrl.check": "このアドレスを確認",
+  "reviews.byUrl.checking": "確認中…",
+  "reviews.byUrl.back": "別のアドレスを使う",
+  "reviews.byUrl.existing": "すでに掲載済み",
+  "reviews.byUrl.indexed": "追加しました",
+  "reviews.byUrl.confirmClose": "閉じますか？入力したアドレスは保存されません。",
+  "reviews.byUrl.detected": "このアドレスは {kind} の mint として応答しました。",
+  "reviews.byUrl.switchTo": "{kind} の mint としてレビューする",
+  "reviews.byUrl.error.empty": "まずアドレスを入力してください。",
+  "reviews.byUrl.error.badUrl": "mint の URL には見えません。",
+  "reviews.byUrl.error.badInvite": "これは Fedimint の invite code ではありません。コードは fed11 で始まります。",
+  "reviews.byUrl.error.badInput": "このサイトではそのアドレスを確認できません。",
+  "reviews.byUrl.error.blocked": "公開アドレスではないため、確認できません。",
+  "reviews.byUrl.error.notAMint": "そのアドレスは応答しましたが、この種類の mint ではありませんでした。",
+  "reviews.byUrl.error.wrongType": "そのアドレスは応答しましたが、別の種類の mint でした。",
+  "reviews.byUrl.error.unverifiable": "そのアドレスからは何も応答がなく、Nostr にもまだ痕跡がありません。",
+  "reviews.byUrl.error.rateLimited.one": "同じ接続からの確認が多すぎます。約 {n} 分後にもう一度お試しください。",
+  "reviews.byUrl.error.rateLimited.other": "同じ接続からの確認が多すぎます。約 {n} 分後にもう一度お試しください。",
+  "reviews.byUrl.error.network": "インデックスに接続できませんでした。接続を確認してからもう一度お試しください。",
+  "seo.lnurl.titleNoReviews": "{name}：LNURL ミントの情報とレビュー | Cashumints.space",
+  "seo.desc.statusWithdraw": "{status}、出金 {min}〜{max} sat。",
+  "mint.chip.noFunding": "ミント / メルト不可",
+  "mint.warnings.lnurlWithdrawalsDisabled.lead": "出金は無効です。",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.online": "このミントは出金上限をゼロと告知しているため、発行されるノートは何とも交換できません。これが変わるまでここでミントしないでください。",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.offline": "最後に到達できたとき、このミントは出金上限をゼロと告知していたため、発行されたノートは何とも交換できませんでした。これが変わるまでここでミントしないでください。",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.online": "現在、出金は無効",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.offline": "最後に確認した時点で出金は無効でした",
+  "mint.warnings.lnurlInvalid.lead": "エンドポイントは応答しますが無効です。",
+  "mint.warnings.lnurlInvalid.body": "ホストは応答しますが、このサイトが読めるミントの告知ではないため、出金が機能しない可能性があります。以下は最後に解析できた状態で、レビューは引き続き利用できます。",
+  "mint.warnings.lnurlInvalid.meta": "応答はあるが、有効なミント告知ではない",
+  "mint.warnings.lnurlNoFunding.lead": "ミントとメルトは利用できません。",
+  "mint.warnings.lnurlNoFunding.body": "既存のノートはローテーション・分割・統合が引き続き可能ですが、現在 Lightning 経由で資金は出入りしません。ミント自体は稼働して応答していますが、その背後の Lightning ノードに到達できていません。",
+  "mint.warnings.lnurlNoFunding.meta": "ミントとメルトは利用不可",
+  "mint.warnings.also.noFunding": "Lightning ノードにも到達できず、ミントもメルトもできませんでした。"
+}

web/src/i18n/locales.mjs

@@ -7,8 +7,13 @@
  * bare codes means the duplication is two short arrays that cannot drift far, and
  * `scripts/check-i18n.mjs` compares the two on every build so they cannot drift at all.
  *
- * Adding a language: add the code here and the full entry in `config.ts`.
+ * Adding a language: the code here, the full entry in `config.ts`, and the import and
+ * `CATALOGS` line in `index.ts`. The last one is the one that gets forgotten, and the
+ * only symptom is the new language rendering in English.
  */
 export const DEFAULT_LOCALE = 'en';
 
-export const LOCALE_CODES = ['en', 'es', 'nl'];
+export const LOCALE_CODES = [
+  'en', 'es', 'nl', 'zh', 'hi', 'ar', 'fr', 'pt', 'it', 'tr', 'pl', 'uk', 'ro', 'el', 'cs',
+  'sv', 'da', 'id', 'ur', 'ru', 'de', 'ja', 'ar-eg', 'vi',
+];

web/src/i18n/nl.json

@@ -50,6 +50,10 @@
   "footer.privacy": "Privacy",
   "footer.madeBy": "Gemaakt met ❤️ door {azzamo} · Draait op Cashu en NIP-87",
   "footer.warning": "Mints zijn custodiaal. Een mint kan er met jouw geld vandoor gaan.",
+  "footer.tagline": "Reviews uit de community voor ecash mints, ondertekend op Nostr.",
+  "footer.col.explore": "Verkennen",
+  "footer.col.site": "Site",
+  "footer.nav": "Voettekst",
   "home.title": "Cashumints.space · Vind een Cashu mint die je kunt vertrouwen",
   "home.description": "Vind een Cashu mint die je kunt vertrouwen. {mints} mints geïndexeerd met {reviews} reviews uit de community, ondertekend op Nostr, plus live uptime, ondersteunde NUTs en mint-software.",
   "home.hero.title": "Vind een Cashu mint",
@@ -61,7 +65,7 @@
   "home.filters.highestRated": "Best beoordeeld",
   "home.filters.recentlyActive": "Recent actief",
   "home.filters.websockets": "Ondersteunt WebSockets",
-  "home.top.title": "Beste mints",
+  "home.top.title": "Beste Cashu mints",
   "home.top.sub": "gerangschikt op reviews en beoordeling",
   "home.top.all": "Alle {n} mints →",
   "home.latest.title": "Laatste reviews",
@@ -114,6 +118,8 @@
   "card.reviewed": "laatste review {when}",
   "card.noReviews": "nog geen reviews",
   "mint.title": "{name} · Reviews van deze Cashu mint",
+  "mint.titleFedimint": "{name} · Reviews van de Fedimint-federatie",
+  "mint.titleLnurl": "{name} · Reviews van de LNURL mint",
   "mint.breadcrumb": "Kruimelpad",
   "mint.crumbMints": "Cashu mints",
   "mint.copyUrl": "Mint-URL kopiëren",
@@ -243,24 +249,40 @@
   "nut.25": "BOLT12-betaalmethode",
   "reviews.title": "Reviews",
   "reviews.anon": "Anon",
+  "reviews.anonTitle": "Geen publiek Nostr-profiel gevonden voor deze sleutel",
+  "reviews.nip05Title": "NIP-05-identifier (niet door deze site geverifieerd)",
   "reviews.filter.group": "Reviews filteren",
   "reviews.filter.all": "Alle",
   "reviews.filter.five": "5★",
   "reviews.filter.critical": "Kritisch",
   "reviews.filter.recent": "Recent",
+  "reviews.filter.hideAnon": "Verberg anon",
+  "reviews.anonHidden.other": "{n} van {total} reviews getoond: anon verborgen.",
+  "reviews.allAnon.one": "De enige review hier is anon.",
+  "reviews.allAnon.other": "Alle {n} reviews hier zijn anon.",
+  "reviews.allAnonShow.one": "Laat hem zien",
+  "reviews.allAnonShow.other": "Laat ze zien",
   "reviews.loading.one": "{n} review van Nostr-relays laden",
   "reviews.loading.other": "{n} reviews van Nostr-relays laden",
   "reviews.empty": "Nog geen reviews. Schrijf als eerste er een.",
   "reviews.emptyWritten": "Hier staan nog geen geschreven reviews. Wees de eerste die er een schrijft.",
   "reviews.emptyFilter": "Geen enkele review past bij dit filter.",
+  "reviews.rate.cashu": "Beoordeel deze mint",
+  "reviews.rate.fedimint": "Beoordeel deze federatie",
+  "reviews.rate.lnurl": "Beoordeel deze mint",
   "reviews.noscript": "Reviews worden op Nostr ondertekend en in je browser geladen, dus deze lijst heeft JavaScript nodig. De beoordeling en de aantallen hierboven komen van de site zelf.",
   "reviews.relayError": "De relay was niet bereikbaar. De reviews zijn misschien niet compleet.",
   "reviews.srRating": "{rating} van de 5",
   "reviews.srNoRating": "Geen beoordeling gegeven",
+  "reviews.readMore": "Lees meer",
+  "reviews.readLess": "Toon minder",
+  "reviews.actions.copyNpub": "Npub kopiëren",
+  "reviews.actions.openNostr": "Bekijk dit event op Nostr",
+  "reviews.actions.copyLink": "Link naar deze review kopiëren",
   "reviews.anonNote": "Eerste review van deze npub, verder geen activiteit gevonden",
   "reviews.published": "Gepubliceerd.",
   "reviews.publishedPartial": "Gepubliceerd op {accepted} van de {total} relays.",
-  "reviews.propagating": "Wordt verspreid, het kan even duren voordat hij elders verschijnt.",
+  "reviews.propagating": "Publiceren naar Nostr-relays",
   "reviews.summary.line.one": "{count} beoordeling zonder tekst: {breakdown}",
   "reviews.summary.line.other": "{count} beoordelingen zonder tekst: {breakdown}",
   "reviews.summary.lineDay.one": "{count} beoordeling zonder tekst op {when}: {breakdown}",
@@ -274,7 +296,12 @@
   "reviews.breakdown.1": "{n} van één ster",
   "reviews.breakdown.none": "{n} zonder beoordeling",
   "reviews.dialog.title": "{name} reviewen",
-  "reviews.dialog.note": "Wordt ondertekend met jouw Nostr-sleutel en gepubliceerd op publieke relays. Hij kan niet bewerkt of verwijderd worden.",
+  "reviews.dialog.lede.cashu": "Deel je ervaring met deze mint.",
+  "reviews.dialog.lede.fedimint": "Deel je ervaring met deze federatie.",
+  "reviews.dialog.lede.lnurl": "Deel je ervaring met deze mint.",
+  "reviews.dialog.permanent": "Wordt permanent gepubliceerd op publieke Nostr-relays.",
+  "reviews.dialog.gate.title": "Log in om een review te schrijven",
+  "reviews.dialog.gate.lead": "Reviews worden ondertekend met je Nostr-sleutel. Die blijft in je signer, deze site ziet hem nooit.",
   "reviews.dialog.ratingLegend": "Jouw beoordeling",
   "reviews.dialog.starsSr.one": "{n} ster",
   "reviews.dialog.starsSr.other": "{n} sterren",
@@ -295,7 +322,6 @@
   "reviews.dialog.waitingSigner": "Wachten op je signer",
   "reviews.dialog.confirmClose": "Deze review sluiten? Je concept blijft bewaard tot je de site verlaat.",
   "reviews.dialog.why.login": "Log in om te publiceren",
-  "reviews.dialog.why.rating": "Kies een beoordeling",
   "reviews.dialog.why.words": "Schrijf een paar woorden",
   "reviews.dialog.why.more.one": "nog {n} teken",
   "reviews.dialog.why.more.other": "nog {n} tekens",
@@ -312,7 +338,7 @@
   "reviews.validate.short": "Schrijf minstens {n} tekens, anders heeft niemand iets aan de review.",
   "reviews.validate.long": "Reviews mogen maximaal {n} tekens lang zijn.",
   "feed.title": "Laatste reviews van mints en federaties · Cashumints.space",
-  "feed.description": "Elke review van een mint of federatie zodra hij verschijnt: {reviews} reviews over {mints} Cashu mints en {federations} Fedimint-federaties, ondertekend op Nostr en hier te lezen met de nieuwste bovenaan. Filter op ecosysteem, op beoordeling of op naam.",
+  "feed.description": "Elke beoordeling van een mint, federatie en LNURL mint zodra die verschijnt: {reviews} beoordelingen over {mints} Cashu mints, {federations} Fedimint-federaties en {lnurl} LNURL mints, ondertekend op Nostr en hier te lezen met de nieuwste bovenaan. Filter op ecosysteem, op cijfer of op naam.",
   "feed.heading": "Laatste reviews",
   "feed.lede": "Elke review van elke Cashu mint en elke Fedimint-federatie, nieuwste bovenaan, live gelezen van de Nostr-relays. Elke review is ondertekend door wie hem schreef en staat op de relays, niet in onze database.",
   "feed.label": "Reviews",
@@ -346,14 +372,20 @@
   "login.connect.remote.title": "Een signer op afstand verbinden",
   "login.connect.remote.lead": "Scan dit met je signer-app, of kopieer de link en plak hem daar.",
   "login.connect.remote.hint": "Werkt met elke NIP-46-signer: nsec.app, Amber, Nostrify, je eigen bunker.",
+  "login.connect.remote.open": "Open in je signer-app",
   "login.connect.primal.title": "Verbinden met Primal",
   "login.connect.primal.lead": "Open Primal op je telefoon, zoek ondertekenen op afstand in de instellingen, en scan deze code.",
   "login.connect.primal.hint": "Primal ondertekent via NIP-46 voor andere apps, dus dit is dezelfde verbinding die elke signer gebruikt, en je sleutel blijft in Primal. {link}",
+  "login.connect.primal.open": "Open in Primal",
   "login.status.buildingLink": "Een verbindingslink maken",
   "login.status.waitingExtension": "Wachten op je extensie",
   "login.status.waitingSigner": "Wachten op je signer",
   "login.status.connecting": "Verbinden met je signer",
   "login.status.connected": "Verbonden",
+  "login.toast.loggedIn": "Ingelogd",
+  "login.toast.fetchingProfile": "Je Nostr-profiel wordt opgehaald bij de relays…",
+  "login.toast.profile": "Profiel: {name}",
+  "login.toast.noProfile": "Geen profiel gevonden op de relays",
   "login.method.extension": "Extensie",
   "login.method.remote": "Op afstand",
   "login.method.primal": "Primal",
@@ -385,7 +417,14 @@
   "notfound.fb.reviews": "Reviews",
   "notfound.fb.software": "Software",
   "notfound.fb.lastOnline": "Laatst online",
-  "notfound.fb.note": "Deze mint is geïndexeerd nadat de site voor het laatst gebouwd is, dus dit is een samenvatting uit de live API. De volledige pagina met reviews verschijnt bij de volgende build.",
+  "notfound.fb.note": "Deze mint is geïndexeerd nadat de site voor het laatst gebouwd werd, dus dit is een samenvatting uit de live API, met de reviews eronder. De volledige pagina verschijnt bij de volgende build.",
+  "notfound.resolve.checking": "Eerste bezoek: deze mint wordt nu gecontroleerd.",
+  "notfound.resolve.failed": "Deze mint kon niet worden toegevoegd",
+  "notfound.resolve.failedFedimint": "Deze federatie kon niet worden toegevoegd",
+  "notfound.resolve.retry": "Een ander adres proberen",
+  "notfound.resolve.switch": "Openen als {kind} mint",
+  "notfound.resolve.fedimint": "Het paginadres van een federatie bevat de invite code niet, dus deze is niet op te zoeken met alleen de link. Plak de invite code en hij wordt toegevoegd.",
+  "notfound.resolve.ambiguous": "Dit adres is niet af te leiden uit alleen de link. Plak de volledige URL van de mint en hij wordt toegevoegd.",
   "wallets.title": "Cashu wallets · Cashumints.space",
   "wallets.description": "Cashu wallets die werken met de mints die hier staan, voor mobiel, web, browser en de opdrachtregel, met waar elke wallet goed in is.",
   "wallets.heading": "Wallets",
@@ -623,9 +662,9 @@
   "feed.filterBySubject": "Filter op mint of federatie",
   "feed.anySubject": "Elke mint of federatie",
   "feed.clearSubject": "Het naamfilter wissen",
-  "home.fedimint.title": "Fedimint-federaties",
-  "home.fedimint.body": "{total} aangekondigd op Nostr, {online} bevestigd draaiend, {announced} nooit bevestigd.",
-  "home.fedimint.link": "Federaties bekijken",
+  "home.topFedimints.title": "Beste Fedimints",
+  "home.topFedimints.sub": "gerangschikt op reviews en beoordeling",
+  "home.topFedimints.all": "Alle {n} federaties →",
   "reviews.validate.subject": "Er is niets om deze review aan te koppelen.",
   "mint.warnings.fedimintOffline.lead": "Gemeld als offline.",
   "mint.warnings.fedimintOffline.body.since": "De laatste controle die deze federatie bereikte was op {date} ({days} geleden). Haar guardians reageren sindsdien niet meer. Beschouw geld dat je er hebt staan als verloren, en doe er niet met nieuw geld mee.",
@@ -639,5 +678,111 @@
   "footer.allFedimints": "Alle federaties",
   "reviews.dialog.bodyPlaceholder.cashu": "Hoe gingen minten, melten en de support? Wees concreet.",
   "reviews.dialog.bodyPlaceholder.fedimint": "Hoe gingen meedoen, Lightning-betalingen en de support? Wees concreet.",
-  "fedimint.details.title": "Gegevens van de federatie"
+  "fedimint.details.title": "Gegevens van de federatie",
+  "nav.lnurlMints": "LNURL mints",
+  "footer.allLnurlMints": "Alle LNURL mints",
+  "lnurlMints.title": "LNURL mints: mints voor lnurlcash toonderbriefjes, beoordeeld | Cashumints.space",
+  "lnurlMints.description": "Alle {total} LNURL mints die vanaf het Nostr-netwerk zijn geïndexeerd: {online} online, {offline} offline. Beoordelingen van de gemeenschap, opnamelimieten en mogelijkheden per mint.",
+  "lnurlMints.heading": "LNURL mints",
+  "lnurlMints.lede": "Elke LNURL mint die deze site kent. Een LNURL mint geeft lnurlcash toonderbriefjes uit: Lightning-briefjes die je als geheim bewaart en die je kunt roteren, splitsen, samenvoegen of terug melten naar een Lightning-betaling. Elke mint wordt om de paar minuten via HTTPS gecontroleerd.",
+  "lnurlMints.search.label": "Zoek LNURL mints",
+  "lnurlMints.search.placeholder": "Zoek op naam of adres…",
+  "lnurlMints.sort.label": "Sorteer LNURL mints op",
+  "lnurlMints.hideOffline": "Verberg offline",
+  "lnurlMints.showing": "{total} LNURL mints getoond ({online} online, {offline} offline)",
+  "lnurlMints.showingFiltered": "{shown} van {total} LNURL mints getoond ({online} online, {offline} offline)",
+  "lnurlMints.noResults": "Geen LNURL mint komt daarmee overeen.",
+  "lnurlMints.emptyIndex": "Er zijn nog geen LNURL mints geïndexeerd.",
+  "lnurl.crumb": "LNURL mints",
+  "lnurl.breadcrumb": "Kruimelpad",
+  "lnurl.copyAddress": "Adres kopiëren",
+  "lnurl.more.title": "Meer LNURL mints",
+  "lnurl.more.all": "Alle LNURL mints →",
+  "lnurl.disclaimer": "Een LNURL mint houdt jouw sats vast terwijl jij zijn briefjes vasthoudt, dus er een gebruiken betekent de beheerder vertrouwen. Beoordelingen zijn meningen van de gemeenschap, en online betekent bereikbaar, niet betrouwbaar.",
+  "lnurl.features.title": "Functies",
+  "lnurl.features.none": "Deze mint heeft niet aangekondigd wat hij ondersteunt.",
+  "lnurl.features.note": "Functies zijn wat de beheerder van de mint op Nostr heeft aangekondigd. Waar deze site er een via HTTPS kan controleren doet hij dat, en hij zegt het als iets aangekondigds nu niet beschikbaar is.",
+  "lnurl.features.notListed": "niet aangekondigd",
+  "lnurl.features.unavailable": "niet beschikbaar",
+  "lnurl.feature.mint": "Minten via Lightning (LUD-06)",
+  "lnurl.feature.melt": "Melten naar Lightning",
+  "lnurl.feature.notes": "Briefjes roteren / splitsen / samenvoegen",
+  "lnurl.feature.lud16": "Lightning-adres",
+  "lnurl.feature.lud21": "Betalingsverificatie (LUD-21)",
+  "lnurl.feature.signed-notes": "Ondertekende briefjes (offline verificatie)",
+  "lnurl.feature.onion": "Tor-adres",
+  "lnurl.feature.rotate": "Een briefje roteren",
+  "lnurl.feature.split": "Een briefje splitsen",
+  "lnurl.feature.merge": "Briefjes samenvoegen",
+  "lnurl.feature.lud06": "LUD-06 payRequest",
+  "lnurl.feature.lud03": "LUD-03 withdrawRequest",
+  "lnurl.limits.label": "Opnamelimieten",
+  "lnurl.limits.notPublished": "niet gepubliceerd",
+  "lnurl.limits.withdrawRow": "Opnemen",
+  "lnurl.limits.disabled": "uitgeschakeld",
+  "lnurl.limits.sats.one": "{n} sat",
+  "lnurl.limits.sats.other": "{n} sats",
+  "lnurl.details.title": "Gegevens van de mint",
+  "lnurl.details.address": "Lightning-adres",
+  "lnurl.details.mintPubkey": "Publieke sleutel van de mint",
+  "lnurl.details.onion": "Tor-adres",
+  "lnurl.details.fee": "Mintkosten",
+  "lnurl.details.node": "Node",
+  "lnurl.details.capacity": "Aangekondigde capaciteit",
+  "lnurl.kind.lightningAddress": "Lightning-adres",
+  "lnurl.kind.mintPubkey": "publieke sleutel van de mint",
+  "lnurl.kind.onionAddress": "Tor-adres",
+  "lnurl.confirmed.label": "Laatst bevestigd",
+  "lnurl.confirmed.when": "bevestigd {when}",
+  "lnurl.fee.base.one": "{n} sat",
+  "lnurl.fee.base.other": "{n} sats",
+  "lnurl.fee.percent": "{percent}%",
+  "home.topLnurl.title": "Top LNURL mints",
+  "home.topLnurl.sub": "gerangschikt op beoordelingen en cijfer",
+  "home.topLnurl.all": "Alle {n} LNURL mints →",
+  "feed.ecosystem.lnurl": "LNURL",
+  "reviews.dialog.bodyPlaceholder.lnurl": "Hoe gingen minten, melten en het roteren van briefjes? Wees concreet.",
+  "reviews.byUrl.open": "Review schrijven",
+  "reviews.byUrl.title": "Review schrijven",
+  "reviews.byUrl.lede": "Plak het adres. Kent deze site het nog niet, dan wordt het nu gecontroleerd en toegevoegd.",
+  "reviews.byUrl.label.cashu": "Mint-URL",
+  "reviews.byUrl.label.fedimint": "Invite code van de federatie",
+  "reviews.byUrl.label.lnurl": "URL van de LNURL mint",
+  "reviews.byUrl.placeholder.cashu": "mint.example.com",
+  "reviews.byUrl.placeholder.fedimint": "fed11…",
+  "reviews.byUrl.placeholder.lnurl": "mint.example.com",
+  "reviews.byUrl.check": "Dit adres controleren",
+  "reviews.byUrl.checking": "Controleren…",
+  "reviews.byUrl.back": "Ander adres gebruiken",
+  "reviews.byUrl.existing": "Staat er al bij",
+  "reviews.byUrl.indexed": "Net toegevoegd",
+  "reviews.byUrl.confirmClose": "Sluiten? Het adres dat je typte wordt niet bewaard.",
+  "reviews.byUrl.detected": "Dat adres antwoordde als een {kind} mint.",
+  "reviews.byUrl.switchTo": "Als {kind} mint reviewen",
+  "reviews.byUrl.error.empty": "Vul eerst een adres in.",
+  "reviews.byUrl.error.badUrl": "Dat lijkt geen mint-URL.",
+  "reviews.byUrl.error.badInvite": "Dat is geen Fedimint invite code. Codes beginnen met fed11.",
+  "reviews.byUrl.error.badInput": "Deze site kan dat adres niet controleren.",
+  "reviews.byUrl.error.blocked": "Dat is geen openbaar adres, dus het kan niet gecontroleerd worden.",
+  "reviews.byUrl.error.notAMint": "Dat adres antwoordde, maar niet als een mint van dit soort.",
+  "reviews.byUrl.error.wrongType": "Dat adres antwoordde, maar als een ander soort mint.",
+  "reviews.byUrl.error.unverifiable": "Op dat adres reageerde niets, en op Nostr is er nog geen spoor van te vinden.",
+  "reviews.byUrl.error.rateLimited.one": "Dat zijn veel controles vanaf één verbinding. Probeer het over ongeveer {n} minuut opnieuw.",
+  "reviews.byUrl.error.rateLimited.other": "Dat zijn veel controles vanaf één verbinding. Probeer het over ongeveer {n} minuten opnieuw.",
+  "reviews.byUrl.error.network": "De index was niet bereikbaar. Controleer je verbinding en probeer het opnieuw.",
+  "seo.lnurl.titleNoReviews": "{name}: info en beoordelingen van de LNURL mint | Cashumints.space",
+  "seo.desc.statusWithdraw": "{status}, opname {min}–{max} sat.",
+  "mint.chip.noFunding": "Geen mint / melt",
+  "mint.warnings.lnurlWithdrawalsDisabled.lead": "Opnemen staat uit.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.online": "Deze mint adverteert een maximale opname van nul, dus geen enkel briefje dat hij uitgeeft kan voor iets worden ingewisseld. Mint hier niet totdat dat verandert.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.offline": "Deze mint adverteerde een maximale opname van nul toen hij voor het laatst bereikt werd, dus geen enkel briefje dat hij uitgaf kon voor iets worden ingewisseld. Mint hier niet totdat dat verandert.",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.online": "Opnemen staat momenteel uit",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.offline": "Opnemen stond uit toen hij voor het laatst gezien werd",
+  "mint.warnings.lnurlInvalid.lead": "Endpoint antwoordt maar is ongeldig.",
+  "mint.warnings.lnurlInvalid.body": "De host antwoordt, maar niet met een mintaankondiging die deze site kan lezen, dus opnemen werkt mogelijk niet. Alles hieronder is de laatste staat die wel te lezen was, en beoordelingen werken nog steeds.",
+  "mint.warnings.lnurlInvalid.meta": "Antwoordt, maar niet met een geldige mintaankondiging",
+  "mint.warnings.lnurlNoFunding.lead": "Minten en melten niet beschikbaar.",
+  "mint.warnings.lnurlNoFunding.body": "Bestaande briefjes kunnen nog steeds geroteerd, gesplitst of samengevoegd worden, maar er gaat nu niets in of uit via Lightning. De mint zelf is bereikbaar en antwoordt; de Lightning-node erachter is vanaf daar niet bereikbaar.",
+  "mint.warnings.lnurlNoFunding.meta": "Minten en melten niet beschikbaar",
+  "mint.warnings.also.noFunding": "De Lightning-node was ook onbereikbaar, dus er kon niets gemint of gemelt worden."
 }

web/src/i18n/pl.json

@@ -0,0 +1,834 @@
+{
+  "site.name": "Cashumints.space",
+  "common.close": "Zamknij",
+  "common.cancel": "Anuluj",
+  "common.done": "Gotowe",
+  "common.back": "Z powrotem",
+  "common.retry": "Próba ponowna",
+  "common.connect": "Połącz się",
+  "common.copied": "Skopiowane",
+  "common.copyFull": "Kopiuję pełny {kind}",
+  "common.previousPage": "Poprzednia strona",
+  "common.nextPage": "Następna strona",
+  "common.reviewPages": "Strony recenzyjne",
+  "time.never": "nigdy",
+  "time.justNow": "Właśnie teraz",
+  "time.none": "-",
+  "time.unknownDate": "data nieznana",
+  "time.ago.minute": "{n}m temu",
+  "time.ago.hour": "{n}h temu",
+  "time.ago.day": "{n}d temu",
+  "time.ago.week": "{n}w temu",
+  "time.ago.month": "{n}mo temu",
+  "time.ago.year": "{n}y temu",
+  "time.short.minute": "{n}m",
+  "time.short.hour": "{n}h",
+  "time.short.day": "{n}d",
+  "time.short.week": "{n}w",
+  "time.short.month": "{n}mo",
+  "time.short.year": "{n}y",
+  "status.online": "Dostępna",
+  "status.offline": "Niedostępna",
+  "status.degraded": "Nieosiągalny",
+  "status.unknown": "Jeszcze nie sprawdzone",
+  "nav.skip": "Przejdź do treści",
+  "nav.main": "Główne",
+  "nav.mints": "Minty Cashu",
+  "nav.reviews": "Recenzje",
+  "nav.wallets": "Portfele",
+  "nav.about": "O nas",
+  "nav.searchMints": "Szukaj wśród {n} mintów",
+  "lang.label": "Język",
+  "lang.switcher": "Wybierz język",
+  "footer.copyright": "© {year} Cashumints.space",
+  "footer.allMints": "Wszystkie minty Cashu",
+  "footer.allReviews": "Wszystkie recenzje",
+  "footer.wallets": "Portfele",
+  "footer.about": "O nas",
+  "footer.disclaimer": "Zastrzeżenie",
+  "footer.terms": "Warunki",
+  "footer.privacy": "Prywatność",
+  "footer.madeBy": "Zrobione z ❤️ przez {azzamo} · Napędzane przez Cashu i NIP-87",
+  "footer.warning": "Minty są powiernicze. Mint może zniknąć z twoimi pieniędzmi.",
+  "footer.tagline": "Recenzje społeczności dotyczące mintów ecash, podpisane w Nostr.",
+  "footer.col.explore": "Przeglądaj",
+  "footer.col.site": "Strona",
+  "footer.nav": "Stopka",
+  "home.title": "Cashumints.space · Znajdź mint Cashu, któremu możesz zaufać",
+  "home.description": "Znajdź mint Cashu, któremu możesz zaufać. {mints} mintów w indeksie, {reviews} recenzji społeczności podpisanych w Nostr, do tego bieżąca dostępność, obsługiwane NUT-y i oprogramowanie mintu.",
+  "home.hero.title": "Znajdź mint Cashu",
+  "home.hero.titleEm": "Możesz zaufać",
+  "home.hero.lede": "Każda moneta w sieci Nostr, z prawdziwymi recenzjami społeczności. Nie ma żadnych strażników, tylko podpisane recenzje, które możesz samodzielnie zweryfikować.",
+  "home.search.label": "Wyszukaj mennicy według nazwy, domeny lub adresu URL",
+  "home.search.placeholder": "Wyszukaj po imieniu, dokumencie lub wklej adres URL Mint...",
+  "home.filters.mostReviewed": "Najczęściej recenzowane",
+  "home.filters.highestRated": "Najwyższa ocena",
+  "home.filters.recentlyActive": "Ostatnio aktywny",
+  "home.filters.websockets": "Obsługuje WebSockets",
+  "home.top.title": "Top mennice Cashu",
+  "home.top.sub": "Oceniane według recenzji i ocen",
+  "home.top.all": "Wszystkie {n} mennice →",
+  "home.latest.title": "Najnowsze recenzje",
+  "home.latest.sub": "na żywo z sieci Nostr",
+  "home.latest.prev": "Poprzednie recenzje",
+  "home.latest.next": "Więcej recenzji",
+  "home.latest.all": "Wszystkie recenzje →",
+  "home.latest.empty": "Obecnie nie można było odczytać żadnych recenzji z przekaźników. Otwórz dowolną stronę Mint, aby czytać i pisać recenzje bezpośrednio.",
+  "home.why.title": "Dlaczego ufać tym opiniom?",
+  "home.why.signed.title": "Podpisane, nie przesłane",
+  "home.why.signed.body": "Każda recenzja to wydarzenie {link} podpisane przez klucz Nostr autora. Nic tutaj nie jest edytowane, klasyfikowane ani usuwane przez nas.",
+  "home.why.signed.link": "NIP-87",
+  "home.why.verify.title": "Sprawdź to samodzielnie",
+  "home.why.verify.body": "Recenzje są dostępne na publicznych przekaźnikach Nostr, nie w naszej bazie danych. Skieruj dowolnego klienta na te same przekaźniki, a zobaczysz te same dane.",
+  "home.why.checked.title": "Sprawdzane na bieżąco",
+  "home.why.checked.body": "Sprawdzamy każdą mennicę pod kątem dostępności, wersji oprogramowania, limitów i obsługiwanych NUT-ów, więc specyfikacje, które widzisz, są aktualne, a nie samoraportowane.",
+  "home.cta.title": "Myślisz o mennicy? Przeczytaj najpierw.",
+  "home.cta.body": "Mennica przechowuje twoje e-pieniądze. Przeczytaj, co inni odkryli, zanim założysz SAT, i zostaw recenzję, gdy sam z niego korzystasz.",
+  "home.cta.explore": "Poznaj wszystkie mennice",
+  "home.cta.learn": "Dowiedz się więcej o Cashu",
+  "pulse.mintsIndexed": "mennice indeksowane",
+  "pulse.reviewsOnNostr": "recenzje na Nostr",
+  "pulse.lastReview": "Ostatnia recenzja",
+  "pulse.mintsOnline": "Mennice online",
+  "pulse.indexer": "Indeksator",
+  "pulse.connected": "połączony",
+  "pulse.stale": "Stale",
+  "mints.title": "Wszystkie mennice Cashu · Cashumints.space",
+  "mints.description": "Wszystkie mennice Cashu {total} indeksowane w sieci Nostr, {online} online i {offline} offline, z ocenami społecznościowymi, dostępnością i oprogramowaniem do mintowania. Wyszukaj i posortuj pełną listę.",
+  "mints.heading": "Wszystkie minty Cashu",
+  "mints.lede": "Każda mennica odkryta w sieci Nostr, włącznie z tymi, które już nie istnieją. Offline minty pozostają na liście, więc nadal można je znaleźć i recenzować.",
+  "mints.search.label": "Wyszukaj mennice według nazwy lub domeny",
+  "mints.search.placeholder": "Wyszukaj po imieniu lub domenie...",
+  "mints.sort.label": "Sortuj mennice",
+  "mints.sort.score": "Najlepszy w ogóle",
+  "mints.sort.rating": "Najwyższa ocena",
+  "mints.sort.reviews": "Najczęściej recenzowane",
+  "mints.sort.recent": "Niedawno recenzowane",
+  "mints.sort.seen": "Niedawno widziane online",
+  "mints.hideOffline": "Ukryj się offline",
+  "mints.showing": "Wyświetlanie {total} mennic ({online} online, {offline} offline)",
+  "mints.showingFiltered": "Wyświetlanie {shown} {total} mennic ({online} online, {offline} offline)",
+  "mints.noResults": "Brak mennic do dopasowania. Spróbuj domeny lub wklej adres URL Mint.",
+  "mints.clearSearch": "Oczyść przeszukanie",
+  "card.noRatings": "Jeszcze brak oglądalności",
+  "card.reviews.one": "{n} recenzja",
+  "card.reviews.few": "{n} recenzje",
+  "card.reviews.many": "{n} recenzji",
+  "card.reviews.other": "{n} recenzje",
+  "card.lastSeen": "Ostatni raz widziana {when}",
+  "card.neverSeen": "Nigdy nie widziano w internecie",
+  "card.reviewed": "Recenzja {when}",
+  "card.noReviews": "Brak jeszcze recenzji",
+  "mint.title": "{name} · Recenzje Cashu Mint",
+  "mint.titleFedimint": "{name} · Recenzje federacji Fedimint",
+  "mint.titleLnurl": "{name} · Recenzje mintu LNURL",
+  "mint.breadcrumb": "Okruszek chleba",
+  "mint.crumbMints": "Mennice cashu",
+  "mint.copyUrl": "Skopiuj URL Mint",
+  "mint.qrButton": "Kod QR mennicy",
+  "mint.writeReview": "Napisz recenzję",
+  "mint.rankByScore": "#{rank} według wyników",
+  "mint.tagLightning": "Lightning",
+  "mint.summary": "Podsumowanie mennicy",
+  "mint.rating.label": "Ocena społeczności",
+  "mint.rating.none": "Jeszcze brak oglądalności",
+  "mint.rating.reviews.one": "{n} recenzja",
+  "mint.rating.reviews.few": "{n} recenzje",
+  "mint.rating.reviews.many": "{n} recenzji",
+  "mint.rating.reviews.other": "{n} recenzje",
+  "mint.rating.unrated.one": "{n} nie zostawił oceny",
+  "mint.rating.unrated.few": "{n} nie pozostawiło żadnej oceny",
+  "mint.rating.unrated.many": "{n} osób nie pozostawiło oceny",
+  "mint.rating.unrated.other": "{n} nie zostawił oceny",
+  "mint.activity.label": "Działalność",
+  "mint.activity.since": "od ostatniej recenzji",
+  "mint.activity.noReviews": "Brak jeszcze recenzji",
+  "mint.activity.recent.one": "{n} przegląd w ciągu ostatnich 90 dni",
+  "mint.activity.recent.few": "{n} recenzje w ciągu ostatnich 90 dni",
+  "mint.activity.recent.many": "{n} recenzji w ciągu ostatnich 90 dni",
+  "mint.activity.recent.other": "{n} recenzje w ciągu ostatnich 90 dni",
+  "mint.limits.label": "Granice",
+  "mint.limits.notPublished": "Nieopublikowane",
+  "mint.limits.min": "min",
+  "mint.limits.max": "Max",
+  "mint.limits.mintRow": "Mint",
+  "mint.limits.meltRow": "topnienie",
+  "mint.limits.disabled": "Niepełnosprawność",
+  "mint.limits.range": "od {min} do {max} {unit}",
+  "mint.limits.upTo": "do {max} {unit}",
+  "mint.limits.from": "od {min} {unit}",
+  "mint.software.label": "Oprogramowanie Mint",
+  "mint.software.unknown": "nieznane",
+  "mint.checked": "sprawdzono {when}",
+  "mint.lastSeen": "Ostatni raz widziana {when}",
+  "mint.neverReached": "nigdy nie dotarł",
+  "mint.uptime.checks": "{ok} ostatnich {total} sprawdzonych dostępnych",
+  "mint.uptime.percent": "{percent}% osiągnięć w ciągu 30 dni",
+  "mint.uptime.description": "{ok} ostatnich {total} sprawdzonych prób zakończyło się sukcesem",
+  "mint.operator.title": "Od operatora",
+  "mint.operator.motd": "Przesłanie dnia",
+  "mint.operator.beta": "Ta mennica opisuje się jako eksperymentalna lub w fazie beta. Przeczytaj poniżej słowa operatora, zanim przechowujesz cokolwiek, czego nie możesz stracić.",
+  "mint.nuts.title": "Obsługiwane NUT-y",
+  "mint.nuts.noneOffline": "Nie było pamięci podręcznej listy NUT dla tej mennicy, została wyłączona zanim została zarejestrowana.",
+  "mint.nuts.noneYet": "Na razie nie ma żadnej listy NUT w pamięci podręcznej dla tej mennicy.",
+  "mint.nuts.supported": "{n} {total} znanych NUT obsługiwanych",
+  "mint.nuts.whatAre": "czym są NUT?",
+  "mint.nutRow.disabled": "Niepełnosprawność",
+  "mint.nutRow.notSupported": "Brak poparcia",
+  "mint.details.title": "Szczegóły mennicy",
+  "mint.details.pubkey": "Pubkey",
+  "mint.details.nostr": "Nostr",
+  "mint.details.email": "E-mail",
+  "mint.details.serverTime": "Czas na serwerze",
+  "mint.details.firstSeen": "Pierwsze pokazanie",
+  "mint.details.terms": "Warunki",
+  "mint.kind.identifier": "Identyfikator",
+  "mint.kind.mintPubkey": "Mint Pubkey",
+  "mint.kind.nostrAddress": "Adres Nostr",
+  "mint.kind.emailAddress": "Adres e-mail",
+  "mint.kind.npub": "npub",
+  "mint.disclaimer": "Ta mennica jest depozytarzem: przechowuje twoje pieniądze i może przestać je przestawać w każdej chwili. Oceny to opinie społeczności, a online to sposób dostępny, a nie godny zaufania.",
+  "mint.disclaimerLink": "Przeczytaj pełne zastrzeżenie",
+  "mint.qr.title": "Dodaj {name} do portfela",
+  "mint.qr.note": "Zeskanuj to portfelem Cashu, aby dodać mint, albo skopiuj URL i wklej go.",
+  "mint.qr.warn": "Dodanie mennicy oznacza zaufanie jej z pieniędzmi.",
+  "mint.qr.whatMeans": "Co to oznacza",
+  "mint.qr.wallets": "Portfele obsługujące Cashu",
+  "mint.chip.frozen": "Zamrożone",
+  "mint.chip.noWithdrawals": "Brak odstawienia",
+  "mint.chip.meltOnly": "Tylko topić",
+  "mint.warnings.dayCount.one": "{n} dzień",
+  "mint.warnings.dayCount.few": "{n} dni",
+  "mint.warnings.dayCount.many": "{n} dni",
+  "mint.warnings.dayCount.other": "{n} dni",
+  "mint.warnings.gone.lead": "Prawdopodobnie już nie ma.",
+  "mint.warnings.gone.body.since": "Ta mennica jest niedostępna od {date} roku ({days}). Traktuj środki przechowywane tam jako zagrożone i nie wysyłaj nowych. Poniżej szczegóły pokazują jego ostatni znany stan.",
+  "mint.warnings.gone.body.neverDated": "Ta mennica nie odpowiedziała na żaden sprawdzony punkt od czasu, gdy zaczęliśmy ją oglądać w {month} roku. Traktuj środki przechowywane tam jako zagrożone i nie wysyłaj nowych. Wszystko poniżej pochodziło z ogłoszenia Nostr, nie z mennicy.",
+  "mint.warnings.gone.body.never": "Ta mennica nie odpowiedziała na żaden czek od czasu, gdy zaczęliśmy ją oglądać. Traktuj środki przechowywane tam jako zagrożone i nie wysyłaj nowych. Wszystko poniżej pochodziło z ogłoszenia Nostr, nie z mennicy.",
+  "mint.warnings.gone.meta.since": "Offline od {date}",
+  "mint.warnings.gone.meta.never": "Nigdy nie było dostępnego od momentu odkrycia",
+  "mint.warnings.meltDisabled.lead": "Objawy odstawienia wyłączone.",
+  "mint.warnings.meltDisabled.body.online": "Ta mennica ma wyłączone Lightning Melting (NUT-05): możesz włożyć saty, ale nie możesz ich pobrać przez Lightning. Nie wpłacaj, dopóki stopienie nie wróci.",
+  "mint.warnings.meltDisabled.body.offline": "Ta mennica miała wyłączone Lightning Melting (NUT-05): można włożyć saty, ale nie da się ich pobrać przez Lightning. Nie wpłacaj, dopóki stopienie nie wróci.",
+  "mint.warnings.meltDisabled.meta.online": "Wycofania obecnie nieaktywne",
+  "mint.warnings.meltDisabled.meta.offline": "Wycofanie było wyłączone przy ostatnim spotkaniu",
+  "mint.warnings.frozen.lead": "Mennica zamrożona.",
+  "mint.warnings.frozen.body.online": "Zarówno bicie, jak i topienie są wyłączone. Żadne satelity nie mogą przechodzić ani wchodzić ani wychodzić przez Lightning.",
+  "mint.warnings.frozen.body.offline": "Zarówno bicie, jak i topienie zostały wyłączone. Żadne satelity nie mogą przechodzić ani wchodzić ani wychodzić przez Lightning.",
+  "mint.warnings.frozen.meta.online": "Obecnie zamrożony, nic nie wchodzi ani nie wychodzi",
+  "mint.warnings.frozen.meta.offline": "Zamarznięty, gdy ostatnio widziano",
+  "mint.warnings.offlineLong.lead": "Offline przez {days}, od {date}.",
+  "mint.warnings.offlineLong.body": "Mennica może już zniknęła. Wszystko poniżej to jego ostatni znany stan, a recenzje nadal działają.",
+  "mint.warnings.offlineLong.meta": "Offline od {date}",
+  "mint.warnings.meltOnly.lead": "Tylko top.",
+  "mint.warnings.meltOnly.body.online": "Nowe wybijanie pieniędzy (NUT-04) jest wyłączone: nie możesz wpłacić, ale istniejące e-pieniądze nadal można wypłacić. Często oznacza to, że mennica się kończy, więc jeśli trzymasz jej ecash, rozważ jej topnienie.",
+  "mint.warnings.meltOnly.body.offline": "Nowe wybijanie (NUT-04) zostało wyłączone: nie można wpłacić, ale istniejące e-pieniądze nadal można wypłacić. Często oznacza to, że mennica się kończy, więc jeśli trzymasz jej ecash, rozważ jej topnienie.",
+  "mint.warnings.meltOnly.meta.online": "Obecnie tylko topi",
+  "mint.warnings.meltOnly.meta.offline": "Topi się tylko przy ostatnim widzeniu",
+  "mint.warnings.offline.lead": "Offline od {date}.",
+  "mint.warnings.offline.body": "Szczegóły zostały wtedy ostatnio potwierdzone. Wciąż możesz napisać recenzję.",
+  "mint.warnings.offline.meta": "Offline od {date}",
+  "mint.warnings.also.meltDisabled": "Przed wyłączeniem wyłączył też odstawienie.",
+  "mint.warnings.also.mintDisabled": "Przed wyłączeniem wyłączył też nowe mintowanie.",
+  "mint.warnings.also.offline": "Od {date} roku ({days}) jest również offline.",
+  "nut.0": "Notacja i modele",
+  "nut.1": "Wymiana klucza publicznego Mint",
+  "nut.2": "Zestawy kluczy i opłaty",
+  "nut.3": "Wymiana tokenów",
+  "nut.4": "Bicie przez Lightning",
+  "nut.5": "Topnienie przez błyskawice",
+  "nut.6": "Informacje o mennicy",
+  "nut.7": "Sprawdzenie stanu tokena",
+  "nut.8": "Zapłacone opłaty za Lightning",
+  "nut.9": "Przywróć sygnatury",
+  "nut.10": "Warunki wydatków",
+  "nut.11": "Płać do klucza publicznego",
+  "nut.12": "Dowody DLEQ",
+  "nut.13": "Sekrety deterministyczne",
+  "nut.14": "Zhasowane kontrakty timelock",
+  "nut.15": "Płatności wielościeżkowe",
+  "nut.16": "Animowane kody QR",
+  "nut.17": "Subskrypcje WebSocket",
+  "nut.18": "Żądania płatności",
+  "nut.19": "Odpowiedzi w pamięci podręcznej",
+  "nut.20": "Podpisane cytaty mennicze",
+  "nut.21": "Czyste uwierzytelnianie",
+  "nut.22": "Uwierzytelnianie ślepe",
+  "nut.23": "Metoda płatności BOLT11",
+  "nut.24": "Wymagana płatność HTTP 402",
+  "nut.25": "Metoda płatności BOLT12",
+  "reviews.title": "Recenzje",
+  "reviews.anon": "Anon",
+  "reviews.anonTitle": "Nie znaleziono publicznego profilu Nostr dla tego klucza",
+  "reviews.nip05Title": "Identyfikator NIP-05 (nie zweryfikowany przez tę stronę)",
+  "reviews.filter.group": "Recenzje filtrów",
+  "reviews.filter.all": "Wszyscy",
+  "reviews.filter.five": "5★",
+  "reviews.filter.critical": "Krytyczne",
+  "reviews.filter.recent": "Ostatnie",
+  "reviews.filter.hideAnon": "Ukryj anonimę",
+  "reviews.anonHidden.other": "Pokazuję {n} z {total} recenzji: anonimowo ukryte.",
+  "reviews.allAnon.one": "Jedyna recenzja tutaj jest anon.",
+  "reviews.allAnon.few": "Wszystkie {n} recenzje tutaj są anonimowe.",
+  "reviews.allAnon.many": "Wszystkie {n} recenzji tutaj są anonimowe.",
+  "reviews.allAnon.other": "Wszystkie {n} recenzje tutaj są anonimowe.",
+  "reviews.allAnonShow.one": "Pokaż to",
+  "reviews.allAnonShow.few": "Pokaż im",
+  "reviews.allAnonShow.many": "Pokaż im",
+  "reviews.allAnonShow.other": "Pokaż im",
+  "reviews.loading.one": "Ładowanie {n} recenzja z Nostr relays",
+  "reviews.loading.few": "Ładowanie {n} recenzji z przekaźników Nostr",
+  "reviews.loading.many": "Ładowanie {n} recenzji z przekaźników Nostr",
+  "reviews.loading.other": "Ładowanie {n} recenzji z Nostr relays",
+  "reviews.empty": "Jeszcze brak recenzji. Bądź pierwszym, który go napisze.",
+  "reviews.emptyWritten": "Na razie nie ma tu żadnych pisemnych recenzji. Bądź pierwszym, który go napisze.",
+  "reviews.emptyFilter": "Żadna recenzja nie pasuje do tego filtra.",
+  "reviews.rate.cashu": "Oceń ten mint",
+  "reviews.rate.fedimint": "Oceń tę federację",
+  "reviews.rate.lnurl": "Oceń ten mint",
+  "reviews.noscript": "Recenzje są zalogowane w Nostr i ładują się w przeglądarce, więc ta lista wymaga JavaScript. Ocena i liczby powyżej pochodzą z samej strony.",
+  "reviews.relayError": "Nie udało się dołączyć do przekaźnika. Recenzje mogą być niekompletne.",
+  "reviews.srRating": "{rating} na 5",
+  "reviews.srNoRating": "Brak oceny",
+  "reviews.readMore": "Czytaj więcej",
+  "reviews.readLess": "Pokazuj mniej",
+  "reviews.actions.copyNpub": "Skopiuj npub",
+  "reviews.actions.openNostr": "Obejrzyj to wydarzenie na Nostr",
+  "reviews.actions.copyLink": "Kopiuj link do tej recenzji",
+  "reviews.anonNote": "Pierwsza recenzja z tego npubu, nie znaleziono żadnej innej aktywności",
+  "reviews.published": "Opublikowano.",
+  "reviews.publishedPartial": "Opublikowano dla {accepted} sztafetyi {total}.",
+  "reviews.propagating": "Publikowanie na relayach Nostr",
+  "reviews.summary.line.one": "{count} ocena bez komentarza: {breakdown}",
+  "reviews.summary.line.few": "{count} oceny bez komentarza: {breakdown}",
+  "reviews.summary.line.many": "{count} ocen bez komentarza: {breakdown}",
+  "reviews.summary.line.other": "{count} oglądalności bez komentarza: {breakdown}",
+  "reviews.summary.lineDay.one": "{count} ocena bez komentarza na temat {when}: {breakdown}",
+  "reviews.summary.lineDay.few": "{count} oceny bez komentarza na {when}: {breakdown}",
+  "reviews.summary.lineDay.many": "{count} ocen bez komentarza na {when}: {breakdown}",
+  "reviews.summary.lineDay.other": "{count} oceny bez komentarza na temat {when}: {breakdown}",
+  "reviews.summary.showOne": "Pokaż to",
+  "reviews.summary.showMany": "Pokaż im",
+  "reviews.breakdown.5": "{n} pięciogwiazdkowy",
+  "reviews.breakdown.4": "{n} czterogwiazdkowy",
+  "reviews.breakdown.3": "{n} trzy gwiazdki",
+  "reviews.breakdown.2": "{n} dwie gwiazdki",
+  "reviews.breakdown.1": "{n} jedną gwiazdką",
+  "reviews.breakdown.none": "{n} bez oceny",
+  "reviews.dialog.title": "Recenzja {name}",
+  "reviews.dialog.lede.cashu": "Podziel się swoim doświadczeniem z tym mintem.",
+  "reviews.dialog.lede.fedimint": "Podziel się swoim doświadczeniem z tą federacją.",
+  "reviews.dialog.lede.lnurl": "Podziel się swoim doświadczeniem z tym mintem.",
+  "reviews.dialog.permanent": "Publikowane na stałe w publicznych relayach Nostr.",
+  "reviews.dialog.gate.title": "Zaloguj się, aby napisać recenzję",
+  "reviews.dialog.gate.lead": "Recenzje są podpisywane twoim kluczem Nostr. Zostaje on w twoim signerze, ta strona nigdy go nie widzi.",
+  "reviews.dialog.ratingLegend": "Twoja ocena",
+  "reviews.dialog.starsSr.one": "{n} gwiazda",
+  "reviews.dialog.starsSr.few": "{n} gwiazdki",
+  "reviews.dialog.starsSr.many": "{n} gwiazdek",
+  "reviews.dialog.starsSr.other": "{n} gwiazdy",
+  "reviews.dialog.chooseRating": "Wybierz ocenę",
+  "reviews.dialog.starLabel": "{n}: {phrase}",
+  "reviews.dialog.stars.1": "Unikaj tego",
+  "reviews.dialog.stars.2": "miał problemy",
+  "reviews.dialog.stars.3": "zadziałało, z zastrzeżeniami",
+  "reviews.dialog.stars.4": "dobrze",
+  "reviews.dialog.stars.5": "Działa świetnie",
+  "reviews.dialog.bodyLabel": "Co powinni wiedzieć inni?",
+  "reviews.dialog.charCount": "{n} / {max}",
+  "reviews.dialog.submit": "Podpisz i opublikuj",
+  "reviews.dialog.signing": "Podpisuję...",
+  "reviews.dialog.publishing": "Wydawnictwo...",
+  "reviews.dialog.publishingTo": "Publikacje do przekaźników ({accepted}/{total})",
+  "reviews.dialog.waitingExtension": "Czekam na przedłużenie",
+  "reviews.dialog.waitingSigner": "Czekam na swojego podpisującego",
+  "reviews.dialog.confirmClose": "Zamknąć tę recenzję? Twój szkic jest przechowywany do momentu opuszczenia strony.",
+  "reviews.dialog.why.login": "Zaloguj się, aby opublikować",
+  "reviews.dialog.why.words": "Napisz kilka słów",
+  "reviews.dialog.why.more.one": "{n} więcej charakteru",
+  "reviews.dialog.why.more.few": "{n} kolejne postacie",
+  "reviews.dialog.why.more.many": "Kolejne {n} postaci",
+  "reviews.dialog.why.more.other": "{n} więcej postaci",
+  "reviews.dialog.why.over.one": "{n} znak przekraczający limit",
+  "reviews.dialog.why.over.few": "{n} znaki powyżej limitu",
+  "reviews.dialog.why.over.many": "{n} znaków powyżej limitu",
+  "reviews.dialog.why.over.other": "{n} znaków powyżej limitu",
+  "reviews.dialog.identity.needSigner": "Do publikacji potrzebujesz osoby do podpisywania Nostr. Twój klucz zostaje w środku, ta strona go nigdy nie widzi.",
+  "reviews.dialog.identity.loginToPublish": "Zaloguj się, aby opublikować",
+  "reviews.dialog.identity.switch": "Zmiana",
+  "reviews.dialog.identity.extension": "Logowanie się za pomocą rozszerzenia przeglądarki",
+  "reviews.dialog.identity.readingKey": "Czytanie twojego klucza publicznego...",
+  "reviews.dialog.identity.willAsk": "Twoje przedłużenie będzie proszone o podpisanie",
+  "reviews.dialog.error.noRelay": "Żaden przekaźnik nie zaakceptował recenzji. Sprawdź połączenie, a potem spróbuj ponownie.",
+  "reviews.validate.rating": "Wybierz ocenę od 1 do 5 gwiazdek.",
+  "reviews.validate.short": "Napisz przynajmniej {n} postaci, żeby recenzja była przydatna.",
+  "reviews.validate.long": "Recenzje ograniczają się do {n} postaci.",
+  "feed.title": "Najnowsze recenzje mennic i federacji · Cashumints.space",
+  "feed.description": "Każda opinia o mincie, federacji i mincie LNURL zaraz po opublikowaniu: {reviews} opinii o {mints} mintach Cashu, {federations} federacjach Fedimint i {lnurl} mintach LNURL, podpisanych w Nostr i czytelnych tutaj od najnowszych. Filtruj po ekosystemie, ocenie lub nazwie.",
+  "feed.heading": "Najnowsze recenzje",
+  "feed.lede": "Każda recenzja każdej mennicy Cashu i federacji Fedimint, najnowsza, czytana na żywo z przekaźników Nostr. Każdy z nich jest podpisany przez autora i znajduje się na przekaźnikach, a nie w naszej bazie danych.",
+  "feed.label": "Recenzje",
+  "feed.showingBuild.one": "Pokaz najnowszej recenzji z poprzedniej wersji",
+  "feed.showingBuild.few": "Wyświetlanie {n} najnowszych recenzji z poprzedniej wersji",
+  "feed.showingBuild.many": "Wyświetlanie {n} najnowszych recenzji z poprzedniej wersji",
+  "feed.showingBuild.other": "Pokazuję {n} najnowsze recenzje z poprzedniej wersji",
+  "feed.noscript": "Recenzje są logowane w Nostr i ładują się w przeglądarce, więc filtrowanie i pełna lista wymagają JavaScript. Poniższe {n} recenzje zostały przeczytane z przekaźników, gdy ta strona została zbudowana.",
+  "feed.emptyBuild": "Nie można było odczytać recenzji z przekaźników, gdy budowano tę stronę. Lista ładuje się ponownie z przekaźników w Twojej przeglądarce.",
+  "feed.foot": "Recenzje to opinie społeczności, a nie zweryfikowane twierdzenia. Przeczytaj {link}, zanim zaufasz mennicy z pieniędzmi.",
+  "feed.footLink": "Zastrzeżenie",
+  "feed.showing": "Pokazywanie {shown} {total} recenzji",
+  "feed.showingMatching": "Pokazując {shown} {matching} pasujących recenzji (łącznie {total})",
+  "feed.emptyRelays": "Nie otrzymałem żadnych opinii z przekaźników. Otwórz dowolną stronę Mint, aby czytać i pisać recenzje.",
+  "feed.emptyFilter": "Żadna recenzja nie pasuje do tego filtra. Opróżnij mennicze pudełko albo spróbuj All.",
+  "feed.relayError": "Nie udało się dotrzeć do przekaźników. Pokazując recenzje z poprzedniej wersji.",
+  "feed.relayEmpty": "Nie otrzymałem żadnych opinii z przekaźników. Pokazując recenzje z poprzedniej wersji.",
+  "feed.reading": "Czytanie przekaźników...",
+  "login.open": "Zaloguj się",
+  "login.title": "Zaloguj się przez Nostr",
+  "login.note": "Twój klucz zostaje w twoim podpisowym rejestratorze. Ta strona nigdy tego nie widzi.",
+  "login.extension.name": "Rozszerzenie przeglądarki",
+  "login.extension.desc": "Podpisz się Alby, nos2x lub innym rozszerzeniem NIP-07",
+  "login.extension.none": "Nie znaleziono przedłużenia",
+  "login.extension.getOne": "Zdobądź jeden:",
+  "login.remote.name": "Zdalny sygnał",
+  "login.remote.desc": "Zeskanuj kod za pomocą aplikacji signer lub wklej link do bunkra",
+  "login.primal.name": "Primal",
+  "login.primal.desc": "Zatwierdzaj logowanie w aplikacji Primal na swoim telefonie",
+  "login.paste.label": "Albo wklej link do połączenia, który dał ci sygnator",
+  "login.copyLink": "Skopiuj link łączący",
+  "login.whatIsNostr": "Czym jest Nostr?",
+  "login.connect.remote.title": "Podłącz zdalnego użytkownika",
+  "login.connect.remote.lead": "Zeskanuj to w aplikacji signer lub skopiuj link i wklej tam.",
+  "login.connect.remote.hint": "Działa z każdym podpisującym NIP-46: nsec.app, Amber, Nostrify, własny bunkier.",
+  "login.connect.remote.open": "Otwórz się w aplikacji signer",
+  "login.connect.primal.title": "Połącz się z Primal",
+  "login.connect.primal.lead": "Otwórz Primal na telefonie, znajdź zdalne logowanie w ustawieniach i zeskanuj ten kod.",
+  "login.connect.primal.hint": "Znaki Primal dla innych aplikacji przez NIP-46, więc to to samo połączenie, którego używa każdy podpisujący, a klucz pozostaje w Primal. {link}",
+  "login.connect.primal.open": "Open w Primal",
+  "login.status.buildingLink": "Budowanie połączenia",
+  "login.status.waitingExtension": "Czekam na przedłużenie",
+  "login.status.waitingSigner": "Czekam na swojego podpisującego",
+  "login.status.connecting": "Łączenie się z Twoim sygnatariuszem",
+  "login.status.connected": "Połączone",
+  "login.toast.loggedIn": "Zalogowano",
+  "login.toast.fetchingProfile": "Pobieranie Twojego profilu Nostr z przekaźników…",
+  "login.toast.profile": "Profil: {name}",
+  "login.toast.noProfile": "Nie znaleziono profilu na przekaźnikach",
+  "login.method.extension": "Rozszerzenie",
+  "login.method.remote": "Zdalne",
+  "login.method.primal": "Primal",
+  "login.account": "Twoje konto Nostr",
+  "login.copyNpub": "Skopiuj cały swój npub",
+  "login.logout": "Wyloguj się",
+  "signer.status.waitingExtension": "Czekam na przedłużenie",
+  "signer.status.signed": "Podpisano",
+  "signer.status.reconnecting": "Ponowne połączenie z twoim sygnalizatorem",
+  "signer.status.approveWindow": "Twój podpisujący potrzebuje, abyś zatwierdził to w osobnym oknie",
+  "signer.status.waitingSigner": "Czekam na swojego podpisującego",
+  "signer.status.stillWaiting": "Wciąż czekam na odpowiedź twojego sygnalizatora",
+  "signer.status.connected": "Połączone",
+  "signer.error.noExtension": "Nie znaleziono przedłużenia podpisu. Zainstaluj Alby lub nos2x, a potem wczytaj tę stronę.",
+  "signer.error.privateKey": "To wygląda na klucz prywatny, a nie na połączenie połączeniowe. Ta strona nigdy nie przyjmuje klucza. Wklej link bunker://, który dał ci sygnatariusz.",
+  "signer.error.badLink": "To nie jest link łączący, który rozumie ta strona. Wklej link bunker:// z twojego sygnalizatora.",
+  "signer.error.noAnswer": "Twój podpisujący nie odpowiedział. Może być zamknięty lub przekaźnik może być uszkodzony. Otwórz go i spróbuj ponownie.",
+  "signer.error.timeout": "Twój sygnator nie odpowiedział na czas. Otwórz go, sprawdź, czy nadal jest podłączony, a potem spróbuj ponownie.",
+  "signer.error.cancelled": "Połączenie odwołane.",
+  "signer.error.declined": "Prośba o podpis została odrzucona",
+  "notfound.title": "Strona nie znaleziona · Cashumints.space",
+  "notfound.description": "Ta strona nie istnieje na Cashumints.space.",
+  "notfound.heading": "Ta strona nie istnieje",
+  "notfound.lede": "Może się przeniosł, albo mennica może jeszcze nie być indeksowana. Wyszukaj mint według nazwy lub domeny, albo wklej adres URL Mint.",
+  "notfound.browse": "Przeglądaj wszystkie menniczki",
+  "notfound.home": "Idź do domu",
+  "notfound.loading": "Ładowanie {host}",
+  "notfound.fb.rating": "Ocena",
+  "notfound.fb.reviews": "Recenzje",
+  "notfound.fb.software": "Oprogramowanie",
+  "notfound.fb.lastOnline": "Ostatni czas online",
+  "notfound.fb.note": "Ten mint został zaindeksowany po ostatnim zbudowaniu strony, więc to podsumowanie z działającego API, a poniżej są recenzje. Pełna strona pojawi się przy następnym budowaniu.",
+  "notfound.resolve.checking": "Pierwsza wizyta: sprawdzam ten mint teraz.",
+  "notfound.resolve.failed": "Nie udało się dodać tego mintu",
+  "notfound.resolve.failedFedimint": "Nie udało się dodać tej federacji",
+  "notfound.resolve.retry": "Spróbuj innego adresu",
+  "notfound.resolve.switch": "Otwórz jako mint {kind}",
+  "notfound.resolve.fedimint": "Adres strony federacji nie zawiera jej kodu zaproszenia, więc nie da się jej odnaleźć na podstawie samego linku. Wklej kod zaproszenia, a zostanie dodana.",
+  "notfound.resolve.ambiguous": "Tego adresu nie da się odtworzyć z samego linku. Wklej pełny URL mintu, a zostanie dodany.",
+  "wallets.title": "Portfele Cashu · Cashumints.space",
+  "wallets.description": "Portfele cashu, które współpracują z wymienionymi tutaj monetami – na urządzeniach mobilnych, w internecie, przeglądarce i wierszu poleceń – z tym, do czego każdy z nich jest dobry.",
+  "wallets.heading": "Portfele",
+  "wallets.lede": "Potrzebujesz portfela, żeby przechowywać e-gotówkę z którejkolwiek z tych mennic. Większość portfeli komunikuje się z kilkoma mintami jednocześnie, więc nie jesteś związany z pierwszym, którego wypróbujesz.",
+  "wallets.note": "Ta lista nie jest wyczerpująca i nie stanowi rekomendacji. Projekt Cashu utrzymuje szerszy indeks na poziomie {link}. Portfel trzyma klucze, mennica trzyma pieniądze: przeczytaj recenzje mennicy, zanim wybierzesz, gdzie mieszczą się twoje saty.",
+  "wallets.platform.android": "Android",
+  "wallets.platform.ios": "iOS",
+  "wallets.platform.web": "Web",
+  "wallets.platform.extension": "Rozszerzenie przeglądarki",
+  "wallets.platform.cli": "CLI",
+  "wallets.platform.python": "Python",
+  "wallets.item.minibits": "Mobilny portfel ecash z własną mint, obsługą adresów Lightning i kontaktami Notr.",
+  "wallets.item.nutstash": "Portfel przeglądarkowy, który obsługuje wiele mennic jednocześnie i importuje oraz eksportuje surowe tokeny.",
+  "wallets.item.enuts": "Portfel mobilny skupiony na saldach multimint i wysyłaniu e-gotówki przez Nostr.",
+  "wallets.item.cashume": "Odniesienie do portfela internetowego z projektu Cashu. Działa całkowicie w przeglądarce, można zainstalować jako PWA.",
+  "wallets.item.boardwalk": "Portfel internetowy zbudowany wokół adresów Lightning i wysyłania ecash przez linki.",
+  "wallets.item.coinos": "Portfel Lightning i punkt sprzedaży, który prowadzi też własną mennicę Cashu.",
+  "wallets.item.oxchat": "Nostr messenger z wbudowanym portfelem ecash, do wysyłania satów w czatach.",
+  "wallets.item.nutshell": "Referencyjna implementacja. Działa jako portfel w wierszu poleceń i jako oprogramowanie Mint.",
+  "about.title": "O Cashumints.space",
+  "about.description": "Czym jest Cashu, co faktycznie posiada mennica, czym jest NIP-87 i jak ta strona indeksuje mennice i czyta recenzje z Nostr relays.",
+  "about.heading": "O nas",
+  "about.lede": "Cashumints.space wymienia każdą mennicę Cashu, jaką możemy znaleźć w sieci Nosr, i pokazuje, co ludzie o nich mówią. Jest produkowany przez Azzamo.",
+  "about.cashu.title": "Czym jest Cashu",
+  "about.cashu.p1": "Cashu to protokół ecash dla Bitcoina. Mennica wydaje tokeny z zaślepieniem zabezpieczone satami, które przechowuje, a te tokeny przechodzą między osobami, bez wiedzy o tym, kto co komu wysłał. Prywatność jest realna i o to chodzi: tokeny to nie są konta, a mennica nie może powiązać tokena, który podpisała, z tokenem, który wróci.",
+  "about.cashu.p2": "Protokół i jego specyfikacje można przeczytać na {link}. Same specyfikacje nazywane są NUT, stąd pochodzą numery NUT na każdej stronie mennicy.",
+  "about.mints.title": "Co to jest mennica i jej wymiana",
+  "about.mints.p1": "Mennica jest opiekunką. Kiedy mintujesz ecash, przekazujesz saty temu, kto prowadzi ten serwer, i ufasz, że uhonoruje tokeny, gdy je z powrotem wytopisz. Nie ma zabezpieczeń przed oszustwami, depozytu i możliwości dochodzenia prawnego. Operator mennicy może zniknąć razem z saldem, a mennice to zrobiły.",
+  "about.mints.p2": "Właśnie dlatego tutaj istnieją recenzje. Ta strona nigdy nie mówi, że mennica jest bezpieczna. Status na stronie Mint mówi {code}, a nie \"zaufany\", i oznacza to tylko, że serwer odpowiedział, gdy ostatnio pytaliśmy. Traktuj salda ecash jak gotówkę w kieszeni płaszcza: kara za wydatki, niewłaściwa za oszczędzanie.",
+  "about.nip87.title": "Czym jest NIP-87",
+  "about.nip87.p1": "NIP-87 to konwencja Nostr, która służy do ogłaszania i rekomendowania mennic ecash. Dwa rodzaje zdarzeń mają tu znaczenie:",
+  "about.nip87.li1": "{code} ogłasza mennicę. URL Mint znajduje się w tagu {tag}. W ten sposób strona odkrywa mennice, których nigdy nie widziała.",
+  "about.nip87.li2": "{code} jest recenzją. Zawiera ocenę i tekst recenzji, a na mennicę, o której chodzi, wskazuje za pomocą tagu {utag} (URL mennicy) oraz {dtag} (własny klucz publiczny mennicy).",
+  "about.nip87.p2": "Każda recenzja jest podpisana klawiszem Nostr autora. Nigdy nie nazywamy recenzji \"zweryfikowaną\", ponieważ nikt jej nie zweryfikował: jest podpisana, co jest innym i bardziej użytecznym twierdzeniem. To znaczy, że możesz sprawdzić, kto go napisał i czy nie został zmieniony. To nie znaczy, że autor jest uczciwy lub kiedykolwiek korzystał z mennicy.",
+  "about.how.title": "Jak działa ta strona",
+  "about.how.p1": "Są dwie pętle i jedna zasada. Zasada jest taka, że mennica posiada swoje metadane, a Nostr recenzje, więc ta strona nie przechowuje żadnego z tych źródeł.",
+  "about.how.li1": "{strong} co dziesięć minut prosi każdą znaną mennicę o {code} i zapisuje, co jest napisane: nazwa, opis, wersja, obsługiwane NUT, limity, dane kontaktowe. Rejestruje się też, czy mennica w ogóle odebrała, stąd pochodzi dostępność.",
+  "about.how.li1Label": "Pętla sondy",
+  "about.how.li2": "{strong} łączy się z przekaźnikami Nostr co godzinę, czyta ogłoszenia i recenzje mint oraz dodaje każdą mintę, której wcześniej nie widział.",
+  "about.how.li2Label": "Pętla odkrywania",
+  "about.how.p2": "Ważne jest, co się dzieje, gdy mennica przestaje odbierać. Jego buforowane metadane nigdy nie są nadpisywane przez nieudane sondę, więc martwa mennica zachowuje całą stronę: specyfikacje, historię i recenzje, z banerem informującym o tym, kiedy zgasła. Poprzednia wersja tej strony wyświetlała stronę z błędami, co oznaczało, że mintówki, o których ludzie musieli się ostrzegać, były tymi, których nie można było przeglądać. To był główny powód odbudowy.",
+  "about.how.p3": "Tekst recenzji nigdy nie jest przechowywany po naszej stronie. Gdy otwierasz stronę Mint, przeglądarka komunikuje się bezpośrednio z relayami i sama czyta recenzje, a gdy napiszesz taką, jest ona podpisywana przez twoje własne rozszerzenie Nostr i wysyłana bezpośrednio do tych relayów. Prowadzimy liczenie, żeby strony mogły być uporządkowane i sortowane, nic więcej. Nic tutaj nie może być edytowane ani usuwane przez nas, w tym recenzje, których wolelibyśmy unikać.",
+  "about.relays.title": "Przekaźniki czytamy",
+  "about.relays.p1": "Oto przekaźniki, których używa zarówno indeksator, jak i przeglądarka:",
+  "about.relays.p2": "Skieruj dowolnego klienta Nostr na te same przekaźniki, a zobaczysz te same zdarzenia. To cała obietnica: nic tutaj nie jest prawdziwe tylko dlatego, że tak mówimy.",
+  "about.nuts.title": "Czym są NUT?",
+  "about.nuts.p1": "NUT to ponumerowane specyfikacje Cashu, podobnie jak BIP dla Bitcoina. Mennica reklamuje, które z nich implementuje, i to pokazuje, co faktycznie potrafi: NUT-04 i NUT-05 biją i topią się na Lightning (bez nich mennica nie ma większego znaczenia), NUT-07 pozwala portfelowi sprawdzić, czy token został już wydany, NUT-17 przekazuje portfelom aktualizacje na żywo przez WebSockets zamiast ankietowania, a NUT-20 pozwala portfelowi udowodnić, że faktycznie wydano mu ofertę z mennicy. Pełna lista jest {link}.",
+  "about.numbers.title": "Właśnie teraz",
+  "about.numbers.p1": "{mints} mennic zindeksowanych, {online} z nich odpowiedziało, {reviews} recenzje były liczone z powyższych przekaźników.",
+  "about.source.title": "Źródło i źródło",
+  "about.source.p1": "Strona jest otwartoźródłowa w {github}. Jest budowana i prowadzona przez {azzamo}. Jeśli na stronie Mint jest coś nie tak, napraw to u źródła: metadane Mint pochodzą z własnego {code}, a recenzje z Nostr.",
+  "terms.title": "Warunki użytkowania · Cashumints.space",
+  "terms.description": "Warunki użytkowania Cashumints.space: czym jest strona, czego nie robi i kto za co odpowiada. Brak kont, brak gwarancji, brak powiązań z żadną mennicą.",
+  "terms.heading": "Warunki użytkowania",
+  "terms.lede": "Proste określenia dla strony, która indeksuje tylko dane publiczne. Ostatnia aktualizacja {date}.",
+  "terms.what.title": "Czym jest ta strona",
+  "terms.what.p1": "Cashumints.space jest indeksem publicznie dostępnych danych dotyczących mennic Cashu. Dwa rodzaje danych, oba pochodzące z innego miejsca:",
+  "terms.what.li1": "Metadane Mint, odczytane z własnego {code} endpointu każdej mennicy: nazwa, opis, wersja oprogramowania, obsługiwane NUT, dane kontaktowe oraz czy mennica odpowiedziała na ostatnie nasze pytania.",
+  "terms.what.li2": "Recenzje, czytane z publicznych przekaźników Nostr. Są to wydarzenia NIP-87 publikowane przez ich autorów, aby przekazać informacje, do których każdy może zapytać.",
+  "terms.what.p2": "Zbieramy te dane, normalizujemy je, klasyfikujemy i pokazujemy. Nie tworzymy jej.",
+  "terms.noAccounts.title": "Brak kont, brak gwarancji",
+  "terms.noAccounts.p1": "Nie ma na co się zapisywać. Strona jest udostępniana taka, jaka jest, bez żadnej gwarancji: nie że dane są dokładne, nie że są aktualne, ani że strona będzie dostępna. Dane z Mint mogą mieć minuty lub godziny, mint może się zmienić po naszej ostatniej kontroli, a przekaźnik może nie odpowiedzieć, w takim przypadku widzisz mniej niż istnieje.",
+  "terms.noAccounts.p2": "Używaj go na własne ryzyko. Nie ponosimy odpowiedzialności za jakiekolwiek straty wynikające z korzystania z tej strony lub polegania na czymkolwiek, co tu przeczytasz. Zobacz {link} dotyczące konkretnych ryzyk związanych z używaniem mennicy Cashu.",
+  "terms.noAccounts.link": "Zastrzeżenie",
+  "terms.noCustody.title": "Nie trzymamy twoich pieniędzy",
+  "terms.noCustody.p1": "Ta strona nigdy nie przejmuje środków do przechowywania. Nie ma portfela, nie dotyka e-gotówki i nie może niczego przenosić, zamrażać ani odzyskiwać. Jeśli masz problem z mennicą, operator mennicy jest jedyną stroną, która może Ci pomóc, i nie możemy się z nim skontaktować w Twoim imieniu.",
+  "terms.noCustody.p2": "Nie jesteśmy powiązani z żadną mennicą wymienioną tutaj, a żadna mennica nie pokrywa kosztów jej wpisu, rankingu ani oceny. Mennice są odkrywane na podstawie publicznych ogłoszeń Nostr i oceniane przez algorytm na podstawie danych z przeglądów publicznych.",
+  "terms.reviews.title": "Recenzje to słowa innych ludzi",
+  "terms.reviews.p1": "Recenzje to treści tworzone przez użytkowników, publikowane przez ich autorów w publicznych relayach Nostr. Prezentujemy je, nie kontrolujemy ich. Nie napisaliśmy ich, nie możemy ich edytować ani usuwać z przekaźników, które je przechowują: są to podpisane zdarzenia w sieci, której nie posiadamy.",
+  "terms.reviews.p2": "Recenzja to doświadczenie jednej osoby, a nie potwierdzony fakt. Jeśli ją opublikujesz, jesteś odpowiedzialny za to, co mówi. Nie publikuj niczego nielegalnego i pamennicaj, że to, co publikujesz, jest publiczne i trwałe (zobacz {link}).",
+  "terms.reviews.link": "Strona prywatności",
+  "terms.reviews.p3": "Możemy przestać wyświetlać konkretną recenzję na tej stronie i zrobimy to w przypadku treści niezgodnych z prawem. To usuwa ją tylko z tych stron. Zdarzenie pozostaje na przekaźnikach, a każdy inny klient Nostr może je nadal odczytywać.",
+  "terms.links.title": "Linki do innych stron",
+  "terms.links.p1": "Adresy URL Mint, linki do portfeli, kontakty operatorów i wszystko inne, co wskazuje na tę stronę, jest tam, ponieważ jest częścią danych. Link nie jest rekomendacją i nie sprawdzamy, co jest po drugiej stronie.",
+  "terms.changes.title": "Zmiany",
+  "terms.changes.p1": "Te warunki mogą się zmieniać. Data na górze pokazuje, kiedy ostatnio to zrobili. Strona jest open source, więc każda zmiana na tej stronie znajduje się w historii commitów.",
+  "terms.contact.title": "Kontakt",
+  "terms.contact.p1": "Problemy i wnioski o usunięcie najlepiej składać na {github}. Serwis jest prowadzony przez {azzamo}.",
+  "privacy.title": "Prywatność · Cashumints.space",
+  "privacy.description": "Prywatność na Cashumints.space: żadnych kont, żadnych plików śledzących, żadnych analiz. localStorage służy do buforowania profilu i nic nie jest nigdzie wysyłane. Recenzje są zalogowane w twojej własnej przeglądarce.",
+  "privacy.heading": "Prywatność",
+  "privacy.lede": "Zbieramy tak mało, jak tylko strona internetowa może to zrobić. Ostatnia aktualizacja {date}.",
+  "privacy.noAccounts.title": "Brak kont",
+  "privacy.noAccounts.p1": "Nie ma rejestracji, logowania ani profilu. Nic na tej stronie nie pyta, kim jesteś, a nie ma żadnego zapisu użytkownika do wycieku, bo nie ma żadnych użytkowników.",
+  "privacy.noTracking.title": "Żadnych plików śledzących, żadnych analityków",
+  "privacy.noTracking.p1": "Strona nie ustawia plików cookie do śledzenia. Nie ma skryptu analitycznego, menedżera tagów, piksela, nagrywania sesji ani sieci reklamowej. Nic na stronie nie zgłasza twojego zachowania nam ani nikomu innemu.",
+  "privacy.logs.title": "Logi serwera",
+  "privacy.logs.p1": "Serwer WWW prowadzi standardowe logi dostępu, co jest standardem każdego serwera WWW. Linia logowania rejestruje Twój adres IP, godzinę, stronę, o którą prosiłeś, status odpowiedzi oraz agenta użytkownika i referrera, które wysłała przeglądarka. Logi te istnieją, by debugować błędy i wykrywać nadużycia. Nie są połączone z niczym innym i nie są sprzedawane ani udostępniane.",
+  "privacy.logs.operatorLabel": "Notatka operatora:",
+  "privacy.logs.operator": "Jeśli prowadzisz tę stronę, podaj tutaj swoją prawdziwą retencję. Wdrożenie w README używa nginx z domyślnym logiem dostępu i rotacją, którą wysyła twoja dystrybucja (na Debianie i Ubuntu to logrotacja, codziennie, utrzymując 14 dni). Potwierdź, czym zajmuje się Twój kelner i zastąp ten akapit numerem.",
+  "privacy.storage.title": "Co jest zapisane w Twojej przeglądarce",
+  "privacy.storage.p1": "Strona korzysta z localStorage dokładnie do dwóch celów, które pozostają na Twoim urządzeniu i nigdy nie są nigdzie wysyłane:",
+  "privacy.storage.li1": "Cache metadanych profilu Nostr (zdarzenia typu 0: imiona, awatary, adresy NIP-05) dla recenzentów, których recenzje oglądałeś. To oszczędza ponowne zapytania przekaźników na każdej stronie. Wpisy wygasają, a cache jest ograniczany i eksmitowany jako najstarszy.",
+  "privacy.storage.li2": "Preferencje interfejsu, żeby strona następnym razem zachowywała się tak samo.",
+  "privacy.storage.p2": "Wyczyszczenie danych przeglądarki usuwa oba te elementy. Nic się nie psuje, wyszukiwania profili po prostu uruchamiają się ponownie.",
+  "privacy.thirdParties.title": "Z czym komunikuje Twoja przeglądarka",
+  "privacy.thirdParties.p1": "Wczytanie strony łączy przeglądarkę z kilkoma innymi miejscami niż ta strona. Tak właśnie strona bez śledzenia po stronie serwera nadal odczytuje dane na żywo:",
+  "privacy.thirdParties.li1Label": "Publiczne sztafety Notru",
+  "privacy.thirdParties.li1": "{strong} przez WebSocket do czytania recenzji i profili recenzentów. Przekaźnik widzi twój adres IP i to, o co prosiłeś, tak jak każdy serwer, do którego się łączysz. Przekaźniki są wymienione na {link}.",
+  "privacy.thirdParties.li1Link": "strona o mnie",
+  "privacy.thirdParties.li2Label": "Obrazy awatarów recenzentów",
+  "privacy.thirdParties.li2": "{strong}, ładowane z miejsca, na które wskazuje profil recenzenta. Są one wysyłane z zasadą braku poleceń, więc gospodarz nie dowiaduje się, na której stronie byłeś.",
+  "privacy.publishing.title": "Publikowanie recenzji",
+  "privacy.publishing.p1": "Pisanie recenzji odbywa się w Twojej przeglądarce, a nie na naszym serwerze. Wydarzenie jest podpisane przez Twój rozszerzenie NIP-07 (Alby, nos2x lub podobne) i transmitowane z przeglądarki bezpośrednio do przekaźników. Twój klucz prywatny nigdy nie opuszcza rozszerzenia i ta strona go nigdy nie widzi. Nie tworzymy niestandardowego zarządzania kluczami i nigdy nie prosimy o klucz ani frazę zalążową.",
+  "privacy.permanent.title": "Wszystko, co publikujesz na Nostr, jest publiczne i trwałe",
+  "privacy.permanent.p1": "To jest część warta przeczytania dwa razy. Przegląd to wydarzenie podpisane na publicznych sztafetach. Gdy już się wydarzy, to już wyjdzie:",
+  "privacy.permanent.li1": "Każdy może go czytać, od czasu do czasu, korzystając z dowolnego klienta Nostr. Nie jest \"publiczna na Cashumints.space\", jest publiczna w sieci.",
+  "privacy.permanent.li2": "Jest on trwale powiązany z Twoim kluczem publicznym Notr, obok wszystkiego, co ten klucz kiedykolwiek opublikował.",
+  "privacy.permanent.li3": "Usunięcie go to prośba, a nie polecenie. Możesz opublikować zdarzenie usunięcia, a niektóre przekaźniki je uhonorują, ale przekaźnik może je zignorować i każdy, kto już skopiował zdarzenie, nadal je ma. Traktuj opublikowaną recenzję jako trwałą.",
+  "privacy.permanent.li4": "Nie możemy go usunąć za Ciebie. Możemy przestać go tu pokazywać; To nic nie zmienia na przekaźnikach.",
+  "privacy.permanent.p2": "Jeśli chcesz recenzować mint, nie będąc powiązanym z twoją główną tożsamością, użyj osobnego klucza Nostr. Zwróć uwagę, że klucz bez innych działań jest pokazywany w ostrych recenzjach, ponieważ nowy klucz piszący jedną gwiazdkę to wzorzec, który czytelnicy powinni zobaczyć.",
+  "privacy.contact.title": "Pytania",
+  "privacy.contact.p1": "Strona jest open source: jeśli chcesz sprawdzić którąkolwiek z powyższych informacji, przeczytaj kod na {github}. Pytania i poprawki mogą trafić do numeru tam.",
+  "disclaimer.title": "Zastrzeżenie · Cashumints.space",
+  "disclaimer.description": "Co warto wiedzieć przed udziałem mennicy Cashu: mennicy są opiekunowe, mennica może zniknąć razem z twoimi pieniędzmi, recenzje to opinie, a internet jest dostępny, a nie godny zaufania.",
+  "disclaimer.heading": "Zastrzeżenie",
+  "disclaimer.lede": "Przeczytaj to, zanim zainwestujesz w kasę. Ostatnia aktualizacja {date}.",
+  "disclaimer.callout": "Mennica Cashu przechowuje twoje pieniądze dla ciebie. Jeśli zniknie, twoja e-gotówka zniknie i nie będzie nikogo, do kogo można się zwrócić. Zatrzymaj tylko tyle, na ile możesz sobie pozwolić stracić.",
+  "disclaimer.custodial.title": "Mennice są opiekuńcze",
+  "disclaimer.custodial.p1": "Kiedy mintujesz ecash, przekazujesz bitcoina operatorowi mennicy i otrzymujesz tokeny z powrotem. Te tokeny są roszczeniem do tego operatora. To nie są bitcoiny, które posiadasz, a operator decyduje, czy je uhonorować.",
+  "disclaimer.custodial.p2": "Oznacza to, że każda mennica niesie ze sobą takie same ryzyko: operator może zniknąć, zostać zmuszonym do zatrzymania się, może stracić środki przez błąd lub włamanie, albo po prostu wyłączyć serwer. Nie ma ubezpieczenia depozytu, nie ma chargebacku, nie ma linii wsparcia ani nie ma żadnych środków prawnych, na których można polegać. Dotyczy to najwyżej ocenianej mennicy na tej stronie.",
+  "disclaimer.custodial.p3": "Cashu jest zaprojektowane dla małych kwot płynących szybko. Wykorzystaj to w ten sposób: trzymaj to, co zamierzasz wydać, nie oszczędności, i rozłóż je na banki mintelowej, zamiast parkować wszystko w jednym.",
+  "disclaimer.reviews.title": "Recenzje to opinie, a nie zweryfikowane twierdzenia",
+  "disclaimer.reviews.p1": "Każda recenzja tutaj została napisana przez kogoś na Nostr i podpisana swoim kluczem. Podpisany oznacza, że możemy powiedzieć, który klucz ją napisał. Nie oznacza to, że recenzja jest prawdziwa, że autor użył mennicy, ani że nie jest operatorem, konkurentem lub osobą z dziesięcioma kluczami.",
+  "disclaimer.reviews.p2": "Nie weryfikujemy recenzentów ani nie edytujemy ani nie usuwamy recenzji, z którymi się nie zgadzamy. Przeczytaj kilka, zobacz, co faktycznie mówią, i waż mennicę z trzema recenzjami inaczej niż z trzystoma.",
+  "disclaimer.status.title": "Online oznacza dostępność, a nie zaufanie",
+  "disclaimer.status.p1": "Regularnie sprawdzamy każdą mennicę i sprawdzamy, czy odebrała. To wszystko, co oznacza zielony status: serwer odpowiedział. Nie mówi nic o tym, czy operator jest wypłacalny, uczciwy lub czy nadal zamierza jutro uhonorować twoje tokeny.",
+  "disclaimer.status.p2": "Mennica może być dostępna do momentu, gdy już nie jest. Historia dostępności, obsługiwane NUT-y i wersje oprogramowania mówią coś o tym, jak działa mennica, ale żadna z tych informacji nie jest obietnicą dotyczącą twoich pieniędzy.",
+  "disclaimer.ranking.title": "Jak działa ranking i co nie oznacza",
+  "disclaimer.ranking.p1": "Mennice są uporządkowane algorytmem na podstawie danych o publicznych recenzjach: ocen, liczby recenzji i ostatniej aktywności, przy czym mennice online są domyślnie przed tymi offline. Szczegóły znajdują się w kodzie open source.",
+  "disclaimer.ranking.p2": "Nikt nie płaci za praktykę. Na tej stronie nie ma sponsorowanego slotu, promowanego ogłoszenia ani żadnej umowy z mennicą. Wysoka pozycja oznacza, że algorytm polubił dane publiczne i nic więcej. To nie jest rekomendacja ani ocena bezpieczeństwa.",
+  "disclaimer.notAdvice.title": "To nie jest porada finansowa",
+  "disclaimer.notAdvice.p1": "Nic na tej stronie nie jest poradą finansową, inwestycyjną, prawną ani podatkową. Nie znamy Twojej sytuacji i nie doradzamy Ci. Wybór mennicy to twoja decyzja.",
+  "disclaimer.dyor.title": "Zrób własne badania",
+  "disclaimer.dyor.li1": "Sprawdź operatora. Mennica prowadzona przez kogoś o publicznej reputacji, którą można stracić, to zupełnie inna sprawa niż anonimowy adres URL.",
+  "disclaimer.dyor.li2": "Przeczytaj regulamin mennicy oraz jej MOTD. Mennica, która nazywa siebie testem lub beta, mówi poważnie.",
+  "disclaimer.dyor.li3": "Zacznij od małych kroków. Trochę wybij, wydaj, roztop z powrotem i zobacz, co się stanie, zanim zaufasz mu w sprawie więcej.",
+  "disclaimer.dyor.li4": "Uważaj na limity. Niskie maksimum często świadczy o ostrożnym użytkowniku, a wysokie nie oznacza bezpiecznego operatora.",
+  "disclaimer.dyor.li5": "Prowadź swoje tokeny w zapasowym zapasie i pamennicaj, że token jest aktywem na nosiciela: kto go posiada, może go wydać.",
+  "disclaimer.site.title": "O samej stronie",
+  "disclaimer.site.p1": "Dane tutaj mogą być błędne lub nieaktualne. Mennice są sprawdzane według harmonogramu, przekaźniki czasem nie odpowiadają, a strona, którą czytasz, została zbudowana w pewnym momencie w przeszłości. Strona jest dostępna tak, jak jest, bez gwarancji. Zobacz {link}.",
+  "disclaimer.site.link": "Warunki użytkowania",
+  "disclaimer.updated": "20 sierpnia 2026",
+  "login.getPrimal": "Zrób Primal",
+  "reviews.dialog.identity.extensionGone": "Twoje rozszerzenie przeglądarki nie odpowiada. Zaloguj się ponownie lub użyj zdalnego podpisu.",
+  "seo.orgDescription": "Katalog mennic Cashu, z aktualnym statusem każdej mennicy oraz opiniami społecznościowymi podpisanymi na Nostr.",
+  "seo.ogImageAlt": "Cashumints.space: znajdź mennicę Cashu, której możesz zaufać.",
+  "seo.mint.title.one": "{name} recenzje: oceną {rating} na podstawie {n} recenzji | Cashumints.space",
+  "seo.mint.title.few": "{name} recenzje: oceny: {rating} na podstawie {n} recenzji | Cashumints.space",
+  "seo.mint.title.many": "{name} recenzje: ocenowane {rating} na podstawie {n} recenzji | Cashumints.space",
+  "seo.mint.title.other": "{name} recenzje: oceny: {rating} na podstawie {n} recenzji | Cashumints.space",
+  "seo.mint.titleOffline.one": "{name}: offline przez {n} dzień | Cashumints.space",
+  "seo.mint.titleOffline.few": "{name}: offline przez {n} dni | Cashumints.space",
+  "seo.mint.titleOffline.many": "{name}: offline przez {n} dni | Cashumints.space",
+  "seo.mint.titleOffline.other": "{name}: offline przez {n} dni | Cashumints.space",
+  "seo.mint.titleNoReviews": "{name}: Informacje i recenzje Cashu Mint | Cashumints.space",
+  "seo.fedimint.titleNoReviews": "{name}: Informacje i recenzje federacji Fedimint | Cashumints.space",
+  "seo.desc.fallback": "Recenzje społeczności dotyczące {name} ({domain}).",
+  "seo.desc.fallbackDomain": "Recenzje społeczności dotyczące mennicy Cashu w {domain}.",
+  "seo.desc.rated.one": "Ocena {rating}/5 według {n} podpisanej recenzji Nostr.",
+  "seo.desc.rated.few": "Ocena {rating}/5 na podstawie {n} podpisanych recenzji Nostr.",
+  "seo.desc.rated.many": "Ocena {rating}/5 na podstawie {n} podpisanych recenzji Nostr.",
+  "seo.desc.rated.other": "Ocena {rating}/5 według {n} podpisanych recenzji Nostr.",
+  "seo.desc.noReviews": "Jeszcze brak recenzji.",
+  "seo.desc.status": "{status}.",
+  "seo.desc.statusLimits": "{status}, granice {limits}.",
+  "seo.desc.fedModules": "{status}. Moduły: {modules}.",
+  "seo.desc.fedModulesNetwork": "{status}. Moduły: {modules} na {network}.",
+  "seo.mint.ogAlt.one": "{name}: {rating} gwiazdek z recenzji {n} Cashumints.space",
+  "seo.mint.ogAlt.few": "{name}: {rating} gwiazdek z {n} recenzji na Cashumints.space",
+  "seo.mint.ogAlt.many": "{name}: {rating} gwiazdek z {n} recenzji na Cashumints.space",
+  "seo.mint.ogAlt.other": "{name}: {rating} gwiazdek z {n} recenzji na Cashumints.space",
+  "seo.mint.ogAltNoReviews": "{name} on Cashumints.space",
+  "nav.home": "Strona główna",
+  "mint.more.title": "Więcej mennic",
+  "mint.more.all": "Zobacz wszystkie mennice",
+  "nav.fedimints": "Fedimints",
+  "status.announced": "Tylko ogłoszone",
+  "card.unnamedFederation": "Nienazwana federacja",
+  "card.notChecked": "Nigdy nie sprawdzałem",
+  "fedimints.title": "Wszystkie federacje Fedimint · Cashumints.space",
+  "fedimints.description": "Wszystkie {total} federacje Fedimint ogłoszone w sieci Nostr: {online} potwierdzone przez zewnętrzną kontrolę, {announced} ogłoszone, ale nigdy nie potwierdzone. Oceny społeczności, moduły i kody zaproszeń dla każdego z nich.",
+  "fedimints.heading": "Wszystkie federacje",
+  "fedimints.lede": "Każda federacja Fedimint ogłaszała to w sieci Nostr. Federacja nie ma własnego oficjalnego punktu końcowego statusu publicznego, więc niektóre z nich są potwierdzone przez zewnętrzną kontrolę, a reszta jest wymieniana dokładnie tak, jak zostały ogłoszone.",
+  "fedimints.search.label": "Wyszukaj federacje według nazwy lub identyfikatora",
+  "fedimints.search.placeholder": "Wyszukaj po imieniu lub identyfikatorze federacji...",
+  "fedimints.sort.label": "Federacje sortowania",
+  "fedimints.hideOffline": "Ukryj się offline",
+  "fedimints.showing": "Wyświetlanie {total} federacji ({online} potwierdzone, {announced} tylko ogłaszane)",
+  "fedimints.showingFiltered": "Wyświetlanie {shown} {total} federacji ({online} potwierdzone, {announced} tylko ogłoszone)",
+  "fedimints.announcedNote.one": "Jeden z nich został ogłoszony na Nostr i od tamtej pory nic nie potwierdziło, że jest w obiegu. Jest to oznaczone jako ogłoszone, a nie jako online czy offline, ponieważ żadne z tych opcji nie byłoby prawdą.",
+  "fedimints.announcedNote.few": "{n} z nich ogłoszono na Nostr i od tamtej pory nic nie potwierdziło, że są w trakcie emisji. Są one wymienione jako ogłoszone, a nie jako online czy offline, ponieważ żadne z tych rozwiązań nie jest prawdą.",
+  "fedimints.announcedNote.many": "{n} z nich zostało ogłoszonych na Nostr i od tamtej pory nic nie potwierdziło, że są w trakcie emisji. Są one wymienione jako ogłoszone, a nie jako online czy offline, ponieważ żadne z tych rozwiązań nie jest prawdą.",
+  "fedimints.announcedNote.other": "{n} z nich zostały ogłoszone na Nostr i od tamtej pory nic nie potwierdziło, że będą działać. Są one wymienione jako ogłoszone, a nie jako online czy offline, ponieważ żadne z tych rozwiązań nie jest prawdą.",
+  "fedimints.noResults": "Brak meczu federacji. Spróbuj nazwy lub wklej identyfikator federacji.",
+  "fedimints.emptyIndex": "Na tej stronie nie ogłoszono żadnych federacji dotyczących sztafet. Lista sama się zapełnia, gdy pojawiają się ogłoszenia.",
+  "fedimint.crumb": "Fediminty",
+  "fedimint.breadcrumb": "Okruszek chleba",
+  "fedimint.unnamed": "Nienazwana federacja",
+  "fedimint.idLabel": "Federacja",
+  "fedimint.kind.federationId": "Identyfikacja federacji",
+  "fedimint.moduleCount.one": "{n} moduł",
+  "fedimint.moduleCount.few": "{n} moduły",
+  "fedimint.moduleCount.many": "{n} modułów",
+  "fedimint.moduleCount.other": "{n} moduły",
+  "fedimint.copyInvite": "Skopiuj kod zaproszenia",
+  "fedimint.confirmed.label": "Potwierdzone",
+  "fedimint.confirmed.never": "Nigdy",
+  "fedimint.confirmed.by": "autor: {source}",
+  "fedimint.confirmed.unattributed": "Ostatnia kontrola",
+  "fedimint.announcedOn": "ogłoszono {when}",
+  "fedimint.announcedUnknown": "brak daty ogłoszenia",
+  "fedimint.modules.title": "Moduły",
+  "fedimint.modules.none": "W ogłoszeniu tej federacji nie wymieniono żadnych modułów.",
+  "fedimint.modules.note": "Moduły to części prowadzone przez federację. W ogłoszeniu jest napisane, które są obecne, a nic nie mówi o tym, czy któraś z nich przyjmuje depozyty.",
+  "fedimint.modules.notListed": "Nie wymienione",
+  "fedimint.invite.title": "Kod zaproszenia",
+  "fedimint.invite.count.one": "{n} kod",
+  "fedimint.invite.count.few": "{n} kody",
+  "fedimint.invite.count.many": "{n} kodów",
+  "fedimint.invite.count.other": "{n} kody",
+  "fedimint.invite.note": "Wklej to do portfela Fedimint, aby dołączyć. Zawiera identyfikator federacji oraz adresy swoich opiekunów, a jego przeznaczenie jest do udostępniania.",
+  "fedimint.invite.kind": "Kod zaproszenia",
+  "fedimint.invite.qr": "QR",
+  "fedimint.invite.qrCaption": "Skanuj, aby dołączyć do {name}",
+  "fedimint.details.federationId": "Identyfikacja federacji",
+  "fedimint.details.network": "Sieć",
+  "fedimint.details.announcedBy": "Ogłoszone przez",
+  "fedimint.details.announced": "Ogłoszono",
+  "fedimint.more.title": "Więcej federacji",
+  "fedimint.more.all": "Zobacz wszystkie federacje",
+  "fedimint.disclaimer": "Dołączenie do federacji oznacza zaufanie jej opiekunom z twoimi pieniędzmi. Oceny to opinie społeczności, a potwierdzone bieganie oznacza osiągalność, a nie godność zaufania.",
+  "fedimint.module.lightning": "Lightning",
+  "fedimint.module.mint": "Mennica Ecash",
+  "fedimint.module.wallet": "Portfel on-chain",
+  "fedimint.module.meta": "Metadane",
+  "fedimint.module.stability_pool": "Pula stabilności",
+  "fedimint.module.multi_sig_stability_pool": "Pula stabilności (multisig)",
+  "fedimint.module.fedi-social": "Ożywienie społeczne",
+  "fedimint.network.mainnet": "Mainnet Bitcoin",
+  "fedimint.network.signet": "Signet",
+  "fedimint.network.testnet": "Testnet",
+  "fedimint.network.testnet4": "Testnet4",
+  "fedimint.network.regtest": "Regtest",
+  "feed.ecosystem.group": "Ekosystem",
+  "feed.ecosystem.all": "Wszyscy",
+  "feed.ecosystem.cashu": "Cashu",
+  "feed.ecosystem.fedimint": "Fedimint",
+  "feed.filterBySubject": "Filtruj według mennicy lub federacji",
+  "feed.anySubject": "Każda mennica czy federacja",
+  "feed.clearSubject": "Wyczyść filtr nazw",
+  "home.topFedimints.title": "Najlepsze Fediminty",
+  "home.topFedimints.sub": "Oceniane według recenzji i ocen",
+  "home.topFedimints.all": "Wszystkie {n} federacje →",
+  "reviews.validate.subject": "Nie ma nic, na co warto wskazać tę recenzję.",
+  "mint.warnings.fedimintOffline.lead": "Zgłoszono offline.",
+  "mint.warnings.fedimintOffline.body.since": "Ostatni test, który dotarł do tej federacji, miał miejsce {date} ({days} temu). Jej strażnicy od tamtej pory nie odpowiedzieli. Traktuj tam przechowywane środki jako zagrożone i nie łącz ich z nowymi środkami.",
+  "mint.warnings.fedimintOffline.body.never": "Żadna kontrola tej federacji nigdy do niej nie dotarła, a ostatnia zawiodła. Traktuj tam przechowywane środki jako zagrożone i nie łącz ich z nowymi środkami.",
+  "mint.warnings.fedimintOffline.meta.since": "Zgłaszane offline od {date}",
+  "mint.warnings.fedimintOffline.meta.never": "Zgłoszono offline, nigdy się z nim nie skontaktowałem",
+  "mint.warnings.neverConfirmed.lead": "Ogłoszono, nigdy nie potwierdzone.",
+  "mint.warnings.neverConfirmed.body.reviewed": "Federacja ta została ogłoszona na Nostr {date} {days} temu i od tamtej pory nic nie potwierdziło, że istnieje. Poniższe recenzje to jedyny znak życia na tej stronie; Wszystko inne pochodziło z ogłoszenia.",
+  "mint.warnings.neverConfirmed.body.quiet": "Ta federacja została ogłoszona na Nostr {date} {days} temu, od tamtej pory nic nie potwierdziło, że działa, i nikt jej ostatnio nie recenzował. Wszystko, co poniżej pochodzi, pochodzi z ogłoszenia.",
+  "mint.warnings.neverConfirmed.meta": "Ogłoszono {date}, nigdy nie potwierdzono",
+  "footer.allFedimints": "Wszystkie federacje",
+  "reviews.dialog.bodyPlaceholder.cashu": "Jak wyglądało bicie, topienie i wspieranie? Bądź konkretny.",
+  "reviews.dialog.bodyPlaceholder.fedimint": "Jak wyglądało dołączenie, płatności i wsparcie Lightning? Bądź konkretny.",
+  "fedimint.details.title": "Szczegóły federacji",
+  "nav.lnurlMints": "Minty LNURL",
+  "footer.allLnurlMints": "Wszystkie minty LNURL",
+  "lnurlMints.title": "Minty LNURL: minty not na okaziciela lnurlcash z opiniami | Cashumints.space",
+  "lnurlMints.description": "Wszystkie {total} mintów LNURL zindeksowanych z sieci Nostr: {online} online, {offline} offline. Oceny społeczności, limity wypłat i możliwości każdego z nich.",
+  "lnurlMints.heading": "Minty LNURL",
+  "lnurlMints.lede": "Każdy mint LNURL, o którym wie ta strona. Mint LNURL emituje noty na okaziciela lnurlcash: noty Lightning, które trzymasz jako sekret i które można obrócić, podzielić, połączyć albo przetopić z powrotem na płatność Lightning. Każdy jest sprawdzany przez HTTPS co kilka minut.",
+  "lnurlMints.search.label": "Szukaj mintów LNURL",
+  "lnurlMints.search.placeholder": "Szukaj po nazwie lub adresie…",
+  "lnurlMints.sort.label": "Sortuj minty LNURL według",
+  "lnurlMints.hideOffline": "Ukryj offline",
+  "lnurlMints.showing": "Pokazano {total} mintów LNURL ({online} online, {offline} offline)",
+  "lnurlMints.showingFiltered": "Pokazano {shown} z {total} mintów LNURL ({online} online, {offline} offline)",
+  "lnurlMints.noResults": "Żaden mint LNURL nie pasuje.",
+  "lnurlMints.emptyIndex": "Nie zindeksowano jeszcze żadnych mintów LNURL.",
+  "lnurl.crumb": "Minty LNURL",
+  "lnurl.breadcrumb": "Okruszki nawigacyjne",
+  "lnurl.copyAddress": "Kopiuj adres",
+  "lnurl.more.title": "Więcej mintów LNURL",
+  "lnurl.more.all": "Wszystkie minty LNURL →",
+  "lnurl.disclaimer": "Mint LNURL przechowuje twoje saty, a ty trzymasz jego noty, więc korzystanie z niego oznacza zaufanie operatorowi. Oceny to opinie społeczności, a online znaczy osiągalny, nie godny zaufania.",
+  "lnurl.features.title": "Funkcje",
+  "lnurl.features.none": "Ten mint nie ogłosił, co obsługuje.",
+  "lnurl.features.note": "Funkcje to to, co operator minta ogłosił w Nostr. Tam, gdzie ta strona może sprawdzić coś przez HTTPS, robi to i informuje, gdy coś ogłoszonego jest w tej chwili niedostępne.",
+  "lnurl.features.notListed": "nieogłoszone",
+  "lnurl.features.unavailable": "niedostępne",
+  "lnurl.feature.mint": "Mintowanie przez Lightning (LUD-06)",
+  "lnurl.feature.melt": "Przetapianie na Lightning",
+  "lnurl.feature.notes": "Obracanie / dzielenie / łączenie not",
+  "lnurl.feature.lud16": "Adres Lightning",
+  "lnurl.feature.lud21": "Weryfikacja płatności (LUD-21)",
+  "lnurl.feature.signed-notes": "Podpisane noty (weryfikacja offline)",
+  "lnurl.feature.onion": "Adres Tor",
+  "lnurl.feature.rotate": "Obróć notę",
+  "lnurl.feature.split": "Podziel notę",
+  "lnurl.feature.merge": "Połącz noty",
+  "lnurl.feature.lud06": "LUD-06 payRequest",
+  "lnurl.feature.lud03": "LUD-03 withdrawRequest",
+  "lnurl.limits.label": "Limity wypłat",
+  "lnurl.limits.notPublished": "nieopublikowane",
+  "lnurl.limits.withdrawRow": "Wypłata",
+  "lnurl.limits.disabled": "wyłączone",
+  "lnurl.limits.sats.one": "{n} sat",
+  "lnurl.limits.sats.few": "{n} saty",
+  "lnurl.limits.sats.many": "{n} satów",
+  "lnurl.limits.sats.other": "{n} sata",
+  "lnurl.details.title": "Szczegóły minta",
+  "lnurl.details.address": "Adres Lightning",
+  "lnurl.details.mintPubkey": "Klucz publiczny minta",
+  "lnurl.details.onion": "Adres Tor",
+  "lnurl.details.fee": "Opłata za mintowanie",
+  "lnurl.details.node": "Węzeł",
+  "lnurl.details.capacity": "Ogłoszona pojemność",
+  "lnurl.kind.lightningAddress": "adres Lightning",
+  "lnurl.kind.mintPubkey": "klucz publiczny minta",
+  "lnurl.kind.onionAddress": "adres Tor",
+  "lnurl.confirmed.label": "Ostatnie potwierdzenie",
+  "lnurl.confirmed.when": "potwierdzony {when}",
+  "lnurl.fee.base.one": "{n} sat",
+  "lnurl.fee.base.few": "{n} saty",
+  "lnurl.fee.base.many": "{n} satów",
+  "lnurl.fee.base.other": "{n} sata",
+  "lnurl.fee.percent": "{percent}%",
+  "home.topLnurl.title": "Najlepsze minty LNURL",
+  "home.topLnurl.sub": "według opinii i oceny",
+  "home.topLnurl.all": "Wszystkie {n} mintów LNURL →",
+  "feed.ecosystem.lnurl": "LNURL",
+  "reviews.dialog.bodyPlaceholder.lnurl": "Jak poszło mintowanie, przetapianie i obracanie not? Napisz konkretnie.",
+  "reviews.byUrl.open": "Napisz recenzję",
+  "reviews.byUrl.title": "Napisz recenzję",
+  "reviews.byUrl.lede": "Wklej adres. Jeśli ta strona jeszcze go nie zna, sprawdzi go i doda teraz.",
+  "reviews.byUrl.label.cashu": "URL mintu",
+  "reviews.byUrl.label.fedimint": "Kod zaproszenia federacji",
+  "reviews.byUrl.label.lnurl": "URL mintu LNURL",
+  "reviews.byUrl.placeholder.cashu": "mint.example.com",
+  "reviews.byUrl.placeholder.fedimint": "fed11…",
+  "reviews.byUrl.placeholder.lnurl": "mint.example.com",
+  "reviews.byUrl.check": "Sprawdź ten adres",
+  "reviews.byUrl.checking": "Sprawdzanie…",
+  "reviews.byUrl.back": "Użyj innego adresu",
+  "reviews.byUrl.existing": "Już na liście",
+  "reviews.byUrl.indexed": "Właśnie dodany",
+  "reviews.byUrl.confirmClose": "Zamknąć? Wpisany adres nie zostanie zachowany.",
+  "reviews.byUrl.detected": "Ten adres odpowiedział jako mint {kind}.",
+  "reviews.byUrl.switchTo": "Oceń go jako mint {kind}",
+  "reviews.byUrl.error.empty": "Najpierw wpisz adres.",
+  "reviews.byUrl.error.badUrl": "To nie wygląda na URL mintu.",
+  "reviews.byUrl.error.badInvite": "To nie jest kod zaproszenia Fedimint. Kody zaczynają się od fed11.",
+  "reviews.byUrl.error.badInput": "Ta strona nie może sprawdzić tego adresu.",
+  "reviews.byUrl.error.blocked": "To nie jest adres publiczny, więc nie da się go sprawdzić.",
+  "reviews.byUrl.error.notAMint": "Ten adres odpowiedział, ale nie jako mint tego rodzaju.",
+  "reviews.byUrl.error.wrongType": "Ten adres odpowiedział, ale jako mint innego rodzaju.",
+  "reviews.byUrl.error.unverifiable": "Pod tym adresem nic nie odpowiedziało, a na Nostr nie ma po nim jeszcze śladu.",
+  "reviews.byUrl.error.rateLimited.one": "To dużo sprawdzeń z jednego połączenia. Spróbuj ponownie za około {n} minutę.",
+  "reviews.byUrl.error.rateLimited.other": "To dużo sprawdzeń z jednego połączenia. Spróbuj ponownie za około {n} minut.",
+  "reviews.byUrl.error.network": "Nie udało się połączyć z indeksem. Sprawdź połączenie i spróbuj ponownie.",
+  "seo.lnurl.titleNoReviews": "{name}: informacje i opinie o mincie LNURL | Cashumints.space",
+  "seo.desc.statusWithdraw": "{status}, wypłata {min}–{max} sat.",
+  "mint.chip.noFunding": "Brak mintowania / przetapiania",
+  "mint.warnings.lnurlWithdrawalsDisabled.lead": "Wypłaty wyłączone.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.online": "Ten mint ogłasza maksymalną wypłatę równą zeru, więc żadnej wyemitowanej przez niego noty nie da się na nic wymienić. Nie mintuj tutaj, dopóki to się nie zmieni.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.offline": "Przy ostatnim kontakcie ten mint ogłaszał maksymalną wypłatę równą zeru, więc żadnej wyemitowanej przez niego noty nie dało się na nic wymienić. Nie mintuj tutaj, dopóki to się nie zmieni.",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.online": "Wypłaty obecnie wyłączone",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.offline": "Przy ostatnim kontakcie wypłaty były wyłączone",
+  "mint.warnings.lnurlInvalid.lead": "Endpoint odpowiada, ale nieprawidłowo.",
+  "mint.warnings.lnurlInvalid.body": "Host odpowiada, ale nie ogłoszeniem minta, które ta strona potrafi odczytać, więc wypłaty mogą nie działać. Poniżej jest ostatni stan, który udało się odczytać, a opinie nadal działają.",
+  "mint.warnings.lnurlInvalid.meta": "Odpowiada, ale nie prawidłowym ogłoszeniem minta",
+  "mint.warnings.lnurlNoFunding.lead": "Mintowanie i przetapianie niedostępne.",
+  "mint.warnings.lnurlNoFunding.body": "Istniejące noty nadal można obracać, dzielić lub łączyć, ale w tej chwili nic nie wchodzi ani nie wychodzi przez Lightning. Sam mint działa i odpowiada; węzeł Lightning za nim jest z niego nieosiągalny.",
+  "mint.warnings.lnurlNoFunding.meta": "Mintowanie i przetapianie niedostępne",
+  "mint.warnings.also.noFunding": "Jego węzeł Lightning też był nieosiągalny, więc nie dało się nic zmintować ani przetopić."
+}

web/src/i18n/pt.json

@@ -0,0 +1,788 @@
+{
+  "site.name": "Cashumints.space",
+  "common.close": "Fechar",
+  "common.cancel": "Cancelar",
+  "common.done": "Feito",
+  "common.back": "Voltar",
+  "common.retry": "Tentar novamente",
+  "common.connect": "Conectar",
+  "common.copied": "Copiado",
+  "common.copyFull": "Copie {kind} completo",
+  "common.previousPage": "Página anterior",
+  "common.nextPage": "Próxima página",
+  "common.reviewPages": "Revise as páginas",
+  "time.never": "nunca",
+  "time.justNow": "agora mesmo",
+  "time.none": "-",
+  "time.unknownDate": "uma data desconhecida",
+  "time.ago.minute": "{n}m atrás",
+  "time.ago.hour": "{n}h atrás",
+  "time.ago.day": "{n}d atrás",
+  "time.ago.week": "{n}w atrás",
+  "time.ago.month": "{n}mo atrás",
+  "time.ago.year": "{n}y atrás",
+  "time.short.minute": "{n}m",
+  "time.short.hour": "{n}h",
+  "time.short.day": "{n}d",
+  "time.short.week": "{n}w",
+  "time.short.month": "{n}mo",
+  "time.short.year": "{n}y",
+  "status.online": "On-line",
+  "status.offline": "Off-line",
+  "status.degraded": "Inacessível",
+  "status.unknown": "Ainda não verificado",
+  "nav.skip": "Pular para o conteúdo",
+  "nav.main": "Principal",
+  "nav.mints": "Cashu mints",
+  "nav.reviews": "Avaliações",
+  "nav.wallets": "Carteiras",
+  "nav.about": "Sobre",
+  "nav.searchMints": "Pesquisar entre {n} mints",
+  "lang.label": "Linguagem",
+  "lang.switcher": "Escolha um idioma",
+  "footer.copyright": "© {year} Cashumints.space",
+  "footer.allMints": "Todos os mints Cashu",
+  "footer.allReviews": "Todas as avaliações",
+  "footer.wallets": "Carteiras",
+  "footer.about": "Sobre",
+  "footer.disclaimer": "Isenção de responsabilidade",
+  "footer.terms": "Termos",
+  "footer.privacy": "Privacidade",
+  "footer.madeBy": "Feito com ❤️ por {azzamo} · Desenvolvido por Cashu e NIP-87",
+  "footer.warning": "Mints são de custódia. Um mint pode desaparecer com o seu dinheiro.",
+  "footer.tagline": "Avaliações da comunidade sobre mints ecash, assinadas no Nostr.",
+  "footer.col.explore": "Explorar",
+  "footer.col.site": "Site",
+  "footer.nav": "Rodapé",
+  "home.title": "Cashumints.space · Encontre um mint Cashu em que você possa confiar",
+  "home.description": "Encontre um mint Cashu em que você possa confiar. {mints} mints indexados com {reviews} avaliações da comunidade assinadas no Nostr, além de disponibilidade ao vivo, NUTs suportados e software do mint.",
+  "home.hero.title": "Encontre um mint Cashu",
+  "home.hero.titleEm": "você pode confiar",
+  "home.hero.lede": "Cada mint na rede Nostr, com análises reais da comunidade. Sem guardiões, apenas comentários assinados que você mesmo pode verificar.",
+  "home.search.label": "Pesquise mints por nome, domínio ou URL",
+  "home.search.placeholder": "Pesquise por nome, domínio ou cole um URL mint…",
+  "home.filters.mostReviewed": "Mais avaliados",
+  "home.filters.highestRated": "Melhor classificação",
+  "home.filters.recentlyActive": "Recentemente ativo",
+  "home.filters.websockets": "Suporta WebSockets",
+  "home.top.title": "Topo Cashu mints",
+  "home.top.sub": "classificado por comentários e classificação",
+  "home.top.all": "Todos {n} mints →",
+  "home.latest.title": "Últimas avaliações",
+  "home.latest.sub": "ao vivo da rede Nostr",
+  "home.latest.prev": "Avaliações anteriores",
+  "home.latest.next": "Mais avaliações",
+  "home.latest.all": "Todas as avaliações →",
+  "home.latest.empty": "Nenhuma revisão pôde ser lida nos relés agora. Abra qualquer página mint para ler e escrever comentários diretamente.",
+  "home.why.title": "Por que confiar nessas avaliações?",
+  "home.why.signed.title": "Assinado, não enviado",
+  "home.why.signed.body": "Cada resenha é um evento {link} assinado pela chave Nostr de quem a escreveu. Nada aqui é editado, classificado ou removido por nós.",
+  "home.why.signed.link": "NIP-87",
+  "home.why.verify.title": "Verifique você mesmo",
+  "home.why.verify.body": "As avaliações estão disponíveis em relés Nostr públicos, não em nosso banco de dados. Aponte qualquer cliente para os mesmos relés e você verá os mesmos dados.",
+  "home.why.checked.title": "Verificado continuamente",
+  "home.why.checked.body": "Analisamos cada mint quanto ao tempo de atividade, versão do software, limites e NUTs compatível, portanto, as especificações que você vê são atuais, não relatadas pelo próprio.",
+  "home.cta.title": "Pensando em um mint? Leia primeiro.",
+  "home.cta.body": "Um mint contém seu ecash. Leia o que outras pessoas encontraram antes de colocar o sats e deixe um comentário quando você mesmo usar um.",
+  "home.cta.explore": "Explore todos os mints",
+  "home.cta.learn": "Saiba mais sobre Cashu",
+  "pulse.mintsIndexed": "mints indexado",
+  "pulse.reviewsOnNostr": "comentários sobre Nostr",
+  "pulse.lastReview": "última revisão",
+  "pulse.mintsOnline": "mints on-line",
+  "pulse.indexer": "indexador",
+  "pulse.connected": "conectado",
+  "pulse.stale": "obsoleto",
+  "mints.title": "Todos Cashu mints · Cashumints.space",
+  "mints.description": "Todos os {total} Cashu mints indexados na rede Nostr, {online} online e {offline} offline, com classificações da comunidade, tempo de atividade e software mint. Pesquise e classifique a lista completa.",
+  "mints.heading": "Todos os mints Cashu",
+  "mints.lede": "Cada mint descoberto na rede Nostr, incluindo aqueles que desapareceram. mints off-line permanecem listados para que você ainda possa encontrá-los e revisá-los.",
+  "mints.search.label": "Pesquise mints por nome ou domínio",
+  "mints.search.placeholder": "Pesquise por nome ou domínio…",
+  "mints.sort.label": "Classificar mints",
+  "mints.sort.score": "Melhor geral",
+  "mints.sort.rating": "Melhor classificação",
+  "mints.sort.reviews": "Mais avaliados",
+  "mints.sort.recent": "Revisado recentemente",
+  "mints.sort.seen": "Visto recentemente on-line",
+  "mints.hideOffline": "Ocultar off-line",
+  "mints.showing": "Mostrando {total} mints ({online} on-line, {offline} off-line)",
+  "mints.showingFiltered": "Mostrando {shown} de {total} mints ({online} on-line, {offline} off-line)",
+  "mints.noResults": "Nenhuma correspondência mints. Experimente um domínio ou cole um URL mint.",
+  "mints.clearSearch": "Limpe a pesquisa",
+  "card.noRatings": "Ainda não há classificações",
+  "card.reviews.one": "Avaliação {n}",
+  "card.reviews.other": "{n} comentários",
+  "card.lastSeen": "visto pela última vez {when}",
+  "card.neverSeen": "nunca vi on-line",
+  "card.reviewed": "revisado {when}",
+  "card.noReviews": "ainda não há comentários",
+  "mint.title": "{name} · Cashu mint comentários",
+  "mint.titleFedimint": "{name} · Avaliações da federação Fedimint",
+  "mint.titleLnurl": "{name} · Avaliações do mint LNURL",
+  "mint.breadcrumb": "Pão ralado",
+  "mint.crumbMints": "Cashu mints",
+  "mint.copyUrl": "Copiar URL mint",
+  "mint.qrButton": "Mint QR",
+  "mint.writeReview": "Escreva um comentário",
+  "mint.rankByScore": "#{rank} por pontuação",
+  "mint.tagLightning": "Lightning",
+  "mint.summary": "Resumo Mint",
+  "mint.rating.label": "Avaliação da comunidade",
+  "mint.rating.none": "Ainda não há classificações",
+  "mint.rating.reviews.one": "Avaliação {n}",
+  "mint.rating.reviews.other": "{n} comentários",
+  "mint.rating.unrated.one": "{n} não deixou nenhuma classificação",
+  "mint.rating.unrated.other": "{n} não deixou nenhuma classificação",
+  "mint.activity.label": "Atividade",
+  "mint.activity.since": "desde a última revisão",
+  "mint.activity.noReviews": "ainda não há comentários",
+  "mint.activity.recent.one": "Revisão {n} nos últimos 90 dias",
+  "mint.activity.recent.other": "Avaliações de {n} nos últimos 90 dias",
+  "mint.limits.label": "Limites",
+  "mint.limits.notPublished": "não publicado",
+  "mint.limits.min": "min",
+  "mint.limits.max": "máx.",
+  "mint.limits.mintRow": "mint",
+  "mint.limits.meltRow": "derretido",
+  "mint.limits.disabled": "desabilitado",
+  "mint.limits.range": "{min} para {max} {unit}",
+  "mint.limits.upTo": "até {max} {unit}",
+  "mint.limits.from": "de {min} {unit}",
+  "mint.software.label": "Software Mint",
+  "mint.software.unknown": "desconhecido",
+  "mint.checked": "verificado {when}",
+  "mint.lastSeen": "visto pela última vez {when}",
+  "mint.neverReached": "nunca alcançado",
+  "mint.uptime.checks": "{ok} das últimas verificações {total} acessíveis",
+  "mint.uptime.percent": "{percent}% alcançável em 30 dias",
+  "mint.uptime.description": "{ok} das últimas verificações {total} bem-sucedidas",
+  "mint.operator.title": "Da operadora",
+  "mint.operator.motd": "Mensagem do dia",
+  "mint.operator.beta": "Este mint se descreve como experimental ou em beta. Leia as palavras do próprio operador abaixo antes de armazenar qualquer coisa que você não possa perder.",
+  "mint.nuts.title": "NUTs compatível",
+  "mint.nuts.noneOffline": "Nenhuma lista NUT armazenada em cache para este mint, ele ficou off-line antes de uma ser gravada.",
+  "mint.nuts.noneYet": "Nenhuma lista NUT armazenada em cache para este mint ainda.",
+  "mint.nuts.supported": "{n} de {total} conhecido NUTs suportado",
+  "mint.nuts.whatAre": "o que são NUTs?",
+  "mint.nutRow.disabled": "desabilitado",
+  "mint.nutRow.notSupported": "não suportado",
+  "mint.details.title": "Detalhes Mint",
+  "mint.details.pubkey": "Pubkey",
+  "mint.details.nostr": "Nostr",
+  "mint.details.email": "E-mail",
+  "mint.details.serverTime": "Hora do servidor",
+  "mint.details.firstSeen": "Visto pela primeira vez",
+  "mint.details.terms": "Termos",
+  "mint.kind.identifier": "identificador",
+  "mint.kind.mintPubkey": "mint pubkey",
+  "mint.kind.nostrAddress": "Endereço Nostr",
+  "mint.kind.emailAddress": "endereço de email",
+  "mint.kind.npub": "npub",
+  "mint.disclaimer": "Este mint tem custódia: ele guarda seu dinheiro e pode parar de fazê-lo a qualquer momento. As classificações são opiniões da comunidade e meios online acessíveis, não confiáveis.",
+  "mint.disclaimerLink": "Leia o aviso completo",
+  "mint.qr.title": "Adicione {name} à sua carteira",
+  "mint.qr.note": "Digitalize isso com uma carteira Cashu para adicionar o mint ou copie o URL e cole-o.",
+  "mint.qr.warn": "Adicionar um mint significa confiar seu dinheiro a ele.",
+  "mint.qr.whatMeans": "O que isso significa",
+  "mint.qr.wallets": "Carteiras que suportam Cashu",
+  "mint.chip.frozen": "Congelado",
+  "mint.chip.noWithdrawals": "Sem retiradas",
+  "mint.chip.meltOnly": "Derreta apenas",
+  "mint.warnings.dayCount.one": "Dia {n}",
+  "mint.warnings.dayCount.other": "{n} dias",
+  "mint.warnings.gone.lead": "Provavelmente desapareceu.",
+  "mint.warnings.gone.body.since": "Este mint está inacessível desde {date} ({days}). Trate os fundos ali mantidos como de risco e não envie novos fundos. Os detalhes abaixo mostram seu último estado conhecido.",
+  "mint.warnings.gone.body.neverDated": "Este mint não respondeu a nenhuma verificação desde que começamos a observá-lo em {month}. Trate os fundos ali mantidos como de risco e não envie novos fundos. Tudo o que está abaixo veio do anúncio do Nostr, não do mint.",
+  "mint.warnings.gone.body.never": "Este mint não respondeu a nenhuma verificação desde que começamos a observá-lo. Trate os fundos ali mantidos como de risco e não envie novos fundos. Tudo o que está abaixo veio do anúncio do Nostr, não do mint.",
+  "mint.warnings.gone.meta.since": "Off-line desde {date}",
+  "mint.warnings.gone.meta.never": "Nunca acessível desde que foi descoberto",
+  "mint.warnings.meltDisabled.lead": "Retiradas desativadas.",
+  "mint.warnings.meltDisabled.body.online": "Este mint tem Lightning melting (NUT-05) desligado: você pode colocar sats, mas não pode retirá-los via Lightning. Não deposite até que melting esteja de volta.",
+  "mint.warnings.meltDisabled.body.offline": "Este mint tinha Lightning melting (NUT-05) desligado: você pode colocar sats, mas não pode retirá-los via Lightning. Não deposite até que melting esteja de volta.",
+  "mint.warnings.meltDisabled.meta.online": "Retiradas atualmente desativadas",
+  "mint.warnings.meltDisabled.meta.offline": "As retiradas foram desativadas quando vistas pela última vez",
+  "mint.warnings.frozen.lead": "Mint congelado.",
+  "mint.warnings.frozen.body.online": "Tanto minting quanto melting estão desabilitados. Nenhum sats pode entrar ou sair via Lightning.",
+  "mint.warnings.frozen.body.offline": "Tanto minting quanto melting foram desativados. Nenhum sats pode entrar ou sair via Lightning.",
+  "mint.warnings.frozen.meta.online": "Atualmente congelado, nada entra ou sai",
+  "mint.warnings.frozen.meta.offline": "Congelado quando visto pela última vez",
+  "mint.warnings.offlineLong.lead": "Off-line para {days}, desde {date}.",
+  "mint.warnings.offlineLong.body": "O mint pode ter desaparecido. Tudo abaixo é o último estado conhecido e as revisões ainda funcionam.",
+  "mint.warnings.offlineLong.meta": "Off-line desde {date}",
+  "mint.warnings.meltOnly.lead": "Derreta apenas.",
+  "mint.warnings.meltOnly.body.online": "O novo minting (NUT-04) está desativado: você não pode depositar, mas o ecash existente ainda pode ser sacado. Isso geralmente significa que um mint está diminuindo, portanto, se você mantiver seu ecash, considere melting fora.",
+  "mint.warnings.meltOnly.body.offline": "O novo minting (NUT-04) foi desativado: você não pode depositar, mas o ecash existente ainda pode ser sacado. Isso geralmente significa que um mint está diminuindo, portanto, se você mantiver seu ecash, considere melting fora.",
+  "mint.warnings.meltOnly.meta.online": "Atualmente derreter apenas",
+  "mint.warnings.meltOnly.meta.offline": "Derreter apenas quando visto pela última vez",
+  "mint.warnings.offline.lead": "Off-line desde {date}.",
+  "mint.warnings.offline.body": "Os detalhes foram confirmados pela última vez então. Você ainda pode escrever um comentário.",
+  "mint.warnings.offline.meta": "Off-line desde {date}",
+  "mint.warnings.also.meltDisabled": "Antes de ficar offline, ele também desativou os saques.",
+  "mint.warnings.also.mintDisabled": "Antes de ficar offline, ele também desativou o novo minting.",
+  "mint.warnings.also.offline": "Também está offline desde {date} ({days}).",
+  "nut.0": "Notação e modelos",
+  "nut.1": "Troca de chave pública Mint",
+  "nut.2": "Conjuntos de chaves e taxas",
+  "nut.3": "Troca de tokens",
+  "nut.4": "Minting através de Lightning",
+  "nut.5": "Melting através de Lightning",
+  "nut.6": "Informações sobre Mint",
+  "nut.7": "Verificação do estado do token",
+  "nut.8": "Taxas Lightning pagas em excesso",
+  "nut.9": "Restaurar assinaturas",
+  "nut.10": "Condições de gasto",
+  "nut.11": "Pague com chave pública",
+  "nut.12": "Provas DLEQ",
+  "nut.13": "Segredos determinísticos",
+  "nut.14": "Contratos de timelock com hash",
+  "nut.15": "Pagamentos multicaminhos",
+  "nut.16": "Códigos QR animados",
+  "nut.17": "Assinaturas WebSocket",
+  "nut.18": "Solicitações de pagamento",
+  "nut.19": "Respostas armazenadas em cache",
+  "nut.20": "Cotações mint assinadas",
+  "nut.21": "Autenticação clara",
+  "nut.22": "Autenticação cega",
+  "nut.23": "Método de pagamento BOLT11",
+  "nut.24": "Pagamento HTTP 402 necessário",
+  "nut.25": "Método de pagamento BOLT12",
+  "reviews.title": "Avaliações",
+  "reviews.anon": "Em breve",
+  "reviews.anonTitle": "Nenhum perfil Nostr público encontrado para esta chave",
+  "reviews.nip05Title": "Identificador NIP-05 (não verificado por este site)",
+  "reviews.filter.group": "Filtrar avaliações",
+  "reviews.filter.all": "Todos",
+  "reviews.filter.five": "5★",
+  "reviews.filter.critical": "Crítico",
+  "reviews.filter.recent": "Recente",
+  "reviews.filter.hideAnon": "Esconda-se imediatamente",
+  "reviews.anonHidden.other": "Mostrando {n} de análises de {total}: imediatamente oculto.",
+  "reviews.allAnon.one": "A única revisão aqui é anon.",
+  "reviews.allAnon.other": "Todas as análises do {n} aqui são imediatas.",
+  "reviews.allAnonShow.one": "Mostre",
+  "reviews.allAnonShow.other": "Mostre a eles",
+  "reviews.loading.one": "Carregando revisão {n} dos relés Nostr",
+  "reviews.loading.other": "Carregando análises {n} dos relés Nostr",
+  "reviews.empty": "Ainda não há comentários. Seja o primeiro a escrever um.",
+  "reviews.emptyWritten": "Ainda não há comentários escritos aqui. Seja o primeiro a escrever um.",
+  "reviews.emptyFilter": "Nenhuma avaliação corresponde a este filtro.",
+  "reviews.rate.cashu": "Avalie este mint",
+  "reviews.rate.fedimint": "Avalie esta federação",
+  "reviews.rate.lnurl": "Avalie este mint",
+  "reviews.noscript": "As avaliações são assinadas em Nostr e carregadas em seu navegador, portanto, esta lista precisa de JavaScript. A classificação e as contagens acima vêm do próprio site.",
+  "reviews.relayError": "Não foi possível alcançar o relé. As avaliações podem estar incompletas.",
+  "reviews.srRating": "{rating} de 5",
+  "reviews.srNoRating": "Nenhuma classificação dada",
+  "reviews.readMore": "Leia mais",
+  "reviews.readLess": "Mostrar menos",
+  "reviews.actions.copyNpub": "Copiar npub",
+  "reviews.actions.openNostr": "Veja este evento em Nostr",
+  "reviews.actions.copyLink": "Copiar link para esta avaliação",
+  "reviews.anonNote": "Primeira revisão deste npub, nenhuma outra atividade encontrada",
+  "reviews.published": "Publicado.",
+  "reviews.publishedPartial": "Publicado em {accepted} dos relés {total}.",
+  "reviews.propagating": "Publicando nos relays Nostr",
+  "reviews.summary.line.one": "Classificação {count} sem comentários: {breakdown}",
+  "reviews.summary.line.other": "Avaliações {count} sem comentários: {breakdown}",
+  "reviews.summary.lineDay.one": "Classificação {count} sem comentários em {when}: {breakdown}",
+  "reviews.summary.lineDay.other": "Classificações {count} sem comentários em {when}: {breakdown}",
+  "reviews.summary.showOne": "Mostre",
+  "reviews.summary.showMany": "Mostre a eles",
+  "reviews.breakdown.5": "{n} cinco estrelas",
+  "reviews.breakdown.4": "{n} quatro estrelas",
+  "reviews.breakdown.3": "{n} três estrelas",
+  "reviews.breakdown.2": "{n} duas estrelas",
+  "reviews.breakdown.1": "{n} uma estrela",
+  "reviews.breakdown.none": "{n} sem classificação",
+  "reviews.dialog.title": "Revisão {name}",
+  "reviews.dialog.lede.cashu": "Compartilhe sua experiência com este mint.",
+  "reviews.dialog.lede.fedimint": "Compartilhe sua experiência com esta federação.",
+  "reviews.dialog.lede.lnurl": "Compartilhe sua experiência com este mint.",
+  "reviews.dialog.permanent": "Publicado permanentemente em relays públicos do Nostr.",
+  "reviews.dialog.gate.title": "Faça login para escrever um comentário",
+  "reviews.dialog.gate.lead": "Os comentários são assinados com sua chave Nostr. Ela permanece no seu assinante, este site nunca a vê.",
+  "reviews.dialog.ratingLegend": "Sua classificação",
+  "reviews.dialog.starsSr.one": "Estrela {n}",
+  "reviews.dialog.starsSr.other": "Estrelas {n}",
+  "reviews.dialog.chooseRating": "Escolha uma classificação",
+  "reviews.dialog.starLabel": "{n}: {phrase}",
+  "reviews.dialog.stars.1": "evite isso",
+  "reviews.dialog.stars.2": "teve problemas",
+  "reviews.dialog.stars.3": "funcionou, com ressalvas",
+  "reviews.dialog.stars.4": "bom",
+  "reviews.dialog.stars.5": "funciona muito bem",
+  "reviews.dialog.bodyLabel": "O que outras pessoas deveriam saber?",
+  "reviews.dialog.charCount": "{n}/{max}",
+  "reviews.dialog.submit": "Assine e publique",
+  "reviews.dialog.signing": "Assinando…",
+  "reviews.dialog.publishing": "Publicando…",
+  "reviews.dialog.publishingTo": "Publicação em relés ({accepted}/{total})",
+  "reviews.dialog.waitingExtension": "Aguardando sua extensão",
+  "reviews.dialog.waitingSigner": "Esperando pelo seu signatário",
+  "reviews.dialog.confirmClose": "Fechar esta avaliação? Seu rascunho é mantido até você sair do site.",
+  "reviews.dialog.why.login": "Faça login para publicar",
+  "reviews.dialog.why.words": "Escreva algumas palavras",
+  "reviews.dialog.why.more.one": "{n} mais caráter",
+  "reviews.dialog.why.more.other": "{n} mais caracteres",
+  "reviews.dialog.why.over.one": "Caractere {n} acima do limite",
+  "reviews.dialog.why.over.other": "Caracteres {n} acima do limite",
+  "reviews.dialog.identity.needSigner": "Você precisa de um assinante Nostr para publicar. Sua chave permanece nela, este site nunca a vê.",
+  "reviews.dialog.identity.loginToPublish": "Faça login para publicar",
+  "reviews.dialog.identity.switch": "Trocar",
+  "reviews.dialog.identity.extension": "Assinando com a extensão do seu navegador",
+  "reviews.dialog.identity.readingKey": "Lendo sua chave pública…",
+  "reviews.dialog.identity.willAsk": "Seu ramal será solicitado a assinar",
+  "reviews.dialog.error.noRelay": "Nenhum relé aceitou a revisão. Verifique sua conexão e tente novamente.",
+  "reviews.validate.rating": "Escolha uma classificação de 1 a 5 estrelas.",
+  "reviews.validate.short": "Escreva pelo menos caracteres {n} para que a revisão seja útil.",
+  "reviews.validate.long": "As resenhas são limitadas a caracteres {n}.",
+  "feed.title": "Últimas análises de mint e da federação · Cashumints.space",
+  "feed.description": "Cada avaliação de mint, federação e mint LNURL assim que é publicada: {reviews} avaliações sobre {mints} mints Cashu, {federations} federações Fedimint e {lnurl} mints LNURL, assinadas no Nostr e legíveis aqui da mais recente para a mais antiga. Filtre por ecossistema, por nota ou por nome.",
+  "feed.heading": "Últimas avaliações",
+  "feed.lede": "Cada revisão de cada federação Cashu mint e Fedimint, as mais recentes primeiro, lida ao vivo nos relés Nostr. Cada um é assinado por seu autor e reside nos relés, não em nosso banco de dados.",
+  "feed.label": "Avaliações",
+  "feed.showingBuild.one": "Mostrando a revisão mais recente da última compilação",
+  "feed.showingBuild.other": "Mostrando as análises mais recentes do {n} da última construção",
+  "feed.noscript": "As avaliações são assinadas em Nostr e carregadas em seu navegador, portanto, a filtragem e a lista completa precisam de JavaScript. As análises do {n} abaixo foram lidas nos relés quando esta página foi construída.",
+  "feed.emptyBuild": "Nenhuma revisão pôde ser lida nos relés quando esta página foi construída. A lista é recarregada a partir dos relés do seu navegador.",
+  "feed.foot": "As avaliações são opiniões da comunidade, não afirmações verificadas. Leia o {link} antes de confiar dinheiro a um mint.",
+  "feed.footLink": "isenção de responsabilidade",
+  "feed.showing": "Mostrando {shown} de avaliações de {total}",
+  "feed.showingMatching": "Mostrando {shown} de análises correspondentes de {matching} ({total} no total)",
+  "feed.emptyRelays": "Nenhuma avaliação voltou dos relés. Abra qualquer página do mint para ler e escrever comentários nela.",
+  "feed.emptyFilter": "Nenhuma avaliação corresponde a este filtro. Limpe a caixa mint ou tente Tudo.",
+  "feed.relayError": "Não foi possível alcançar os relés. Mostrando os comentários da última compilação.",
+  "feed.relayEmpty": "Nenhuma avaliação voltou dos relés. Mostrando os comentários da última compilação.",
+  "feed.reading": "Lendo os relés…",
+  "login.open": "Conecte-se",
+  "login.title": "Faça login com Nostr",
+  "login.note": "Sua chave permanece com seu signatário. Este site nunca poderá ver isso.",
+  "login.extension.name": "Extensão do navegador",
+  "login.extension.desc": "Assine com Alby, nos2x ou outra extensão NIP-07",
+  "login.extension.none": "Nenhuma extensão encontrada",
+  "login.extension.getOne": "Obtenha um:",
+  "login.remote.name": "Signatário remoto",
+  "login.remote.desc": "Digitalize um código com um aplicativo assinante ou cole um link de bunker",
+  "login.primal.name": "Primal",
+  "login.primal.desc": "Aprove o login no aplicativo Primal em seu telefone",
+  "login.paste.label": "Ou cole o link de conexão fornecido pelo seu signatário",
+  "login.copyLink": "Copie o link de conexão",
+  "login.whatIsNostr": "O que é Nostr?",
+  "login.connect.remote.title": "Conecte um signatário remoto",
+  "login.connect.remote.lead": "Digitalize com seu aplicativo de signatário ou copie o link e cole-o lá.",
+  "login.connect.remote.hint": "Funciona com qualquer signatário NIP-46: nsec.app, Amber, Nostrify, seu próprio bunker.",
+  "login.connect.remote.open": "Abra em seu aplicativo de signatário",
+  "login.connect.primal.title": "Conecte-se com Primal",
+  "login.connect.primal.lead": "Abra Primal em seu telefone, encontre a assinatura remota em suas configurações e leia este código.",
+  "login.connect.primal.hint": "Primal assina para outros aplicativos através de NIP-46, portanto, esta é a mesma conexão que qualquer signatário usa e sua chave permanece em Primal. {link}",
+  "login.connect.primal.open": "Abrir em Primal",
+  "login.status.buildingLink": "Construindo um link de conexão",
+  "login.status.waitingExtension": "Aguardando sua extensão",
+  "login.status.waitingSigner": "Esperando pelo seu signatário",
+  "login.status.connecting": "Conectando-se ao seu signatário",
+  "login.status.connected": "Conectado",
+  "login.toast.loggedIn": "Sessão iniciada",
+  "login.toast.fetchingProfile": "Obtendo o seu perfil Nostr dos relés…",
+  "login.toast.profile": "Perfil: {name}",
+  "login.toast.noProfile": "Nenhum perfil encontrado nos relés",
+  "login.method.extension": "Extensão",
+  "login.method.remote": "Remoto",
+  "login.method.primal": "Primal",
+  "login.account": "Sua conta Nostr",
+  "login.copyNpub": "Copie seu npub completo",
+  "login.logout": "Sair",
+  "signer.status.waitingExtension": "Aguardando sua extensão",
+  "signer.status.signed": "Assinado",
+  "signer.status.reconnecting": "Reconectando-se ao seu signatário",
+  "signer.status.approveWindow": "Seu signatário precisa que você aprove isso em sua própria janela",
+  "signer.status.waitingSigner": "Esperando pelo seu signatário",
+  "signer.status.stillWaiting": "Ainda esperando a resposta do seu signatário",
+  "signer.status.connected": "Conectado",
+  "signer.error.noExtension": "Nenhuma extensão de assinatura encontrada. Instale Alby ou nos2x e recarregue esta página.",
+  "signer.error.privateKey": "Parece uma chave privada, não um link de conexão. Este site nunca aceita uma chave. Cole o link bunker:// fornecido pelo seu signatário.",
+  "signer.error.badLink": "Esse não é um link de conexão que este site entende. Cole o link bunker:// do seu signatário.",
+  "signer.error.noAnswer": "Seu signatário não respondeu. Ele pode estar fechado ou seu relé pode estar inativo. Abra-o e tente novamente.",
+  "signer.error.timeout": "Seu signatário não respondeu a tempo. Abra-o, verifique se ainda está conectado e tente novamente.",
+  "signer.error.cancelled": "Conexão cancelada.",
+  "signer.error.declined": "A solicitação de assinatura foi recusada",
+  "notfound.title": "Página não encontrada · Cashumints.space",
+  "notfound.description": "Essa página não existe em Cashumints.space.",
+  "notfound.heading": "Esta página não existe",
+  "notfound.lede": "Ele pode ter sido movido ou o mint pode ainda não estar indexado. Pesquise um mint por nome ou domínio ou cole um URL mint.",
+  "notfound.browse": "Procurar todos os mints",
+  "notfound.home": "Ir para casa",
+  "notfound.loading": "Carregando {host}",
+  "notfound.fb.rating": "Avaliação",
+  "notfound.fb.reviews": "Avaliações",
+  "notfound.fb.software": "Programas",
+  "notfound.fb.lastOnline": "Última vez on-line",
+  "notfound.fb.note": "Este mint foi indexado depois da última construção do site, por isso este é um resumo da API em direto, com as avaliações abaixo. A página completa aparece na próxima construção.",
+  "notfound.resolve.checking": "Primeira visita: a verificar este mint agora.",
+  "notfound.resolve.failed": "Não foi possível adicionar este mint",
+  "notfound.resolve.failedFedimint": "Não foi possível adicionar esta federação",
+  "notfound.resolve.retry": "Tentar outro endereço",
+  "notfound.resolve.switch": "Abri-lo como mint {kind}",
+  "notfound.resolve.fedimint": "O endereço da página de uma federação não contém o seu código de convite, por isso esta não pode ser encontrada só com o link. Cola o código de convite e ela é adicionada.",
+  "notfound.resolve.ambiguous": "Este endereço não pode ser deduzido só a partir do link. Cola o URL completo do mint e ele é adicionado.",
+  "wallets.title": "Carteiras Cashu · Cashumints.space",
+  "wallets.description": "Carteiras Cashu que funcionam com o mints listado aqui, em dispositivos móveis, web, navegador e linha de comando, com o que cada uma é boa.",
+  "wallets.heading": "Carteiras",
+  "wallets.lede": "Você precisa de uma carteira para guardar ecash de qualquer um desses mints. A maioria das carteiras conversa com vários mints ao mesmo tempo, então você não fica preso ao primeiro que tentar.",
+  "wallets.note": "Esta lista não é exaustiva e não é um endosso. O projeto Cashu mantém um índice mais amplo em {link}. Uma carteira guarda as chaves, um mint guarda o dinheiro: leia as análises do mint antes de escolher onde seu sats mora.",
+  "wallets.platform.android": "Android",
+  "wallets.platform.ios": "iOS",
+  "wallets.platform.web": "Rede",
+  "wallets.platform.extension": "Extensão do navegador",
+  "wallets.platform.cli": "CLI",
+  "wallets.platform.python": "Python",
+  "wallets.item.minibits": "Carteira móvel ecash com seu próprio mint, suporte de endereço Lightning e contatos Nostr.",
+  "wallets.item.nutstash": "Carteira de navegador que lida com vários mints de uma só vez e importa e exporta tokens brutos.",
+  "wallets.item.enuts": "Carteira móvel focada em saldos multimint e envio de ecash sobre Nostr.",
+  "wallets.item.cashume": "Carteira web de referência do projeto Cashu. Funciona inteiramente no navegador, instalável como PWA.",
+  "wallets.item.boardwalk": "Carteira Web construída em torno de endereços Lightning e enviando ecash por link.",
+  "wallets.item.coinos": "Carteira e ponto de venda Lightning que também administra seu próprio Cashu mint.",
+  "wallets.item.oxchat": "Mensageiro Nostr com carteira ecash integrada, para enviar sats dentro de chats.",
+  "wallets.item.nutshell": "A implementação de referência. Funciona como carteira na linha de comando e como software mint.",
+  "about.title": "Sobre Cashumints.space",
+  "about.description": "O que é Cashu, o que um mint realmente contém, o que é NIP-87 e como este site indexa mints e lê comentários dos relés Nostr.",
+  "about.heading": "Sobre",
+  "about.lede": "Cashumints.space lista todos os Cashu mint que podemos encontrar na rede Nostr e mostra o que as pessoas dizem sobre eles. É feito pela Azzamo.",
+  "about.cashu.title": "O que é Cashu",
+  "about.cashu.p1": "Cashu é um protocolo ecash para Bitcoin. Um mint emite tokens cegos apoiados por sats que possui, e esses tokens se movem entre as pessoas sem que o mint saiba quem enviou o quê para quem. A privacidade é real e esse é o ponto: tokens não são contas e o mint não pode vincular o token que assinou ao token que retorna.",
+  "about.cashu.p2": "Você pode ler o protocolo e suas especificações em {link}. As próprias especificações são chamadas de NUTs, de onde vêm os números NUT em cada página mint.",
+  "about.mints.title": "O que é um mint e a compensação",
+  "about.mints.p1": "Um mint é de custódia. Quando você mint ecash você está entregando sats para quem administra esse servidor e confia nele para honrar os tokens quando você os derreter novamente. Não há prova de fraude, nenhum depósito e nenhum recurso. Um operador mint pode desaparecer com o saldo, e mints desapareceu.",
+  "about.mints.p2": "É exatamente por isso que existem comentários aqui. Este site nunca informa que um mint é seguro. O status em uma página mint diz {code}, não \"confiável\", e significa apenas que o servidor respondeu quando perguntamos pela última vez. Trate os saldos ecash como dinheiro no bolso do casaco: bom para gastar, errado para poupar.",
+  "about.nip87.title": "O que é NIP-87",
+  "about.nip87.p1": "NIP-87 é a convenção Nostr para anunciar e recomendar ecash mints. Dois tipos de eventos são importantes aqui:",
+  "about.nip87.li1": "{code} anuncia um mint. O URL mint está na tag {tag}. É assim que o site descobre mints que nunca viu.",
+  "about.nip87.li2": "{code} é uma revisão. Ele carrega a classificação e o texto de revisão e aponta para o mint com uma tag {utag} (o URL mint) e uma tag {dtag} (a própria chave pública do mint).",
+  "about.nip87.p2": "Cada revisão é assinada pela chave Nostr do seu autor. Nunca chamamos uma avaliação de “verificada”, porque ninguém a verificou: está assinada, o que é uma afirmação diferente e mais útil. Isso significa que você pode verificar quem o escreveu e se não foi alterado. Isso não significa que o autor seja honesto ou que já tenha usado o mint.",
+  "about.how.title": "Como este site funciona",
+  "about.how.p1": "Existem dois loops e uma regra. A regra é que mint possui seus metadados e Nostr possui as avaliações, portanto, este site não armazena nenhum dos dois como autoridade.",
+  "about.how.li1": "{strong} solicita {code} a cada mint conhecido a cada dez minutos e registra o que diz: nome, descrição, versão, NUTs compatível, limites, detalhes de contato. Ele também registra se o mint respondeu, e é daí que vem o tempo de atividade.",
+  "about.how.li1Label": "O circuito da sonda",
+  "about.how.li2": "{strong} se conecta aos relés Nostr a cada hora, lê anúncios e análises de mint e adiciona qualquer mint que nunca tenha visto antes.",
+  "about.how.li2Label": "O ciclo de descoberta",
+  "about.how.p2": "A parte importante é o que acontece quando um mint para de atender. Seus metadados em cache nunca são substituídos por uma investigação com falha, portanto, um mint morto mantém sua página inteira: suas especificações, seu histórico e suas análises, com um banner informando quando ele escureceu. A versão anterior deste site exibia uma página de erro, o que significava que as pessoas do mints mais precisavam avisar umas às outras eram aquelas que não podiam ser revisadas. Esse foi o principal motivo da reconstrução.",
+  "about.how.p3": "O texto de revisão nunca é armazenado do nosso lado. Quando você abre uma página mint, seu navegador se comunica diretamente com os relés e lê os próprios comentários, e quando você escreve um, ele é assinado por sua própria extensão Nostr e enviado diretamente para esses relés. Mantemos uma contagem para que as páginas possam ser classificadas e ordenadas, nada mais. Nada aqui pode ser editado ou excluído por nós, incluindo comentários que preferiríamos não ter.",
+  "about.relays.title": "Relés que lemos",
+  "about.relays.p1": "Estes são os relés que o indexador e seu navegador usam:",
+  "about.relays.p2": "Aponte qualquer cliente Nostr para os mesmos relés e você verá os mesmos eventos. Essa é toda a promessa: nada aqui só é verdade porque o dizemos.",
+  "about.nuts.title": "O que são NUTs?",
+  "about.nuts.p1": "NUTs são as especificações Cashu numeradas, como BIPs para Bitcoin. Um mint anuncia quais ele implementa, e isso informa o que ele realmente pode fazer: NUT-04 e NUT-05 são minting e melting sobre Lightning (sem eles um mint não é muito útil), NUT-07 permite que uma carteira verifique se um token já foi gasto, NUT-17 fornece às carteiras atualizações ao vivo sobre WebSockets em vez de pesquisa, e NUT-20 permite que uma carteira prove que uma cotação mint foi realmente emitida para ela. A lista completa está em {link}.",
+  "about.numbers.title": "Agora mesmo",
+  "about.numbers.p1": "{mints} mints indexado, {online} deles respondendo, avaliações {reviews} contadas a partir dos relés acima.",
+  "about.source.title": "Fonte e crédito",
+  "about.source.p1": "O site é de código aberto em {github}. Ele é construído e executado por {azzamo}. Se uma página mint tiver algo errado, corrija na fonte: os metadados mint vêm do próprio mint do {code} e as análises vêm do Nostr.",
+  "terms.title": "Termos de uso · Cashumints.space",
+  "terms.description": "Termos de uso do Cashumints.space: o que é o site, o que não faz e quem é responsável por quê. Sem contas, sem garantias, sem afiliação com qualquer mint.",
+  "terms.heading": "Termos de uso",
+  "terms.lede": "Termos simples para um site que indexa apenas dados públicos. Última atualização {date}.",
+  "terms.what.title": "O que é este site",
+  "terms.what.p1": "Cashumints.space é um índice de dados publicamente disponíveis sobre Cashu mints. Dois tipos de dados, ambos de outro lugar:",
+  "terms.what.li1": "Metadados Mint, lidos do próprio endpoint {code} de cada mint: nome, descrição, versão do software, NUTs compatível, detalhes de contato e se o mint respondeu quando perguntamos pela última vez.",
+  "terms.what.li2": "Comentários, leia os relés públicos Nostr. Estes são eventos NIP-87 publicados por seus autores para relés que qualquer pessoa pode consultar.",
+  "terms.what.p2": "Coletamos esses dados, normalizamos, classificamos e mostramos. Nós não o criamos.",
+  "terms.noAccounts.title": "Sem contas, sem garantias",
+  "terms.noAccounts.p1": "Não há nada para se inscrever. O site é fornecido tal como está, sem qualquer tipo de garantia: nem que os dados sejam precisos, nem que sejam atuais, nem que o site esteja disponível. Os dados do Mint podem ter minutos ou horas, um mint pode mudar após a última verificação e um relé pode não responder e, nesse caso, você está vendo menos do que existe.",
+  "terms.noAccounts.p2": "Use-o por sua conta e risco. Não nos responsabilizamos por qualquer perda resultante do uso deste site ou da confiança em qualquer coisa que você leia aqui. Consulte o {link} para saber os riscos específicos do uso de um Cashu mint.",
+  "terms.noAccounts.link": "isenção de responsabilidade",
+  "terms.noCustody.title": "Nós não guardamos seu dinheiro",
+  "terms.noCustody.p1": "Este site nunca assume a custódia de fundos. Não tem carteira, não toca em ecash e não pode mover, congelar ou recuperar nada. Se você tiver um problema com um mint, o operador mint é a única pessoa que pode ajudá-lo e não podemos contatá-lo em seu nome.",
+  "terms.noCustody.p2": "Não somos afiliados a nenhum mint listado aqui e nenhum mint paga por sua listagem, classificação ou classificação. Mints são descobertos em anúncios públicos de Nostr e classificados por um algoritmo em dados de revisão pública.",
+  "terms.reviews.title": "Avaliações são palavras de outras pessoas",
+  "terms.reviews.p1": "As resenhas são conteúdos gerados por usuários e publicados em relés Nostr públicos por seus autores. Nós os exibimos, não os controlamos. Nós não os escrevemos, não podemos editá-los e não podemos excluí-los dos relés que os contêm: são eventos assinados em uma rede que não nos pertence.",
+  "terms.reviews.p2": "Uma avaliação é a experiência de uma pessoa, não um fato verificado. Se você publicar um, você será responsável pelo que ele diz. Não publique nada ilegal e esteja ciente de que o que você publica é público e permanente (consulte o {link}).",
+  "terms.reviews.link": "página de privacidade",
+  "terms.reviews.p3": "Podemos parar de exibir uma avaliação específica neste site e faremos isso para conteúdo ilegal. Isso o remove apenas dessas páginas. O evento permanece nos relés e qualquer outro cliente Nostr ainda pode lê-lo.",
+  "terms.links.title": "Links para outros sites",
+  "terms.links.p1": "URLs Mint, links de carteira, contatos de operadoras e tudo o mais que aponta para fora deste site estão lá porque fazem parte dos dados. Um link não é um endosso e não examinamos o que está do outro lado.",
+  "terms.changes.title": "Mudanças",
+  "terms.changes.p1": "Esses termos podem mudar. A data no topo indica quando foi a última vez. O site é de código aberto, portanto, cada alteração nesta página fica no histórico de commits.",
+  "terms.contact.title": "Contato",
+  "terms.contact.p1": "Problemas e solicitações de remoção são melhor arquivados em {github}. O site é administrado por {azzamo}.",
+  "privacy.title": "Privacidade · Cashumints.space",
+  "privacy.description": "Privacidade no Cashumints.space: sem contas, sem cookies de rastreamento, sem análises. localStorage é usado para cache de perfil e nada é enviado para lugar nenhum. As avaliações são assinadas no seu próprio navegador.",
+  "privacy.heading": "Privacidade",
+  "privacy.lede": "Coletamos o mínimo que um site pode. Última atualização {date}.",
+  "privacy.noAccounts.title": "Nenhuma conta",
+  "privacy.noAccounts.p1": "Não há inscrição, login e perfil. Nada neste site pergunta quem você é e não há nenhum registro de usuário para vazar porque não há usuários.",
+  "privacy.noTracking.title": "Sem cookies de rastreamento, sem análises",
+  "privacy.noTracking.p1": "O site não define cookies para rastreamento. Não há script de análise, gerenciador de tags, pixel, gravação de sessão e rede de publicidade. Nada na página informa seu comportamento para nós ou para qualquer outra pessoa.",
+  "privacy.logs.title": "Registros do servidor",
+  "privacy.logs.p1": "O servidor web mantém logs de acesso padrão, que é o que qualquer servidor web faz por padrão. Uma linha de registro registra seu endereço IP, a hora, a página que você solicitou, o status da resposta e o agente do usuário e referenciador que seu navegador enviou. Os logs existem para depurar erros e detectar abusos. Eles não estão unidos a mais nada e não são vendidos ou compartilhados.",
+  "privacy.logs.operatorLabel": "Nota do operador:",
+  "privacy.logs.operator": "se você administra este site, indique sua retenção real aqui. A implantação no README usa nginx com seu log de acesso padrão e qualquer rotação que sua distribuição enviar (em Debian e Ubuntu que é logrotate, diariamente, mantendo 14 dias). Confirme o que o seu servidor faz e substitua este parágrafo pelo número.",
+  "privacy.storage.title": "O que está armazenado no seu navegador",
+  "privacy.storage.p1": "O site usa localStorage para exatamente duas coisas, ambas permanecem no seu dispositivo e nunca são enviadas para lugar nenhum:",
+  "privacy.storage.li1": "Um cache de metadados de perfil Nostr (eventos tipo 0: nomes, avatares, endereços NIP-05) para os revisores cujas avaliações você leu. Isso evita novas consultas de retransmissões em todas as páginas. As entradas expiram e o cache é limitado e removido primeiro.",
+  "privacy.storage.li2": "Preferências de interface, para que o site se comporte da mesma maneira na próxima vez.",
+  "privacy.storage.p2": "Limpar os dados do site do seu navegador remove ambos. Nada quebra, as pesquisas de perfil são executadas novamente.",
+  "privacy.thirdParties.title": "Com o que seu navegador fala",
+  "privacy.thirdParties.p1": "Carregar uma página conecta seu navegador a alguns lugares além deste site. É assim que um site sem rastreamento no servidor ainda lê dados ativos:",
+  "privacy.thirdParties.li1Label": "Relés públicos Nostr",
+  "privacy.thirdParties.li1": "{strong}, sobre WebSocket, para ler avaliações e perfis de revisores. O relé vê seu IP e o que você solicitou, como qualquer servidor ao qual você se conecta. Os relés estão listados no {link}.",
+  "privacy.thirdParties.li1Link": "sobre a página",
+  "privacy.thirdParties.li2Label": "Imagens de avatar do revisor",
+  "privacy.thirdParties.li2": "{strong}, carregado de onde o perfil do revisor apontar. Eles são enviados com uma política de não referência, para que o host não saiba em qual página você estava.",
+  "privacy.publishing.title": "Publicando uma revisão",
+  "privacy.publishing.p1": "Escrever um comentário acontece no seu navegador, não no nosso servidor. O evento é assinado pela sua extensão NIP-07 (Alby, nos2x ou similar) e transmitido do seu navegador direto para os relés. Sua chave privada nunca sai da extensão e este site nunca a vê. Não criamos gerenciamento de chaves personalizado e nunca solicitamos uma chave ou frase-semente.",
+  "privacy.permanent.title": "Qualquer coisa que você publicar no Nostr é pública e permanente",
+  "privacy.permanent.p1": "Esta é a parte que vale a pena ler duas vezes. Uma revisão é um evento assinado em retransmissões públicas. Uma vez lançado, está fora:",
+  "privacy.permanent.li1": "Qualquer pessoa pode lê-lo, agora e posteriormente, usando qualquer cliente Nostr. Não é “público em Cashumints.space”, é público na rede.",
+  "privacy.permanent.li2": "Ele está permanentemente vinculado à sua chave pública Nostr, juntamente com tudo o mais que essa chave já publicou.",
+  "privacy.permanent.li3": "Excluí-lo é uma solicitação, não um comando. Você pode publicar um evento de exclusão e alguns retransmissores irão honrá-lo, mas um retransmissor é livre para ignorá-lo e qualquer pessoa que já copiou o evento ainda o possui. Trate uma revisão publicada como permanente.",
+  "privacy.permanent.li4": "Não podemos excluí-lo para você. Podemos parar de exibi-lo aqui; isso não muda nada nos relés.",
+  "privacy.permanent.p2": "Se você quiser revisar um mint sem que ele esteja vinculado à sua identidade principal, use uma chave Nostr separada. Observe que uma chave sem nenhuma outra atividade é mostrada como tal em avaliações severas, porque uma chave totalmente nova escrevendo uma avaliação de uma estrela é um padrão que os leitores merecem ver.",
+  "privacy.contact.title": "Questões",
+  "privacy.contact.p1": "O site é open source: se quiser verificar alguma das opções acima, leia o código em {github}. Perguntas e correções podem entrar em um problema lá.",
+  "disclaimer.title": "Isenção de responsabilidade · Cashumints.space",
+  "disclaimer.description": "O que saber antes de usar um Cashu mint: mints são de custódia, um mint pode desaparecer com seu dinheiro, avaliações são opiniões e meios online acessíveis, não confiáveis.",
+  "disclaimer.heading": "Isenção de responsabilidade",
+  "disclaimer.lede": "Leia isto antes de colocar dinheiro em um mint. Última atualização {date}.",
+  "disclaimer.callout": "Um Cashu mint guarda seu dinheiro para você. Se desaparecer, seu ecash desapareceu e não há ninguém a quem recorrer. Guarde apenas o que você pode perder.",
+  "disclaimer.custodial.title": "Mints são de custódia",
+  "disclaimer.custodial.p1": "Ao mint ecash, você entrega bitcoin ao operador mint e recebe os tokens de volta. Esses tokens são uma reivindicação desse operador. Eles não são bitcoin que você possui, e o operador é quem decide se os honrará.",
+  "disclaimer.custodial.p2": "Isso significa que cada mint acarreta os mesmos riscos: o operador pode desaparecer, pode ser obrigado a parar, pode perder os fundos devido a um bug ou hack, ou pode simplesmente desligar o servidor. Não há seguro de depósito, nenhum estorno, nenhuma linha de suporte e nenhum recurso legal com o qual valha a pena contar. Isso se aplica ao mint com melhor classificação neste site.",
+  "disclaimer.custodial.p3": "Cashu foi projetado para pequenas quantidades que se movem rapidamente. Use dessa forma: guarde o que você está prestes a gastar, não suas economias, e distribua por mints em vez de estacionar tudo em um.",
+  "disclaimer.reviews.title": "Avaliações são opiniões, não afirmações verificadas",
+  "disclaimer.reviews.p1": "Cada comentário aqui foi escrito por alguém no Nostr e assinado com sua chave. Assinado significa que podemos dizer qual chave o escreveu. Isso não significa que a avaliação seja verdadeira, que o autor usou o mint, ou que o autor não seja o operador, um concorrente ou uma pessoa com dez chaves.",
+  "disclaimer.reviews.p2": "Não verificamos revisores e não editamos ou removemos avaliações das quais discordamos. Leia alguns, veja o que eles realmente dizem e avalie um mint com três avaliações diferentemente de um com trezentos.",
+  "disclaimer.status.title": "Online significa acessível, não confiável",
+  "disclaimer.status.p1": "Verificamos cada mint regularmente e mostramos se ele respondeu. Isso é tudo que um status verde significa: o servidor respondeu. Não diz nada sobre se o operador é solvente, honesto ou ainda pretende honrar seus tokens amanhã.",
+  "disclaimer.status.p2": "Um mint pode estar online até o momento em que não está. O histórico de tempo de atividade, o NUTs compatível e a versão do software informam algo sobre como um mint é executado, mas nenhum deles é uma promessa sobre o seu dinheiro.",
+  "disclaimer.ranking.title": "Como funciona a classificação e o que isso não significa",
+  "disclaimer.ranking.p1": "Mints são ordenados por um algoritmo sobre dados de avaliações públicas: classificação, número de avaliações e atividades recentes, com mints online à frente dos offline por padrão. Os detalhes estão no código-fonte aberto.",
+  "disclaimer.ranking.p2": "Ninguém paga pela colocação. Não há slot patrocinado, listagem promovida e nenhum acordo com qualquer mint neste site. Uma classificação alta significa que o algoritmo gostou dos dados públicos e nada mais. Não é uma recomendação e não é uma classificação de segurança.",
+  "disclaimer.notAdvice.title": "Este não é um conselho financeiro",
+  "disclaimer.notAdvice.p1": "Nada neste site representa aconselhamento financeiro, de investimento, jurídico ou fiscal. Não conhecemos a sua situação e não o estamos aconselhando. Usar um mint e escolher qual deles é uma decisão sua.",
+  "disclaimer.dyor.title": "Faça sua própria pesquisa",
+  "disclaimer.dyor.li1": "Procure a operadora. Um mint executado por alguém com uma reputação pública a perder é uma proposta diferente de um URL anônimo.",
+  "disclaimer.dyor.li2": "Leia os próprios termos do mint e seu MOTD. Um mint que se autodenomina teste ou beta significa isso.",
+  "disclaimer.dyor.li3": "Comece pequeno. Mint um pouco, gaste, derreta e veja o que acontece antes de confiar mais nele.",
+  "disclaimer.dyor.li4": "Cuidado com os limites. Um máximo baixo costuma ser sinal de um operador cuidadoso, e um máximo alto não é sinal de um operador seguro.",
+  "disclaimer.dyor.li5": "Mantenha um backup de seus tokens e lembre-se de que um token é um ativo ao portador: quem o possui pode gastá-lo.",
+  "disclaimer.site.title": "Sobre o próprio site",
+  "disclaimer.site.p1": "Os dados aqui podem estar errados ou desatualizados. Mints são sondados de acordo com uma programação, os relés às vezes não respondem e uma página que você está lendo foi criada em algum momento no passado. O site é fornecido como está, sem garantia. Veja o {link}.",
+  "disclaimer.site.link": "termos de uso",
+  "disclaimer.updated": "20 de agosto de 2026",
+  "login.getPrimal": "Obtenha Primal",
+  "reviews.dialog.identity.extensionGone": "A extensão do seu navegador não está respondendo. Faça login novamente ou use um signatário remoto.",
+  "seo.orgDescription": "Um diretório de Cashu mints, com status ao vivo de cada mint e avaliações da comunidade assinadas em Nostr.",
+  "seo.ogImageAlt": "Cashumints.space: encontre um Cashu mint em que você possa confiar.",
+  "seo.mint.title.one": "Avaliações de {name}: avaliado como {rating} da análise de {n} | Cashumints.space",
+  "seo.mint.title.other": "Avaliações de {name}: avaliado como {rating} de avaliações de {n} | Cashumints.space",
+  "seo.mint.titleOffline.one": "{name}: off-line para o dia {n} | Cashumints.space",
+  "seo.mint.titleOffline.other": "{name}: off-line por dias {n} | Cashumints.space",
+  "seo.mint.titleNoReviews": "{name}: Cashu mint informações e comentários | Cashumints.space",
+  "seo.fedimint.titleNoReviews": "{name}: informações e análises da federação Fedimint | Cashumints.space",
+  "seo.desc.fallback": "Avaliações da comunidade para {name} ({domain}).",
+  "seo.desc.fallbackDomain": "Avaliações da comunidade para Cashu mint em {domain}.",
+  "seo.desc.rated.one": "Classificado como {rating}/5 de {n} assinado revisão Nostr.",
+  "seo.desc.rated.other": "Classificado como {rating}/5 de {n} com avaliações Nostr assinadas.",
+  "seo.desc.noReviews": "Ainda não há comentários.",
+  "seo.desc.status": "{status}.",
+  "seo.desc.statusLimits": "{status}, limita {limits}.",
+  "seo.desc.fedModules": "{status}. Módulos: {modules}.",
+  "seo.desc.fedModulesNetwork": "{status}. Módulos: {modules} em {network}.",
+  "seo.mint.ogAlt.one": "{name}: {rating} estrelas da análise de {n} em Cashumints.space",
+  "seo.mint.ogAlt.other": "{name}: {rating} estrelas de comentários de {n} em Cashumints.space",
+  "seo.mint.ogAltNoReviews": "{name} em Cashumints.space",
+  "nav.home": "Início",
+  "mint.more.title": "Mais mints",
+  "mint.more.all": "Ver todos os mints",
+  "nav.fedimints": "Fedimints",
+  "status.announced": "Anunciado apenas",
+  "card.unnamedFederation": "Federação sem nome",
+  "card.notChecked": "nunca verifiquei",
+  "fedimints.title": "Todas as federações Fedimint · Cashumints.space",
+  "fedimints.description": "Todas as federações {total} Fedimint anunciadas na rede Nostr: {online} confirmada em execução por uma verificação externa, {announced} anunciada e nunca confirmada. Avaliações da comunidade, módulos e códigos de convite para cada um.",
+  "fedimints.heading": "Todas as federações",
+  "fedimints.lede": "Cada federação Fedimint anunciada na rede Nostr. Uma federação não possui um endpoint de status público próprio, portanto, alguns deles são confirmados por uma verificação externa e o restante é listado exatamente como foi anunciado.",
+  "fedimints.search.label": "Pesquise federações por nome ou ID",
+  "fedimints.search.placeholder": "Pesquise por nome ou ID da federação…",
+  "fedimints.sort.label": "Classificar federações",
+  "fedimints.hideOffline": "Ocultar off-line",
+  "fedimints.showing": "Mostrando federações {total} ({online} confirmada, apenas {announced} anunciada)",
+  "fedimints.showingFiltered": "Mostrando {shown} de federações {total} ({online} confirmado, {announced} anunciado apenas)",
+  "fedimints.announcedNote.one": "Um deles foi anunciado no Nostr e nada foi confirmado desde que está em execução. Está listado como anunciado e não como online ou offline, porque nada disso seria verdade.",
+  "fedimints.announcedNote.other": "{n} deles foram anunciados em Nostr e nada foi confirmado desde então que eles estão em execução. Eles são listados como anunciados e não como online ou offline, porque nada disso seria verdade.",
+  "fedimints.noResults": "Nenhuma federação corresponde. Experimente um nome ou cole um ID de federação.",
+  "fedimints.emptyIndex": "Nenhuma federação foi anunciada nos revezamentos que este site lê. A lista se enche à medida que chegam os anúncios.",
+  "fedimint.crumb": "Fedimints",
+  "fedimint.breadcrumb": "Pão ralado",
+  "fedimint.unnamed": "Federação sem nome",
+  "fedimint.idLabel": "Federação",
+  "fedimint.kind.federationId": "ID da federação",
+  "fedimint.moduleCount.one": "Módulo {n}",
+  "fedimint.moduleCount.other": "Módulos {n}",
+  "fedimint.copyInvite": "Copiar código de convite",
+  "fedimint.confirmed.label": "Confirmado",
+  "fedimint.confirmed.never": "Nunca",
+  "fedimint.confirmed.by": "por {source}",
+  "fedimint.confirmed.unattributed": "última verificação",
+  "fedimint.announcedOn": "anunciou {when}",
+  "fedimint.announcedUnknown": "sem data de anúncio",
+  "fedimint.modules.title": "Módulos",
+  "fedimint.modules.none": "O anúncio desta federação não lista nenhum módulo.",
+  "fedimint.modules.note": "Módulos são as partes que uma federação administra. O anúncio diz quais estão presentes e nada sobre se algum deles está aceitando depósitos.",
+  "fedimint.modules.notListed": "não listado",
+  "fedimint.invite.title": "Código de convite",
+  "fedimint.invite.count.one": "Código {n}",
+  "fedimint.invite.count.other": "Códigos {n}",
+  "fedimint.invite.note": "Cole isso em uma carteira Fedimint para ingressar. Ele carrega o ID da federação e os endereços de seus responsáveis ​​e deve ser compartilhado.",
+  "fedimint.invite.kind": "código de convite",
+  "fedimint.invite.qr": "QR",
+  "fedimint.invite.qrCaption": "Digitalize para ingressar no {name}",
+  "fedimint.details.federationId": "ID da federação",
+  "fedimint.details.network": "Rede",
+  "fedimint.details.announcedBy": "Anunciado por",
+  "fedimint.details.announced": "Anunciado",
+  "fedimint.more.title": "Mais federações",
+  "fedimint.more.all": "Ver todas as federações",
+  "fedimint.disclaimer": "Participar de uma federação significa confiar seu dinheiro aos seus guardiões. As classificações são opiniões da comunidade e a execução confirmada significa alcançável, não confiável.",
+  "fedimint.module.lightning": "Lightning",
+  "fedimint.module.mint": "Ecash mint",
+  "fedimint.module.wallet": "Carteira na rede",
+  "fedimint.module.meta": "Metadados",
+  "fedimint.module.stability_pool": "Piscina de estabilidade",
+  "fedimint.module.multi_sig_stability_pool": "Pool de estabilidade (multisig)",
+  "fedimint.module.fedi-social": "Recuperação social",
+  "fedimint.network.mainnet": "Rede principal Bitcoin",
+  "fedimint.network.signet": "Signet",
+  "fedimint.network.testnet": "Testnet",
+  "fedimint.network.testnet4": "Testnet4",
+  "fedimint.network.regtest": "Regtest",
+  "feed.ecosystem.group": "Ecossistema",
+  "feed.ecosystem.all": "Todos",
+  "feed.ecosystem.cashu": "Cashu",
+  "feed.ecosystem.fedimint": "Fedimint",
+  "feed.filterBySubject": "Filtrar por mint ou federação",
+  "feed.anySubject": "Qualquer mint ou federação",
+  "feed.clearSubject": "Limpe o filtro de nome",
+  "home.topFedimints.title": "Principais Fedimints",
+  "home.topFedimints.sub": "classificado por comentários e classificação",
+  "home.topFedimints.all": "Todas as federações {n} →",
+  "reviews.validate.subject": "Não há nada para apontar esta revisão.",
+  "mint.warnings.fedimintOffline.lead": "Relatado off-line.",
+  "mint.warnings.fedimintOffline.body.since": "A última verificação que chegou a esta federação foi em {date} ({days} atrás). Seus guardiões não responderam desde então. Trate os fundos ali mantidos como de risco e não os junte a novos fundos.",
+  "mint.warnings.fedimintOffline.body.never": "Nenhuma verificação desta federação chegou até lá, e a mais recente falhou. Trate os fundos ali mantidos como de risco e não os junte a novos fundos.",
+  "mint.warnings.fedimintOffline.meta.since": "Relatado off-line desde {date}",
+  "mint.warnings.fedimintOffline.meta.never": "Relatado off-line, nunca alcançado",
+  "mint.warnings.neverConfirmed.lead": "Anunciado, nunca confirmado.",
+  "mint.warnings.neverConfirmed.body.reviewed": "Esta federação foi anunciada em Nostr em {date}, {days} atrás, e nada foi confirmado desde então que ela está funcionando. Os comentários abaixo são o único sinal de vida nesta página; todo o resto veio do anúncio.",
+  "mint.warnings.neverConfirmed.body.quiet": "Esta federação foi anunciada em Nostr em {date}, {days} atrás, nada foi confirmado desde então que ela está funcionando e ninguém a revisou recentemente. Tudo abaixo veio do anúncio.",
+  "mint.warnings.neverConfirmed.meta": "Anunciado {date}, nunca confirmado",
+  "footer.allFedimints": "Todas as federações",
+  "reviews.dialog.bodyPlaceholder.cashu": "Como funcionou minting, melting e suporte? Seja específico.",
+  "reviews.dialog.bodyPlaceholder.fedimint": "Como funcionou a adesão, os pagamentos e o suporte do Lightning? Seja específico.",
+  "fedimint.details.title": "Detalhes da federação",
+  "nav.lnurlMints": "Mints LNURL",
+  "footer.allLnurlMints": "Todos os mints LNURL",
+  "lnurlMints.title": "Mints LNURL: mints de notas ao portador lnurlcash, avaliados | Cashumints.space",
+  "lnurlMints.description": "Todos os {total} mints LNURL indexados da rede Nostr: {online} on-line, {offline} off-line. Avaliações da comunidade, limites de saque e recursos de cada um.",
+  "lnurlMints.heading": "Mints LNURL",
+  "lnurlMints.lede": "Todos os mints LNURL que este site conhece. Um mint LNURL emite notas ao portador lnurlcash: notas Lightning que você guarda como um segredo e que podem ser rotacionadas, divididas, mescladas ou derretidas de volta em um pagamento Lightning. Cada um é verificado por HTTPS a cada poucos minutos.",
+  "lnurlMints.search.label": "Pesquisar mints LNURL",
+  "lnurlMints.search.placeholder": "Pesquisar por nome ou endereço…",
+  "lnurlMints.sort.label": "Ordenar mints LNURL por",
+  "lnurlMints.hideOffline": "Ocultar off-line",
+  "lnurlMints.showing": "Mostrando {total} mints LNURL ({online} on-line, {offline} off-line)",
+  "lnurlMints.showingFiltered": "Mostrando {shown} de {total} mints LNURL ({online} on-line, {offline} off-line)",
+  "lnurlMints.noResults": "Nenhum mint LNURL corresponde a isso.",
+  "lnurlMints.emptyIndex": "Ainda não há mints LNURL indexados.",
+  "lnurl.crumb": "Mints LNURL",
+  "lnurl.breadcrumb": "Trilha de navegação",
+  "lnurl.copyAddress": "Copiar endereço",
+  "lnurl.more.title": "Mais mints LNURL",
+  "lnurl.more.all": "Todos os mints LNURL →",
+  "lnurl.disclaimer": "Um mint LNURL guarda seus sats enquanto você guarda as notas dele, então usá-lo significa confiar em seu operador. As avaliações são opiniões da comunidade, e on-line significa acessível, não confiável.",
+  "lnurl.features.title": "Recursos",
+  "lnurl.features.none": "Este mint não anunciou o que oferece.",
+  "lnurl.features.note": "Os recursos são o que o operador do mint anunciou no Nostr. Quando este site consegue verificar algum por HTTPS, ele o faz, e avisa quando algo anunciado não está disponível no momento.",
+  "lnurl.features.notListed": "não anunciado",
+  "lnurl.features.unavailable": "indisponível",
+  "lnurl.feature.mint": "Minting via Lightning (LUD-06)",
+  "lnurl.feature.melt": "Melting para Lightning",
+  "lnurl.feature.notes": "Rotacionar / dividir / mesclar notas",
+  "lnurl.feature.lud16": "Endereço Lightning",
+  "lnurl.feature.lud21": "Verificação de pagamento (LUD-21)",
+  "lnurl.feature.signed-notes": "Notas assinadas (verificação off-line)",
+  "lnurl.feature.onion": "Endereço Tor",
+  "lnurl.feature.rotate": "Rotacionar uma nota",
+  "lnurl.feature.split": "Dividir uma nota",
+  "lnurl.feature.merge": "Mesclar notas",
+  "lnurl.feature.lud06": "payRequest LUD-06",
+  "lnurl.feature.lud03": "withdrawRequest LUD-03",
+  "lnurl.limits.label": "Limites de saque",
+  "lnurl.limits.notPublished": "não publicado",
+  "lnurl.limits.withdrawRow": "Saque",
+  "lnurl.limits.disabled": "desativado",
+  "lnurl.limits.sats.one": "{n} sat",
+  "lnurl.limits.sats.other": "{n} sats",
+  "lnurl.details.title": "Detalhes do mint",
+  "lnurl.details.address": "Endereço Lightning",
+  "lnurl.details.mintPubkey": "Chave pública do mint",
+  "lnurl.details.onion": "Endereço Tor",
+  "lnurl.details.fee": "Taxa de minting",
+  "lnurl.details.node": "Nó",
+  "lnurl.details.capacity": "Capacidade anunciada",
+  "lnurl.kind.lightningAddress": "endereço Lightning",
+  "lnurl.kind.mintPubkey": "chave pública do mint",
+  "lnurl.kind.onionAddress": "endereço Tor",
+  "lnurl.confirmed.label": "Última confirmação",
+  "lnurl.confirmed.when": "confirmado {when}",
+  "lnurl.fee.base.one": "{n} sat",
+  "lnurl.fee.base.other": "{n} sats",
+  "lnurl.fee.percent": "{percent}%",
+  "home.topLnurl.title": "Melhores mints LNURL",
+  "home.topLnurl.sub": "classificados por avaliações e nota",
+  "home.topLnurl.all": "Todos os {n} mints LNURL →",
+  "feed.ecosystem.lnurl": "LNURL",
+  "reviews.dialog.bodyPlaceholder.lnurl": "Como foram o minting, o melting e a rotação de notas? Seja específico.",
+  "reviews.byUrl.open": "Escrever uma avaliação",
+  "reviews.byUrl.title": "Escrever uma avaliação",
+  "reviews.byUrl.lede": "Cola o endereço. Se este site ainda não o conhece, ele é verificado e adicionado agora.",
+  "reviews.byUrl.label.cashu": "URL do mint",
+  "reviews.byUrl.label.fedimint": "Código de convite da federação",
+  "reviews.byUrl.label.lnurl": "URL do mint LNURL",
+  "reviews.byUrl.placeholder.cashu": "mint.example.com",
+  "reviews.byUrl.placeholder.fedimint": "fed11…",
+  "reviews.byUrl.placeholder.lnurl": "mint.example.com",
+  "reviews.byUrl.check": "Verificar este endereço",
+  "reviews.byUrl.checking": "A verificar…",
+  "reviews.byUrl.back": "Usar outro endereço",
+  "reviews.byUrl.existing": "Já está listado",
+  "reviews.byUrl.indexed": "Acabado de adicionar",
+  "reviews.byUrl.confirmClose": "Fechar? O endereço que escreveste não é guardado.",
+  "reviews.byUrl.detected": "Esse endereço respondeu como um mint {kind}.",
+  "reviews.byUrl.switchTo": "Avaliá-lo como mint {kind}",
+  "reviews.byUrl.error.empty": "Escreve primeiro um endereço.",
+  "reviews.byUrl.error.badUrl": "Isso não parece o URL de um mint.",
+  "reviews.byUrl.error.badInvite": "Isso não é um código de convite Fedimint. Os códigos começam por fed11.",
+  "reviews.byUrl.error.badInput": "Este site não consegue verificar esse endereço.",
+  "reviews.byUrl.error.blocked": "Esse não é um endereço público, por isso não pode ser verificado.",
+  "reviews.byUrl.error.notAMint": "Esse endereço respondeu, mas não como um mint deste tipo.",
+  "reviews.byUrl.error.wrongType": "Esse endereço respondeu, mas como um mint de outro tipo.",
+  "reviews.byUrl.error.unverifiable": "Nada respondeu nesse endereço, e ainda não há qualquer rasto dele no Nostr.",
+  "reviews.byUrl.error.rateLimited.one": "São muitas verificações a partir de uma só ligação. Tenta de novo daqui a cerca de {n} minuto.",
+  "reviews.byUrl.error.rateLimited.other": "São muitas verificações a partir de uma só ligação. Tenta de novo daqui a cerca de {n} minutos.",
+  "reviews.byUrl.error.network": "Não foi possível contactar o índice. Verifica a tua ligação e tenta de novo.",
+  "seo.lnurl.titleNoReviews": "{name}: informações e avaliações do mint LNURL | Cashumints.space",
+  "seo.desc.statusWithdraw": "{status}, saque de {min}–{max} sat.",
+  "mint.chip.noFunding": "Sem mint / melt",
+  "mint.warnings.lnurlWithdrawalsDisabled.lead": "Saques desativados.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.online": "Este mint anuncia um saque máximo de zero, então nenhuma nota que ele emite pode ser resgatada por nada. Não faça minting aqui até que isso mude.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.offline": "Este mint anunciava um saque máximo de zero no último contato, então nenhuma nota que ele emitia podia ser resgatada por nada. Não faça minting aqui até que isso mude.",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.online": "Saques desativados no momento",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.offline": "Os saques estavam desativados no último contato",
+  "mint.warnings.lnurlInvalid.lead": "O endpoint responde, mas é inválido.",
+  "mint.warnings.lnurlInvalid.body": "O host responde, mas não com um anúncio de mint que este site consiga ler, então os saques podem não funcionar. O que está abaixo é o último estado legível, e as avaliações continuam funcionando.",
+  "mint.warnings.lnurlInvalid.meta": "Responde, mas não com um anúncio de mint válido",
+  "mint.warnings.lnurlNoFunding.lead": "Minting e melting indisponíveis.",
+  "mint.warnings.lnurlNoFunding.body": "As notas existentes ainda podem ser rotacionadas, divididas ou mescladas, mas nada entra nem sai via Lightning no momento. O mint em si está no ar e respondendo; o nó Lightning por trás dele não está acessível a partir dali.",
+  "mint.warnings.lnurlNoFunding.meta": "Minting e melting indisponíveis",
+  "mint.warnings.also.noFunding": "O nó Lightning também estava inacessível, então nada podia ser mintado ou derretido."
+}

web/src/i18n/ro.json

@@ -0,0 +1,811 @@
+{
+  "site.name": "Cashumints.space",
+  "common.close": "Închide",
+  "common.cancel": "Anulează",
+  "common.done": "Gata",
+  "common.back": "Înapoi",
+  "common.retry": "Încearcă din nou",
+  "common.connect": "Conectează",
+  "common.copied": "Copiat",
+  "common.copyFull": "Copiază complet{kind}",
+  "common.previousPage": "Pagina anterioară",
+  "common.nextPage": "Pagina următoare",
+  "common.reviewPages": "Pagini recapitulative",
+  "time.never": "niciodată",
+  "time.justNow": "chiar acum",
+  "time.none": "-",
+  "time.unknownDate": "o dată necunoscută",
+  "time.ago.minute": "{n} acum un an",
+  "time.ago.hour": "{n} Acum câteva ore.",
+  "time.ago.day": "{n} Acum ceva timp",
+  "time.ago.week": "{n} Acum ceva timp",
+  "time.ago.month": "{n} acum două luni",
+  "time.ago.year": "{n}Da.",
+  "time.short.minute": "{n}m",
+  "time.short.hour": "{n}h",
+  "time.short.day": "{n}d",
+  "time.short.week": "{n}w",
+  "time.short.month": "{n}mo",
+  "time.short.year": "{n}Da.",
+  "status.online": "Online",
+  "status.offline": "Offline",
+  "status.degraded": "De negăsit",
+  "status.unknown": "Încă nu s-a verificat.",
+  "nav.skip": "Sari la conținut",
+  "nav.main": "Principal",
+  "nav.mints": "Mint-uri Cashu",
+  "nav.reviews": "Recenzii",
+  "nav.wallets": "Portofele",
+  "nav.about": "Despre",
+  "nav.searchMints": "Caută printre {n} mint-uri",
+  "lang.label": "Limbă",
+  "lang.switcher": "Alege o limbă",
+  "footer.copyright": "© {year} Cashumints.space",
+  "footer.allMints": "Toate mint-urile Cashu",
+  "footer.allReviews": "Toate recenziile",
+  "footer.wallets": "Portofele",
+  "footer.about": "Despre",
+  "footer.disclaimer": "Declinarea responsabilității",
+  "footer.terms": "Termeni",
+  "footer.privacy": "Confidenţialitatea",
+  "footer.madeBy": "Făcut cu ❤️ de {azzamo} · Susținut de Cashu și NIP-87",
+  "footer.warning": "Mint-urile sunt custodiale. Un mint poate dispărea cu banii tăi.",
+  "footer.tagline": "Recenzii ale comunității pentru mint-urile ecash, semnate pe Nostr.",
+  "footer.col.explore": "Explorează",
+  "footer.col.site": "Site",
+  "footer.nav": "Subsol",
+  "home.title": "Cashumints.space · Găsește un mint Cashu în care poți avea încredere",
+  "home.description": "Găsește un mint Cashu în care poți avea încredere. {mints} mint-uri indexate, cu {reviews} recenzii ale comunității semnate pe Nostr, plus disponibilitate în timp real, NUT-uri acceptate și software-ul mintului.",
+  "home.hero.title": "Găsește un mint Cashu",
+  "home.hero.titleEm": "Poţi avea încredere în tine.",
+  "home.hero.lede": "Fiecare monetărie de pe reţeaua Nostr, cu comentarii comunitare reale, fără paznici, doar recenzii semnate pe care le puteţi verifica.",
+  "home.search.label": "Caută monetării după nume, domeniu sau URL",
+  "home.search.placeholder": "Caută după nume, domeniu, sau lipește un URL monetărie...",
+  "home.filters.mostReviewed": "Cele mai revizuite",
+  "home.filters.highestRated": "Cel mai înalt rating",
+  "home.filters.recentlyActive": "Active recente",
+  "home.filters.websockets": "Suportă WebSockets",
+  "home.top.title": "Top Cashu monetării",
+  "home.top.sub": "clasificate în funcție de evaluări și de rating",
+  "home.top.all": "Toate{n}Monetari →",
+  "home.latest.title": "Ultimele recenzii",
+  "home.latest.sub": "live din rețeaua Nostr",
+  "home.latest.prev": "Recenzii anterioare",
+  "home.latest.next": "Mai multe comentarii",
+  "home.latest.all": "Toate recenziile →",
+  "home.latest.empty": "Nu s-au putut citi recenzii de la relee doar acum. Deschide orice pagină monetărie pentru a citi și scrie recenzii direct.",
+  "home.why.title": "De ce ai încredere în aceste recenzii?",
+  "home.why.signed.title": "Semnat, neprezentat",
+  "home.why.signed.body": "Fiecare recenzie este o{link} eveniment semnat de tasta Nostr autorului său. Nimic aici nu este editat, clasat, sau eliminat de noi.",
+  "home.why.signed.link": "NIP- 87",
+  "home.why.verify.title": "Verifică-l singur.",
+  "home.why.verify.body": "Recenzii live pe relee publice Nostr, nu baza noastră de date. Punctul orice client la aceleași relee și veți vedea aceleași date.",
+  "home.why.checked.title": "Verificat continuu",
+  "home.why.checked.body": "Sondăm fiecare monetărie pentru uptime, versiunea software, limite și NUT-uri susținute, astfel încât specificațiile pe care le vedeți sunt actuale, nu auto-raportate.",
+  "home.cta.title": "Te gândeşti la o monetărie?",
+  "home.cta.body": "O monetărie îţi ţine ecash-ul. Citiţi ce au găsit alţii înainte de a pune sat-uri, şi lăsaţi o recenzie după ce aţi folosit unul singur.",
+  "home.cta.explore": "Explorează toate monetării",
+  "home.cta.learn": "Aflaţi despre Cashu",
+  "pulse.mintsIndexed": "Monetări indexate",
+  "pulse.reviewsOnNostr": "recenzii cu privire la Nostr",
+  "pulse.lastReview": "ultima reexaminare",
+  "pulse.mintsOnline": "Monetări online",
+  "pulse.indexer": "indexator",
+  "pulse.connected": "conectată",
+  "pulse.stale": "vechi",
+  "mints.title": "All Cashu monetării · Cashumints.space",
+  "mints.description": "Toate{total}Cashu monetării indexate din rețeaua Nostr;{online}online și{offline}Offline, cu evaluări comunitare, uptime și software-ul monetărie. Caută și sortează lista completă.",
+  "mints.heading": "Toate mint-urile Cashu",
+  "mints.lede": "Fiecare monetărie descoperită pe rețeaua Nostr, inclusiv cele care au dispărut. Offline monetării se află pe listă, astfel încât să puteți găsi și să le revizuiască.",
+  "mints.search.label": "Caută după nume sau domeniu",
+  "mints.search.placeholder": "Caută după nume sau domeniu...",
+  "mints.sort.label": "Sortare monetării",
+  "mints.sort.score": "Cel mai bun ansamblu",
+  "mints.sort.rating": "Cel mai înalt rating",
+  "mints.sort.reviews": "Cele mai revizuite",
+  "mints.sort.recent": "Recent revăzut",
+  "mints.sort.seen": "Recent văzut online",
+  "mints.hideOffline": "Ascundeți offline",
+  "mints.showing": "Afişare{total}dna MUNTĂRII ({online}online;{offline}Offline)",
+  "mints.showingFiltered": "Afişare{shown} din{total}dna MUNTĂRII ({online}online;{offline}Offline)",
+  "mints.noResults": "Nicio monetărie nu corespunde. Încearcă un domeniu sau lipește URL-ul unei monetării.",
+  "mints.clearSearch": "Eliberează căutarea.",
+  "card.noRatings": "Nu există ratinguri încă",
+  "card.reviews.one": "{n} reexaminare",
+  "card.reviews.other": "{n} reexaminări",
+  "card.reviews.few": "{n} reexaminări",
+  "card.lastSeen": "ultima dată văzut{when}",
+  "card.neverSeen": "nu a fost văzut niciodată online",
+  "card.reviewed": "revăzut{when}",
+  "card.noReviews": "nu există comentarii încă",
+  "mint.title": "{name}· Cashu monetărie recenzii",
+  "mint.titleFedimint": "{name} · Recenzii ale federației Fedimint",
+  "mint.titleLnurl": "{name} · Recenzii ale mintului LNURL",
+  "mint.breadcrumb": "Cremă de pâine",
+  "mint.crumbMints": "Caju muntetării",
+  "mint.copyUrl": "Copiază URL- ul monetărie",
+  "mint.qrButton": "monetărie QR",
+  "mint.writeReview": "Scrie un comentariu",
+  "mint.rankByScore": "#{rank} după scor",
+  "mint.tagLightning": "Fulger",
+  "mint.summary": "rezumat al monetăriei",
+  "mint.rating.label": "Evaluarea comunitară",
+  "mint.rating.none": "Nu există ratinguri încă",
+  "mint.rating.reviews.one": "{n} reexaminare",
+  "mint.rating.reviews.other": "{n} reexaminări",
+  "mint.rating.reviews.few": "{n} reexaminări",
+  "mint.rating.unrated.one": "{n} nu a lăsat niciun rating",
+  "mint.rating.unrated.other": "{n} nu a lăsat niciun rating",
+  "mint.rating.unrated.few": "{n} nu a lăsat niciun rating",
+  "mint.activity.label": "Activitate",
+  "mint.activity.since": "de la ultima reexaminare",
+  "mint.activity.noReviews": "nu există comentarii încă",
+  "mint.activity.recent.one": "{n} revizuire în ultimele 90 de zile",
+  "mint.activity.recent.other": "{n} comentarii în ultimele 90 de zile",
+  "mint.activity.recent.few": "{n} comentarii în ultimele 90 de zile",
+  "mint.limits.label": "Limite",
+  "mint.limits.notPublished": "nepublicat",
+  "mint.limits.min": "min",
+  "mint.limits.max": "max",
+  "mint.limits.mintRow": "emitere",
+  "mint.limits.meltRow": "retragere",
+  "mint.limits.disabled": "dezactivată",
+  "mint.limits.range": "{min}la{max}{unit}",
+  "mint.limits.upTo": "până la{max}{unit}",
+  "mint.limits.from": "de la{min}{unit}",
+  "mint.software.label": "software-ul monetărie",
+  "mint.software.unknown": "necunoscut",
+  "mint.checked": "verificat{when}",
+  "mint.lastSeen": "ultima dată văzut{when}",
+  "mint.neverReached": "nu a ajuns niciodată la",
+  "mint.uptime.checks": "{ok}a ultimei{total} controale accesibile",
+  "mint.uptime.percent": "{percent}% accesibil pe o perioadă de 30 zile",
+  "mint.uptime.description": "{ok}a ultimei{total} controale reușite",
+  "mint.operator.title": "De la operator",
+  "mint.operator.motd": "Mesajul zilei",
+  "mint.operator.beta": "Această monetărie se descrie ca fiind experimentală sau în beta. Citiți propriile cuvinte ale operatorului de mai jos înainte de a stoca orice nu puteți pierde.",
+  "mint.nuts.title": "NUS-uri susținute",
+  "mint.nuts.noneOffline": "Nici o listă NUT cached pentru această monetărie, a mers offline înainte de o a fost înregistrată.",
+  "mint.nuts.noneYet": "Nici o listă NUT cached pentru această monetărie încă.",
+  "mint.nuts.supported": "{n} din{total}TNU cunoscute acceptate",
+  "mint.nuts.whatAre": "Ce sunt NUT-urile?",
+  "mint.nutRow.disabled": "dezactivată",
+  "mint.nutRow.notSupported": "nesusţinut",
+  "mint.details.title": "Detalii privind modul de operare",
+  "mint.details.pubkey": "Cheie publică",
+  "mint.details.nostr": "Nostr",
+  "mint.details.email": "Email",
+  "mint.details.serverTime": "Timp server",
+  "mint.details.firstSeen": "Prima dată văzută.",
+  "mint.details.terms": "Termeni",
+  "mint.kind.identifier": "identificator",
+  "mint.kind.mintPubkey": "monetărie pubkey",
+  "mint.kind.nostrAddress": "Adresa Nostrului",
+  "mint.kind.emailAddress": "adresa de e-mail",
+  "mint.kind.npub": "npub",
+  "mint.disclaimer": "Această monetărie este custodia: deține banii, și se poate opri făcând acest lucru în orice moment. Ratingurile sunt opinii comunitare și mijloace online accesibile, nu de încredere.",
+  "mint.disclaimerLink": "Citeşte toată disclaimer",
+  "mint.qr.title": "Adaugă{name}la portofel",
+  "mint.qr.note": "Scanați acest lucru cu un portofel Cashu pentru a adăuga monetărie, sau copia URL-ul și lipiți-l în.",
+  "mint.qr.warn": "Adăugând un monetărie înseamnă încredere în ea cu banii.",
+  "mint.qr.whatMeans": "Ce înseamnă asta?",
+  "mint.qr.wallets": "Portofele care îl susţin pe Cashu.",
+  "mint.chip.frozen": "Congelate",
+  "mint.chip.noWithdrawals": "Fără retrageri",
+  "mint.chip.meltOnly": "Se topește numai",
+  "mint.warnings.dayCount.one": "{n} zi",
+  "mint.warnings.dayCount.other": "{n} zile",
+  "mint.warnings.dayCount.few": "{n} zile",
+  "mint.warnings.gone.lead": "Probabil că s-a dus.",
+  "mint.warnings.gone.body.since": "Această monetărie a fost de negăsit de atunci{date}({days}) Trataţi fondurile deţinute acolo ca fiind în pericol, şi nu trimiteţi fonduri noi. Detaliile de mai jos arată ultima sa stare cunoscută.",
+  "mint.warnings.gone.body.neverDated": "Această monetărie nu a răspuns nici măcar unui cec de când am început să-l vedem.{month}. Trataţi fondurile acolo ca fiind în pericol, şi nu trimiteţi fonduri noi. Orice de mai jos a venit din anunţul Nostr, nu din monetărie.",
+  "mint.warnings.gone.body.never": "Această monetărie nu a răspuns la niciun cec de când am început să-l urmărim. Trataţi fondurile deţinute acolo ca fiind în pericol şi nu trimiteţi fonduri noi. Tot ce este mai jos a venit din anunţul Nostr, nu din monetărie.",
+  "mint.warnings.gone.meta.since": "Offline deoarece{date}",
+  "mint.warnings.gone.meta.never": "Nu se poate ajunge de când a fost descoperită.",
+  "mint.warnings.meltDisabled.lead": "Retrageri dezactivate.",
+  "mint.warnings.meltDisabled.body.online": "Această monetărie are topirea fulgerului (NUT-05) oprit: puteți pune sat-uri în, dar nu le puteți retrage prin Lightning. Nu depuneți până când topirea este din nou.",
+  "mint.warnings.meltDisabled.body.offline": "Această monetărie a avut topirea fulgerului (NUT-05) oprită: puteți pune sat-uri în, dar nu le puteți retrage prin Lightning. Nu depuneți până când topirea este din nou.",
+  "mint.warnings.meltDisabled.meta.online": "Retragerile sunt în prezent dezactivate",
+  "mint.warnings.meltDisabled.meta.offline": "Retragerile au fost dezactivate când au fost observate ultima dată",
+  "mint.warnings.frozen.lead": "Monetărie congelată.",
+  "mint.warnings.frozen.body.online": "Atât menţinerea, cât şi topirea sunt dezactivate. Nici un sat nu poate intra sau ieşi prin Lightning.",
+  "mint.warnings.frozen.body.offline": "Atât menţinerea, cât şi topirea au fost dezactivate.",
+  "mint.warnings.frozen.meta.online": "În prezent îngheţat, nimic nu se mişcă sau iese",
+  "mint.warnings.frozen.meta.offline": "Îngheţat când l-am văzut ultima dată.",
+  "mint.warnings.offlineLong.lead": "Offline pentru{days}, din moment ce{date}.",
+  "mint.warnings.offlineLong.body": "Monetăria poate fi plecată. Tot ce este mai jos este ultimul său stat cunoscut, și recenzii încă funcționează.",
+  "mint.warnings.offlineLong.meta": "Offline deoarece{date}",
+  "mint.warnings.meltOnly.lead": "Doar topit.",
+  "mint.warnings.meltOnly.body.online": "Menting nou (NUT-04) este dezactivat: nu puteți depune, dar numerarul existent poate fi încă retras. Aceasta înseamnă adesea o monetărie este de lichidare în jos, așa că, dacă vă țineți cash-ul său, ia în considerare topirea.",
+  "mint.warnings.meltOnly.body.offline": "Menting nou (NUT-04) a fost dezactivat: nu puteți depune, dar numerarul existent poate fi încă retras. Acest lucru înseamnă de multe ori o monetărie este lichidare în jos, așa că, dacă vă țineți ecash-ul său, ia în considerare topirea.",
+  "mint.warnings.meltOnly.meta.online": "Doar în prezent se topesc",
+  "mint.warnings.meltOnly.meta.offline": "Se topeşte doar când l-am văzut ultima dată.",
+  "mint.warnings.offline.lead": "Offline deoarece{date}.",
+  "mint.warnings.offline.body": "Detaliile au fost confirmate ultima dată atunci.",
+  "mint.warnings.offline.meta": "Offline deoarece{date}",
+  "mint.warnings.also.meltDisabled": "Înainte de a merge offline, a avut, de asemenea, retrageri dezactivate.",
+  "mint.warnings.also.mintDisabled": "Înainte de a merge offline a avut, de asemenea, dezactivat noi menting.",
+  "mint.warnings.also.offline": "De asemenea, a fost offline de când{date}({days}).",
+  "nut.0": "Notație și modele",
+  "nut.1": "schimbul de chei publice",
+  "nut.2": "Cheile și taxele",
+  "nut.3": "Cu toate acestea, în cazul în care nu se aplică dispozițiile de la punctul 1 din anexa I la Regulamentul (CE) nr.",
+  "nut.4": "Emiterea prin Lightning",
+  "nut.5": "Retragerea prin Lightning",
+  "nut.6": "Informații legate de monetărie",
+  "nut.7": "Verificare stare jeton",
+  "nut.8": "Taxele plătite pentru fulgere excesive",
+  "nut.9": "Restabilește semnăturile",
+  "nut.10": "Condiții de cheltuieli",
+  "nut.11": "Plătiți cheii publice",
+  "nut.12": "Dovezi DLEQ",
+  "nut.13": "Secrete determinante",
+  "nut.14": "Contracte de tip timelock încheiate",
+  "nut.15": "Plăți multipatice",
+  "nut.16": "Coduri QR animate",
+  "nut.17": "Abonamente WebSocket",
+  "nut.18": "Cererile de plată",
+  "nut.19": "Răspunsurile cache",
+  "nut.20": "Citate de monetărie semnate",
+  "nut.21": "Autentificare clară",
+  "nut.22": "Autentificare oarbă",
+  "nut.23": "Metoda de plată BOLT11",
+  "nut.24": "HTTP 402 este necesară plata",
+  "nut.25": "Metoda de plată BOLT12",
+  "reviews.title": "Revizuiri",
+  "reviews.anon": "Anonim",
+  "reviews.anonTitle": "Nu s-a găsit niciun profil Nostrist public pentru această cheie.",
+  "reviews.nip05Title": "Identificatorul NIP-05 (neverificat de acest site)",
+  "reviews.filter.group": "Revizuiri privind filtrele",
+  "reviews.filter.all": "Toate",
+  "reviews.filter.five": "5",
+  "reviews.filter.critical": "Critică",
+  "reviews.filter.recent": "Recente",
+  "reviews.filter.hideAnon": "Ascunde anon",
+  "reviews.anonHidden.other": "Afişare{n} din{total} recenzii: Anon ascunse.",
+  "reviews.allAnon.one": "Singura recenzie aici este anon.",
+  "reviews.allAnon.other": "Toate{n} recenziile de aici sunt anon.",
+  "reviews.allAnon.few": "Toate{n} recenziile de aici sunt anon.",
+  "reviews.allAnonShow.one": "Arată-l.",
+  "reviews.allAnonShow.other": "Arată-le",
+  "reviews.allAnonShow.few": "Arată-le",
+  "reviews.loading.one": "Se încarcă{n} recenzie de la releele Nostr",
+  "reviews.loading.other": "Se încarcă{n} recenzii de la releele Nostr",
+  "reviews.loading.few": "Se încarcă{n} recenzii de la releele Nostr",
+  "reviews.empty": "Fii primul care scrie una.",
+  "reviews.emptyWritten": "Nu scriem recenzii aici încă.",
+  "reviews.emptyFilter": "Nici o recenzie nu se potriveşte cu acest filtru.",
+  "reviews.rate.cashu": "Evaluează acest mint",
+  "reviews.rate.fedimint": "Evaluează această federație",
+  "reviews.rate.lnurl": "Evaluează acest mint",
+  "reviews.noscript": "Recenziile sunt semnate pe Nostr și încărcați în browser-ul dvs., astfel încât această listă are nevoie de JavaScript. Evaluarea și numărul de mai sus provin de la site-ul în sine.",
+  "reviews.relayError": "Nu am putut ajunge la releu. Recenziile pot fi incomplete.",
+  "reviews.srRating": "{rating} din 5",
+  "reviews.srNoRating": "Nu s-a acordat rating",
+  "reviews.readMore": "Citeste mai multe",
+  "reviews.readLess": "Arată mai puțin",
+  "reviews.actions.copyNpub": "Copiază npub",
+  "reviews.actions.openNostr": "Vizualizați acest eveniment pe Nostr",
+  "reviews.actions.copyLink": "Copiază link-ul către această revizuire",
+  "reviews.anonNote": "Prima revizuire a acestei npub-uri, nicio altă activitate nu a fost găsită",
+  "reviews.published": "Publicat.",
+  "reviews.publishedPartial": "Publicată în{accepted} din{total} relee.",
+  "reviews.propagating": "Se publică pe relayurile Nostr",
+  "reviews.summary.line.one": "{count}rating fără comentarii:{breakdown}",
+  "reviews.summary.line.other": "{count} ratinguri fără comentarii:{breakdown}",
+  "reviews.summary.line.few": "{count} ratinguri fără comentarii:{breakdown}",
+  "reviews.summary.lineDay.one": "{count}rating fără comentarii{when}:{breakdown}",
+  "reviews.summary.lineDay.other": "{count} ratinguri fără comentarii{when}:{breakdown}",
+  "reviews.summary.lineDay.few": "{count} ratinguri fără comentarii{when}:{breakdown}",
+  "reviews.summary.showOne": "Arată-l.",
+  "reviews.summary.showMany": "Arată-le",
+  "reviews.breakdown.5": "{n} cinci stele",
+  "reviews.breakdown.4": "{n} patru stele",
+  "reviews.breakdown.3": "{n} trei stele",
+  "reviews.breakdown.2": "{n} două stele",
+  "reviews.breakdown.1": "{n}o stea",
+  "reviews.breakdown.none": "{n} fără rating",
+  "reviews.dialog.title": "Reexaminare{name}",
+  "reviews.dialog.lede.cashu": "Împărtășește experiența ta cu acest mint.",
+  "reviews.dialog.lede.fedimint": "Împărtășește experiența ta cu această federație.",
+  "reviews.dialog.lede.lnurl": "Împărtășește experiența ta cu acest mint.",
+  "reviews.dialog.permanent": "Publicat permanent pe relayuri Nostr publice.",
+  "reviews.dialog.gate.title": "Autentifică-te pentru a scrie un comentariu",
+  "reviews.dialog.gate.lead": "Recenziile sunt semnate cu cheia ta Nostr. Rămâne în signerul tău, acest site nu o vede niciodată.",
+  "reviews.dialog.ratingLegend": "Evaluarea dvs.",
+  "reviews.dialog.starsSr.one": "{n} stea",
+  "reviews.dialog.starsSr.other": "{n} stele",
+  "reviews.dialog.starsSr.few": "{n} stele",
+  "reviews.dialog.chooseRating": "Alegeți un rating",
+  "reviews.dialog.starLabel": "{n}:{phrase}",
+  "reviews.dialog.stars.1": "Evit-o.",
+  "reviews.dialog.stars.2": "a avut probleme",
+  "reviews.dialog.stars.3": "lucrate, cu pretentii",
+  "reviews.dialog.stars.4": "Bine.",
+  "reviews.dialog.stars.5": "Lucrează grozav.",
+  "reviews.dialog.bodyLabel": "Ce ar trebui să ştie alţii?",
+  "reviews.dialog.charCount": "{n}/{max}",
+  "reviews.dialog.submit": "Semnează și publică",
+  "reviews.dialog.signing": "Semnez...",
+  "reviews.dialog.publishing": "Editura...",
+  "reviews.dialog.publishingTo": "Editarea către relee ({accepted}/{total})",
+  "reviews.dialog.waitingExtension": "Aşteptăm prelungirea.",
+  "reviews.dialog.waitingSigner": "Aştept semnalul tău.",
+  "reviews.dialog.confirmClose": "Ţi-ai păstrat proiectul până când ai plecat de pe site.",
+  "reviews.dialog.why.login": "Autentifică-te pentru publicare",
+  "reviews.dialog.why.words": "Scrie câteva cuvinte.",
+  "reviews.dialog.why.more.one": "{n} mai mult caracter",
+  "reviews.dialog.why.more.other": "{n} mai multe caractere",
+  "reviews.dialog.why.more.few": "{n} mai multe caractere",
+  "reviews.dialog.why.over.one": "{n} caracter peste limită",
+  "reviews.dialog.why.over.other": "{n} caractere peste limită",
+  "reviews.dialog.why.over.few": "{n} caractere peste limită",
+  "reviews.dialog.identity.needSigner": "Cheia ta rămâne în ea, site-ul ăsta nu-l vede niciodată.",
+  "reviews.dialog.identity.loginToPublish": "Autentifică-te pentru publicare",
+  "reviews.dialog.identity.switch": "Comută",
+  "reviews.dialog.identity.extension": "Semnare cu extensia browser-ului",
+  "reviews.dialog.identity.readingKey": "Citirea cheii publice...",
+  "reviews.dialog.identity.willAsk": "Prelungirea dvs. va fi cerut să semneze",
+  "reviews.dialog.error.noRelay": "Niciun releu nu a acceptat recenzia. Verificați conexiunea, apoi încercați din nou.",
+  "reviews.validate.rating": "Alegeți un rating de la 1 la 5 stele.",
+  "reviews.validate.short": "Scrie cel puţin{n} caractere, astfel încât revizuirea este utilă.",
+  "reviews.validate.long": "Revizuirile sunt limitate la{n}Personaje.",
+  "feed.title": "Cele mai recente recenzii de mint-uri și federații · Cashumints.space",
+  "feed.description": "Fiecare recenzie de mint, federație și mint LNURL pe măsură ce este publicată: {reviews} recenzii pentru {mints} mint-uri Cashu, {federations} federații Fedimint și {lnurl} mint-uri LNURL, semnate pe Nostr și de citit aici de la cele mai noi. Filtrează după ecosistem, evaluare sau nume.",
+  "feed.heading": "Ultimele recenzii",
+  "feed.lede": "Fiecare recenzie a fiecărei federații Cashu monetărie și Fedimint, cea mai nouă primă, citește în direct de la releele Nostr. Fiecare este semnată de autorul său și trăiește pe relee, nu în baza noastră de date.",
+  "feed.label": "Revizuiri",
+  "feed.showingBuild.one": "Arata cea mai recenta recenzie din ultima constructie",
+  "feed.showingBuild.other": "Afişarea{n}cele mai recente recenzii din ultima clădire",
+  "feed.showingBuild.few": "Afişarea{n}cele mai recente recenzii din ultima clădire",
+  "feed.noscript": "Recenziile sunt semnate pe Nostr și încărcați în browser-ul dvs., astfel încât filtrarea și lista completă au nevoie de JavaScript.{n} recenziile de mai jos au fost citite de la relee atunci când această pagină a fost construită.",
+  "feed.emptyBuild": "Nu au putut fi citite recenzii de la relee atunci când această pagină a fost construită. Lista reîncărca de la relee în browser-ul.",
+  "feed.foot": "Revizuirile sunt opinii comunitare, neverificate.{link} înainte să ai încredere într-o monetărie cu bani.",
+  "feed.footLink": "dezaclaimer",
+  "feed.showing": "Afişare{shown} din{total} reexaminări",
+  "feed.showingMatching": "Afişare{shown} din{matching}Recenzii corespunzătoare ({total} în total)",
+  "feed.emptyRelays": "Nu s-au întors recenzii de la relee. Deschideți orice pagină monetărie pentru a citi și scrie recenzii acolo.",
+  "feed.emptyFilter": "Nicio recenzie nu se potrivește cu acest filtru. Eliberați cutia monetărie sau încercați All.",
+  "feed.relayError": "Nu am putut ajunge la relee. Arătând recenziile de la ultima clădire.",
+  "feed.relayEmpty": "Nu s-au primit recenzii de la relee, arată recenziile de la ultima clădire.",
+  "feed.reading": "Citind releele...",
+  "login.open": "Autentificare",
+  "login.title": "Autentifică-te cu Nostr",
+  "login.note": "Cheia ta rămâne în autograful tău.",
+  "login.extension.name": "Extensie browser",
+  "login.extension.desc": "Semnează cu Alby, nos2x sau o altă extensie NIP-07",
+  "login.extension.none": "Nu s-a găsit nicio extensie",
+  "login.extension.getOne": "Ia unul:",
+  "login.remote.name": "Semnător la distanță",
+  "login.remote.desc": "Scanează un cod cu o aplicație de signer, sau lipește un link de buncăr",
+  "login.primal.name": "Primal",
+  "login.primal.desc": "Aprobati login-ul din aplicatia Primal de pe telefon",
+  "login.paste.label": "Sau lipi link-ul de conectare signer-ul dvs. a dat",
+  "login.copyLink": "Copiază link-ul de conexiune",
+  "login.whatIsNostr": "Ce este Nostr?",
+  "login.connect.remote.title": "Conectează un signer la distanță",
+  "login.connect.remote.lead": "Scanați acest lucru cu aplicația dvs. de signer, sau copiați link-ul și lipiți-l acolo.",
+  "login.connect.remote.hint": "Funcţionează cu orice signer NIP-46: nsec.app, Amber, Nostriify, propriul buncăr.",
+  "login.connect.remote.open": "Deschideți în aplicația de signer",
+  "login.connect.primal.title": "Conectare cu Primal",
+  "login.connect.primal.lead": "Deschideți Primal pe telefon, găsiți semnarea de la distanță în setările sale, și scanați acest cod.",
+  "login.connect.primal.hint": "Semne primare pentru alte aplicații peste NIP-46, deci aceasta este aceeași conexiune orice utilizare a semnarului, și cheia rămâne în Primal.{link}",
+  "login.connect.primal.open": "Deschide în Primal",
+  "login.status.buildingLink": "Construirea unui link de conexiune",
+  "login.status.waitingExtension": "Aşteptăm prelungirea.",
+  "login.status.waitingSigner": "Aştept semnalul tău.",
+  "login.status.connecting": "Conectarea la signer",
+  "login.status.connected": "Conectat",
+  "login.toast.loggedIn": "Autentificat",
+  "login.toast.fetchingProfile": "Se preia profilul tău Nostr de la relee…",
+  "login.toast.profile": "Profil: {name}",
+  "login.toast.noProfile": "Niciun profil găsit pe relee",
+  "login.method.extension": "Extensie",
+  "login.method.remote": "Remote",
+  "login.method.primal": "Primal",
+  "login.account": "Contul Nostr",
+  "login.copyNpub": "Copiați întreaga ta npub",
+  "login.logout": "Deconectează",
+  "signer.status.waitingExtension": "Aşteptăm prelungirea.",
+  "signer.status.signed": "Semnat",
+  "signer.status.reconnecting": "Reconectare la signer",
+  "signer.status.approveWindow": "Semnatorul tău vrea să aprobi asta în propria fereastră.",
+  "signer.status.waitingSigner": "Aştept semnalul tău.",
+  "signer.status.stillWaiting": "Încă aştept să-ţi răspundă soneria.",
+  "signer.status.connected": "Conectat",
+  "signer.error.noExtension": "Instalează Alby sau Nos2x, apoi reîncarcă această pagină.",
+  "signer.error.privateKey": "Pare o cheie privată, nu o legătură. Acest site nu ia niciodată o cheie. Lipește buncărul / link-ul pe care ți l-a dat signerul.",
+  "signer.error.badLink": "Acesta nu este un link de conexiune acest site înțelege. Lipiți link-ul buncăr:// de la signer.",
+  "signer.error.noAnswer": "Semnatorul nu a răspuns. Poate fi închis, sau releul său poate fi oprit. Deschideți și încercați din nou.",
+  "signer.error.timeout": "Semnatorul nu a răspuns la timp. Deschide-l, verifică-l încă este conectat, apoi încearcă din nou.",
+  "signer.error.cancelled": "Conexiune anulată.",
+  "signer.error.declined": "Cererea de semnătură a fost respinsă.",
+  "notfound.title": "Pagina nu a fost găsită · Cashumints.space",
+  "notfound.description": "Această pagină nu există pe Cashumints.space.",
+  "notfound.heading": "Această pagină nu există",
+  "notfound.lede": "Este posibil să fi mutat, sau monetărie nu poate fi indexat încă. Caută o monetărie după nume sau domeniu, sau lipește un URL monetărie.",
+  "notfound.browse": "Răsfoiește toate monetării",
+  "notfound.home": "Du-te acasă.",
+  "notfound.loading": "Se încarcă{host}",
+  "notfound.fb.rating": "Evaluare",
+  "notfound.fb.reviews": "Revizuiri",
+  "notfound.fb.software": "Programe",
+  "notfound.fb.lastOnline": "Ultima dată online",
+  "notfound.fb.note": "Acest mint a fost indexat după ultima construire a site-ului, deci acesta e un rezumat din API-ul live, cu recenziile dedesubt. Pagina completă apare la următoarea construire.",
+  "notfound.resolve.checking": "Prima vizită: verific acest mint acum.",
+  "notfound.resolve.failed": "Acest mint nu a putut fi adăugat",
+  "notfound.resolve.failedFedimint": "Această federație nu a putut fi adăugată",
+  "notfound.resolve.retry": "Încearcă altă adresă",
+  "notfound.resolve.switch": "Deschide-l ca mint {kind}",
+  "notfound.resolve.fedimint": "Adresa paginii unei federații nu conține codul ei de invitație, așa că aceasta nu poate fi găsită doar din link. Lipește codul de invitație și va fi adăugată.",
+  "notfound.resolve.ambiguous": "Această adresă nu poate fi dedusă doar din link. Lipește URL-ul complet al mintului și va fi adăugat.",
+  "wallets.title": "Portofele Cashu · Cashumints.space",
+  "wallets.description": "Portofelele Cashu care lucrează cu monetării enumerate aici, prin telefon mobil, web, browser și linia de comandă, cu ceea ce fiecare este bun la.",
+  "wallets.heading": "Portofele",
+  "wallets.lede": "Aveți nevoie de un portofel pentru a deține ecash de la oricare dintre aceste monetării. Cele mai multe portofele vorbesc cu mai multe monetării dintr-o dată, astfel încât să nu sunt legate de primul pe care încercați.",
+  "wallets.note": "Această listă nu este exhaustivă și nu este o aprobare. Proiectul Cashu păstrează un indice mai larg la{link}. Un portofel deține chei, o monetărie deține banii: citiți comentarii monetărie înainte de a alege în cazul în care sats trăiești.",
+  "wallets.platform.android": "Android",
+  "wallets.platform.ios": "iOS",
+  "wallets.platform.web": "Web",
+  "wallets.platform.extension": "Extensie browser",
+  "wallets.platform.cli": "CLI",
+  "wallets.platform.python": "Python",
+  "wallets.item.minibits": "Portofel mobil ecash cu propria sa monetărie, suport pentru adrese Lightning și contacte Nostr.",
+  "wallets.item.nutstash": "Portofel browser care se ocupă de mai multe monetări simultan și importă și exportă jetoane brute.",
+  "wallets.item.enuts": "Portofel mobil axat pe solduri multimint și trimiterea ecash peste Nostr.",
+  "wallets.item.cashume": "Portofel web de referinţă din proiectul Cashu. Funcţionează în întregime în browser, instalabil ca PWA.",
+  "wallets.item.boardwalk": "Portofel web construit în jurul adreselor Lightning și trimiterea ecash prin link.",
+  "wallets.item.coinos": "Fulger portofel și punctul de vânzare, care rulează, de asemenea, propria sa Cashu monetărie.",
+  "wallets.item.oxchat": "Nostr mesager cu un portofel cash construit în, pentru trimiterea de sat-uri în interiorul chat-uri.",
+  "wallets.item.nutshell": "Implementarea de referinţă. Funcţionează ca un portofel pe linia de comandă şi ca software monetărie.",
+  "about.title": "Despre Cashumints.space",
+  "about.description": "Ce este Cashu, ce deține de fapt o monetărie, ce este NIP-87, și cum acest site indexează monetării și citește recenzii de la releele Nostr.",
+  "about.heading": "Despre",
+  "about.lede": "Cashumints.space enumeră fiecare mint Cashu pe care îl putem găsi în rețeaua Nostr și îți arată ce spun oamenii despre ele. Este făcut de Azzamo.",
+  "about.cashu.title": "Ce este Cashu",
+  "about.cashu.p1": "Cashu este un protocol de cash pentru Bitcoin. Un monetărie probleme orbite jetoane susținute de sat-uri ea deține, și acele jetoane se mișcă între oameni fără monetărie învățare care a trimis la ce. Confidențialitatea este reală și este punctul: jetoane nu sunt conturi, iar monetăria nu poate lega jetonul semnat cu jetonul care vine înapoi.",
+  "about.cashu.p2": "Puteți citi protocolul și specificațiile sale la{link}. Specificaţiile în sine se numesc NUT-uri, de unde provin numerele NUT de pe fiecare pagină monetărie.",
+  "about.mints.title": "Ce este un monetărie, și compromisul",
+  "about.mints.p1": "O monetărie este custodia. Când monetăria ecash vă sunt predarea sat-uri la oricine rulează acel server, și sunteți încredere în ei să onoreze jetoane atunci când le topi înapoi. Nu există nici o dovadă fraudă, nici un escrow și nici un recurs. Un operator monetărie poate dispărea cu soldul, și monetării au.",
+  "about.mints.p2": "Tocmai de aceea există recenzii aici. Acest site nu vă spune niciodată că o monetărie este sigură.{code}, nu \"încredere,\" și înseamnă doar serverul a răspuns atunci când am cerut ultima dată. Trata solduri de ecash ca numerar într-un buzunar haina: amendă pentru cheltuieli, greșit pentru economii.",
+  "about.nip87.title": "Ce este NIP- 87",
+  "about.nip87.p1": "NIP-87 este Convenţia Nostr pentru anunţarea şi recomandarea ecash monetării. Două tipuri de evenimente contează aici:",
+  "about.nip87.li1": "{code} anunţă o monetărie. URL-ul monetărie este în{tag}tag. Acesta este modul în care site-ul descoperă monetării pe care nu l-a văzut niciodată.",
+  "about.nip87.li2": "{code} este o recenzie. Acesta poartă ratingul și textul de revizuire, și puncte la monetărie este vorba despre cu o{utag}tag ( URL-ul monetărie) și a{dtag}tag (propria cheie publică a monetăriei).",
+  "about.nip87.p2": "Fiecare recenzie este semnată de tasta Nostr a autorului său. Noi nu numim niciodată o recenzie \"verificată,\" pentru că nimeni nu a verificat-o: este semnată, care este o pretenţie diferită şi mai utilă. Aceasta înseamnă că puteţi verifica cine a scris-o şi că nu a fost modificată. Aceasta nu înseamnă că autorul este cinstit sau folosit vreodată monetărie.",
+  "about.how.title": "Cum funcționează acest site",
+  "about.how.p1": "Există două bucle și o regulă. Regula este că monetăria deține metadatele sale și Nostr deține recenziile, astfel încât acest site nu stochează nici ca autoritate.",
+  "about.how.li1": "{strong} întreabă fiecare monetărie cunoscută pentru{code}la fiecare zece minute și înregistrează ce spune: nume, descriere, versiune, NUT-uri acceptate, limite, detalii de contact. De asemenea, se înregistrează dacă monetăria a răspuns la toate, care este în cazul în care vine timpul.",
+  "about.how.li1Label": "Bucla sondei",
+  "about.how.li2": "{strong}se conectează la releele Nostr la fiecare oră, citește anunțuri și recenzii monetărie, și adaugă orice monetărie pe care nu a mai văzut-o până acum.",
+  "about.how.li2Label": "Bucla descoperirii",
+  "about.how.p2": "Partea importantă este ceea ce se întâmplă atunci când un monetărie încetează să răspundă. Metadatele sale cache nu este niciodată suprascrisă de o sondă eșuată, astfel încât o monetărie moartă păstrează pagina completă: specificațiile sale, istoria și recenziile sale, cu un banner spunând atunci când a mers întuneric. Versiunea anterioară a acestui site a arătat o pagină de eroare în loc, ceea ce a însemnat că cei mai necesari monetari să se avertizeze unii pe alții au fost cei care nu au putut fi revizuite. Acesta a fost motivul principal pentru reconstrucție.",
+  "about.how.p3": "Review text nu este niciodată stocat pe partea noastră. Când deschideți o pagină de monetărie browserul dvs. vorbește direct la relee și citește recenziile în sine, și atunci când scrieți unul este semnat de propria extensie Nostr și trimis direct la aceste relee. Păstrăm un număr astfel încât paginile pot fi clasificate și sortate, nimic mai mult. Nimic aici nu poate fi editat sau șters de noi, inclusiv recenziile pe care nu le-am avea.",
+  "about.relays.title": "Reluări pe care le citim",
+  "about.relays.p1": "Acestea sunt releele indexer și browser-ul ambele folosesc:",
+  "about.relays.p2": "Îndreptaţi orice client Nostr la aceleaşi relee şi veţi vedea aceleaşi evenimente. Aceasta este întreaga promisiune: nimic aici nu este adevărat doar pentru că aşa spunem noi.",
+  "about.nuts.title": "Ce sunt NUT-urile?",
+  "about.nuts.p1": "NUTS sunt specificațiile numerotate Cashu, cum ar fi BIP-uri pentru Bitcoin. O monetărie face publicitate pe care o pune în aplicare, și care vă spune ce poate face de fapt: NUT-04 și NUT-05 sunt menting și topirea peste Lightning (fără ele o monetărie nu este de mult folos), NUT-07 permite o verificare a portofelului dacă un token a fost deja cheltuit, NUT-17 oferă portofele actualizări live peste WebSockets în loc de sondaje, și Nut-20 permite unui portofel dovedi un citat monetărie a fost într-adevăr emis la ea. Lista completă este la{link}.",
+  "about.numbers.title": "Chiar acum.",
+  "about.numbers.p1": "{mints} monetării indexate, dintre care {online} răspund, și {reviews} recenzii numărate din releele de mai sus.",
+  "about.source.title": "Sursa și creditul",
+  "about.source.p1": "Site-ul este open source la{github} Este construit și condus de{azzamo}. Dacă o pagină de monetărie are ceva greșit pe ea, fixați-l la sursă: metadate monetărie vine de la propria monetărie{code}, și recenzii provin de la Nostr.",
+  "terms.title": "Termeni de utilizare · Cashumints.space",
+  "terms.description": "Termeni de utilizare pentru Cashumints.space: ce este site-ul, ce nu face, și cine este responsabil pentru ce. Fără conturi, fără garanții, fără afiliere la orice monetărie.",
+  "terms.heading": "Termeni de utilizare",
+  "terms.lede": "Termeni simpli pentru un site care indexează doar datele publice. Ultima actualizare{date}.",
+  "terms.what.title": "Ce este acest site",
+  "terms.what.p1": "Cashumints.space este un indice al datelor disponibile publicului despre Cashu monetării. Două tipuri de date, ambele din altă parte:",
+  "terms.what.li1": "Metadate monetărie, citite de la fiecare monetărie{code} obiectiv: nume, descriere, versiune software, NUT-uri acceptate, detalii de contact și dacă monetăria a răspuns când am întrebat ultima dată.",
+  "terms.what.li2": "Recenzii, citite din releele Nostre publice. Acestea sunt evenimente NIP-87 publicate de autorii lor la relee oricine poate interoga.",
+  "terms.what.p2": "Noi colectăm aceste date, le normalizăm, le clasificăm şi le arătăm. Nu le creăm.",
+  "terms.noAccounts.title": "Fără conturi, fără garanţii.",
+  "terms.noAccounts.p1": "Site-ul este oferit, fără nici o garanție de orice fel: nu că datele sunt corecte, nu că ar fi actuale, nu că site-ul va fi disponibil. datele monetare pot fi vechi de câteva minute sau ore, o monetărie se poate schimba după ce am verificat ultima dată, și un releu nu poate răspunde, caz în care vedeți mai puțin decât există.",
+  "terms.noAccounts.p2": "Folosiţi-l pe riscul dvs. Nu suntem răspunzători pentru orice pierdere care rezultă din utilizarea acestui site sau bazându-vă pe orice citiţi aici.{link} pentru riscurile specifice de utilizare a unei monede Cashu.",
+  "terms.noAccounts.link": "dezaclaimer",
+  "terms.noCustody.title": "Noi nu ținem banii",
+  "terms.noCustody.p1": "Acest site nu ia niciodată custodia fondurilor. Nu are portofel, nu atinge ecash, și nu poate muta, îngheța sau recupera nimic. Dacă aveți o problemă cu o monetărie, operatorul monetărie este singura parte care vă poate ajuta, și nu le putem contacta în numele dumneavoastră.",
+  "terms.noCustody.p2": "Nu suntem afiliati nici unei monetãrii enumerate aici, si nici unei monetãrii nu i se plãteste cotarea, rangul sau ratingul. monetãrii sunt descoperiti din anunturile publice Nostr si clasate de un algoritm pe baza datelor de recenzie publica.",
+  "terms.reviews.title": "Recenziile sunt cuvintele altor oameni",
+  "terms.reviews.p1": "Recenziile sunt conținuturi generate de utilizator publicate la releele publice Nostr de către autorii lor. Le afișam, nu le controlăm. Nu le-am scris, nu le putem edita și nu le putem șterge de pe releele care le dețin: sunt evenimente semnate pe o rețea pe care nu o deținem.",
+  "terms.reviews.p2": "O revizuire este experiența unei persoane, nu un fapt verificat. Dacă publicați unul, sunteți responsabil pentru ceea ce spune. Nu publicați nimic ilegal, și să fie conștienți de faptul că ceea ce publicați este public și permanent (vezi{link}).",
+  "terms.reviews.link": "pagina de confidențialitate",
+  "terms.reviews.p3": "Putem opri afișarea unei evaluări specifice pe acest site, și vom face acest lucru pentru conținut care este ilegal. Asta îl elimină doar din aceste pagini. Evenimentul rămâne pe relee și orice alt client Nostr poate citi încă.",
+  "terms.links.title": "Linkuri către alte situri",
+  "terms.links.p1": "URL-uri, linkuri de portofel, contacte cu operatorul și orice altceva care puncte de pe acest site sunt acolo pentru că acestea fac parte din date. Un link nu este o aprobare și nu veterinar ceea ce este la celălalt capăt.",
+  "terms.changes.title": "Modificări",
+  "terms.changes.p1": "Acesti termeni se pot schimba. Data de la partea de sus spune când au făcut-o ultima dată. Site-ul este open source, astfel încât fiecare schimbare a acestei pagini este în istoria comite.",
+  "terms.contact.title": "Contact",
+  "terms.contact.p1": "Problemele și cererile de preluare sunt cele mai bune depuse pe{github}Site-ul este condus de{azzamo}.",
+  "privacy.title": "Confidențialitate · Cashumints.space",
+  "privacy.description": "Privacy on Cashumints.space: no accounts, no tracking cookies, no analytics. localStorage is used for profile caching and nothing is end anywhere. Reviews are signed in your own browser.",
+  "privacy.heading": "Confidenţialitatea",
+  "privacy.lede": "Noi colecta cât mai puțin ca un site web poate. Ultima actualizare{date}.",
+  "privacy.noAccounts.title": "Fără conturi",
+  "privacy.noAccounts.p1": "Nu există nici o înregistrare, nici o autentificare și nici un profil. Nimic de pe acest site vă întreabă cine sunteți, și nu există nici o înregistrare a utilizatorului pentru că nu există nici un utilizator.",
+  "privacy.noTracking.title": "Fără cookie-uri de urmărire, fără analize",
+  "privacy.noTracking.p1": "Site-ul nu stabilește cookie-uri pentru urmărire. Nu există nici un script de analiză, nici un manager de tag-uri, nici un pixel, nici înregistrare sesiune și nici o rețea de publicitate. Nimic pe pagina raportează comportamentul dumneavoastră pentru noi sau pentru oricine altcineva.",
+  "privacy.logs.title": "Jurnalele serverului",
+  "privacy.logs.p1": "Serverul web păstrează jurnalele de acces standard, ceea ce face orice server web implicit. O linie de jurnal înregistrează adresa IP, ora, pagina pe care ați cerut-o, starea de răspuns, și agentul utilizator și referer browser-ul trimis. Jurnalele există pentru a depana erori și abuz la fața locului. Ei nu sunt uniți la nimic altceva și nu sunt vândute sau partajate.",
+  "privacy.logs.operatorLabel": "Notă operator:",
+  "privacy.logs.operator": "dacă executați acest site, spuneți-vă adevărata retenție aici. Desfășurarea în README folosește nginx cu jurnalul de acces implicit și orice rotație a navelor de distribuție (pe Debian și Ubuntu care este logrotat, zilnic, păstrând 14 zile). Confirmați ce face serverul și înlocuiți acest paragraf cu numărul.",
+  "privacy.storage.title": "Ce se păstrează în browser-ul dumneavoastră",
+  "privacy.storage.p1": "Site-ul utilizează localStorage pentru exact două lucruri, ambele rămân pe dispozitivul dumneavoastră și nu sunt trimise nicăieri:",
+  "privacy.storage.li1": "O cache de metadate de profil Nostr (kind 0 evenimente: nume, avatare, adrese NIP-05) pentru revizorii ale căror recenzii le-ați privit. Acest lucru salvează relee re-querying pe fiecare pagină. Intrări expiră, și cache-ul este limitat și evacuat mai vechi primul.",
+  "privacy.storage.li2": "Preferintele de interfata, astfel site-ul se comporta la fel data viitoare.",
+  "privacy.storage.p2": "Curățarea datelor site-ului browser-ului elimină ambele. Nimic nu se rupe, căutarea profilului doar rula din nou.",
+  "privacy.thirdParties.title": "Cu ce vorbește browser-ul tău",
+  "privacy.thirdParties.p1": "Încărcare o pagină conectează browser-ul la câteva locuri în afară de acest site. Acesta este modul în care un site cu nici un server-side de urmărire citește încă date live:",
+  "privacy.thirdParties.li1Label": "Relee Nostre publice",
+  "privacy.thirdParties.li1": "{strong}Releul vede IP-ul și ce ați cerut, ca orice server la care vă conectați. Releele sunt enumerate pe{link}.",
+  "privacy.thirdParties.li1Link": "despre pagina",
+  "privacy.thirdParties.li2Label": "Imagini avatar reviewer",
+  "privacy.thirdParties.li2": "{strong} Acestea sunt trimise cu o politică fără referinţe, astfel încât gazda să nu afle pe ce pagină aţi fost.",
+  "privacy.publishing.title": "Editarea unei recenzii",
+  "privacy.publishing.p1": "Scrierea unei recenzii se întâmplă în browser-ul dvs., nu pe serverul Nostru. Evenimentul este semnat de extensia dvs. NIP-07 (Alby, nos2x sau similar) și transmis direct din browser-ul dvs. direct la relee. Cheia dvs. privată nu părăsește niciodată extensia și acest site nu o vede. Noi nu construim managementul cheii personalizate și nu cerem niciodată o cheie sau o frază de semințe.",
+  "privacy.permanent.title": "Orice publicaţi la Nostr este public şi permanent.",
+  "privacy.permanent.p1": "Aceasta este partea care merită citită de două ori. O revizuire este un eveniment semnat pe relee publice. Odată ce este afară, este afară:",
+  "privacy.permanent.li1": "Oricine o poate citi, din când în când, folosind orice client Nostr. Nu este \"public pe Cashumints.space,\" este public în reţea.",
+  "privacy.permanent.li2": "Acesta este permanent legat de tasta dvs. publică Nostr, alături de orice altceva care cheia a publicat vreodată.",
+  "privacy.permanent.li3": "Ștergerea este o cerere, nu o comandă. Puteți publica un eveniment de ștergere și unele relee îl va onora, dar un releu este liber să-l ignore și oricine care a copiat deja evenimentul încă mai are. Trataţi o revizuire publicată ca permanent.",
+  "privacy.permanent.li4": "Nu-l putem șterge pentru tine. Putem opri afișarea aici; care nu schimbă nimic pe relee.",
+  "privacy.permanent.p2": "Dacă doriți să revizuiți o monetărie fără ca aceasta să fie legată de identitatea dumneavoastră principală, utilizați o cheie Nost separat. Rețineți că o cheie fără altă activitate este afișată ca atare pe recenzii dure, pentru că o cheie de brand nou scris o recenzie o stea este un cititor de model merită să vadă.",
+  "privacy.contact.title": "Întrebări",
+  "privacy.contact.p1": "Site-ul este open source: dacă doriți să verificați oricare dintre cele de mai sus, citiți codul la{github} Întrebările şi corecţiile pot intra într-o problemă.",
+  "disclaimer.title": "Declinarea responsabilității · Cashumints.space",
+  "disclaimer.description": "Ce trebuie să știți înainte de a utiliza un Cashu montarie: banii sunt custodia, o monetărie poate dispărea cu banii, recenziile sunt opinii și mijloace online accesibile, nedemne de încredere.",
+  "disclaimer.heading": "Retragere",
+  "disclaimer.lede": "Citiți acest lucru înainte de a pune bani într-o monetărie. Ultima actualizare{date}.",
+  "disclaimer.callout": "Dacă dispare, nu mai ai la cine apela. Păstrează doar ceea ce îți poți permite să pierzi.",
+  "disclaimer.custodial.title": "Banii sunt custodia",
+  "disclaimer.custodial.p1": "Atunci când monetărie ecash, vă înmânați Bitcoin operatorului de monetărie și obțineți jetoane înapoi. Aceste jetoane sunt o cerere pe care operatorul. Ei nu sunt Bitcoin vă dețineți, iar operatorul este cel care decide dacă să-i onoreze.",
+  "disclaimer.custodial.p2": "Asta înseamnă că fiecare monetărie poartă aceleași riscuri: operatorul poate dispărea, poate fi obligat să se oprească, poate pierde fondurile printr-un bug sau un hack, sau poate pur și simplu opri serverul. Nu există asigurare de depozit, nici un chargeback, nici o linie de sprijin și nici un recurs legal în valoare de numărare pe. Acest lucru este valabil pentru cea mai mare monetărie evaluat pe acest site.",
+  "disclaimer.custodial.p3": "Cashu este proiectat pentru sume mici care se deplasează rapid. Utilizați-l astfel: țineți ceea ce sunteți pe cale să cheltuiți, nu economiile, și răspândiți peste monetări mai degrabă decât parcarea totul într-unul singur.",
+  "disclaimer.reviews.title": "Revizuirile sunt opinii, nu cereri verificate",
+  "disclaimer.reviews.p1": "Fiecare recenzie de aici a fost scrisă de cineva de pe Nostr şi semnată cu cheia lor. Semnat înseamnă că vă putem spune care cheie a scris-o. Aceasta nu înseamnă că recenzia este adevărată, că autorul a folosit monetărie, sau că autorul nu este operatorul, un concurent, sau o persoană cu zece chei.",
+  "disclaimer.reviews.p2": "Noi nu verificăm recenzorii și nu edităm sau eliminăm recenziile cu care nu suntem de acord. Citiți câteva, priviți ce spun ei de fapt și cântăriți o monetărie cu trei recenzii diferite față de una cu trei sute.",
+  "disclaimer.status.title": "Mijloace online accesibile, nedemne de încredere",
+  "disclaimer.status.p1": "Verificam fiecare monetărie în mod regulat și arătăm dacă răspunde. Aceasta este tot o stare verde înseamnă: serverul a răspuns. Nu spune nimic despre dacă operatorul este solvent, onest, sau încă intenționează să onoreze jetoanele mâine.",
+  "disclaimer.status.p2": "O monetărie poate fi online până în momentul în care nu este. Istoria actualizată, NUT-uri sprijinite și versiunea software-ului vă spun ceva despre modul în care o monetărie este condusă, dar niciunul dintre ele nu este o promisiune despre banii dumneavoastră.",
+  "disclaimer.ranking.title": "Cum funcţionează clasamentul, şi ce nu înseamnă",
+  "disclaimer.ranking.p1": "Monetarii sunt comandati de un algoritm pe baza datelor de recenzie publica: rating, numar de recenzii si activitate recenta, cu monetari online inainte de cele offline in mod implicit. Detaliile sunt in codul open source.",
+  "disclaimer.ranking.p2": "Nimeni nu plătește pentru plasare. Nu există nici un slot sponsorizat, nici o cotare promovată și nici un aranjament cu nici o monetărie pe acest site. Un rang înalt înseamnă algoritmul plăcut datele publice, și nimic mai mult. Nu este o recomandare și nu este un rating de siguranță.",
+  "disclaimer.notAdvice.title": "Asta nu e consiliere financiară.",
+  "disclaimer.notAdvice.p1": "Nimic de pe acest site nu este financiar, de investiții, consiliere juridică sau fiscală. Nu știm situația dumneavoastră și nu vă sfătuim. Folosind o monetărie și alegând care dintre ele, este decizia dumneavoastră.",
+  "disclaimer.dyor.title": "Fă-ţi singur cercetările.",
+  "disclaimer.dyor.li1": "O monetărie condusă de cineva cu o reputaţie publică de pierdut este o propunere diferită de un URL anonim.",
+  "disclaimer.dyor.li2": "Citiți termenii monetăriei și MOTD-ul său. O monetărie care se numește test sau beta înseamnă.",
+  "disclaimer.dyor.li3": "Începeți mici. monetărie un pic, cheltuiți-l, topiți-l înapoi, și a vedea ce se întâmplă înainte de a avea încredere în ea cu mai mult.",
+  "disclaimer.dyor.li4": "Atenţie la limite. Un maxim scăzut este adesea un semn al unui operator atent, iar unul înalt nu este un semn al unuia sigur.",
+  "disclaimer.dyor.li5": "Ţineţi jetoanele susţinute şi amintiţi-vă că un jeton este un bun purtător: oricine îl deţine îl poate cheltui.",
+  "disclaimer.site.title": "Despre site-ul în sine",
+  "disclaimer.site.p1": "Datele de aici pot fi greșite sau expirate. monetării sunt verificați pe un program, releele uneori nu reușesc să răspundă, iar o pagină pe care o citiți a fost construită la un moment dat în trecut. Site-ul este furnizat așa cum este, fără nicio garanție. Vezi pagina{link}.",
+  "disclaimer.site.link": "termeni de utilizare",
+  "disclaimer.updated": "20 august 2026",
+  "login.getPrimal": "Ia-l pe Primal.",
+  "reviews.dialog.identity.extensionGone": "Extensia browser-ului nu răspunde. Autentifică-te din nou sau foloseşte un signer de la distanţă.",
+  "seo.orgDescription": "Un director al Cashu monetării, cu statut live din fiecare monetărie și comentarii comunitare semnate pe Nostr.",
+  "seo.ogImageAlt": "Cashumints.space: găsește un mint Cashu în care poți avea încredere.",
+  "seo.mint.title.one": "{name} recenzii: evaluat {rating} din {n} recenzie | Cashumints.space",
+  "seo.mint.title.other": "{name} recenzii: evaluat {rating} din {n} recenzii | Cashumints.space",
+  "seo.mint.title.few": "{name} recenzii: evaluat{rating}de la{n} recenzii bază.spaţiu",
+  "seo.mint.titleOffline.one": "{name}: offline de {n} zi | Cashumints.space",
+  "seo.mint.titleOffline.other": "{name}: offline de {n} zile | Cashumints.space",
+  "seo.mint.titleOffline.few": "{name}: offline for{n} zile? Cajumints.space",
+  "seo.mint.titleNoReviews": "{name}: Cashu monetărie info and reviews - Cashumints.space",
+  "seo.fedimint.titleNoReviews": "{name}: informații și recenzii despre federația Fedimint | Cashumints.space",
+  "seo.desc.fallback": "Recenzii comunitare pentru{name}({domain}).",
+  "seo.desc.fallbackDomain": "Recenzii comunitare pentru Cashu monetărie la{domain}.",
+  "seo.desc.rated.one": "Evaluat{rating}/5 de la{n}a semnat revizuirea Nostr.",
+  "seo.desc.rated.other": "Evaluat{rating}/5 de la{n}Nostr recenzii semnate.",
+  "seo.desc.rated.few": "Evaluat{rating}/5 de la{n}Nostr recenzii semnate.",
+  "seo.desc.noReviews": "Încă nu am primit recenzii.",
+  "seo.desc.status": "{status}.",
+  "seo.desc.statusLimits": "{status}, limite{limits}.",
+  "seo.desc.fedModules": "{status}. Module:{modules}.",
+  "seo.desc.fedModulesNetwork": "{status}. Module:{modules} privind{network}.",
+  "seo.mint.ogAlt.one": "{name}:{rating} stele din{n} revizuire pe Cashumints.space",
+  "seo.mint.ogAlt.other": "{name}:{rating} stele din{n} comentarii cu privire la Cashumints.space",
+  "seo.mint.ogAlt.few": "{name}:{rating} stele din{n} comentarii cu privire la Cashumints.space",
+  "seo.mint.ogAltNoReviews": "{name}pe Cashumints.space",
+  "nav.home": "Acasă",
+  "mint.more.title": "Mai multe monede",
+  "mint.more.all": "A se vedea toate monetări",
+  "nav.fedimints": "Fedimints",
+  "status.announced": "Doar anunţat",
+  "card.unnamedFederation": "federație fără nume",
+  "card.notChecked": "Nu am verificat niciodată.",
+  "fedimints.title": "Toate federațiile Fedimint · Cashumints.space",
+  "fedimints.description": "Toate{total} Federaţiile federale au anunţat pe reţeaua Nostr:{online} confirmat de un control extern,{announced} ratinguri comunitare, module şi coduri de invitaţie pentru fiecare.",
+  "fedimints.heading": "Toate federațiile",
+  "fedimints.lede": "Fiecare federație Fedimint anunțat pe rețeaua Nostr. O federație nu are un obiectiv de statut public propriu, astfel încât unele dintre acestea sunt confirmate de funcționare printr-un control extern și restul sunt enumerate exact așa cum au fost anunțate.",
+  "fedimints.search.label": "federații de căutare după nume sau ID",
+  "fedimints.search.placeholder": "Caută după nume sau federație id...",
+  "fedimints.sort.label": "Sortează federațiile",
+  "fedimints.hideOffline": "Ascundeți offline",
+  "fedimints.showing": "Afişare{total} federații ({online} confirmat,{announced} numai a anunțat)",
+  "fedimints.showingFiltered": "Afişare{shown} din{total} federații ({online} confirmat,{announced} numai a anunțat)",
+  "fedimints.announcedNote.one": "Una dintre acestea a fost anunțată pe Nostr și nimic nu a confirmat de la rulare. Este listat ca anunțat mai degrabă decât ca on-line sau offline, pentru că nici nu ar fi adevărat.",
+  "fedimints.announcedNote.other": "{n} dintre acestea au fost anunțate pe Nostr și nimic nu a confirmat, deoarece acestea sunt difuzate. Acestea sunt enumerate ca anunțate mai degrabă decât ca on-line sau offline, pentru că nici nu ar fi adevărat.",
+  "fedimints.announcedNote.few": "{n} dintre acestea au fost anunțate pe Nostr și nimic nu a confirmat, deoarece acestea sunt difuzate. Acestea sunt enumerate ca anunțate mai degrabă decât ca on-line sau offline, pentru că nici nu ar fi adevărat.",
+  "fedimints.noResults": "Nu se potrivesc federaţiile, încearcă un nume, sau lipeşte un act de identitate al federaţiei.",
+  "fedimints.emptyIndex": "Nicio federaţie nu a fost anunţată pe releele pe care le citeşte site-ul. Lista se completează pe măsură ce sosesc anunţurile.",
+  "fedimint.crumb": "Fediminți",
+  "fedimint.breadcrumb": "Cremă de pâine",
+  "fedimint.unnamed": "federație fără nume",
+  "fedimint.idLabel": "Federaţia",
+  "fedimint.kind.federationId": "ID al federaţiei",
+  "fedimint.moduleCount.one": "{n} modul",
+  "fedimint.moduleCount.other": "{n}module",
+  "fedimint.moduleCount.few": "{n}module",
+  "fedimint.copyInvite": "Copiază codul de invitație",
+  "fedimint.confirmed.label": "Confirmat.",
+  "fedimint.confirmed.never": "Niciodată.",
+  "fedimint.confirmed.by": "de{source}",
+  "fedimint.confirmed.unattributed": "ultima verificare",
+  "fedimint.announcedOn": "anunţat{when}",
+  "fedimint.announcedUnknown": "nicio dată de anunțare",
+  "fedimint.modules.title": "Module",
+  "fedimint.modules.none": "Anunţul federaţiei nu enumeră module.",
+  "fedimint.modules.note": "Modulele sunt piesele pe care se execută o federație. Anuntul spune care sunt prezente, și nimic despre dacă oricare dintre ele acceptă depozite.",
+  "fedimint.modules.notListed": "nelistate",
+  "fedimint.invite.title": "Invită codul",
+  "fedimint.invite.count.one": "{n}cod",
+  "fedimint.invite.count.other": "{n} coduri",
+  "fedimint.invite.count.few": "{n} coduri",
+  "fedimint.invite.note": "Lipeşte asta într-un portofel Fedimint ca să se alăture.",
+  "fedimint.invite.kind": "cod de invitație",
+  "fedimint.invite.qr": "QR",
+  "fedimint.invite.qrCaption": "Scanează pentru a te alătura{name}",
+  "fedimint.details.federationId": "Număr de identificare al Federației",
+  "fedimint.details.network": "Rețea",
+  "fedimint.details.announcedBy": "Anunțat de",
+  "fedimint.details.announced": "Anunțat",
+  "fedimint.more.title": "Mai multe federații",
+  "fedimint.more.all": "Vezi toate federaţiile",
+  "fedimint.disclaimer": "Alături de o federaţie înseamnă să ai încredere în tutorii săi cu banii tăi. Ratingurile sunt opinii comunitare, şi confirmă mijloacele de rulare accesibile, nedemne de încredere.",
+  "fedimint.module.lightning": "Fulger",
+  "fedimint.module.mint": "Ecash monetărie",
+  "fedimint.module.wallet": "Portofelul pe lant",
+  "fedimint.module.meta": "Metadate",
+  "fedimint.module.stability_pool": "Rezerva de stabilitate",
+  "fedimint.module.multi_sig_stability_pool": "Rezerva de stabilitate (multisisig)",
+  "fedimint.module.fedi-social": "Redresarea socială",
+  "fedimint.network.mainnet": "Bitcoin mainnet",
+  "fedimint.network.signet": "Signet",
+  "fedimint.network.testnet": "Testnet",
+  "fedimint.network.testnet4": "Testnet4",
+  "fedimint.network.regtest": "Regletează",
+  "feed.ecosystem.group": "Ecosistem",
+  "feed.ecosystem.all": "Toate",
+  "feed.ecosystem.cashu": "Caju",
+  "feed.ecosystem.fedimint": "Fedimint",
+  "feed.filterBySubject": "Filtrare prin monetărie sau federație",
+  "feed.anySubject": "Orice monetărie sau federație",
+  "feed.clearSubject": "Șterge filtrul de nume",
+  "home.topFedimints.title": "Cele mai bune Fedimint-uri",
+  "home.topFedimints.sub": "clasificate în funcție de evaluări și de rating",
+  "home.topFedimints.all": "Toate{n} federații →",
+  "reviews.validate.subject": "Nu e nimic care să indice această recenzie.",
+  "mint.warnings.fedimintOffline.lead": "Raportat offline.",
+  "mint.warnings.fedimintOffline.body.since": "Ultima verificare care a ajuns la această federație a fost pe{date}({days} În urmă). Gardienii săi nu au răspuns de atunci. Trataţi fonduri deţinute acolo ca fiind în pericol, şi nu-l alătura cu noi fonduri.",
+  "mint.warnings.fedimintOffline.body.never": "Nici un cec al acestei federații nu a ajuns vreodată la ea, iar cel mai recent a eșuat. Tratați fonduri deținute acolo ca fiind în pericol, și nu-l alătura cu fonduri noi.",
+  "mint.warnings.fedimintOffline.meta.since": "Raportat offline deoarece{date}",
+  "mint.warnings.fedimintOffline.meta.never": "Raportat offline, niciodată atins",
+  "mint.warnings.neverConfirmed.lead": "Anuntat, nu confirmat.",
+  "mint.warnings.neverConfirmed.body.reviewed": "Această federaţie a fost anunţată pe Nostr pe{date},{days} În urmă, și nimic nu a confirmat de atunci că este difuzate. Comentariile de mai jos sunt singurul semn de viață pe această pagină; orice altceva a venit de la anunțul.",
+  "mint.warnings.neverConfirmed.body.quiet": "Această federaţie a fost anunţată pe Nostr pe{date},{days} Acum, nimic nu a confirmat de atunci că funcţionează, şi nimeni nu l-a revăzut recent. Totul de mai jos a venit din anunţ.",
+  "mint.warnings.neverConfirmed.meta": "Anunțat{date}, nu a confirmat",
+  "footer.allFedimints": "Toate federațiile",
+  "reviews.dialog.bodyPlaceholder.cashu": "Cum a funcţionat menţinerea, topirea şi susţinerea?",
+  "reviews.dialog.bodyPlaceholder.fedimint": "Cum s-a realizat aderarea, plăţile pentru fulger şi sprijinul acordat?",
+  "fedimint.details.title": "Detaliile Federaţiei",
+  "nav.lnurlMints": "Mint-uri LNURL",
+  "footer.allLnurlMints": "Toate mint-urile LNURL",
+  "lnurlMints.title": "Mint-uri LNURL: mint-uri de bilete la purtător lnurlcash, cu recenzii | Cashumints.space",
+  "lnurlMints.description": "Toate cele {total} mint-uri LNURL indexate din rețeaua Nostr: {online} online, {offline} offline. Evaluări ale comunității, limite de retragere și funcții pentru fiecare.",
+  "lnurlMints.heading": "Mint-uri LNURL",
+  "lnurlMints.lede": "Fiecare mint LNURL pe care îl cunoaște acest site. Un mint LNURL emite bilete la purtător lnurlcash: bilete Lightning pe care le păstrezi ca pe un secret și care pot fi rotite, împărțite, unite sau topite înapoi într-o plată Lightning. Fiecare este verificat prin HTTPS la câteva minute.",
+  "lnurlMints.search.label": "Caută mint-uri LNURL",
+  "lnurlMints.search.placeholder": "Caută după nume sau adresă…",
+  "lnurlMints.sort.label": "Sortează mint-urile LNURL după",
+  "lnurlMints.hideOffline": "Ascunde offline",
+  "lnurlMints.showing": "Se afișează {total} mint-uri LNURL ({online} online, {offline} offline)",
+  "lnurlMints.showingFiltered": "Se afișează {shown} din {total} mint-uri LNURL ({online} online, {offline} offline)",
+  "lnurlMints.noResults": "Niciun mint LNURL nu corespunde.",
+  "lnurlMints.emptyIndex": "Niciun mint LNURL nu este indexat încă.",
+  "lnurl.crumb": "Mint-uri LNURL",
+  "lnurl.breadcrumb": "Firimituri de navigare",
+  "lnurl.copyAddress": "Copiază adresa",
+  "lnurl.more.title": "Mai multe mint-uri LNURL",
+  "lnurl.more.all": "Toate mint-urile LNURL →",
+  "lnurl.disclaimer": "Un mint LNURL îți păstrează sat-ii cât timp tu îi păstrezi biletele, deci folosirea lui înseamnă să ai încredere în operatorul său. Evaluările sunt păreri ale comunității, iar online înseamnă accesibil, nu demn de încredere.",
+  "lnurl.features.title": "Funcții",
+  "lnurl.features.none": "Acest mint nu a anunțat ce acceptă.",
+  "lnurl.features.note": "Funcțiile sunt ceea ce operatorul mint-ului a anunțat pe Nostr. Acolo unde acest site poate verifica una prin HTTPS, o face, și semnalează când ceva anunțat nu este disponibil chiar acum.",
+  "lnurl.features.notListed": "neanunțat",
+  "lnurl.features.unavailable": "indisponibil",
+  "lnurl.feature.mint": "Mint prin Lightning (LUD-06)",
+  "lnurl.feature.melt": "Topire către Lightning",
+  "lnurl.feature.notes": "Rotire / împărțire / unire bilete",
+  "lnurl.feature.lud16": "Adresă Lightning",
+  "lnurl.feature.lud21": "Verificarea plății (LUD-21)",
+  "lnurl.feature.signed-notes": "Bilete semnate (verificare offline)",
+  "lnurl.feature.onion": "Adresă Tor",
+  "lnurl.feature.rotate": "Rotește un bilet",
+  "lnurl.feature.split": "Împarte un bilet",
+  "lnurl.feature.merge": "Unește bilete",
+  "lnurl.feature.lud06": "LUD-06 payRequest",
+  "lnurl.feature.lud03": "LUD-03 withdrawRequest",
+  "lnurl.limits.label": "Limite de retragere",
+  "lnurl.limits.notPublished": "nepublicat",
+  "lnurl.limits.withdrawRow": "Retragere",
+  "lnurl.limits.disabled": "dezactivat",
+  "lnurl.limits.sats.one": "{n} sat",
+  "lnurl.limits.sats.few": "{n} sați",
+  "lnurl.limits.sats.other": "{n} de sați",
+  "lnurl.details.title": "Detalii mint",
+  "lnurl.details.address": "Adresă Lightning",
+  "lnurl.details.mintPubkey": "Cheia publică a mint-ului",
+  "lnurl.details.onion": "Adresă Tor",
+  "lnurl.details.fee": "Comision de mint",
+  "lnurl.details.node": "Nod",
+  "lnurl.details.capacity": "Capacitate anunțată",
+  "lnurl.kind.lightningAddress": "adresă Lightning",
+  "lnurl.kind.mintPubkey": "cheia publică a mint-ului",
+  "lnurl.kind.onionAddress": "adresă Tor",
+  "lnurl.confirmed.label": "Ultima confirmare",
+  "lnurl.confirmed.when": "confirmat {when}",
+  "lnurl.fee.base.one": "{n} sat",
+  "lnurl.fee.base.few": "{n} sați",
+  "lnurl.fee.base.other": "{n} de sați",
+  "lnurl.fee.percent": "{percent}%",
+  "home.topLnurl.title": "Top mint-uri LNURL",
+  "home.topLnurl.sub": "clasate după recenzii și evaluare",
+  "home.topLnurl.all": "Toate cele {n} mint-uri LNURL →",
+  "feed.ecosystem.lnurl": "LNURL",
+  "reviews.dialog.bodyPlaceholder.lnurl": "Cum au mers mint-ul, topirea și rotirea biletelor? Fii concret.",
+  "reviews.byUrl.open": "Scrie o recenzie",
+  "reviews.byUrl.title": "Scrie o recenzie",
+  "reviews.byUrl.lede": "Lipește adresa. Dacă site-ul nu o cunoaște încă, o verifică și o adaugă acum.",
+  "reviews.byUrl.label.cashu": "URL-ul mintului",
+  "reviews.byUrl.label.fedimint": "Codul de invitație al federației",
+  "reviews.byUrl.label.lnurl": "URL-ul mintului LNURL",
+  "reviews.byUrl.placeholder.cashu": "mint.example.com",
+  "reviews.byUrl.placeholder.fedimint": "fed11…",
+  "reviews.byUrl.placeholder.lnurl": "mint.example.com",
+  "reviews.byUrl.check": "Verifică această adresă",
+  "reviews.byUrl.checking": "Se verifică…",
+  "reviews.byUrl.back": "Folosește altă adresă",
+  "reviews.byUrl.existing": "Deja în listă",
+  "reviews.byUrl.indexed": "Tocmai adăugat",
+  "reviews.byUrl.confirmClose": "Închizi? Adresa scrisă nu se păstrează.",
+  "reviews.byUrl.detected": "Acea adresă a răspuns ca un mint {kind}.",
+  "reviews.byUrl.switchTo": "Recenzează-l ca mint {kind}",
+  "reviews.byUrl.error.empty": "Scrie mai întâi o adresă.",
+  "reviews.byUrl.error.badUrl": "Asta nu pare un URL de mint.",
+  "reviews.byUrl.error.badInvite": "Acesta nu e un cod de invitație Fedimint. Codurile încep cu fed11.",
+  "reviews.byUrl.error.badInput": "Site-ul nu poate verifica acea adresă.",
+  "reviews.byUrl.error.blocked": "Nu e o adresă publică, deci nu poate fi verificată.",
+  "reviews.byUrl.error.notAMint": "Acea adresă a răspuns, dar nu ca un mint de acest fel.",
+  "reviews.byUrl.error.wrongType": "Acea adresă a răspuns, dar ca un alt fel de mint.",
+  "reviews.byUrl.error.unverifiable": "Nimic nu a răspuns la acea adresă și nu există încă nicio urmă a ei pe Nostr.",
+  "reviews.byUrl.error.rateLimited.one": "Sunt multe verificări de pe o singură conexiune. Încearcă din nou în aproximativ {n} minut.",
+  "reviews.byUrl.error.rateLimited.other": "Sunt multe verificări de pe o singură conexiune. Încearcă din nou în aproximativ {n} de minute.",
+  "reviews.byUrl.error.network": "Indexul nu a putut fi contactat. Verifică-ți conexiunea și încearcă din nou.",
+  "seo.lnurl.titleNoReviews": "{name}: informații și recenzii despre mint-ul LNURL | Cashumints.space",
+  "seo.desc.statusWithdraw": "{status}, retragere {min}–{max} sat.",
+  "mint.chip.noFunding": "Fără mint / topire",
+  "mint.warnings.lnurlWithdrawalsDisabled.lead": "Retrageri dezactivate.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.online": "Acest mint anunță o retragere maximă de zero, deci niciun bilet emis de el nu poate fi schimbat pe nimic. Nu face mint aici până nu se schimbă asta.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.offline": "La ultimul contact, acest mint anunța o retragere maximă de zero, deci niciun bilet emis de el nu putea fi schimbat pe nimic. Nu face mint aici până nu se schimbă asta.",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.online": "Retrageri dezactivate în prezent",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.offline": "Retragerile erau dezactivate la ultimul contact",
+  "mint.warnings.lnurlInvalid.lead": "Endpoint-ul răspunde, dar este invalid.",
+  "mint.warnings.lnurlInvalid.body": "Gazda răspunde, dar nu cu un anunț de mint pe care acest site îl poate citi, așa că retragerile s-ar putea să nu funcționeze. Mai jos este ultima stare care a putut fi citită, iar recenziile funcționează în continuare.",
+  "mint.warnings.lnurlInvalid.meta": "Răspunde, dar nu cu un anunț de mint valid",
+  "mint.warnings.lnurlNoFunding.lead": "Mint și topire indisponibile.",
+  "mint.warnings.lnurlNoFunding.body": "Biletele existente pot fi în continuare rotite, împărțite sau unite, dar chiar acum nimic nu intră și nu iese prin Lightning. Mint-ul în sine funcționează și răspunde; nodul Lightning din spatele lui nu îi este accesibil.",
+  "mint.warnings.lnurlNoFunding.meta": "Mint și topire indisponibile",
+  "mint.warnings.also.noFunding": "Și nodul său Lightning era inaccesibil, deci nu se putea face mint sau topire."
+}

web/src/i18n/ru.json

@@ -0,0 +1,834 @@
+{
+  "site.name": "Cashumints.space",
+  "common.close": "Закрыть",
+  "common.cancel": "Отменить",
+  "common.done": "Готово",
+  "common.back": "Назад",
+  "common.retry": "Повторить попытку",
+  "common.connect": "Подключиться",
+  "common.copied": "Скопировано",
+  "common.copyFull": "Скопировать полный текст: {kind}",
+  "common.previousPage": "Предыдущая страница",
+  "common.nextPage": "Следующая страница",
+  "common.reviewPages": "Страницы с отзывами",
+  "time.never": "никогда",
+  "time.justNow": "только что",
+  "time.none": "-",
+  "time.unknownDate": "неизвестная дата",
+  "time.ago.minute": "{n} мин. назад",
+  "time.ago.hour": "{n} ч. назад",
+  "time.ago.day": "{n} дн. назад",
+  "time.ago.week": "{n} нед. назад",
+  "time.ago.month": "{n} мес. назад",
+  "time.ago.year": "{n} г. назад",
+  "time.short.minute": "{n}m",
+  "time.short.hour": "{n}h",
+  "time.short.day": "{n}d",
+  "time.short.week": "{n}w",
+  "time.short.month": "{n}mo",
+  "time.short.year": "{n}y",
+  "status.online": "Онлайн",
+  "status.offline": "Офлайн",
+  "status.degraded": "Недоступно",
+  "status.unknown": "Еще не проверено",
+  "nav.skip": "Перейти к содержанию",
+  "nav.main": "Главная",
+  "nav.mints": "Минты Cashu",
+  "nav.reviews": "Отзывы",
+  "nav.wallets": "Кошельки",
+  "nav.about": "О нас",
+  "nav.searchMints": "Поиск среди {n} минтов",
+  "lang.label": "Язык",
+  "lang.switcher": "Выберите язык",
+  "footer.copyright": "© {year} Cashumints.space",
+  "footer.allMints": "Все минты Cashu",
+  "footer.allReviews": "Все отзывы",
+  "footer.wallets": "Кошельки",
+  "footer.about": "О нас",
+  "footer.disclaimer": "Отказ от ответственности",
+  "footer.terms": "Условия",
+  "footer.privacy": "Конфиденциальность",
+  "footer.madeBy": "Сделано с ❤️ {azzamo} · Работает на Cashu и NIP-87",
+  "footer.warning": "Минты хранят ваши средства. Минт может исчезнуть вместе с вашими деньгами.",
+  "footer.tagline": "Отзывы сообщества о ecash-минтах, подписанные в Nostr.",
+  "footer.col.explore": "Обзор",
+  "footer.col.site": "Сайт",
+  "footer.nav": "Подвал сайта",
+  "home.title": "Cashumints.space · Найдите минт Cashu, которому можно доверять",
+  "home.description": "Найдите минт Cashu, которому можно доверять. В каталоге {mints} минтов, {reviews} подписанных в Nostr отзывов сообщества, актуальная доступность, поддерживаемые NUT и ПО минтов.",
+  "home.hero.title": "Найдите минт Cashu",
+  "home.hero.titleEm": "которому можно доверять",
+  "home.hero.lede": "Все минты из сети Nostr с настоящими отзывами сообщества. Никаких посредников, только подписанные отзывы, которые можно проверить самостоятельно.",
+  "home.search.label": "Поиск минтов по названию, домену или URL",
+  "home.search.placeholder": "Введите название, домен или URL минта…",
+  "home.filters.mostReviewed": "Больше всего отзывов",
+  "home.filters.highestRated": "Самый высокий рейтинг",
+  "home.filters.recentlyActive": "Недавно активные",
+  "home.filters.websockets": "Поддерживает WebSockets",
+  "home.top.title": "Лучшие минты Cashu",
+  "home.top.sub": "по отзывам и рейтингу",
+  "home.top.all": "Все минты ({n}) →",
+  "home.latest.title": "Последние отзывы",
+  "home.latest.sub": "напрямую из сети Nostr",
+  "home.latest.prev": "Предыдущие отзывы",
+  "home.latest.next": "Еще отзывы",
+  "home.latest.all": "Все отзывы →",
+  "home.latest.empty": "Сейчас не удалось получить отзывы с relays. Откройте страницу любого минта, чтобы читать и публиковать отзывы напрямую.",
+  "home.why.title": "Почему стоит доверять этим отзывам?",
+  "home.why.signed.title": "Подписаны, а не отправлены нам",
+  "home.why.signed.body": "Каждый отзыв представляет собой событие {link}, подписанное ключом Nostr его автора. Мы не редактируем, не ранжируем и не удаляем здесь ничего.",
+  "home.why.signed.link": "NIP-87",
+  "home.why.verify.title": "Убедитесь в этом сами",
+  "home.why.verify.body": "Отзывы хранятся на публичных Nostr relays, а не в нашей базе данных. Подключите любой клиент к тем же relays и увидите те же данные.",
+  "home.why.checked.title": "Проверяется непрерывно",
+  "home.why.checked.body": "Мы постоянно проверяем доступность каждого минта, версию ПО, лимиты и поддерживаемые NUT. Поэтому вы видите актуальные характеристики, а не только заявления оператора.",
+  "home.cta.title": "Выбираете минт? Сначала прочитайте отзывы.",
+  "home.cta.body": "Минт хранит ваш ecash. Перед внесением sats узнайте об опыте других людей, а после использования оставьте свой отзыв.",
+  "home.cta.explore": "Посмотреть все минты",
+  "home.cta.learn": "Узнайте о Cashu",
+  "pulse.mintsIndexed": "минтов в каталоге",
+  "pulse.reviewsOnNostr": "отзывов в Nostr",
+  "pulse.lastReview": "последний отзыв",
+  "pulse.mintsOnline": "минтов онлайн",
+  "pulse.indexer": "индексатор",
+  "pulse.connected": "подключен",
+  "pulse.stale": "данные устарели",
+  "mints.title": "Все минты Cashu · Cashumints.space",
+  "mints.description": "Все {total} минтов Cashu из сети Nostr: {online} онлайн и {offline} офлайн. Рейтинги сообщества, доступность и ПО минтов. Поиск и сортировка полного списка.",
+  "mints.heading": "Все минты Cashu",
+  "mints.lede": "Все минты, найденные в сети Nostr, включая уже исчезнувшие. Офлайн-минты остаются в списке, чтобы их по-прежнему можно было найти и оценить.",
+  "mints.search.label": "Поиск минтов по названию или домену",
+  "mints.search.placeholder": "Поиск по названию или домену…",
+  "mints.sort.label": "Сортировать минты",
+  "mints.sort.score": "Лучший в целом",
+  "mints.sort.rating": "Самый высокий рейтинг",
+  "mints.sort.reviews": "Больше всего отзывов",
+  "mints.sort.recent": "Недавние отзывы",
+  "mints.sort.seen": "Недавно были онлайн",
+  "mints.hideOffline": "Скрыть офлайн",
+  "mints.showing": "Показано {total} минтов ({online} онлайн, {offline} офлайн)",
+  "mints.showingFiltered": "Показано {shown} из {total} минтов ({online} онлайн, {offline} офлайн)",
+  "mints.noResults": "Соответствующих «минтов» не найдено. Попробуйте ввести домен или вставьте URL-адрес «минта».",
+  "mints.clearSearch": "Очистить результаты поиска",
+  "card.noRatings": "Оценок пока нет",
+  "card.reviews.one": "{n} отзыв",
+  "card.reviews.other": "{n} отзывов",
+  "card.reviews.few": "{n} отзыва",
+  "card.reviews.many": "{n} отзывов",
+  "card.lastSeen": "был онлайн {when}",
+  "card.neverSeen": "ни разу не был онлайн",
+  "card.reviewed": "отзыв оставлен {when}",
+  "card.noReviews": "пока нет отзывов",
+  "mint.title": "{name} · Отзывы о минте Cashu",
+  "mint.titleFedimint": "{name} · Отзывы о федерации Fedimint",
+  "mint.titleLnurl": "{name} · Отзывы о LNURL-минте",
+  "mint.breadcrumb": "Навигационная цепочка",
+  "mint.crumbMints": "Минты Cashu",
+  "mint.copyUrl": "Скопировать URL минта",
+  "mint.qrButton": "QR-код минта",
+  "mint.writeReview": "Написать отзыв",
+  "mint.rankByScore": "№ {rank} по рейтингу",
+  "mint.tagLightning": "Lightning",
+  "mint.summary": "Кратко о минте",
+  "mint.rating.label": "Рейтинг сообщества",
+  "mint.rating.none": "Оценок пока нет",
+  "mint.rating.reviews.one": "{n} отзыв",
+  "mint.rating.reviews.other": "{n} отзывов",
+  "mint.rating.reviews.few": "{n} отзыва",
+  "mint.rating.reviews.many": "{n} отзывов",
+  "mint.rating.unrated.one": "{n} не оставил оценку",
+  "mint.rating.unrated.other": "{n} не оставил оценку",
+  "mint.rating.unrated.few": "{n} не оставил оценку",
+  "mint.rating.unrated.many": "{n} не оставил оценку",
+  "mint.activity.label": "Деятельность",
+  "mint.activity.since": "с последнего отзыва",
+  "mint.activity.noReviews": "пока нет отзывов",
+  "mint.activity.recent.one": "{n} отзыв за последние 90 дней",
+  "mint.activity.recent.other": "{n} отзывов за последние 90 дней",
+  "mint.activity.recent.few": "{n} отзыва за последние 90 дней",
+  "mint.activity.recent.many": "{n} отзывов за последние 90 дней",
+  "mint.limits.label": "Лимиты",
+  "mint.limits.notPublished": "не опубликовано",
+  "mint.limits.min": "мин",
+  "mint.limits.max": "макс.",
+  "mint.limits.mintRow": "mint",
+  "mint.limits.meltRow": "melt",
+  "mint.limits.disabled": "отключено",
+  "mint.limits.range": "от {min} до {max} {unit}",
+  "mint.limits.upTo": "до {max} {unit}",
+  "mint.limits.from": "от {min} {unit}",
+  "mint.software.label": "ПО минта",
+  "mint.software.unknown": "неизвестно",
+  "mint.checked": "проверено {when}",
+  "mint.lastSeen": "был онлайн {when}",
+  "mint.neverReached": "ни разу не ответил",
+  "mint.uptime.checks": "доступен в {ok} из последних {total} проверок",
+  "mint.uptime.percent": "доступен {percent}% времени за 30 дней",
+  "mint.uptime.description": "успешно пройдено {ok} из последних {total} проверок",
+  "mint.operator.title": "От оператора",
+  "mint.operator.motd": "Сообщение дня",
+  "mint.operator.beta": "Этот минт называет себя экспериментальным или находящимся в бета-версии. Прежде чем хранить в нем то, что вы не можете позволить себе потерять, прочитайте слова оператора ниже.",
+  "mint.nuts.title": "Поддерживаемые NUT",
+  "mint.nuts.noneOffline": "Список NUT для этого минта не сохранен: минт ушел офлайн до его получения.",
+  "mint.nuts.noneYet": "Список NUT для этого минта пока не сохранен.",
+  "mint.nuts.supported": "поддерживается {n} из {total} известных NUT",
+  "mint.nuts.whatAre": "Что такое NUTs?",
+  "mint.nutRow.disabled": "отключено",
+  "mint.nutRow.notSupported": "не поддерживается",
+  "mint.details.title": "Сведения о минте",
+  "mint.details.pubkey": "Открытый ключ",
+  "mint.details.nostr": "Nostr",
+  "mint.details.email": "Электронная почта",
+  "mint.details.serverTime": "Время сервера",
+  "mint.details.firstSeen": "Впервые замечено",
+  "mint.details.terms": "Условия",
+  "mint.kind.identifier": "идентификатор",
+  "mint.kind.mintPubkey": "pubkey минта",
+  "mint.kind.nostrAddress": "адрес Nostr",
+  "mint.kind.emailAddress": "адрес электронной почты",
+  "mint.kind.npub": "npub",
+  "mint.disclaimer": "Этот минт хранит ваши средства и может перестать это делать в любой момент. Рейтинги отражают мнения сообщества, а статус «онлайн» означает доступность, но не надежность.",
+  "mint.disclaimerLink": "Ознакомьтесь с полным текстом заявления об ограничении ответственности",
+  "mint.qr.title": "Добавьте «{name}» в свой кошелек",
+  "mint.qr.note": "Отсканируйте код кошельком Cashu, чтобы добавить минт, или скопируйте и вставьте URL.",
+  "mint.qr.warn": "Добавляя минт, вы доверяете ему свои деньги.",
+  "mint.qr.whatMeans": "Что это означает",
+  "mint.qr.wallets": "Кошельки, поддерживающие Cashu",
+  "mint.chip.frozen": "Заморожен",
+  "mint.chip.noWithdrawals": "Вывод отключен",
+  "mint.chip.meltOnly": "Только melt",
+  "mint.warnings.dayCount.one": "{n} день",
+  "mint.warnings.dayCount.other": "{n} дней",
+  "mint.warnings.dayCount.few": "{n} дня",
+  "mint.warnings.dayCount.many": "{n} дней",
+  "mint.warnings.gone.lead": "Скорее всего, пропал.",
+  "mint.warnings.gone.body.since": "Этот минт недоступен с {date} ({days}). Считайте средства в нем находящимися под угрозой и не отправляйте туда новые средства. Ниже показано его последнее известное состояние.",
+  "mint.warnings.gone.body.neverDated": "С начала наблюдения в {month} этот минт не ответил ни на одну проверку. Считайте средства в нем находящимися под угрозой и не отправляйте туда новые средства. Все данные ниже взяты из объявления Nostr, а не от минта.",
+  "mint.warnings.gone.body.never": "С начала наблюдения этот минт не ответил ни на одну проверку. Считайте средства в нем находящимися под угрозой и не отправляйте туда новые средства. Все данные ниже взяты из объявления Nostr, а не от минта.",
+  "mint.warnings.gone.meta.since": "Не в сети с {date}",
+  "mint.warnings.gone.meta.never": "Ни разу не был доступен с момента обнаружения",
+  "mint.warnings.meltDisabled.lead": "Вывод средств отключен.",
+  "mint.warnings.meltDisabled.body.online": "В этом минте отключен melt через Lightning (NUT-05): вносить sats можно, но вывести их через Lightning нельзя. Не вносите средства, пока melt не будет снова включен.",
+  "mint.warnings.meltDisabled.body.offline": "В этом минте был отключен melt через Lightning (NUT-05): вносить sats можно, но вывести их через Lightning нельзя. Не вносите средства, пока melt не будет снова включен.",
+  "mint.warnings.meltDisabled.meta.online": "Вывод средств в настоящее время недоступен",
+  "mint.warnings.meltDisabled.meta.offline": "При последней проверке вывод был отключен",
+  "mint.warnings.frozen.lead": "Минт заморожен.",
+  "mint.warnings.frozen.body.online": "Mint и melt отключены. Через Lightning нельзя ни внести, ни вывести sats.",
+  "mint.warnings.frozen.body.offline": "Mint и melt были отключены. Через Lightning нельзя ни внести, ни вывести sats.",
+  "mint.warnings.frozen.meta.online": "Сейчас заморожен, ввод и вывод отключены",
+  "mint.warnings.frozen.meta.offline": "Был заморожен при последней проверке",
+  "mint.warnings.offlineLong.lead": "Офлайн {days}, с {date}.",
+  "mint.warnings.offlineLong.body": "Возможно, минт исчез. Ниже показано его последнее известное состояние. Отзывы по-прежнему работают.",
+  "mint.warnings.offlineLong.meta": "Не в сети с {date}",
+  "mint.warnings.meltOnly.lead": "Только melt.",
+  "mint.warnings.meltOnly.body.online": "Новый mint через Lightning (NUT-04) отключен: внести средства нельзя, но существующий ecash еще можно вывести. Часто это означает, что минт прекращает работу. Если у вас есть его ecash, рассмотрите вывод через melt.",
+  "mint.warnings.meltOnly.body.offline": "Новый mint через Lightning (NUT-04) был отключен: внести средства нельзя, но существующий ecash еще можно вывести. Часто это означает, что минт прекращает работу. Если у вас есть его ecash, рассмотрите вывод через melt.",
+  "mint.warnings.meltOnly.meta.online": "Сейчас доступен только melt",
+  "mint.warnings.meltOnly.meta.offline": "При последней проверке был доступен только melt",
+  "mint.warnings.offline.lead": "Не в сети с {date}.",
+  "mint.warnings.offline.body": "Последнее подтверждение деталей было получено тогда. Вы по-прежнему можете оставить отзыв.",
+  "mint.warnings.offline.meta": "Не в сети с {date}",
+  "mint.warnings.also.meltDisabled": "Перед уходом офлайн минт также отключил вывод средств.",
+  "mint.warnings.also.mintDisabled": "Перед уходом офлайн минт также отключил новый mint.",
+  "mint.warnings.also.offline": "Минт также находится офлайн с {date} ({days}).",
+  "nut.0": "Обозначения и модели",
+  "nut.1": "Обмен открытым ключом минта",
+  "nut.2": "Наборы ключей и сборы",
+  "nut.3": "Обмен токенами",
+  "nut.4": "Mint через Lightning",
+  "nut.5": "Melt через Lightning",
+  "nut.6": "Информация о минте",
+  "nut.7": "Проверка состояния токена",
+  "nut.8": "Излишне уплаченные комиссии Lightning",
+  "nut.9": "Восстановить подписи",
+  "nut.10": "Условия расходования средств",
+  "nut.11": "Оплата на открытый ключ",
+  "nut.12": "Доказательства DLEQ",
+  "nut.13": "Детерминированные секреты",
+  "nut.14": "Контракты с хешированной временной блокировкой",
+  "nut.15": "Платежи с несколькими путями прохождения",
+  "nut.16": "Анимированные QR-коды",
+  "nut.17": "Подписки WebSocket",
+  "nut.18": "Запросы на оплату",
+  "nut.19": "Ответы из кэша",
+  "nut.20": "Подписанные котировки минта",
+  "nut.21": "Открытая аутентификация",
+  "nut.22": "Слепая аутентификация",
+  "nut.23": "Способ оплаты BOLT11",
+  "nut.24": "HTTP 402: требуется оплата",
+  "nut.25": "Способ оплаты BOLT12",
+  "reviews.title": "Отзывы",
+  "reviews.anon": "Аноним",
+  "reviews.anonTitle": "Для этого ключа не найден общедоступный профиль в Nostr",
+  "reviews.nip05Title": "Идентификатор NIP-05 (не подтвержден данным сайтом)",
+  "reviews.filter.group": "Отфильтровать отзывы",
+  "reviews.filter.all": "Все",
+  "reviews.filter.five": "5★",
+  "reviews.filter.critical": "Критические",
+  "reviews.filter.recent": "Последние",
+  "reviews.filter.hideAnon": "Скрыть анонимные",
+  "reviews.anonHidden.other": "Показано {n} из {total} отзывов: анонимные скрыты.",
+  "reviews.allAnon.one": "Единственный отзыв анонимный.",
+  "reviews.allAnon.other": "Все {n} отзывов анонимные.",
+  "reviews.allAnon.few": "Все {n} отзыва анонимные.",
+  "reviews.allAnon.many": "Все {n} отзывов анонимные.",
+  "reviews.allAnonShow.one": "Показать",
+  "reviews.allAnonShow.other": "Показать их",
+  "reviews.allAnonShow.few": "Показать их",
+  "reviews.allAnonShow.many": "Показать их",
+  "reviews.loading.one": "Загрузка {n} отзыва с Nostr relays",
+  "reviews.loading.other": "Загрузка {n} отзывов с Nostr relays",
+  "reviews.loading.few": "Загрузка {n} отзывов с Nostr relays",
+  "reviews.loading.many": "Загрузка {n} отзывов с Nostr relays",
+  "reviews.empty": "Отзывов пока нет. Будьте первым, кто оставит отзыв.",
+  "reviews.emptyWritten": "Здесь пока нет письменных отзывов. Будьте первым, кто оставит отзыв.",
+  "reviews.emptyFilter": "По данному фильтру отзывов не найдено.",
+  "reviews.rate.cashu": "Оцените этот минт",
+  "reviews.rate.fedimint": "Оцените эту федерацию",
+  "reviews.rate.lnurl": "Оцените этот минт",
+  "reviews.noscript": "Отзывы на Nostr подписываются и загружаются в браузере, поэтому для просмотра этого списка требуется JavaScript. Оценки и количество просмотров, указанные выше, взяты с самого сайта.",
+  "reviews.relayError": "Не удалось подключиться к relay. Часть отзывов может отсутствовать.",
+  "reviews.srRating": "{rating} из 5",
+  "reviews.srNoRating": "Оценка не указана",
+  "reviews.readMore": "Подробнее",
+  "reviews.readLess": "Показать меньше",
+  "reviews.actions.copyNpub": "Скопировать npub",
+  "reviews.actions.openNostr": "Посмотреть это событие на Nostr",
+  "reviews.actions.copyLink": "Скопировать ссылку на этот отзыв",
+  "reviews.anonNote": "Первый отзыв с этого npub, другой активности не найдено",
+  "reviews.published": "Опубликовано.",
+  "reviews.publishedPartial": "Опубликовано на {accepted} из {total} relays.",
+  "reviews.propagating": "Публикация на relays Nostr",
+  "reviews.summary.line.one": "Рейтинг «{count}» без комментариев: {breakdown}",
+  "reviews.summary.line.other": "Рейтинги «{count}» без комментариев: {breakdown}",
+  "reviews.summary.line.few": "Рейтинги «{count}» без комментариев: {breakdown}",
+  "reviews.summary.line.many": "Рейтинги «{count}» без комментариев: {breakdown}",
+  "reviews.summary.lineDay.one": "{count} оценка без комментария за {when}: {breakdown}",
+  "reviews.summary.lineDay.other": "{count} оценок без комментария за {when}: {breakdown}",
+  "reviews.summary.lineDay.few": "{count} оценки без комментария за {when}: {breakdown}",
+  "reviews.summary.lineDay.many": "{count} оценок без комментария за {when}: {breakdown}",
+  "reviews.summary.showOne": "Показать",
+  "reviews.summary.showMany": "Показать их",
+  "reviews.breakdown.5": "{n}, пять звезд",
+  "reviews.breakdown.4": "{n}, четыре звезды",
+  "reviews.breakdown.3": "{n}, три звезды",
+  "reviews.breakdown.2": "{n}, две звезды",
+  "reviews.breakdown.1": "{n}, одна звезда",
+  "reviews.breakdown.none": "{n}, без оценки",
+  "reviews.dialog.title": "Отзыв о {name}",
+  "reviews.dialog.lede.cashu": "Расскажите о своём опыте с этим минтом.",
+  "reviews.dialog.lede.fedimint": "Расскажите о своём опыте с этой федерацией.",
+  "reviews.dialog.lede.lnurl": "Расскажите о своём опыте с этим минтом.",
+  "reviews.dialog.permanent": "Публикуется навсегда на публичных relays Nostr.",
+  "reviews.dialog.gate.title": "Войдите, чтобы написать отзыв",
+  "reviews.dialog.gate.lead": "Отзывы подписываются вашим ключом Nostr. Он остаётся в вашем signer, сайт никогда его не видит.",
+  "reviews.dialog.ratingLegend": "Ваша оценка",
+  "reviews.dialog.starsSr.one": "{n} звезда",
+  "reviews.dialog.starsSr.other": "{n} звезд",
+  "reviews.dialog.starsSr.few": "{n} звезды",
+  "reviews.dialog.starsSr.many": "{n} звезд",
+  "reviews.dialog.chooseRating": "Выберите оценку",
+  "reviews.dialog.starLabel": "{n}: {phrase}",
+  "reviews.dialog.stars.1": "избегайте этого",
+  "reviews.dialog.stars.2": "были проблемы",
+  "reviews.dialog.stars.3": "сработало, но с некоторыми оговорками",
+  "reviews.dialog.stars.4": "хорошо",
+  "reviews.dialog.stars.5": "работает отлично",
+  "reviews.dialog.bodyLabel": "Что следует знать другим людям?",
+  "reviews.dialog.charCount": "{n} / {max}",
+  "reviews.dialog.submit": "Подписать и опубликовать",
+  "reviews.dialog.signing": "Подписываю…",
+  "reviews.dialog.publishing": "Публикация…",
+  "reviews.dialog.publishingTo": "Публикация на relays ({accepted}/{total})",
+  "reviews.dialog.waitingExtension": "Ожидание расширения",
+  "reviews.dialog.waitingSigner": "Ожидание signer",
+  "reviews.dialog.confirmClose": "Закрыть этот отзыв? Ваш черновик сохранится до тех пор, пока вы не покинете сайт.",
+  "reviews.dialog.why.login": "Войдите в систему, чтобы опубликовать",
+  "reviews.dialog.why.words": "Напишите несколько слов",
+  "reviews.dialog.why.more.one": "нужен еще {n} символ",
+  "reviews.dialog.why.more.other": "{n} еще символов",
+  "reviews.dialog.why.more.few": "{n} еще символов",
+  "reviews.dialog.why.more.many": "{n} еще символов",
+  "reviews.dialog.why.over.one": "{n}: символ выходит за пределы допустимого диапазона",
+  "reviews.dialog.why.over.other": "{n}: количество символов превышает допустимый предел",
+  "reviews.dialog.why.over.few": "{n}: количество символов превышает допустимый предел",
+  "reviews.dialog.why.over.many": "{n}: количество символов превышает допустимый предел",
+  "reviews.dialog.identity.needSigner": "Для публикации нужен Nostr signer. Ваш ключ остается в нем, сайт никогда его не видит.",
+  "reviews.dialog.identity.loginToPublish": "Войдите в систему, чтобы опубликовать",
+  "reviews.dialog.identity.switch": "Сменить",
+  "reviews.dialog.identity.extension": "Подпись через расширение браузера",
+  "reviews.dialog.identity.readingKey": "Считывание вашего открытого ключа…",
+  "reviews.dialog.identity.willAsk": "Расширение запросит подтверждение подписи",
+  "reviews.dialog.error.noRelay": "Ни один relay не принял отзыв. Проверьте подключение и попробуйте еще раз.",
+  "reviews.validate.rating": "Выберите оценку от 1 до 5 звезд.",
+  "reviews.validate.short": "Напишите не менее {n} символов, чтобы отзыв был полезен.",
+  "reviews.validate.long": "Длина отзыва ограничена {n} символами.",
+  "feed.title": "Последние отзывы о минтах и федерациях · Cashumints.space",
+  "feed.description": "Каждый отзыв о минте, федерации и LNURL-минте сразу после публикации: {reviews} отзывов о {mints} минтах Cashu, {federations} федерациях Fedimint и {lnurl} LNURL-минтах, подписанных в Nostr и доступных здесь начиная с самых новых. Фильтруйте по экосистеме, оценке или названию.",
+  "feed.heading": "Последние отзывы",
+  "feed.lede": "Все отзывы о минтах Cashu и федерациях Fedimint, от новых к старым, напрямую с Nostr relays. Каждый отзыв подписан автором и хранится на relays, а не в нашей базе данных.",
+  "feed.label": "Отзывы",
+  "feed.showingBuild.one": "Отображение самого последнего отзыва из последней сборки",
+  "feed.showingBuild.other": "Отображение последних отзывов о {n} за последнюю версию",
+  "feed.showingBuild.few": "Отображение последних отзывов о {n} за последнюю версию",
+  "feed.showingBuild.many": "Отображение последних отзывов о {n} за последнюю версию",
+  "feed.noscript": "Отзывы подписаны в Nostr и загружаются в браузере, поэтому для фильтров и полного списка нужен JavaScript. Эти {n} отзывов были получены с relays при сборке страницы.",
+  "feed.emptyBuild": "При сборке страницы получить отзывы с relays не удалось. В браузере список загрузится с relays заново.",
+  "feed.foot": "Отзывы отражают мнения сообщества, а не проверенные факты. Прочитайте {link}, прежде чем доверять минту деньги.",
+  "feed.footLink": "отказ от ответственности",
+  "feed.showing": "Отображается {shown} из {total} отзывов",
+  "feed.showingMatching": "Отображаются {shown} из {matching} соответствующих отзывов (всего {total})",
+  "feed.emptyRelays": "С relays не получено отзывов. Откройте страницу любого минта, чтобы читать и публиковать отзывы.",
+  "feed.emptyFilter": "По данному фильтру отзывов не найдено. Очистите поле «Минт» или выберите «Все».",
+  "feed.relayError": "Не удалось подключиться к relays. Показаны отзывы из последней сборки.",
+  "feed.relayEmpty": "С relays не получено отзывов. Показаны отзывы из последней сборки.",
+  "feed.reading": "Чтение relays…",
+  "login.open": "Войти",
+  "login.title": "Войти через Nostr",
+  "login.note": "Ваш ключ остается в signer. Этот сайт никогда его не увидит.",
+  "login.extension.name": "Расширение для браузера",
+  "login.extension.desc": "Подпишите через Alby, nos2x или другое расширение NIP-07",
+  "login.extension.none": "Расширение не найдено",
+  "login.extension.getOne": "Установить:",
+  "login.remote.name": "Удаленный signer",
+  "login.remote.desc": "Отсканируйте код приложением signer или вставьте bunker-ссылку",
+  "login.primal.name": "Primal",
+  "login.primal.desc": "Подтвердите вход в приложение Primal на вашем телефоне",
+  "login.paste.label": "Или вставьте ссылку подключения из signer",
+  "login.copyLink": "Скопируйте ссылку для подключения",
+  "login.whatIsNostr": "Что такое Nostr?",
+  "login.connect.remote.title": "Подключить удаленный signer",
+  "login.connect.remote.lead": "Отсканируйте код приложением signer или скопируйте ссылку и вставьте ее туда.",
+  "login.connect.remote.hint": "Работает с любым NIP-46 signer: nsec.app, Amber, Nostrify или вашим bunker.",
+  "login.connect.remote.open": "Открыть в приложении signer",
+  "login.connect.primal.title": "Подключиться через Primal",
+  "login.connect.primal.lead": "Откройте приложение Primal на телефоне, найдите в настройках пункт «Удаленная авторизация» и отсканируйте этот код.",
+  "login.connect.primal.hint": "Primal подписывает запросы других приложений по NIP-46. Это то же подключение, которое использует любой signer, а ваш ключ остается в Primal. {link}",
+  "login.connect.primal.open": "Открыть в Primal",
+  "login.status.buildingLink": "Создание ссылки подключения",
+  "login.status.waitingExtension": "Ожидание расширения",
+  "login.status.waitingSigner": "Ожидание signer",
+  "login.status.connecting": "Подключение к signer",
+  "login.status.connected": "Подключено",
+  "login.toast.loggedIn": "Вход выполнен",
+  "login.toast.fetchingProfile": "Загрузка вашего профиля Nostr с relays…",
+  "login.toast.profile": "Профиль: {name}",
+  "login.toast.noProfile": "Профиль на relays не найден",
+  "login.method.extension": "Расширение",
+  "login.method.remote": "Удаленный",
+  "login.method.primal": "Primal",
+  "login.account": "Ваша учетная запись Nostr",
+  "login.copyNpub": "Скопировать полный npub",
+  "login.logout": "Выйти",
+  "signer.status.waitingExtension": "Ожидание расширения",
+  "signer.status.signed": "Подписано",
+  "signer.status.reconnecting": "Повторное подключение к signer",
+  "signer.status.approveWindow": "Подтвердите запрос в окне signer",
+  "signer.status.waitingSigner": "Ожидание signer",
+  "signer.status.stillWaiting": "Signer все еще не ответил",
+  "signer.status.connected": "Подключено",
+  "signer.error.noExtension": "Не найдено расширения для подписи. Установите Alby или nos2x, а затем перезагрузите эту страницу.",
+  "signer.error.privateKey": "Это похоже на закрытый ключ, а не на ссылку подключения. Сайт никогда не принимает ключи. Вставьте ссылку bunker:// из signer.",
+  "signer.error.badLink": "Сайт не распознает эту ссылку подключения. Вставьте ссылку bunker:// из signer.",
+  "signer.error.noAnswer": "Signer не ответил. Возможно, он закрыт или его relay недоступен. Откройте signer и попробуйте еще раз.",
+  "signer.error.timeout": "Signer не ответил вовремя. Откройте его, проверьте подключение и попробуйте еще раз.",
+  "signer.error.cancelled": "Соединение прервано.",
+  "signer.error.declined": "Запрос на подпись был отклонен",
+  "notfound.title": "Страница не найдена · Cashumints.space",
+  "notfound.description": "Эта страница отсутствует на сайте Cashumints.space.",
+  "notfound.heading": "Эта страница не существует",
+  "notfound.lede": "Возможно, страница перемещена или минт еще не добавлен в каталог. Найдите минт по названию или домену либо вставьте URL минта.",
+  "notfound.browse": "Посмотреть все минты",
+  "notfound.home": "На главную",
+  "notfound.loading": "Загрузка {host}",
+  "notfound.fb.rating": "Рейтинг",
+  "notfound.fb.reviews": "Отзывы",
+  "notfound.fb.software": "Программное обеспечение",
+  "notfound.fb.lastOnline": "Последний раз онлайн",
+  "notfound.fb.note": "Этот минт был проиндексирован после последней сборки сайта, поэтому здесь сводка из живого API, а ниже его отзывы. Полная страница появится при следующей сборке.",
+  "notfound.resolve.checking": "Первое посещение: проверяем этот минт.",
+  "notfound.resolve.failed": "Не удалось добавить этот минт",
+  "notfound.resolve.failedFedimint": "Не удалось добавить эту федерацию",
+  "notfound.resolve.retry": "Попробовать другой адрес",
+  "notfound.resolve.switch": "Открыть как минт {kind}",
+  "notfound.resolve.fedimint": "Адрес страницы федерации не содержит её код приглашения, поэтому найти её по одной ссылке нельзя. Вставь код приглашения, и она будет добавлена.",
+  "notfound.resolve.ambiguous": "Этот адрес нельзя восстановить по одной ссылке. Вставь полный URL минта, и он будет добавлен.",
+  "wallets.title": "Кошельки Cashu · Cashumints.space",
+  "wallets.description": "Кошельки Cashu для перечисленных здесь минтов: мобильные, веб-кошельки, расширения и CLI, с описанием сильных сторон каждого.",
+  "wallets.heading": "Кошельки",
+  "wallets.lede": "Для хранения ecash из этих минтов нужен кошелек. Большинство кошельков работают сразу с несколькими минтами, поэтому вы не привязаны к первому выбранному.",
+  "wallets.note": "Список неполный и не является рекомендацией. Более широкий каталог проекта Cashu доступен по ссылке {link}. Кошелек хранит ключи, а минт хранит деньги. Прочитайте отзывы о минтах, прежде чем выбирать, где держать sats.",
+  "wallets.platform.android": "Android",
+  "wallets.platform.ios": "iOS",
+  "wallets.platform.web": "Веб",
+  "wallets.platform.extension": "Расширение для браузера",
+  "wallets.platform.cli": "CLI",
+  "wallets.platform.python": "Python",
+  "wallets.item.minibits": "Мобильный ecash-кошелек с собственным минтом, поддержкой Lightning-адресов и контактами Nostr.",
+  "wallets.item.nutstash": "Браузерный кошелек для нескольких минтов с импортом и экспортом необработанных токенов.",
+  "wallets.item.enuts": "Мобильный кошелек для балансов в нескольких минтах и отправки ecash через Nostr.",
+  "wallets.item.cashume": "Эталонный веб-кошелек от проекта Cashu. Работает полностью в браузере, устанавливается как PWA.",
+  "wallets.item.boardwalk": "Веб-кошелек, построенный на основе адресов Lightning и позволяющий отправлять электронные деньги по ссылке.",
+  "wallets.item.coinos": "Кошелек Lightning и кассовое приложение с собственным минтом Cashu.",
+  "wallets.item.oxchat": "Мессенджер Nostr со встроенным кошельком ecash для отправки сатов в чатах.",
+  "wallets.item.nutshell": "Эталонная реализация. Работает как CLI-кошелек и как ПО минта.",
+  "about.title": "О сайте Cashumints.space",
+  "about.description": "Что такое Cashu, какие средства хранит минт, что такое NIP-87 и как сайт индексирует минты и читает отзывы с Nostr relays.",
+  "about.heading": "О нас",
+  "about.lede": "Cashumints.space показывает все найденные нами в сети Nostr минты Cashu и отзывы о них. Сайт создан Azzamo.",
+  "about.cashu.title": "Что такое Cashu",
+  "about.cashu.p1": "Cashu представляет собой протокол ecash для Bitcoin. Минт выпускает ослепленные токены, обеспеченные хранящимися у него sats. Токены переходят между людьми, а минт не узнает, кто, что и кому отправил. В этом и состоит приватность: токены не являются счетами, и минт не может связать подписанный им токен с вернувшимся токеном.",
+  "about.cashu.p2": "Протокол и его спецификации доступны по ссылке {link}. Спецификации называются NUT, отсюда номера NUT на странице каждого минта.",
+  "about.mints.title": "Что такое «минт» и в чём заключается компромисс",
+  "about.mints.p1": "Минт хранит средства пользователей. При mint ecash вы передаете sats оператору сервера и доверяете ему погасить токены при melt. Здесь нет доказательства мошенничества, эскроу или возможности добиться возмещения. Оператор минта может исчезнуть со всеми средствами, и такое уже случалось.",
+  "about.mints.p2": "Именно поэтому здесь есть отзывы. Сайт никогда не называет минт безопасным. Статус на странице минта означает {code}, а не «надежный»: сервер лишь ответил на последнюю проверку. Относитесь к ecash как к наличным в кармане: они подходят для расходов, но не для сбережений.",
+  "about.nip87.title": "Что такое NIP-87",
+  "about.nip87.p1": "NIP-87 представляет собой соглашение Nostr для объявлений и рекомендаций ecash-минтов. Здесь важны два вида событий:",
+  "about.nip87.li1": "{code} объявляет минт. URL минта находится в теге {tag}. Так сайт находит ранее неизвестные минты.",
+  "about.nip87.li2": "{code} представляет собой отзыв. Он содержит оценку и текст и указывает на минт тегом {utag} (URL минта) и тегом {dtag} (собственный pubkey минта).",
+  "about.nip87.p2": "Каждый отзыв подписан ключом Nostr его автора. Мы никогда не называем отзыв «проверенным», поскольку никто его не проверял: он подписан, а это совсем другое и более полезное утверждение. Это означает, что вы можете проверить, кто его написал, и что он не был изменен. Это не означает, что автор честен или когда-либо пользовался сервисом Mint.",
+  "about.how.title": "Как работает этот сайт",
+  "about.how.p1": "Есть два цикла и одно правило. Метаданные принадлежат минту, а отзывы принадлежат Nostr, поэтому сайт не считает себя первичным источником ни того, ни другого.",
+  "about.how.li1": "{strong} каждые десять минут запрашивает {code} у всех известных минтов и записывает название, описание, версию, поддерживаемые NUT, лимиты и контакты. Он также отмечает, ответил ли минт. Из этого рассчитывается доступность.",
+  "about.how.li1Label": "Контур зонда",
+  "about.how.li2": "{strong} каждый час подключается к Nostr relays, читает объявления минтов и отзывы и добавляет ранее неизвестные минты.",
+  "about.how.li2Label": "Цикл открытий",
+  "about.how.p2": "Особенно важно, что происходит, когда минт перестает отвечать. Неудачная проверка не перезаписывает кэшированные метаданные, поэтому у исчезнувшего минта сохраняется полная страница: характеристики, история и отзывы, а баннер сообщает дату отключения. Раньше сайт показывал вместо нее ошибку, и именно минты, о которых важнее всего было предупредить других, нельзя было оценить. Это стало главной причиной переработки.",
+  "about.how.p3": "Тексты отзывов не хранятся у нас. При открытии страницы минта браузер напрямую читает отзывы с relays. Новый отзыв подписывается вашим расширением Nostr и отправляется прямо на relays. Мы храним только число отзывов для ранжирования и сортировки. Мы не можем редактировать или удалять отзывы, даже если они нам не нравятся.",
+  "about.relays.title": "Реле, о которых мы читали",
+  "about.relays.p1": "Индексатор и ваш браузер используют эти relays:",
+  "about.relays.p2": "Подключите любой клиент Nostr к тем же relays и увидите те же события. Ничто здесь не становится правдой только потому, что так сказали мы.",
+  "about.nuts.title": "Что такое NUT?",
+  "about.nuts.p1": "NUT представляют собой нумерованные спецификации Cashu, подобно BIP в Bitcoin. Минт сообщает, какие NUT он реализует. NUT-04 и NUT-05 определяют mint и melt через Lightning, NUT-07 позволяет проверить, потрачен ли токен, NUT-17 дает кошелькам обновления через WebSockets без опроса, а NUT-20 позволяет доказать, что котировка действительно выдана минтом. Полный список доступен по ссылке {link}.",
+  "about.numbers.title": "Прямо сейчас",
+  "about.numbers.p1": "В каталоге {mints} минтов, из них {online} отвечают. На указанных выше relays найдено {reviews} отзывов.",
+  "about.source.title": "Источник и указание авторства",
+  "about.source.p1": "Исходный код сайта доступен на {github}. Сайт создан и поддерживается {azzamo}. Если на странице минта есть ошибка, исправьте первоисточник: метаданные поступают из {code} самого минта, а отзывы из Nostr.",
+  "terms.title": "Условия использования · Cashumints.space",
+  "terms.description": "Условия использования Cashumints.space: что представляет собой сайт, чего он не делает и кто за что отвечает. Без учетных записей, гарантий и связи с каким-либо минтом.",
+  "terms.heading": "Условия использования",
+  "terms.lede": "Простые условия использования сайта, который индексирует только общедоступные данные. Последнее обновление: {date}.",
+  "terms.what.title": "Что представляет собой этот сайт",
+  "terms.what.p1": "Cashumints.space представляет собой каталог публичных данных о минтах Cashu. Здесь есть два вида данных, оба из внешних источников:",
+  "terms.what.li1": "Метаданные из собственного эндпоинта {code} каждого минта: название, описание, версия ПО, поддерживаемые NUT, контакты и результат последней проверки доступности.",
+  "terms.what.li2": "Отзывы с публичных Nostr relays. Это события NIP-87, опубликованные авторами на relays, доступных для запросов любому пользователю.",
+  "terms.what.p2": "Мы собираем эти данные, приводим их к единому формату, ранжируем и отображаем. Мы их не создаем.",
+  "terms.noAccounts.title": "Без учета, без гарантий",
+  "terms.noAccounts.p1": "Регистрироваться не нужно. Сайт предоставляется «как есть» без гарантий точности и актуальности данных или доступности сайта. Данные минта могут отставать на минуты или часы, минт может измениться после проверки, а relay может не ответить. В таком случае вы увидите не все существующие данные.",
+  "terms.noAccounts.p2": "Используйте сайт на свой риск. Мы не отвечаем за убытки, вызванные использованием сайта или доверием к опубликованной здесь информации. Конкретные риски использования минта Cashu описаны в разделе {link}.",
+  "terms.noAccounts.link": "отказ от ответственности",
+  "terms.noCustody.title": "Мы не удерживаем ваши деньги",
+  "terms.noCustody.p1": "Сайт никогда не принимает средства на хранение. У него нет кошелька, он не распоряжается ecash и не может переводить, замораживать или возвращать средства. При проблеме с минтом помочь может только его оператор, и мы не можем связаться с ним от вашего имени.",
+  "terms.noCustody.p2": "Мы не связаны ни с одним минтом из каталога, и ни один минт не платит за размещение, позицию или рейтинг. Минты находятся через публичные объявления Nostr и ранжируются алгоритмом по публичным отзывам.",
+  "terms.reviews.title": "Отзывы написаны другими людьми",
+  "terms.reviews.p1": "Отзывы представляют собой пользовательский контент, опубликованный авторами на публичных Nostr relays. Мы показываем, но не контролируем их. Мы их не писали, не можем редактировать и не можем удалить с relays: это подписанные события в сети, которая нам не принадлежит.",
+  "terms.reviews.p2": "Отзыв отражает опыт одного человека, а не подтвержденный факт. Публикуя отзыв, вы отвечаете за его содержание. Не публикуйте незаконные материалы и помните, что публикация общедоступна и постоянна. Подробнее на {link}.",
+  "terms.reviews.link": "страница о конфиденциальности",
+  "terms.reviews.p3": "Мы можем скрыть конкретный отзыв на сайте и сделаем это для незаконного контента. Он исчезнет только с этих страниц. Событие останется на relays, и другие клиенты Nostr по-прежнему смогут его прочитать.",
+  "terms.links.title": "Ссылки на другие сайты",
+  "terms.links.p1": "URL-адреса Mint, ссылки на кошельки, контактные данные операторов и всё остальное, что ведёт за пределы этого сайта, приводятся здесь, поскольку являются частью данных. Ссылка не означает одобрения, и мы не проверяем содержание страниц, на которые она ведёт.",
+  "terms.changes.title": "Изменения",
+  "terms.changes.p1": "Эти условия могут изменяться. Дата, указанная вверху, показывает, когда они в последний раз обновлялись. Сайт является проектом с открытым исходным кодом, поэтому каждое изменение на этой странице отражается в истории коммитов.",
+  "terms.contact.title": "Контакты",
+  "terms.contact.p1": "О проблемах и запросах на удаление материалов лучше всего сообщать на сайте {github}. Сайт управляется организацией «{azzamo}».",
+  "privacy.title": "Политика конфиденциальности · Cashumints.space",
+  "privacy.description": "Конфиденциальность на Cashumints.space: никаких учетных записей, никаких отслеживающих файлов cookie, никакой аналитики. localStorage используется для кэширования профиля, и никакие данные никуда не отправляются. Отзывы подписываются в вашем собственном браузере.",
+  "privacy.heading": "Конфиденциальность",
+  "privacy.lede": "Мы собираем минимум данных, насколько это возможно для веб-сайта. Последнее обновление: {date}.",
+  "privacy.noAccounts.title": "Учетных записей нет",
+  "privacy.noAccounts.p1": "Здесь нет ни регистрации, ни входа в систему, ни личного профиля. Ничто на этом сайте не спрашивает, кто вы, и нет никаких пользовательских данных, которые могли бы стать предметом утечки, поскольку здесь нет пользователей.",
+  "privacy.noTracking.title": "Без отслеживающих файлов cookie, без аналитики",
+  "privacy.noTracking.p1": "Сайт не использует файлы cookie для отслеживания. На сайте отсутствуют аналитические скрипты, менеджеры тегов, пиксели, средства записи сеансов и рекламные сети. Ничто на этой странице не передает информацию о вашем поведении ни нам, ни кому-либо ещё.",
+  "privacy.logs.title": "Журналы сервера",
+  "privacy.logs.p1": "Веб-сервер ведет стандартные журналы доступа, как любой веб-сервер по умолчанию. Строка журнала содержит IP-адрес, время, запрошенную страницу, статус ответа, user agent и referrer, отправленные браузером. Журналы нужны для поиска ошибок и злоупотреблений. Они не связываются с другими данными, не продаются и не передаются.",
+  "privacy.logs.operatorLabel": "Примечание оператора:",
+  "privacy.logs.operator": "Если вы администрируете этот сайт, укажите здесь фактический срок хранения. В примере развертывания, приведённом в файле README, используется nginx с журналом доступа по умолчанию и той схемой ротации, которая предусмотрена в вашем дистрибутиве (в Debian и Ubuntu это logrotate с ежедневной ротацией и хранением записей в течение 14 дней). Уточните настройки вашего сервера и замените этот абзац соответствующим числом.",
+  "privacy.storage.title": "Что хранится в вашем браузере",
+  "privacy.storage.p1": "Сайт использует localStorage ровно для двух целей, и в обоих случаях данные остаются на вашем устройстве и никуда не отправляются:",
+  "privacy.storage.li1": "Кэш метаданных профилей Nostr (события kind 0: имена, аватары, адреса NIP-05) для авторов просмотренных отзывов. Это позволяет не запрашивать relays заново на каждой странице. Записи имеют срок действия, а при заполнении кэша первыми удаляются самые старые.",
+  "privacy.storage.li2": "Настройки интерфейса, чтобы сайт при следующем посещении работал так же.",
+  "privacy.storage.p2": "Очистка данных сайта в браузере удалит и то, и другое. Ничего не сломается, поиск профилей просто запустится заново.",
+  "privacy.thirdParties.title": "С чем взаимодействует ваш браузер",
+  "privacy.thirdParties.p1": "При загрузке страницы ваш браузер подключается не только к этому сайту, но и к нескольким другим ресурсам. Именно так сайт, не использующий отслеживание на стороне сервера, всё же получает актуальные данные:",
+  "privacy.thirdParties.li1Label": "Публичные Nostr relays",
+  "privacy.thirdParties.li1": "{strong} через WebSocket для чтения отзывов и профилей авторов. Relay видит ваш IP-адрес и запрос, как любой сервер, к которому вы подключаетесь. Список relays находится на {link}.",
+  "privacy.thirdParties.li1Link": "странице «О сайте»",
+  "privacy.thirdParties.li2Label": "Аватары авторов отзывов",
+  "privacy.thirdParties.li2": "{strong}, загружаемый с того адреса, на который указывает профиль рецензента. Эти запросы отправляются без указания реферера, поэтому хост не узнает, на какой странице вы находились.",
+  "privacy.publishing.title": "Публикация отзыва",
+  "privacy.publishing.p1": "Отзыв создается в браузере, а не на нашем сервере. Событие подписывается вашим расширением NIP-07 (Alby, nos2x или аналогичным) и отправляется из браузера прямо на relays. Закрытый ключ не покидает расширение, и сайт его не видит. Мы не создаем собственную систему управления ключами и никогда не запрашиваем ключ или seed phrase.",
+  "privacy.permanent.title": "Всё, что вы публикуете в Nostr, становится общедоступным и сохраняется навсегда",
+  "privacy.permanent.p1": "Этот раздел стоит прочитать дважды. Отзыв представляет собой подписанное событие на публичных relays. После публикации вернуть его нельзя:",
+  "privacy.permanent.li1": "Любой может прочитать его сейчас или позже через любой клиент Nostr. Он общедоступен не только на Cashumints.space, а во всей сети.",
+  "privacy.permanent.li2": "Она навсегда привязана к вашему открытому ключу Nostr наряду со всем остальным, что когда-либо публиковалось с помощью этого ключа.",
+  "privacy.permanent.li3": "Удаление представляет собой просьбу, а не команду. Можно опубликовать событие удаления, и некоторые relays его выполнят, но любой relay может проигнорировать его, а копии события останутся. Считайте опубликованный отзыв постоянным.",
+  "privacy.permanent.li4": "Мы не можем удалить событие за вас. Мы можем перестать показывать его здесь, но это никак не повлияет на relays.",
+  "privacy.permanent.p2": "Чтобы отзыв о минте не был связан с основной личностью, используйте отдельный ключ Nostr. Для резких отзывов мы отмечаем ключи без другой активности: читателям важно видеть, что отзыв на одну звезду оставлен совершенно новым ключом.",
+  "privacy.contact.title": "Вопросы",
+  "privacy.contact.p1": "Сайт имеет открытый исходный код: если вы хотите проверить что-либо из вышеперечисленного, ознакомьтесь с кодом по адресу {github}. Вопросы и исправления можно оставлять в виде задач на этом сайте.",
+  "disclaimer.title": "Отказ от ответственности · Cashumints.space",
+  "disclaimer.description": "Что нужно знать перед использованием минта Cashu: минты хранят средства и могут исчезнуть с вашими деньгами, отзывы являются мнениями, а статус «онлайн» означает доступность, но не надежность.",
+  "disclaimer.heading": "Отказ от ответственности",
+  "disclaimer.lede": "Прочитайте это, прежде чем вносить деньги в минт. Последнее обновление: {date}.",
+  "disclaimer.callout": "Минт Cashu хранит ваши деньги. Если он исчезнет, ваш ecash пропадет, и обратиться будет не к кому. Храните только ту сумму, которую можете позволить себе потерять.",
+  "disclaimer.custodial.title": "Минты хранят средства пользователей",
+  "disclaimer.custodial.p1": "При mint ecash вы передаете bitcoin оператору минта и получаете токены. Эти токены представляют собой требование к оператору, а не bitcoin под вашим контролем. Оператор решает, погашать ли их.",
+  "disclaimer.custodial.p2": "Все минты несут одинаковые риски: оператор может исчезнуть, его могут вынудить остановиться, средства могут быть потеряны из-за ошибки или взлома, а сервер может быть просто выключен. Нет страхования вкладов, возврата платежа, гарантированной поддержки или надежной правовой защиты. Это относится и к минту с самым высоким рейтингом.",
+  "disclaimer.custodial.p3": "Cashu рассчитан на быстрое перемещение небольших сумм. Храните то, что собираетесь потратить, а не сбережения, и распределяйте средства между минтами.",
+  "disclaimer.reviews.title": "Отзывы являются мнениями, а не проверенными фактами",
+  "disclaimer.reviews.p1": "Каждый отзыв на этом сайте был написан пользователем Nostr и подписан его ключом. Подпись означает, что мы можем указать, какой именно ключ его написал. Это не означает, что отзыв соответствует действительности, что автор пользовался сервисом или что автор не является оператором, конкурентом или одним человеком, владеющим десятью ключами.",
+  "disclaimer.reviews.p2": "Мы не проверяем авторов, не редактируем и не удаляем отзывы, с которыми не согласны. Прочитайте несколько отзывов и учитывайте, что три отзыва дают меньше оснований для вывода, чем триста.",
+  "disclaimer.status.title": "«Онлайн» означает «доступный», а не «надежный»",
+  "disclaimer.status.p1": "Мы регулярно проверяем каждый минт и показываем, ответил ли он. Зеленый статус означает только ответ сервера. Он ничего не говорит о платежеспособности и честности оператора или о том, погасит ли он ваши токены завтра.",
+  "disclaimer.status.p2": "Минт может работать в сети вплоть до того момента, когда он перестанет работать. История безотказной работы, поддерживаемые NUT и версия программного обеспечения дают некоторое представление о том, как управляется минт, но ни один из этих факторов не является гарантией сохранности ваших средств.",
+  "disclaimer.ranking.title": "Как работает рейтинг и что он не означает",
+  "disclaimer.ranking.p1": "Минты ранжируются с помощью алгоритма на основе данных публичных отзывов: рейтинга, количества отзывов и недавней активности, при этом по умолчанию онлайн-минты отображаются перед офлайн-минтами. Подробности приведены в открытом исходном коде.",
+  "disclaimer.ranking.p2": "Никто не платит за размещение. Здесь нет спонсорских мест, продвижения или договоренностей с минтами. Высокая позиция означает лишь благоприятную оценку публичных данных алгоритмом. Это не рекомендация и не оценка безопасности.",
+  "disclaimer.notAdvice.title": "Это не является финансовой рекомендацией",
+  "disclaimer.notAdvice.p1": "Ничто на сайте не является финансовой, инвестиционной, юридической или налоговой консультацией. Мы не знаем вашу ситуацию и не даем рекомендаций. Решение об использовании и выборе минта принимаете вы.",
+  "disclaimer.dyor.title": "Проведите собственное исследование",
+  "disclaimer.dyor.li1": "Изучите оператора. Минт человека с публичной репутацией отличается от анонимного URL.",
+  "disclaimer.dyor.li2": "Прочитайте условия и MOTD самого минта. Если минт называет себя тестовым или бета-версией, отнеситесь к этому серьезно.",
+  "disclaimer.dyor.li3": "Начните с малого. Выполните mint небольшой суммы, потратьте ее, затем сделайте melt и проверьте результат, прежде чем доверять больше.",
+  "disclaimer.dyor.li4": "Следите за лимитами. Низкий максимум часто говорит об осторожности оператора, а высокий не доказывает безопасность.",
+  "disclaimer.dyor.li5": "Храните резервные копии токенов. Токен является активом на предъявителя: потратить его может любой владелец.",
+  "disclaimer.site.title": "О самом сайте",
+  "disclaimer.site.p1": "Данные могут быть неверными или устаревшими. Минты проверяются по расписанию, relays иногда не отвечают, а страница была собрана раньше. Сайт предоставляется «как есть» без гарантий. См. {link}.",
+  "disclaimer.site.link": "условия использования",
+  "disclaimer.updated": "20 августа 2026 года",
+  "login.getPrimal": "Станьте «праймалом»",
+  "reviews.dialog.identity.extensionGone": "Ваше расширение для браузера не отвечает. Войдите в систему заново или воспользуйтесь удаленным средством подписи.",
+  "seo.orgDescription": "Каталог минтов Cashu с актуальным статусом и подписанными в Nostr отзывами сообщества.",
+  "seo.ogImageAlt": "Cashumints.space: найдите минт Cashu, которому можно доверять.",
+  "seo.mint.title.one": "Отзывы о {name}: оценка {rating} по {n} отзыву | Cashumints.space",
+  "seo.mint.title.other": "Отзывы о {name}: рейтинг «{rating}» по результатам {n} отзывов | Cashumints.space",
+  "seo.mint.title.few": "Отзывы о {name}: рейтинг «{rating}» по результатам {n} отзывов | Cashumints.space",
+  "seo.mint.title.many": "Отзывы о {name}: рейтинг «{rating}» по результатам {n} отзывов | Cashumints.space",
+  "seo.mint.titleOffline.one": "{name}: сайт не работает в связи с Днем «{n}» | Cashumints.space",
+  "seo.mint.titleOffline.other": "{name}: не работает в течение {n} дней | Cashumints.space",
+  "seo.mint.titleOffline.few": "{name}: не работает в течение {n} дней | Cashumints.space",
+  "seo.mint.titleOffline.many": "{name}: не работает в течение {n} дней | Cashumints.space",
+  "seo.mint.titleNoReviews": "{name}: информация и отзывы о минте Cashu | Cashumints.space",
+  "seo.fedimint.titleNoReviews": "{name}: информация и отзывы о федерации Fedimint | Cashumints.space",
+  "seo.desc.fallback": "Отзывы пользователей о сайте «{name}» ({domain}).",
+  "seo.desc.fallbackDomain": "Отзывы сообщества о минте Cashu на {domain}.",
+  "seo.desc.rated.one": "Оценка {rating}/5 по {n} подписанному отзыву Nostr.",
+  "seo.desc.rated.other": "Оценка {rating}/5 по {n} подписанным отзывам Nostr.",
+  "seo.desc.rated.few": "Оценка {rating}/5 по {n} подписанным отзывам Nostr.",
+  "seo.desc.rated.many": "Оценка {rating}/5 по {n} подписанным отзывам Nostr.",
+  "seo.desc.noReviews": "Отзывов пока нет.",
+  "seo.desc.status": "{status}.",
+  "seo.desc.statusLimits": "{status}, лимиты: {limits}.",
+  "seo.desc.fedModules": "{status}. Модули: {modules}.",
+  "seo.desc.fedModulesNetwork": "{status}. Модули: {modules}, сеть {network}.",
+  "seo.mint.ogAlt.one": "{name}: {rating} звезд по {n} отзыву на Cashumints.space",
+  "seo.mint.ogAlt.other": "{name}: {rating} звезд по {n} отзывам на Cashumints.space",
+  "seo.mint.ogAlt.few": "{name}: {rating} звезд по {n} отзывам на Cashumints.space",
+  "seo.mint.ogAlt.many": "{name}: {rating} звезд по {n} отзывам на Cashumints.space",
+  "seo.mint.ogAltNoReviews": "«{name}» на сайте Cashumints.space",
+  "nav.home": "Главная",
+  "mint.more.title": "Другие минты",
+  "mint.more.all": "Посмотреть все минты",
+  "nav.fedimints": "Fedimints",
+  "status.announced": "Только объявлено",
+  "card.unnamedFederation": "Федерация без названия",
+  "card.notChecked": "никогда не проверял",
+  "fedimints.title": "Все федерации Fedimint · Cashumints.space",
+  "fedimints.description": "Все {total} федераций Fedimint, объявленных в сети Nostr: {online} подтверждены внешней проверкой, {announced} объявлены, но ни разу не подтверждены. Рейтинги сообщества, модули и коды приглашений.",
+  "fedimints.heading": "Все федерации",
+  "fedimints.lede": "Каждая федерация Fedimint была объявлена в сети Nostr. У федерации нет собственной общедоступной конечной точки статуса, поэтому работоспособность некоторых из них подтверждается внешней проверкой, а остальные перечислены в том виде, в каком они были объявлены.",
+  "fedimints.search.label": "Поиск федераций по названию или идентификатору",
+  "fedimints.search.placeholder": "Поиск по имени или идентификатору федерации…",
+  "fedimints.sort.label": "Сортировать федерации",
+  "fedimints.hideOffline": "Скрыть статус «не в сети»",
+  "fedimints.showing": "Показано {total} федераций ({online} подтверждены, {announced} только объявлены)",
+  "fedimints.showingFiltered": "Отображаются {shown} из {total} федераций ({online} подтверждены, {announced} только объявлены)",
+  "fedimints.announcedNote.one": "Один из них был анонсирован на Nostr, и с тех пор не появилось никаких подтверждений того, что он работает. Он указан как «анонсированный», а не как «онлайн» или «офлайн», поскольку ни то, ни другое не соответствует действительности.",
+  "fedimints.announcedNote.other": "{n} из них были анонсированы на Nostr, и с тех пор не поступало никаких подтверждений того, что они работают. Они указаны как «анонсированные», а не как «онлайн» или «офлайн», поскольку ни то, ни другое не соответствует действительности.",
+  "fedimints.announcedNote.few": "{n} из них были анонсированы на Nostr, и с тех пор не поступало никаких подтверждений того, что они работают. Они указаны как «анонсированные», а не как «онлайн» или «офлайн», поскольку ни то, ни другое не соответствует действительности.",
+  "fedimints.announcedNote.many": "{n} из них были анонсированы на Nostr, и с тех пор не поступало никаких подтверждений того, что они работают. Они указаны как «анонсированные», а не как «онлайн» или «офлайн», поскольку ни то, ни другое не соответствует действительности.",
+  "fedimints.noResults": "Нет результатов по федерациям. Введите название или вставьте идентификатор федерации.",
+  "fedimints.emptyIndex": "На relays, которые читает сайт, пока не объявлено ни одной федерации. Список пополняется по мере новых объявлений.",
+  "fedimint.crumb": "Федиминтс",
+  "fedimint.breadcrumb": "Навигационная цепочка",
+  "fedimint.unnamed": "Федерация без названия",
+  "fedimint.idLabel": "Федерация",
+  "fedimint.kind.federationId": "идентификатор федерации",
+  "fedimint.moduleCount.one": "Модуль {n}",
+  "fedimint.moduleCount.other": "Модули {n}",
+  "fedimint.moduleCount.few": "Модули {n}",
+  "fedimint.moduleCount.many": "Модули {n}",
+  "fedimint.copyInvite": "Скопировать код приглашения",
+  "fedimint.confirmed.label": "Подтверждено",
+  "fedimint.confirmed.never": "Никогда",
+  "fedimint.confirmed.by": "Автор: {source}",
+  "fedimint.confirmed.unattributed": "последняя проверка",
+  "fedimint.announcedOn": "объявлена {when}",
+  "fedimint.announcedUnknown": "дата объявления не указана",
+  "fedimint.modules.title": "Модули",
+  "fedimint.modules.none": "В объявлении этой федерации не указано ни одного модуля.",
+  "fedimint.modules.note": "Модули представляют собой компоненты федерации. Объявление перечисляет установленные модули, но не сообщает, принимает ли какой-либо из них депозиты.",
+  "fedimint.modules.notListed": "не указан",
+  "fedimint.invite.title": "Код приглашения",
+  "fedimint.invite.count.one": "Код {n}",
+  "fedimint.invite.count.other": "Коды {n}",
+  "fedimint.invite.count.few": "Коды {n}",
+  "fedimint.invite.count.many": "Коды {n}",
+  "fedimint.invite.note": "Скопируйте этот текст в кошелек Fedimint, чтобы присоединиться. В нём содержатся идентификатор федерации и адреса её хранителей; его следует передавать другим пользователям.",
+  "fedimint.invite.kind": "код приглашения",
+  "fedimint.invite.qr": "QR",
+  "fedimint.invite.qrCaption": "Отсканируйте QR-код, чтобы присоединиться к группе «{name}»",
+  "fedimint.details.federationId": "Идентификатор федерации",
+  "fedimint.details.network": "Сеть",
+  "fedimint.details.announcedBy": "Объявлен",
+  "fedimint.details.announced": "Объявлено",
+  "fedimint.more.title": "Другие федерации",
+  "fedimint.more.all": "Посмотреть все федерации",
+  "fedimint.disclaimer": "Присоединяясь к федерации, вы доверяете деньги ее guardians. Рейтинги отражают мнения сообщества, а подтвержденная работа означает доступность, но не надежность.",
+  "fedimint.module.lightning": "Lightning",
+  "fedimint.module.mint": "Минт ecash",
+  "fedimint.module.wallet": "Кошелек в цепочке блоков",
+  "fedimint.module.meta": "Метаданные",
+  "fedimint.module.stability_pool": "Резерв стабильности",
+  "fedimint.module.multi_sig_stability_pool": "Пул стабильности (мультисиг)",
+  "fedimint.module.fedi-social": "Социальная реабилитация",
+  "fedimint.network.mainnet": "Основная сеть Биткойна",
+  "fedimint.network.signet": "Сигнет",
+  "fedimint.network.testnet": "Тестовая сеть",
+  "fedimint.network.testnet4": "Testnet4",
+  "fedimint.network.regtest": "Regtest",
+  "feed.ecosystem.group": "Экосистема",
+  "feed.ecosystem.all": "Все",
+  "feed.ecosystem.cashu": "Кашу",
+  "feed.ecosystem.fedimint": "Федиминт",
+  "feed.filterBySubject": "Фильтр по «Mint» или «Federation»",
+  "feed.anySubject": "Любой минт или федерация",
+  "feed.clearSubject": "Очистить фильтр по названию",
+  "home.topFedimints.title": "Лучшие Fedimints",
+  "home.topFedimints.sub": "по отзывам и рейтингу",
+  "home.topFedimints.all": "Все федерации «{n}» →",
+  "reviews.validate.subject": "Не указан минт или федерация для отзыва.",
+  "mint.warnings.fedimintOffline.lead": "Сообщается, что федерация офлайн.",
+  "mint.warnings.fedimintOffline.body.since": "Последняя успешная проверка федерации была {date} ({days} назад). С тех пор ее guardians не отвечают. Считайте средства в ней находящимися под угрозой и не вносите новые.",
+  "mint.warnings.fedimintOffline.body.never": "Эта федерация так и не прошла ни одной проверки, а последняя из них закончилась неудачей. Считайте хранящиеся там средства подверженными риску и не вкладывайте в неё новые средства.",
+  "mint.warnings.fedimintOffline.meta.since": "Сообщается об отсутствии связи с момента {date}",
+  "mint.warnings.fedimintOffline.meta.never": "Сообщается, что федерация офлайн, ни одна проверка не была успешной",
+  "mint.warnings.neverConfirmed.lead": "Объявлено, но так и не подтверждено.",
+  "mint.warnings.neverConfirmed.body.reviewed": "Эта федерация была объявлена в Nostr {date}, {days} назад, и с тех пор ее работу ничто не подтвердило. Отзывы ниже служат единственным признаком активности на странице, все остальные данные взяты из объявления.",
+  "mint.warnings.neverConfirmed.body.quiet": "Эта федерация была объявлена в Nostr {date}, {days} назад. С тех пор ее работу ничто не подтвердило, и свежих отзывов нет. Все данные ниже взяты из объявления.",
+  "mint.warnings.neverConfirmed.meta": "Объявлено о выпуске «{date}», но так и не подтверждено",
+  "footer.allFedimints": "Все федерации",
+  "reviews.dialog.bodyPlaceholder.cashu": "Как работали mint, melt и поддержка? Опишите конкретно.",
+  "reviews.dialog.bodyPlaceholder.fedimint": "Как прошло подключение к системе, работали ли платежи Lightning и поддержка? Расскажите подробнее.",
+  "fedimint.details.title": "Сведения о федерации",
+  "nav.lnurlMints": "LNURL-минты",
+  "footer.allLnurlMints": "Все LNURL-минты",
+  "lnurlMints.title": "LNURL-минты: минты предъявительских нот lnurlcash с отзывами | Cashumints.space",
+  "lnurlMints.description": "Все {total} LNURL-минтов, проиндексированных из сети Nostr: {online} онлайн, {offline} офлайн. Оценки сообщества, лимиты вывода и возможности каждого.",
+  "lnurlMints.heading": "LNURL-минты",
+  "lnurlMints.lede": "Все LNURL-минты, которые знает этот сайт. LNURL-минт выпускает предъявительские ноты lnurlcash: ноты Lightning, которые вы храните как секрет и которые можно провернуть, разделить, объединить или расплавить обратно в платёж Lightning. Каждый проверяется по HTTPS раз в несколько минут.",
+  "lnurlMints.search.label": "Поиск LNURL-минтов",
+  "lnurlMints.search.placeholder": "Поиск по имени или адресу…",
+  "lnurlMints.sort.label": "Сортировать LNURL-минты по",
+  "lnurlMints.hideOffline": "Скрыть офлайн",
+  "lnurlMints.showing": "Показано {total} LNURL-минтов ({online} онлайн, {offline} офлайн)",
+  "lnurlMints.showingFiltered": "Показано {shown} из {total} LNURL-минтов ({online} онлайн, {offline} офлайн)",
+  "lnurlMints.noResults": "Ни один LNURL-минт не подходит.",
+  "lnurlMints.emptyIndex": "LNURL-минты ещё не проиндексированы.",
+  "lnurl.crumb": "LNURL-минты",
+  "lnurl.breadcrumb": "Хлебные крошки",
+  "lnurl.copyAddress": "Скопировать адрес",
+  "lnurl.more.title": "Другие LNURL-минты",
+  "lnurl.more.all": "Все LNURL-минты →",
+  "lnurl.disclaimer": "LNURL-минт хранит ваши саты, пока вы держите его ноты, так что пользоваться им — значит доверять его оператору. Оценки — это мнения сообщества, а «онлайн» означает доступен, а не надёжен.",
+  "lnurl.features.title": "Возможности",
+  "lnurl.features.none": "Этот минт не объявлял, что он поддерживает.",
+  "lnurl.features.note": "Возможности — это то, что оператор минта объявил в Nostr. Там, где сайт может проверить их по HTTPS, он это делает и сообщает, если объявленное сейчас недоступно.",
+  "lnurl.features.notListed": "не объявлено",
+  "lnurl.features.unavailable": "недоступно",
+  "lnurl.feature.mint": "Чеканка через Lightning (LUD-06)",
+  "lnurl.feature.melt": "Плавка в Lightning",
+  "lnurl.feature.notes": "Проворот / разделение / объединение нот",
+  "lnurl.feature.lud16": "Lightning-адрес",
+  "lnurl.feature.lud21": "Проверка платежа (LUD-21)",
+  "lnurl.feature.signed-notes": "Подписанные ноты (офлайн-проверка)",
+  "lnurl.feature.onion": "Tor-адрес",
+  "lnurl.feature.rotate": "Провернуть ноту",
+  "lnurl.feature.split": "Разделить ноту",
+  "lnurl.feature.merge": "Объединить ноты",
+  "lnurl.feature.lud06": "LUD-06 payRequest",
+  "lnurl.feature.lud03": "LUD-03 withdrawRequest",
+  "lnurl.limits.label": "Лимиты вывода",
+  "lnurl.limits.notPublished": "не опубликовано",
+  "lnurl.limits.withdrawRow": "Вывод",
+  "lnurl.limits.disabled": "отключено",
+  "lnurl.limits.sats.one": "{n} сат",
+  "lnurl.limits.sats.few": "{n} сата",
+  "lnurl.limits.sats.many": "{n} сатов",
+  "lnurl.limits.sats.other": "{n} сатов",
+  "lnurl.details.title": "Данные минта",
+  "lnurl.details.address": "Lightning-адрес",
+  "lnurl.details.mintPubkey": "Публичный ключ минта",
+  "lnurl.details.onion": "Tor-адрес",
+  "lnurl.details.fee": "Комиссия за чеканку",
+  "lnurl.details.node": "Узел",
+  "lnurl.details.capacity": "Объявленная ёмкость",
+  "lnurl.kind.lightningAddress": "Lightning-адрес",
+  "lnurl.kind.mintPubkey": "публичный ключ минта",
+  "lnurl.kind.onionAddress": "Tor-адрес",
+  "lnurl.confirmed.label": "Последнее подтверждение",
+  "lnurl.confirmed.when": "подтверждён {when}",
+  "lnurl.fee.base.one": "{n} сат",
+  "lnurl.fee.base.few": "{n} сата",
+  "lnurl.fee.base.many": "{n} сатов",
+  "lnurl.fee.base.other": "{n} сатов",
+  "lnurl.fee.percent": "{percent}%",
+  "home.topLnurl.title": "Лучшие LNURL-минты",
+  "home.topLnurl.sub": "по отзывам и оценке",
+  "home.topLnurl.all": "Все {n} LNURL-минтов →",
+  "feed.ecosystem.lnurl": "LNURL",
+  "reviews.dialog.bodyPlaceholder.lnurl": "Как прошли чеканка, плавка и проворот нот? Пишите конкретно.",
+  "reviews.byUrl.open": "Написать отзыв",
+  "reviews.byUrl.title": "Написать отзыв",
+  "reviews.byUrl.lede": "Вставь адрес. Если сайт его ещё не знает, он проверит его и добавит прямо сейчас.",
+  "reviews.byUrl.label.cashu": "URL минта",
+  "reviews.byUrl.label.fedimint": "Код приглашения федерации",
+  "reviews.byUrl.label.lnurl": "URL LNURL-минта",
+  "reviews.byUrl.placeholder.cashu": "mint.example.com",
+  "reviews.byUrl.placeholder.fedimint": "fed11…",
+  "reviews.byUrl.placeholder.lnurl": "mint.example.com",
+  "reviews.byUrl.check": "Проверить этот адрес",
+  "reviews.byUrl.checking": "Проверяем…",
+  "reviews.byUrl.back": "Другой адрес",
+  "reviews.byUrl.existing": "Уже в списке",
+  "reviews.byUrl.indexed": "Только что добавлен",
+  "reviews.byUrl.confirmClose": "Закрыть? Введённый адрес не сохранится.",
+  "reviews.byUrl.detected": "Этот адрес ответил как минт {kind}.",
+  "reviews.byUrl.switchTo": "Оценить как минт {kind}",
+  "reviews.byUrl.error.empty": "Сначала введи адрес.",
+  "reviews.byUrl.error.badUrl": "Это не похоже на URL минта.",
+  "reviews.byUrl.error.badInvite": "Это не код приглашения Fedimint. Коды начинаются с fed11.",
+  "reviews.byUrl.error.badInput": "Сайт не может проверить этот адрес.",
+  "reviews.byUrl.error.blocked": "Это не публичный адрес, поэтому проверить его нельзя.",
+  "reviews.byUrl.error.notAMint": "Адрес ответил, но не как минт этого типа.",
+  "reviews.byUrl.error.wrongType": "Адрес ответил, но как минт другого типа.",
+  "reviews.byUrl.error.unverifiable": "По этому адресу ничего не ответило, и в Nostr о нём пока нет ни следа.",
+  "reviews.byUrl.error.rateLimited.one": "Слишком много проверок с одного соединения. Попробуй снова примерно через {n} минуту.",
+  "reviews.byUrl.error.rateLimited.other": "Слишком много проверок с одного соединения. Попробуй снова примерно через {n} минут.",
+  "reviews.byUrl.error.network": "Не удалось связаться с индексом. Проверь соединение и попробуй снова.",
+  "seo.lnurl.titleNoReviews": "{name}: информация и отзывы о LNURL-минте | Cashumints.space",
+  "seo.desc.statusWithdraw": "{status}, вывод {min}–{max} сат.",
+  "mint.chip.noFunding": "Нет чеканки / плавки",
+  "mint.warnings.lnurlWithdrawalsDisabled.lead": "Вывод отключён.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.online": "Этот минт объявляет максимальный вывод в ноль, поэтому ни одну выпущенную им ноту нельзя ни на что обменять. Не чеканьте здесь, пока это не изменится.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.offline": "При последнем контакте этот минт объявлял максимальный вывод в ноль, поэтому ни одну выпущенную им ноту нельзя было ни на что обменять. Не чеканьте здесь, пока это не изменится.",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.online": "Вывод сейчас отключён",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.offline": "При последнем контакте вывод был отключён",
+  "mint.warnings.lnurlInvalid.lead": "Эндпоинт отвечает, но некорректно.",
+  "mint.warnings.lnurlInvalid.body": "Хост отвечает, но не объявлением минта, которое сайт может прочитать, поэтому вывод может не работать. Ниже — последнее состояние, которое удалось разобрать, а отзывы по-прежнему работают.",
+  "mint.warnings.lnurlInvalid.meta": "Отвечает, но не корректным объявлением минта",
+  "mint.warnings.lnurlNoFunding.lead": "Чеканка и плавка недоступны.",
+  "mint.warnings.lnurlNoFunding.body": "Существующие ноты по-прежнему можно провернуть, разделить или объединить, но сейчас через Lightning ничего не входит и не выходит. Сам минт работает и отвечает; узел Lightning за ним для него недоступен.",
+  "mint.warnings.lnurlNoFunding.meta": "Чеканка и плавка недоступны",
+  "mint.warnings.also.noFunding": "Его узел Lightning тоже был недоступен, поэтому ничего нельзя было отчеканить или расплавить."
+}

web/src/i18n/sv.json

@@ -0,0 +1,788 @@
+{
+  "site.name": "Cashumints.space",
+  "common.close": "Stäng",
+  "common.cancel": "Avbryt",
+  "common.done": "Klart",
+  "common.back": "Tillbaka",
+  "common.retry": "Försök igen",
+  "common.connect": "Anslut",
+  "common.copied": "Kopierat",
+  "common.copyFull": "Kopiera hela {kind}",
+  "common.previousPage": "Föregående sida",
+  "common.nextPage": "Nästa sida",
+  "common.reviewPages": "Recensionssidor",
+  "time.never": "aldrig",
+  "time.justNow": "alldeles nyss",
+  "time.none": "-",
+  "time.unknownDate": "ett okänt datum",
+  "time.ago.minute": "{n}m sedan",
+  "time.ago.hour": "{n}h för en stund sedan",
+  "time.ago.day": "{n}d sedan",
+  "time.ago.week": "{n}w sedan",
+  "time.ago.month": "{n}mo för en stund sedan",
+  "time.ago.year": "{n}y sedan",
+  "time.short.minute": "{n}m",
+  "time.short.hour": "{n}h",
+  "time.short.day": "{n}d",
+  "time.short.week": "{n}w",
+  "time.short.month": "{n}mo",
+  "time.short.year": "{n}y",
+  "status.online": "Online",
+  "status.offline": "Offline",
+  "status.degraded": "Oåtkomlig",
+  "status.unknown": "Har inte kontrollerats ännu",
+  "nav.skip": "Gå direkt till innehållet",
+  "nav.main": "Huvudsida",
+  "nav.mints": "Cashu-mints",
+  "nav.reviews": "Recensioner",
+  "nav.wallets": "Plånböcker",
+  "nav.about": "Om",
+  "nav.searchMints": "Sök bland {n} mints",
+  "lang.label": "Språk",
+  "lang.switcher": "Välj språk",
+  "footer.copyright": "© {year} Cashumints.space",
+  "footer.allMints": "Alla Cashu-mints",
+  "footer.allReviews": "Alla recensioner",
+  "footer.wallets": "Plånböcker",
+  "footer.about": "Om",
+  "footer.disclaimer": "Ansvarsfriskrivning",
+  "footer.terms": "Villkor",
+  "footer.privacy": "Sekretess",
+  "footer.madeBy": "Skapad med ❤️ av {azzamo} · Drivs av Cashu och NIP-87",
+  "footer.warning": "Mints är förvaringsinstitut. Ett mint kan försvinna med dina pengar.",
+  "footer.tagline": "Recensioner från communityn om ecash-mints, signerade på Nostr.",
+  "footer.col.explore": "Utforska",
+  "footer.col.site": "Webbplats",
+  "footer.nav": "Sidfot",
+  "home.title": "Cashumints.space · Hitta ett Cashu-mint du kan lita på",
+  "home.description": "Hitta ett Cashu-mint du kan lita på. {mints} mints i indexet med {reviews} recensioner från communityn, signerade på Nostr, plus live drifttid, stöd för NUTs och mint-programvara.",
+  "home.hero.title": "Hitta ett Cashu-mint",
+  "home.hero.titleEm": "som du kan lita på",
+  "home.hero.lede": "Varje mint i Nostr-nätverket, med äkta recensioner från communityn. Inga grindvakter, bara signerade recensioner du kan verifiera själv.",
+  "home.search.label": "Sök mints på namn, domän eller URL",
+  "home.search.placeholder": "Sök efter namn, domän eller klistra in en Mint-URL…",
+  "home.filters.mostReviewed": "Mest omtalade",
+  "home.filters.highestRated": "Högst betygsatta",
+  "home.filters.recentlyActive": "Nyligen aktiva",
+  "home.filters.websockets": "Stöder WebSockets",
+  "home.top.title": "De bästa Cashu-mints",
+  "home.top.sub": "rangerade efter recensioner och betyg",
+  "home.top.all": "Alla {n} mints →",
+  "home.latest.title": "Senaste recensionerna",
+  "home.latest.sub": "direkt från nätverket Nostr",
+  "home.latest.prev": "Tidigare recensioner",
+  "home.latest.next": "Fler recensioner",
+  "home.latest.all": "Alla recensioner →",
+  "home.latest.empty": "Det gick inte att läsa några recensioner från reläerna just nu. Öppna valfri Mint-sida för att läsa och skriva recensioner direkt.",
+  "home.why.title": "Varför kan man lita på dessa recensioner?",
+  "home.why.signed.title": "Undertecknat, men inte inlämnat",
+  "home.why.signed.body": "Varje recension är en {link}-händelse som signerats med författarens Nostr-nyckel. Inget här redigeras, rangordnas eller tas bort av oss.",
+  "home.why.signed.link": "NIP-87",
+  "home.why.verify.title": "Kontrollera det själv",
+  "home.why.verify.body": "Recensionerna finns på de offentliga Nostr-reläerna, inte i vår databas. Rikta vilken cli-enhet som helst mot samma reläer så ser du samma data.",
+  "home.why.checked.title": "Kontrolleras kontinuerligt",
+  "home.why.checked.body": "Vi kontrollerar varje mint med avseende på drifttid, programvaruversion, begränsningar och vilka NUTs-enheter som stöds, så de specifikationer du ser är aktuella och inte självrapporterade.",
+  "home.cta.title": "Funderar du på att köpa en mint? Läs det här först.",
+  "home.cta.body": "Ett mint håller din ecash. Läs vad andra har kommit fram till innan du sätter in sats, och lämna en recension när du själv har använt ett.",
+  "home.cta.explore": "Upptäck alla mintsorter",
+  "home.cta.learn": "Läs mer om Cashu",
+  "pulse.mintsIndexed": "mints i indexet",
+  "pulse.reviewsOnNostr": "recensioner på Nostr",
+  "pulse.lastReview": "senaste granskningen",
+  "pulse.mintsOnline": "mints online",
+  "pulse.indexer": "indexerare",
+  "pulse.connected": "ansluten",
+  "pulse.stale": "föråldrad",
+  "mints.title": "Alla Cashu-mints · Cashumints.space",
+  "mints.description": "Alla {total} Cashu-mints indexerade från Nostr-nätverket, {online} online och {offline} offline, med betyg från communityn, drifttid och mint-programvara. Sök och sortera hela listan.",
+  "mints.heading": "Alla Cashu-mints",
+  "mints.lede": "Varje mint som hittats i Nostr-nätverket, inklusive de som är borta. Mints som är offline står kvar i listan så att du fortfarande kan hitta och recensera dem.",
+  "mints.search.label": "Sök mints på namn eller domän",
+  "mints.search.placeholder": "Sök efter namn eller domän…",
+  "mints.sort.label": "Sortera mints",
+  "mints.sort.score": "Bäst totalt sett",
+  "mints.sort.rating": "Högst betygsatta",
+  "mints.sort.reviews": "Mest omtalade",
+  "mints.sort.recent": "Nyligen granskade",
+  "mints.sort.seen": "Nyligen visade på nätet",
+  "mints.hideOffline": "Dölj offline",
+  "mints.showing": "Visar {total} mints ({online} online, {offline} offline)",
+  "mints.showingFiltered": "Visar {shown} av {total} mints ({online} online, {offline} offline)",
+  "mints.noResults": "Inga mints matchar. Prova en domän, eller klistra in en mint-URL.",
+  "mints.clearSearch": "Rensa sökningen",
+  "card.noRatings": "Inga betyg ännu",
+  "card.reviews.one": "{n} recension",
+  "card.reviews.other": "{n} recensioner",
+  "card.lastSeen": "senast sett {when}",
+  "card.neverSeen": "har aldrig setts på nätet",
+  "card.reviewed": "recenserat {when}",
+  "card.noReviews": "inga recensioner ännu",
+  "mint.title": "{name} · recensioner av Cashu-mint",
+  "mint.titleFedimint": "{name} · recensioner av Fedimint-federation",
+  "mint.titleLnurl": "{name} · recensioner av LNURL-mint",
+  "mint.breadcrumb": "Navigationsspår",
+  "mint.crumbMints": "Cashu-mints",
+  "mint.copyUrl": "Kopiera mint-URL",
+  "mint.qrButton": "Mint QR",
+  "mint.writeReview": "Skriv en recension",
+  "mint.rankByScore": "#{rank} efter poäng",
+  "mint.tagLightning": "Lightning",
+  "mint.summary": "Mint-sammanfattning",
+  "mint.rating.label": "Gemenskapens betyg",
+  "mint.rating.none": "Inga betyg ännu",
+  "mint.rating.reviews.one": "{n} recension",
+  "mint.rating.reviews.other": "{n} recensioner",
+  "mint.rating.unrated.one": "{n} har inte lämnat något betyg",
+  "mint.rating.unrated.other": "{n} har inte lämnat något betyg",
+  "mint.activity.label": "Aktivitet",
+  "mint.activity.since": "sedan senaste recensionen",
+  "mint.activity.noReviews": "inga recensioner ännu",
+  "mint.activity.recent.one": "{n} recension de senaste 90 dagarna",
+  "mint.activity.recent.other": "{n} recensioner de senaste 90 dagarna",
+  "mint.limits.label": "Gränser",
+  "mint.limits.notPublished": "ej publicerad",
+  "mint.limits.min": "min",
+  "mint.limits.max": "max",
+  "mint.limits.mintRow": "mint",
+  "mint.limits.meltRow": "melt",
+  "mint.limits.disabled": "avstängd",
+  "mint.limits.range": "{min} till {max} {unit}",
+  "mint.limits.upTo": "upp till {max} {unit}",
+  "mint.limits.from": "från {min} {unit}",
+  "mint.software.label": "Mint-programvara",
+  "mint.software.unknown": "okänt",
+  "mint.checked": "kontrollerad {when}",
+  "mint.lastSeen": "senast sett {when}",
+  "mint.neverReached": "aldrig nåtts",
+  "mint.uptime.checks": "{ok} av de senaste {total} kontrollerna nåbara",
+  "mint.uptime.percent": "{percent}% tillgänglig under 30 dagar",
+  "mint.uptime.description": "{ok} av de senaste {total} kontrollerna lyckades",
+  "mint.operator.title": "Från operatören",
+  "mint.operator.motd": "Dagens meddelande",
+  "mint.operator.beta": "Denna mint beskriver sig själv som experimentell eller i betafas. Läs operatörens egna ord nedan innan du förvarar något som du inte har råd att förlora.",
+  "mint.nuts.title": "NUTs som stöds",
+  "mint.nuts.noneOffline": "Ingen NUT-lista är cachad för detta mint, det gick offline innan någon hann registreras.",
+  "mint.nuts.noneYet": "Ingen NUT-lista är cachad för detta mint ännu.",
+  "mint.nuts.supported": "{n} av {total} kända NUTs stöds",
+  "mint.nuts.whatAre": "Vad är NUTs?",
+  "mint.nutRow.disabled": "avstängd",
+  "mint.nutRow.notSupported": "stöds inte",
+  "mint.details.title": "Mint-detaljer",
+  "mint.details.pubkey": "Pubkey",
+  "mint.details.nostr": "Nostr",
+  "mint.details.email": "E-post",
+  "mint.details.serverTime": "Servertid",
+  "mint.details.firstSeen": "Första gången",
+  "mint.details.terms": "Villkor",
+  "mint.kind.identifier": "identifierare",
+  "mint.kind.mintPubkey": "mint-pubkey",
+  "mint.kind.nostrAddress": "Nostr-adress",
+  "mint.kind.emailAddress": "e-postadress",
+  "mint.kind.npub": "npub",
+  "mint.disclaimer": "Detta mint är förvarande: det håller dina pengar, och det kan sluta göra det när som helst. Betyg är åsikter från communityn, och online betyder nåbar, inte pålitlig.",
+  "mint.disclaimerLink": "Läs hela ansvarsfriskrivningen",
+  "mint.qr.title": "Lägg till {name} i din plånbok",
+  "mint.qr.note": "Skanna den här med en Cashu-wallet för att lägga till mintet, eller kopiera URL:en och klistra in den.",
+  "mint.qr.warn": "Att lägga till ett mint betyder att anförtro det dina pengar.",
+  "mint.qr.whatMeans": "Vad det innebär",
+  "mint.qr.wallets": "Plånböcker som stöder Cashu",
+  "mint.chip.frozen": "Fryst",
+  "mint.chip.noWithdrawals": "Inga uttag",
+  "mint.chip.meltOnly": "Endast melt",
+  "mint.warnings.dayCount.one": "{n} dag",
+  "mint.warnings.dayCount.other": "{n} dagar",
+  "mint.warnings.gone.lead": "Förmodligen borta.",
+  "mint.warnings.gone.body.since": "Detta mint har varit onåbart sedan {date} ({days}). Betrakta medel som ligger där som utsatta, och skicka inte in nya medel. Detaljerna nedan visar dess senast kända tillstånd.",
+  "mint.warnings.gone.body.neverDated": "Detta mint har inte svarat på en enda kontroll sedan vi började bevaka det i {month}. Betrakta medel som ligger där som utsatta, och skicka inte in nya medel. Allt nedan kommer från Nostr-annonseringen, inte från mintet.",
+  "mint.warnings.gone.body.never": "Detta mint har inte svarat på en enda kontroll sedan vi började bevaka det. Betrakta medel som ligger där som utsatta, och skicka inte in nya medel. Allt nedan kommer från Nostr-annonseringen, inte från mintet.",
+  "mint.warnings.gone.meta.since": "Offline sedan {date}",
+  "mint.warnings.gone.meta.never": "Har aldrig gått att nå sedan den upptäcktes",
+  "mint.warnings.meltDisabled.lead": "Uttag är inaktiverade.",
+  "mint.warnings.meltDisabled.body.online": "Detta mint har melting via Lightning (NUT-05) avstängt: du kan sätta in sats, men du kan inte ta ut dem via Lightning. Sätt inte in något förrän melting är tillbaka.",
+  "mint.warnings.meltDisabled.body.offline": "Detta mint hade melting via Lightning (NUT-05) avstängt: du kan sätta in sats, men du kan inte ta ut dem via Lightning. Sätt inte in något förrän melting är tillbaka.",
+  "mint.warnings.meltDisabled.meta.online": "Uttag är för närvarande inaktiverade",
+  "mint.warnings.meltDisabled.meta.offline": "Uttag var inaktiverade när de senast visades",
+  "mint.warnings.frozen.lead": "Mint fryst.",
+  "mint.warnings.frozen.body.online": "Både minting och melting är avstängt. Inga sats kan flyttas in eller ut via Lightning.",
+  "mint.warnings.frozen.body.offline": "Både minting och melting var avstängt. Inga sats kan flyttas in eller ut via Lightning.",
+  "mint.warnings.frozen.meta.online": "För närvarande är verksamheten fryst, ingenting kommer in eller går ut",
+  "mint.warnings.frozen.meta.offline": "Fryst när den senast sågs",
+  "mint.warnings.offlineLong.lead": "Inaktiv för {days}, från och med {date}.",
+  "mint.warnings.offlineLong.body": "Mintet kan vara borta. Allt nedan är dess senast kända tillstånd, och recensioner fungerar fortfarande.",
+  "mint.warnings.offlineLong.meta": "Offline sedan {date}",
+  "mint.warnings.meltOnly.lead": "Endast melt.",
+  "mint.warnings.meltOnly.body.online": "Ny minting (NUT-04) är avstängd: du kan inte sätta in, men befintlig ecash kan fortfarande tas ut. Det betyder ofta att ett mint håller på att avvecklas, så om du håller dess ecash, överväg att melta ut.",
+  "mint.warnings.meltOnly.body.offline": "Ny minting (NUT-04) var avstängd: du kan inte sätta in, men befintlig ecash kan fortfarande tas ut. Det betyder ofta att ett mint håller på att avvecklas, så om du håller dess ecash, överväg att melta ut.",
+  "mint.warnings.meltOnly.meta.online": "För närvarande endast melt",
+  "mint.warnings.meltOnly.meta.offline": "Endast melt när den senast sågs",
+  "mint.warnings.offline.lead": "Offline sedan {date}.",
+  "mint.warnings.offline.body": "Detaljerna bekräftades senast då. Du kan fortfarande skriva en recension.",
+  "mint.warnings.offline.meta": "Offline sedan {date}",
+  "mint.warnings.also.meltDisabled": "Innan tjänsten stängdes ner hade man dessutom inaktiverat uttagen.",
+  "mint.warnings.also.mintDisabled": "Innan det gick offline hade det också stängt av ny minting.",
+  "mint.warnings.also.offline": "Den har dessutom varit ur drift sedan {date} ({days}).",
+  "nut.0": "Beteckningar och modeller",
+  "nut.1": "Utbyte av offentliga nycklar i Mint",
+  "nut.2": "Nökkombinationer och avgifter",
+  "nut.3": "Byta tokens",
+  "nut.4": "Minting via Lightning",
+  "nut.5": "Smältning med Lightning",
+  "nut.6": "Mint-information",
+  "nut.7": "Kontroll av tokenets status",
+  "nut.8": "Överbetalda avgifter för Lightning",
+  "nut.9": "Återställ signaturer",
+  "nut.10": "Utgiftsvillkor",
+  "nut.11": "Betala till offentlig nyckel",
+  "nut.12": "DLEQ-korrekturutskrifter",
+  "nut.13": "Deterministiska hemligheter",
+  "nut.14": "Kontrakt med tidslås baserade på hashfunktioner",
+  "nut.15": "Betalningar via flera kanaler",
+  "nut.16": "Animerade QR-koder",
+  "nut.17": "WebSocket-abonnemang",
+  "nut.18": "Betalningsförfrågningar",
+  "nut.19": "Cachelagrade svar",
+  "nut.20": "Signerade mint-quotes",
+  "nut.21": "Rensa autentisering",
+  "nut.22": "Autentisering utan inloggning",
+  "nut.23": "BOLT11 – betalningssätt",
+  "nut.24": "HTTP 402 – betalning krävs",
+  "nut.25": "BOLT12 – betalningssätt",
+  "reviews.title": "Recensioner",
+  "reviews.anon": "Anonym",
+  "reviews.anonTitle": "Ingen offentlig profil med namnet Nostr hittades för denna nyckel",
+  "reviews.nip05Title": "Identifierare NIP-05 (inte verifierad av denna webbplats)",
+  "reviews.filter.group": "Filtrera recensioner",
+  "reviews.filter.all": "Alla",
+  "reviews.filter.five": "5★",
+  "reviews.filter.critical": "Kritisk",
+  "reviews.filter.recent": "Senaste",
+  "reviews.filter.hideAnon": "Dölj anonymitet",
+  "reviews.anonHidden.other": "Visar recensioner av {n} av {total}: anonym, dold.",
+  "reviews.allAnon.one": "Den enda recensionen här är anonym.",
+  "reviews.allAnon.other": "Alla recensioner av {n} här är anonyma.",
+  "reviews.allAnonShow.one": "Visa det",
+  "reviews.allAnonShow.other": "Visa dem",
+  "reviews.loading.one": "Laddar recension av {n} från reläerna Nostr",
+  "reviews.loading.other": "Hämtar recensioner av {n} från reläerna Nostr",
+  "reviews.empty": "Inga recensioner ännu. Bli den första att skriva en.",
+  "reviews.emptyWritten": "Det finns inga skriftliga recensioner här än. Bli den första att skriva en.",
+  "reviews.emptyFilter": "Det finns inga recensioner som stämmer överens med detta filter.",
+  "reviews.rate.cashu": "Betygsätt denna mint",
+  "reviews.rate.fedimint": "Betygsätt denna federation",
+  "reviews.rate.lnurl": "Betygsätt denna mint",
+  "reviews.noscript": "Recensionerna är signerade med Nostr och laddas i din webbläsare, så den här listan kräver JavaScript. Betygen och antalet nedan hämtas direkt från webbplatsen.",
+  "reviews.relayError": "Det gick inte att nå reläet. Recensionerna kan vara ofullständiga.",
+  "reviews.srRating": "{rating} av 5",
+  "reviews.srNoRating": "Inget betyg angivet",
+  "reviews.readMore": "Läs mer",
+  "reviews.readLess": "Visa mindre",
+  "reviews.actions.copyNpub": "Kopiera npub",
+  "reviews.actions.openNostr": "Se detta evenemang på Nostr",
+  "reviews.actions.copyLink": "Kopiera länken till den här recensionen",
+  "reviews.anonNote": "Första recensionen av denna npub, inga andra aktiviteter har hittats",
+  "reviews.published": "Publicerad.",
+  "reviews.publishedPartial": "Publicerad till reläet {accepted} i serien {total}.",
+  "reviews.propagating": "Publicerar till Nostr-relayer",
+  "reviews.summary.line.one": "{count}-betyg utan kommentar: {breakdown}",
+  "reviews.summary.line.other": "{count}-betyg utan kommentar: {breakdown}",
+  "reviews.summary.lineDay.one": "Betyg för {count} utan kommentar om {when}: {breakdown}",
+  "reviews.summary.lineDay.other": "Betyg för {count} utan kommentar om {when}: {breakdown}",
+  "reviews.summary.showOne": "Visa det",
+  "reviews.summary.showMany": "Visa dem",
+  "reviews.breakdown.5": "{n} fem stjärnor",
+  "reviews.breakdown.4": "{n} fyra stjärnor",
+  "reviews.breakdown.3": "{n} tre stjärnor",
+  "reviews.breakdown.2": "{n} två stjärnor",
+  "reviews.breakdown.1": "{n} en stjärna",
+  "reviews.breakdown.none": "{n} utan betyg",
+  "reviews.dialog.title": "Recension av {name}",
+  "reviews.dialog.lede.cashu": "Dela din upplevelse av denna mint.",
+  "reviews.dialog.lede.fedimint": "Dela din upplevelse av denna federation.",
+  "reviews.dialog.lede.lnurl": "Dela din upplevelse av denna mint.",
+  "reviews.dialog.permanent": "Publiceras permanent på publika Nostr-relayer.",
+  "reviews.dialog.gate.title": "Logga in för att skriva en recension",
+  "reviews.dialog.gate.lead": "Recensioner signeras med din Nostr-nyckel. Den stannar i din signer, den här webbplatsen ser den aldrig.",
+  "reviews.dialog.ratingLegend": "Ditt betyg",
+  "reviews.dialog.starsSr.one": "{n}-stjärna",
+  "reviews.dialog.starsSr.other": "{n} stjärnor",
+  "reviews.dialog.chooseRating": "Välj ett betyg",
+  "reviews.dialog.starLabel": "{n}: {phrase}",
+  "reviews.dialog.stars.1": "undvik det",
+  "reviews.dialog.stars.2": "hade problem",
+  "reviews.dialog.stars.3": "fungerade, med vissa förbehåll",
+  "reviews.dialog.stars.4": "bra",
+  "reviews.dialog.stars.5": "fungerar utmärkt",
+  "reviews.dialog.bodyLabel": "Vad bör andra veta?",
+  "reviews.dialog.charCount": "{n} / {max}",
+  "reviews.dialog.submit": "Underteckna och publicera",
+  "reviews.dialog.signing": "Skriver under…",
+  "reviews.dialog.publishing": "Publicerar…",
+  "reviews.dialog.publishingTo": "Publicering till reläer ({accepted}/{total})",
+  "reviews.dialog.waitingExtension": "Väntar på din förlängning",
+  "reviews.dialog.waitingSigner": "Väntar på din undertecknare",
+  "reviews.dialog.confirmClose": "Vill du stänga den här recensionen? Ditt utkast sparas tills du lämnar webbplatsen.",
+  "reviews.dialog.why.login": "Logga in för att publicera",
+  "reviews.dialog.why.words": "Skriv några ord",
+  "reviews.dialog.why.more.one": "{n} fler tecken",
+  "reviews.dialog.why.more.other": "{n} fler tecken",
+  "reviews.dialog.why.over.one": "Tecknet {n} överskrider gränsen",
+  "reviews.dialog.why.over.other": "{n} – antalet tecken överskrider gränsen",
+  "reviews.dialog.identity.needSigner": "Du behöver en Nostr-signaturenhet för att publicera. Din nyckel förvaras i enheten; den här webbplatsen får aldrig tillgång till den.",
+  "reviews.dialog.identity.loginToPublish": "Logga in för att publicera",
+  "reviews.dialog.identity.switch": "Omkopplare",
+  "reviews.dialog.identity.extension": "Inloggning med webbläsartillägget",
+  "reviews.dialog.identity.readingKey": "Läser din publika nyckel…",
+  "reviews.dialog.identity.willAsk": "Din tilläggsmodul kommer att ombes att signera",
+  "reviews.dialog.error.noRelay": "Inget relä godkände granskningen. Kontrollera din anslutning och försök sedan igen.",
+  "reviews.validate.rating": "Välj ett betyg mellan 1 och 5 stjärnor.",
+  "reviews.validate.short": "Skriv minst {n} tecken så att recensionen blir till nytta.",
+  "reviews.validate.long": "Recensioner får högst {n} tecken.",
+  "feed.title": "Senaste recensionerna av mints och federationer · Cashumints.space",
+  "feed.description": "Varje recension av mints, federationer och LNURL-mints så fort den publiceras: {reviews} recensioner om {mints} Cashu-mints, {federations} Fedimint-federationer och {lnurl} LNURL-mints, signerade på Nostr och läsbara här med nyast först. Filtrera på ekosystem, betyg eller namn.",
+  "feed.heading": "Senaste recensionerna",
+  "feed.lede": "Alla recensioner av alla Cashu-mint- och Fedimint-federationer, med de senaste först, läses direkt från Nostr-reläerna. Varje recension är signerad av sin författare och finns lagrad på reläerna, inte i vår databas.",
+  "feed.label": "Recensioner",
+  "feed.showingBuild.one": "Visar den senaste granskningen från den senaste versionen",
+  "feed.showingBuild.other": "Här visas de senaste recensionerna av {n} från den senaste versionen",
+  "feed.noscript": "Recensionerna är signerade med Nostr och laddas i din webbläsare, så för filtrering och den fullständiga listan krävs JavaScript. Recensionerna med {n} nedan hämtades från reläerna när denna sida skapades.",
+  "feed.emptyBuild": "Inga avläsningar kunde hämtas från reläerna när denna sida skapades. Listan uppdateras automatiskt från reläerna i din webbläsare.",
+  "feed.foot": "Recensioner är åsikter från communityn, inte verifierade påståenden. Läs {link} innan du anförtror ett mint dina pengar.",
+  "feed.footLink": "ansvarsfriskrivning",
+  "feed.showing": "Visar recensioner av {shown} och {total}",
+  "feed.showingMatching": "Visar {shown} av {matching} matchande recensioner (totalt {total})",
+  "feed.emptyRelays": "Inga recensioner har kommit in från reläerna. Öppna valfri Mint-sida för att läsa och skriva recensioner där.",
+  "feed.emptyFilter": "Inga recensioner matchar detta filter. Rensa mint-rutan, eller prova Alla.",
+  "feed.relayError": "Det gick inte att nå reläerna. Visar recensionerna från den senaste versionen.",
+  "feed.relayEmpty": "Inga granskningar har kommit tillbaka från reläerna. Visar granskningarna från den senaste versionen.",
+  "feed.reading": "Avläsning av reläerna…",
+  "login.open": "Logga in",
+  "login.title": "Logga in med Nostr",
+  "login.note": "Din nyckel förvaras i din signaturenhet. Den här webbplatsen kan aldrig se den.",
+  "login.extension.name": "Webbläsartillägg",
+  "login.extension.desc": "Spara med filändelsen Alby, nos2x eller NIP-07",
+  "login.extension.none": "Ingen tilläggsfil hittades",
+  "login.extension.getOne": "Skaffa en:",
+  "login.remote.name": "Fjärrsignatör",
+  "login.remote.desc": "Skanna en kod med en signeringsapp eller klistra in en bunkerlänk",
+  "login.primal.name": "Primal",
+  "login.primal.desc": "Godkänn inloggningen i appen Primal på din telefon",
+  "login.paste.label": "Eller klistra in den länk som din undertecknare har gett dig",
+  "login.copyLink": "Kopiera länken till anslutningen",
+  "login.whatIsNostr": "Vad är Nostr?",
+  "login.connect.remote.title": "Anslut en fjärrundertecknare",
+  "login.connect.remote.lead": "Skanna den här med din signeringsapp, eller kopiera länken och klistra in den där.",
+  "login.connect.remote.hint": "Fungerar med alla NIP-46-signaturenheter: nsec.app, Amber, Nostrify, din egen bunker.",
+  "login.connect.remote.open": "Öppna i din signeringsapp",
+  "login.connect.primal.title": "Följ Primal",
+  "login.connect.primal.lead": "Öppna Primal på din telefon, leta reda på ”fjärrinsloggning” i inställningarna och skanna den här koden.",
+  "login.connect.primal.hint": "Primal används för att signera andra appar istället för NIP-46, så det här är samma anslutning som alla signatärer använder, och din nyckel förblir i Primal. {link}",
+  "login.connect.primal.open": "Öppna i Primal",
+  "login.status.buildingLink": "Skapa en länk",
+  "login.status.waitingExtension": "Väntar på din förlängning",
+  "login.status.waitingSigner": "Väntar på din undertecknare",
+  "login.status.connecting": "Ansluta till din signatär",
+  "login.status.connected": "Ansluten",
+  "login.toast.loggedIn": "Inloggad",
+  "login.toast.fetchingProfile": "Hämtar din Nostr-profil från reläerna…",
+  "login.toast.profile": "Profil: {name}",
+  "login.toast.noProfile": "Ingen profil hittades på reläerna",
+  "login.method.extension": "Förlängning",
+  "login.method.remote": "Fjärrstyrning",
+  "login.method.primal": "Primal",
+  "login.account": "Ditt Nostr-konto",
+  "login.copyNpub": "Kopiera hela koden npub",
+  "login.logout": "Logga ut",
+  "signer.status.waitingExtension": "Väntar på din förlängning",
+  "signer.status.signed": "Undertecknat",
+  "signer.status.reconnecting": "Återuppta kontakten med din undertecknare",
+  "signer.status.approveWindow": "Den som ska underteckna vill att du godkänner detta i ett separat fönster",
+  "signer.status.waitingSigner": "Väntar på din undertecknare",
+  "signer.status.stillWaiting": "Väntar fortfarande på svar från din undertecknare",
+  "signer.status.connected": "Ansluten",
+  "signer.error.noExtension": "Ingen signaturförlängning hittades. Installera Alby eller nos2x och ladda sedan om sidan.",
+  "signer.error.privateKey": "Det ser ut som en privat nyckel, inte en länk. Den här webbplatsen tar aldrig emot nycklar. Klistra in länken bunker:// som din signatär gav dig.",
+  "signer.error.badLink": "Det är inte en länk som den här webbplatsen känner igen. Klistra in länken bunker:// från din signaturtjänst.",
+  "signer.error.noAnswer": "Din signaturtjänst svarade inte. Den kan vara stängd, eller så kan dess relä vara ur funktion. Öppna den och försök igen.",
+  "signer.error.timeout": "Din signatär svarade inte i tid. Öppna enheten, kontrollera att den fortfarande är ansluten och försök sedan igen.",
+  "signer.error.cancelled": "Anslutningen avbröts.",
+  "signer.error.declined": "Signaturförfrågan avvisades",
+  "notfound.title": "Sidan hittades inte · Cashumints.space",
+  "notfound.description": "Den sidan finns inte på Cashumints.space.",
+  "notfound.heading": "Den här sidan finns inte",
+  "notfound.lede": "Den kan ha flyttat, eller så är mintet inte indexerat än. Sök efter ett mint på namn eller domän, eller klistra in en mint-URL.",
+  "notfound.browse": "Se alla mints",
+  "notfound.home": "Gå hem",
+  "notfound.loading": "Laddar {host}",
+  "notfound.fb.rating": "Betyg",
+  "notfound.fb.reviews": "Recensioner",
+  "notfound.fb.software": "Programvara",
+  "notfound.fb.lastOnline": "Senast online",
+  "notfound.fb.note": "Den här minten indexerades efter att sajten senast byggdes, så det här är en sammanfattning från det live-API:t, med recensionerna nedanför. Hela sidan dyker upp vid nästa bygge.",
+  "notfound.resolve.checking": "Första besöket: kontrollerar minten nu.",
+  "notfound.resolve.failed": "Den här minten kunde inte läggas till",
+  "notfound.resolve.failedFedimint": "Den här federationen kunde inte läggas till",
+  "notfound.resolve.retry": "Prova en annan adress",
+  "notfound.resolve.switch": "Öppna den som {kind}-mint",
+  "notfound.resolve.fedimint": "En federations sidadress innehåller inte dess invite code, så den här går inte att slå upp enbart via länken. Klistra in invite code så läggs den till.",
+  "notfound.resolve.ambiguous": "Adressen går inte att härleda enbart ur länken. Klistra in mintens fullständiga URL så läggs den till.",
+  "wallets.title": "Cashu-plånböcker · Cashumints.space",
+  "wallets.description": "Cashu-wallets som fungerar med de mints som listas här, för mobil, webb, webbläsare och kommandoraden, med vad var och en är bra på.",
+  "wallets.heading": "Plånböcker",
+  "wallets.lede": "Du behöver en wallet för att hålla ecash från något av dessa mints. De flesta wallets pratar med flera mints samtidigt, så du är inte bunden till det första du provar.",
+  "wallets.note": "Den här listan är inte uttömmande och är ingen rekommendation. Cashu-projektet har ett bredare register på {link}. En wallet håller nycklar, ett mint håller pengarna: läs recensionerna av mintet innan du väljer var dina sats ska bo.",
+  "wallets.platform.android": "Android",
+  "wallets.platform.ios": "iOS",
+  "wallets.platform.web": "Webb",
+  "wallets.platform.extension": "Webbläsartillägg",
+  "wallets.platform.cli": "CLI",
+  "wallets.platform.python": "Python",
+  "wallets.item.minibits": "Mobilplånboken ecash med egen mint-funktion, stöd för adresser av typen Lightning och kontakter av typen Nostr.",
+  "wallets.item.nutstash": "Webbläsar-wallet som hanterar flera mints samtidigt och importerar och exporterar råa tokens.",
+  "wallets.item.enuts": "Mobilplånbok med fokus på saldon i flera valutor och överföring av ecash till Nostr.",
+  "wallets.item.cashume": "Referenswebbplånbok från projektet Cashu. Körs helt i webbläsaren och kan installeras som PWA.",
+  "wallets.item.boardwalk": "Webbplånbok baserad på Lightning-adresser och överföring av ecash via länk.",
+  "wallets.item.coinos": "Lightning-wallet och kassasystem som också kör sitt eget Cashu-mint.",
+  "wallets.item.oxchat": "Nostr-messenger med en inbyggd ecash-plånbok, för att skicka sats i chattar.",
+  "wallets.item.nutshell": "Referensimplementationen. Körs som wallet på kommandoraden och som mint-programvara.",
+  "about.title": "Om Cashumints.space",
+  "about.description": "Vad Cashu är, vad en mint egentligen innehåller, vad NIP-87 är och hur den här webbplatsen indexerar mints och läser av recensioner från Nostr-reläer.",
+  "about.heading": "Om",
+  "about.lede": "Cashumints.space listar varje Cashu-mint vi kan hitta i Nostr-nätverket och visar vad folk säger om dem. Den är byggd av Azzamo.",
+  "about.cashu.title": "Vad Cashu är",
+  "about.cashu.p1": "Cashu är ett ecash-protokoll för Bitcoin. Ett mint ger ut blindade tokens som backas av de sats det håller, och de tokens rör sig mellan människor utan att mintet får veta vem som skickade vad till vem. Integriteten är verklig och den är hela poängen: tokens är inte konton, och mintet kan inte koppla den token det signerade till den token som kommer tillbaka.",
+  "about.cashu.p2": "Du kan läsa protokollet och dess specifikationer på {link}. Specifikationerna kallas NUTs, och det är därifrån NUT-numren på varje mint-sida kommer.",
+  "about.mints.title": "Vad ett mint är, och avvägningen",
+  "about.mints.p1": "Ett mint är förvarande. När du mintar ecash lämnar du sats till den som driver servern, och du litar på att den infriar dina tokens när du meltar ut dem igen. Det finns inget bedrägeribevis, ingen deposition och ingen möjlighet till upprättelse. En mint-operatör kan försvinna med saldot, och mints har gjort det.",
+  "about.mints.p2": "Det är precis därför recensioner finns här. Den här webbplatsen säger aldrig att ett mint är säkert. Statusen på en mint-sida säger {code}, inte ”betrodd”, och den betyder bara att servern svarade när vi frågade senast. Behandla ecash-saldon som kontanter i en rockficka: bra att spendera, fel att spara.",
+  "about.nip87.title": "Vad NIP-87 är",
+  "about.nip87.p1": "NIP-87 är Nostr-konventionen för att annonsera och rekommendera ecash-mints. Två händelsetyper spelar roll här:",
+  "about.nip87.li1": "{code} annonserar ett mint. Mint-URL:en ligger i {tag}-taggen. Det är så webbplatsen hittar mints den aldrig sett.",
+  "about.nip87.li2": "{code} är en recension. Den bär betyget och recensionstexten, och pekar på det mint den handlar om med en {utag}-tagg (mintets URL) och en {dtag}-tagg (mintets egen publika nyckel).",
+  "about.nip87.p2": "Varje recension är signerad med författarens Nostr-nyckel. Vi kallar aldrig en recension ”verifierad”, för ingen har verifierat den: den är signerad, vilket är ett annat och mer användbart påstående. Det betyder att du kan kontrollera vem som skrev den och att den inte har ändrats. Det betyder inte att författaren är ärlig eller någonsin har använt mintet.",
+  "about.how.title": "Så här fungerar den här webbplatsen",
+  "about.how.p1": "Det finns två slingor och en regel. Regeln är att mintet äger sina metadata och Nostr äger recensionerna, så den här webbplatsen lagrar ingetdera som auktoritet.",
+  "about.how.li1": "{strong} frågar varje känt mint efter {code} var tionde minut och registrerar vad det säger: namn, beskrivning, version, stödda NUTs, gränser, kontaktuppgifter. Den registrerar också om mintet svarade alls, vilket är varifrån drifttiden kommer.",
+  "about.how.li1Label": "Mätkretsen",
+  "about.how.li2": "{strong} ansluter till Nostr-reläerna varje timme, läser mint-annonseringar och recensioner, och lägger till varje mint den inte sett förut.",
+  "about.how.li2Label": "Upptäcktscykeln",
+  "about.how.p2": "Det viktiga är vad som händer när ett mint slutar svara. Dess cachade metadata skrivs aldrig över av en misslyckad kontroll, så ett dött mint behåller hela sin sida: sina specifikationer, sin historik och sina recensioner, med en banner som säger när det tystnade. Den tidigare versionen av webbplatsen visade en felsida istället, vilket innebar att just de mints som folk mest behövde varna varandra för var de som inte gick att recensera. Det var huvudskälet till ombyggnaden.",
+  "about.how.p3": "Recensionstexter lagras aldrig hos oss. När du öppnar en mint-sida kommunicerar din webbläsare direkt med reläerna och hämtar recensionerna själv, och när du skriver en recension signeras den av din egen Nostr-förlängning och skickas direkt till dessa reläer. Vi håller reda på antalet så att sidorna kan rangordnas och sorteras, men inget mer än så. Ingenting här kan redigeras eller raderas av oss, inte heller recensioner som vi helst skulle vilja slippa.",
+  "about.relays.title": "Reläer som vi läser om",
+  "about.relays.p1": "Det här är de reläer som både indexeraren och din webbläsare använder:",
+  "about.relays.p2": "Rikta vilken Nostr eller cli som helst mot samma reläer så kommer du att se samma händelser. Det är hela löftet: ingenting här är sant bara för att vi säger det.",
+  "about.nuts.title": "Vad är NUTs?",
+  "about.nuts.p1": "NUTs är de numrerade Cashu-specifikationerna, som BIP:er för Bitcoin. Ett mint anger vilka det implementerar, och det säger dig vad det faktiskt kan göra: NUT-04 och NUT-05 är minting och melting via Lightning (utan dem är ett mint inte till mycket nytta), NUT-07 låter en wallet kontrollera om en token redan är spenderad, NUT-17 ger wallets liveuppdateringar via WebSockets istället för polling, och NUT-20 låter en wallet bevisa att en mint-quote verkligen utfärdades till den. Hela listan finns på {link}.",
+  "about.numbers.title": "Just nu",
+  "about.numbers.p1": "{mints}-enheterna är indexerade, {online} av dem svarar, {reviews}-enheterna räknas utifrån reläerna ovan.",
+  "about.source.title": "Källa och upphovsangivelse",
+  "about.source.p1": "Webbplatsen är öppen källkod på {github}. Den är byggd och driven av {azzamo}. Om något är fel på en mint-sida, fixa det vid källan: mint-metadata kommer från mintets eget {code}, och recensioner kommer från Nostr.",
+  "terms.title": "Användarvillkor · Cashumints.space",
+  "terms.description": "Användarvillkor för Cashumints.space: vad webbplatsen är, vad den inte gör och vem som ansvarar för vad. Inga konton, inga garantier, ingen anknytning till något mint.",
+  "terms.heading": "Användarvillkor",
+  "terms.lede": "Enkel förklaring av en webbplats som endast indexerar offentliga data. Senast uppdaterad {date}.",
+  "terms.what.title": "Vad den här webbplatsen handlar om",
+  "terms.what.p1": "Cashumints.space är ett index över offentligt tillgängliga data om Cashu-mints. Två sorters data, båda från någon annanstans:",
+  "terms.what.li1": "Mint-metadata, läst från varje mints eget {code}-endpoint: namn, beskrivning, programvaruversion, stödda NUTs, kontaktuppgifter och om mintet svarade när vi frågade senast.",
+  "terms.what.li2": "Recensioner, hämtade från de offentliga Nostr-reläerna. Det rör sig om NIP-87-händelser som publicerats av sina författare till reläer som vem som helst kan söka information från.",
+  "terms.what.p2": "Vi samlar in dessa uppgifter, normaliserar dem, rangordnar dem och visar dem. Vi skapar dem inte.",
+  "terms.noAccounts.title": "Inga konton, inga garantier",
+  "terms.noAccounts.p1": "Det finns inget att registrera sig för. Webbplatsen tillhandahålls som den är, utan garanti av något slag: inte att data stämmer, inte att de är aktuella, inte att webbplatsen är tillgänglig. Mint-data kan vara minuter eller timmar gamla, ett mint kan ha ändrats sedan vi kontrollerade senast, och ett relä kan låta bli att svara, och då ser du mindre än vad som finns.",
+  "terms.noAccounts.p2": "Använd den på egen risk. Vi ansvarar inte för förluster som följer av att använda den här webbplatsen eller av att förlita sig på något du läser här. Se {link} för de specifika riskerna med att använda ett Cashu-mint.",
+  "terms.noAccounts.link": "ansvarsfriskrivning",
+  "terms.noCustody.title": "Vi förvarar inte dina pengar",
+  "terms.noCustody.p1": "Den här webbplatsen tar aldrig hand om medel. Den har ingen wallet, den rör inte ecash, och den kan inte flytta, frysa eller återställa något. Om du har problem med ett mint är mint-operatören den enda part som kan hjälpa dig, och vi kan inte kontakta dem åt dig.",
+  "terms.noCustody.p2": "Vi har ingen koppling till något mint som listas här, och inget mint betalar för sin listning, sin placering eller sitt betyg. Mints hittas via offentliga Nostr-annonseringar och rangordnas av en algoritm över offentliga recensionsdata.",
+  "terms.reviews.title": "Recensioner är andras ord",
+  "terms.reviews.p1": "Recensioner är användargenererat innehåll som publiceras på de offentliga Nostr-reläerna av sina författare. Vi visar dem, men vi kontrollerar dem inte. Vi har inte skrivit dem, vi kan inte redigera dem och vi kan inte ta bort dem från de reläer där de finns: de är signerade händelser i ett nätverk som vi inte äger.",
+  "terms.reviews.p2": "En recension är en enskild persons upplevelse, inte ett verifierat faktum. Om du publicerar en recension är du ansvarig för dess innehåll. Publicera inte något olagligt, och tänk på att det du publicerar är offentligt och blir kvar för alltid (se {link}).",
+  "terms.reviews.link": "sidan om integritet",
+  "terms.reviews.p3": "Vi kan sluta visa en viss recension på den här webbplatsen, och vi kommer att göra det när det gäller olagligt innehåll. Detta innebär att recensionen endast tas bort från dessa sidor. Evenemanget finns kvar på reläerna och alla andra Nostr client kan fortfarande läsa den.",
+  "terms.links.title": "Länkar till andra webbplatser",
+  "terms.links.p1": "Mint-URL:er, länkar till plånböcker, kontaktuppgifter till operatörer och allt annat som länkar bort från den här webbplatsen finns där eftersom de ingår i informationen. En länk innebär inte att vi rekommenderar innehållet, och vi granskar inte vad som finns på den andra sidan.",
+  "terms.changes.title": "Ändringar",
+  "terms.changes.p1": "Dessa villkor kan ändras. Datumet högst upp anger när de senast ändrades. Webbplatsen är öppen källkod, så varje ändring på denna sida finns med i ändringshistoriken.",
+  "terms.contact.title": "Kontakt",
+  "terms.contact.p1": "Problem och begäranden om borttagning lämnas helst in via {github}. Webbplatsen drivs av {azzamo}.",
+  "privacy.title": "Integritet · Cashumints.space",
+  "privacy.description": "Sekretess på Cashumints.space: inga konton, inga spårningscookies, ingen analys. localStorage används för cachelagring av profiler och inga uppgifter skickas någonstans. Omdömen signeras i din egen webbläsare.",
+  "privacy.heading": "Integritet",
+  "privacy.lede": "Vi samlar in så lite information som möjligt för en webbplats. Senast uppdaterad {date}.",
+  "privacy.noAccounts.title": "Inga konton",
+  "privacy.noAccounts.p1": "Det finns ingen registrering, ingen inloggning och ingen profil. Ingenting på den här webbplatsen frågar vem du är, och det finns inga användaruppgifter som kan läcka eftersom det inte finns några användare.",
+  "privacy.noTracking.title": "Inga spårningscookies, ingen analys",
+  "privacy.noTracking.p1": "Webbplatsen använder inga spårningscookies. Det finns inga analysskript, inga tagghanterare, inga pixlar, ingen sessionsinspelning och inga annonsnätverk. Ingenting på sidan rapporterar ditt beteende till oss eller någon annan.",
+  "privacy.logs.title": "Serverloggar",
+  "privacy.logs.p1": "Webbservern för standardmässiga åtkomstloggar, vilket är vad alla webbservrar gör som standard. En loggrad registrerar din IP-adress, tidpunkten, den sida du begärde, svarsstatusen samt den användaragent och den hänvisningskälla som din webbläsare skickade. Loggarna finns till för att felsöka fel och upptäcka missbruk. De kopplas inte samman med något annat och säljs eller delas inte.",
+  "privacy.logs.operatorLabel": "Anmärkning från operatören:",
+  "privacy.logs.operator": "Om du driver den här webbplatsen, ange din faktiska lagringstid här. I README används nginx med dess standardåtkomstlogg och den rotationsinställning som medföljer din distribution (på Debian och Ubuntu är det logrotate, dagligen, med 14 dagars lagring). Kontrollera vad din server gör och ersätt detta stycke med siffran.",
+  "privacy.storage.title": "Vad som lagras i din webbläsare",
+  "privacy.storage.p1": "Webbplatsen använder localStorage för exakt två saker, vilka båda lagras på din enhet och aldrig skickas vidare någonstans:",
+  "privacy.storage.li1": "En cache med metadata för profilen Nostr (händelser av typ 0: namn, avatarer, adresser av typ NIP-05) för de granskare vars recensioner du har tittat på. Detta gör att du slipper skicka nya förfrågningar till reläerna på varje sida. Posterna har en giltighetstid, och cachen har en storleksbegränsning – de äldsta posterna tas bort först.",
+  "privacy.storage.li2": "Inställningar för gränssnittet, så att webbplatsen fungerar på samma sätt nästa gång.",
+  "privacy.storage.p2": "Om du rensar webbläsarens webbplatsdata tas båda bort. Inget slutar fungera, profiluppslagningarna körs bara om.",
+  "privacy.thirdParties.title": "Vad din webbläsare kommunicerar med",
+  "privacy.thirdParties.p1": "När en sida laddas ansluts din webbläsare till några andra platser utöver den här webbplatsen. Det är så en webbplats utan spårning på serversidan ändå kan hämta realtidsdata:",
+  "privacy.thirdParties.li1Label": "Offentliga Nostr-reläer",
+  "privacy.thirdParties.li1": "{strong}, istället för WebSocket, för att läsa recensioner och recensenters profiler. Reläet ser din IP-adress och vad du har begärt, precis som alla servrar du ansluter till gör. Reläerna finns listade på {link}.",
+  "privacy.thirdParties.li1Link": "Om oss-sidan",
+  "privacy.thirdParties.li2Label": "Avatarbilder för granskare",
+  "privacy.thirdParties.li2": "{strong}, som laddas in från den plats som recensentens profil pekar på. Dessa skickas enligt en policy om att inte ange referrer, vilket innebär att webbhotellet inte får reda på vilken sida du befann dig på.",
+  "privacy.publishing.title": "Publicera en recension",
+  "privacy.publishing.p1": "Att skriva en recension sker i din webbläsare, inte på vår server. Händelsen signeras av ditt NIP-07-tillägg (Alby, nos2x eller liknande) och sänds från din webbläsare direkt till reläerna. Din privata nyckel lämnar aldrig tillägget och den här webbplatsen får aldrig tillgång till den. Vi bygger inte in någon anpassad nyckelhantering och vi ber aldrig om en nyckel eller en seed-fras.",
+  "privacy.permanent.title": "Allt du publicerar på Nostr är offentligt och permanent",
+  "privacy.permanent.p1": "Det här är den del som är värd att läsa två gånger. En recension är en signerad händelse på offentliga reläer. När den väl har publicerats är den publicerad:",
+  "privacy.permanent.li1": "Vem som helst kan läsa den, både nu och senare, med hjälp av vilken Nostr client som helst. Den är inte ”offentlig på Cashumints.space”, utan den är offentlig på nätverket.",
+  "privacy.permanent.li2": "Den är permanent kopplad till din publika nyckel Nostr, tillsammans med allt annat som den nyckeln någonsin har publicerat.",
+  "privacy.permanent.li3": "Att ta bort den är en begäran, inte en order. Du kan publicera en borttagningshändelse och vissa reläer kommer att följa den, men ett relä kan välja att ignorera den och alla som redan har kopierat händelsen har den kvar. Betrakta en publicerad recension som permanent.",
+  "privacy.permanent.li4": "Vi kan inte ta bort det åt dig. Vi kan sluta visa det här, men det påverkar inte reläerna på något sätt.",
+  "privacy.permanent.p2": "Om du vill recensera ett mint utan att det knyts till din huvudidentitet, använd en separat Nostr-nyckel. Observera att en nyckel utan annan aktivitet visas som sådan vid hårda recensioner, eftersom en helt ny nyckel som skriver en enstjärnig recension är ett mönster läsare förtjänar att se.",
+  "privacy.contact.title": "Frågor",
+  "privacy.contact.p1": "Webbplatsen är öppen källkod: om du vill kontrollera något av ovanstående kan du läsa koden på {github}. Frågor och rättelser kan lämnas som ett ärende där.",
+  "disclaimer.title": "Ansvarsfriskrivning · Cashumints.space",
+  "disclaimer.description": "Vad du bör veta innan du använder ett Cashu-mint: mints är förvarande, ett mint kan försvinna med dina pengar, recensioner är åsikter, och online betyder nåbar, inte pålitlig.",
+  "disclaimer.heading": "Ansvarsfriskrivning",
+  "disclaimer.lede": "Läs det här innan du lägger pengar i ett mint. Senast uppdaterad {date}.",
+  "disclaimer.callout": "Ett Cashu-mint förvarar dina pengar åt dig. Om det försvinner är din ecash borta, och det finns ingen att vända sig till. Ha bara kvar det du har råd att förlora.",
+  "disclaimer.custodial.title": "Mints är förvarande",
+  "disclaimer.custodial.p1": "När du mintar ecash lämnar du bitcoin till mint-operatören och får tillbaka tokens. De tokens är en fordran på den operatören. De är inte bitcoin du håller, och operatören är den som avgör om de infrias.",
+  "disclaimer.custodial.p2": "Det betyder att varje mint bär samma risker: operatören kan försvinna, kan tvingas sluta, kan förlora medlen genom en bugg eller ett intrång, eller kan helt enkelt stänga av servern. Det finns ingen insättningsgaranti, ingen återbetalning, ingen supportlinje och ingen rättslig väg värd att räkna med. Detta gäller även det högst rankade mintet på den här webbplatsen.",
+  "disclaimer.custodial.p3": "Cashu är gjort för små belopp som rör sig snabbt. Använd det så: håll det du är på väg att spendera, inte ditt sparande, och sprid över flera mints i stället för att parkera allt i ett.",
+  "disclaimer.reviews.title": "Recensioner är åsikter, inte verifierade påståenden",
+  "disclaimer.reviews.p1": "Varje recension här skrevs av någon på Nostr och signerades med deras nyckel. Signerad betyder att vi kan tala om vilken nyckel som skrev den. Det betyder inte att recensionen är sann, att författaren använde mintet, eller att författaren inte är operatören, en konkurrent eller en person med tio nycklar.",
+  "disclaimer.reviews.p2": "Vi verifierar inte recensenter, och vi redigerar eller tar inte bort recensioner vi inte håller med om. Läs några, se vad de faktiskt säger, och väg ett mint med tre recensioner annorlunda än ett med trehundra.",
+  "disclaimer.status.title": "”Online” betyder tillgänglig, inte pålitlig",
+  "disclaimer.status.p1": "Vi kontrollerar varje mint regelbundet och visar om den har svarat. Det är allt som en grön status betyder: servern har svarat. Det säger ingenting om huruvida operatören är solvent, ärlig eller fortfarande har för avsikt att infria dina tokens i morgon.",
+  "disclaimer.status.p2": "Ett mint kan vara online ända fram till det ögonblick det inte är det. Drifttidshistorik, stödda NUTs och programvaruversion säger något om hur ett mint drivs, men inget av det är ett löfte om dina pengar.",
+  "disclaimer.ranking.title": "Hur rankningen fungerar, och vad den inte innebär",
+  "disclaimer.ranking.p1": "Mints rangordnas enligt en algoritm baserad på data från offentliga recensioner: betyg, antal recensioner och senaste aktivitet, där online-mints som standard prioriteras framför offline-mints. Mer information finns i den öppna källkoden.",
+  "disclaimer.ranking.p2": "Ingen betalar för placering. Det finns ingen sponsrad plats, ingen marknadsförd listning och ingen överenskommelse med något mint på den här webbplatsen. En hög placering betyder att algoritmen gillade de offentliga uppgifterna, inget mer. Det är ingen rekommendation och det är inget säkerhetsbetyg.",
+  "disclaimer.notAdvice.title": "Detta är inte finansiell rådgivning",
+  "disclaimer.notAdvice.p1": "Ingenting på den här webbplatsen är finansiell, investerings-, juridisk eller skatterådgivning. Vi känner inte till din situation och vi ger dig inga råd. Att använda ett mint, och att välja vilket, är ditt beslut.",
+  "disclaimer.dyor.title": "Gör din egen efterforskning",
+  "disclaimer.dyor.li1": "Slå upp operatören. Ett mint som drivs av någon med ett offentligt rykte att förlora är något annat än en anonym URL.",
+  "disclaimer.dyor.li2": "Läs mintets egna villkor och dess MOTD. Ett mint som kallar sig ett test eller en beta menar det.",
+  "disclaimer.dyor.li3": "Börja smått. Minta lite, spendera det, melta ut det igen, och se vad som händer innan du anförtror det mer.",
+  "disclaimer.dyor.li4": "Håll koll på gränsvärdena. Ett lågt maximivärde är ofta ett tecken på en försiktig operatör, medan ett högt värde inte nödvändigtvis innebär att operatören är säker.",
+  "disclaimer.dyor.li5": "Se till att du har en säkerhetskopia av dina tokens och kom ihåg att en token är ett innehavarvärdepapper: den som innehar den kan använda den.",
+  "disclaimer.site.title": "Om själva webbplatsen",
+  "disclaimer.site.p1": "Uppgifterna här kan vara felaktiga eller inaktuella. Mints kontrolleras enligt ett schema, reläer svarar ibland inte, och den sida du läser skapades vid någon tidpunkt i det förflutna. Webbplatsen tillhandahålls i befintligt skick, utan någon garanti. Se {link}.",
+  "disclaimer.site.link": "användarvillkor",
+  "disclaimer.updated": "20 augusti 2026",
+  "login.getPrimal": "Skaffa Primal",
+  "reviews.dialog.identity.extensionGone": "Ditt webbläsartillägg svarar inte. Logga in igen eller använd en fjärrsignaturtjänst.",
+  "seo.orgDescription": "En katalog över Cashu-mints, med live-status från varje mint och recensioner från communityn signerade på Nostr.",
+  "seo.ogImageAlt": "Cashumints.space: hitta ett Cashu-mint du kan lita på.",
+  "seo.mint.title.one": "{name} recensioner: {rating} från {n} recension | Cashumints.space",
+  "seo.mint.title.other": "{name} recensioner: {rating} från {n} recensioner | Cashumints.space",
+  "seo.mint.titleOffline.one": "{name}: offline i {n} dag | Cashumints.space",
+  "seo.mint.titleOffline.other": "{name}: offline i {n} dagar | Cashumints.space",
+  "seo.mint.titleNoReviews": "{name}: info och recensioner om Cashu-mint | Cashumints.space",
+  "seo.fedimint.titleNoReviews": "{name}: Information och recensioner om Fedimint | Cashumints.space",
+  "seo.desc.fallback": "Recensioner från communityn av {name} ({domain}).",
+  "seo.desc.fallbackDomain": "Recensioner från communityn av Cashu-mintet på {domain}.",
+  "seo.desc.rated.one": "{rating}/5 från {n} signerad Nostr-recension.",
+  "seo.desc.rated.other": "{rating}/5 från {n} signerade Nostr-recensioner.",
+  "seo.desc.noReviews": "Inga recensioner ännu.",
+  "seo.desc.status": "{status}.",
+  "seo.desc.statusLimits": "{status}, gränser {limits}.",
+  "seo.desc.fedModules": "{status}. Moduler: {modules}.",
+  "seo.desc.fedModulesNetwork": "{status}. Moduler: {modules} på {network}.",
+  "seo.mint.ogAlt.one": "{name}: {rating} stjärnor från {n} recension på Cashumints.space",
+  "seo.mint.ogAlt.other": "{name}: {rating} stjärnor från {n} recensioner på Cashumints.space",
+  "seo.mint.ogAltNoReviews": "{name} på Cashumints.space",
+  "nav.home": "Hem",
+  "mint.more.title": "Fler mints",
+  "mint.more.all": "Visa alla mints",
+  "nav.fedimints": "Fedimints",
+  "status.announced": "Endast tillkännagivet",
+  "card.unnamedFederation": "Namnlös federation",
+  "card.notChecked": "har aldrig kontrollerats",
+  "fedimints.title": "Alla Fedimint-förbund · Cashumints.space",
+  "fedimints.description": "Alla {total}- och Fedimint-federationer som har tillkännagivits i Nostr-nätverket: {online} har bekräftats vara i drift genom en extern kontroll, {announced} har tillkännagivits men aldrig bekräftats. Användarbetyg, moduler och inbjudningskoder för var och en.",
+  "fedimints.heading": "Alla förbund",
+  "fedimints.lede": "Varje Fedimint-federation som tillkännagivits i Nostr-nätverket. En federation har ingen egen offentlig statusändpunkt, så vissa av dessa bekräftas vara i drift genom en extern kontroll, medan resten listas exakt så som de tillkännagavs.",
+  "fedimints.search.label": "Sök efter federationer efter namn eller ID",
+  "fedimints.search.placeholder": "Sök efter namn eller federations-ID…",
+  "fedimints.sort.label": "Sortera förbund",
+  "fedimints.hideOffline": "Dölj offline-status",
+  "fedimints.showing": "Visar {total}-förbund ({online} bekräftat, {announced} endast tillkännagivet)",
+  "fedimints.showingFiltered": "Visar {shown} av {total}-förbunden ({online} bekräftat, {announced} endast tillkännagivet)",
+  "fedimints.announcedNote.one": "En av dessa tillkännagavs på Nostr, och det har sedan dess inte bekräftats att den är i drift. Den anges som ”tillkännagiven” snarare än som ”online” eller ”offline”, eftersom inget av dessa alternativ stämmer.",
+  "fedimints.announcedNote.other": "{n} av dessa tillkännagavs på Nostr, och det har sedan dess inte bekräftats att de är i drift. De anges som ”tillkännagivna” snarare än som ”online” eller ”offline”, eftersom inget av dessa alternativ stämmer.",
+  "fedimints.noResults": "Ingen matchning av förbund. Prova med ett namn eller klistra in ett förbunds-ID.",
+  "fedimints.emptyIndex": "Enligt denna webbplats har inga förbund anmälts till stafetterna. Listan fylls på automatiskt allteftersom anmälningarna kommer in.",
+  "fedimint.crumb": "Fedimints",
+  "fedimint.breadcrumb": "Navigationsspår",
+  "fedimint.unnamed": "Namnlös förbund",
+  "fedimint.idLabel": "Förbundet",
+  "fedimint.kind.federationId": "federations-id",
+  "fedimint.moduleCount.one": "{n}-modul",
+  "fedimint.moduleCount.other": "{n}-moduler",
+  "fedimint.copyInvite": "Kopiera inbjudningskoden",
+  "fedimint.confirmed.label": "Bekräftat",
+  "fedimint.confirmed.never": "Aldrig",
+  "fedimint.confirmed.by": "av {source}",
+  "fedimint.confirmed.unattributed": "senaste kontrollen",
+  "fedimint.announcedOn": "tillkännagav {when}",
+  "fedimint.announcedUnknown": "inget datum för tillkännagivandet",
+  "fedimint.modules.title": "Moduler",
+  "fedimint.modules.none": "I detta förbunds meddelande anges inga moduler.",
+  "fedimint.modules.note": "Moduler är de delar som en federation driver. I meddelandet anges vilka moduler som finns, men det framgår inte om någon av dem tar emot insättningar.",
+  "fedimint.modules.notListed": "finns inte med i listan",
+  "fedimint.invite.title": "Inbjudningskod",
+  "fedimint.invite.count.one": "Kod {n}",
+  "fedimint.invite.count.other": "{n}-koder",
+  "fedimint.invite.note": "Klistra in detta i en Fedimint-plånbok för att gå med. Den innehåller federations-ID:t och adresserna till dess förvaltare, och är avsedd att delas.",
+  "fedimint.invite.kind": "inbjudningskod",
+  "fedimint.invite.qr": "QR",
+  "fedimint.invite.qrCaption": "Skanna för att gå med i {name}",
+  "fedimint.details.federationId": "Federations-ID",
+  "fedimint.details.network": "Nätverk",
+  "fedimint.details.announcedBy": "Tillkännagivet av",
+  "fedimint.details.announced": "Tillkännagivet",
+  "fedimint.more.title": "Fler förbund",
+  "fedimint.more.all": "Visa alla förbund",
+  "fedimint.disclaimer": "Att gå med i en sammanslutning innebär att man anförtror sina pengar åt dess förvaltare. Betygen är åsikter från gemenskapen, och att en verksamhet är bekräftad innebär att den är tillgänglig, inte att den är pålitlig.",
+  "fedimint.module.lightning": "Lightning",
+  "fedimint.module.mint": "Ecash-mint",
+  "fedimint.module.wallet": "Plånbok på blockkedjan",
+  "fedimint.module.meta": "Metadata",
+  "fedimint.module.stability_pool": "Stabilitetsreserv",
+  "fedimint.module.multi_sig_stability_pool": "Stabilitetspool (multisig)",
+  "fedimint.module.fedi-social": "Social återhämtning",
+  "fedimint.network.mainnet": "Bitcoin mainnet",
+  "fedimint.network.signet": "Signet",
+  "fedimint.network.testnet": "Testnet",
+  "fedimint.network.testnet4": "Testnet4",
+  "fedimint.network.regtest": "Regtest",
+  "feed.ecosystem.group": "Ekosystem",
+  "feed.ecosystem.all": "Alla",
+  "feed.ecosystem.cashu": "Cashu",
+  "feed.ecosystem.fedimint": "Fedimint",
+  "feed.filterBySubject": "Filtrera på mint eller federation",
+  "feed.anySubject": "Vilket mint eller vilken federation som helst",
+  "feed.clearSubject": "Rensa namnfiltret",
+  "home.topFedimints.title": "De bästa Fedimint-modellerna",
+  "home.topFedimints.sub": "rangerade efter recensioner och betyg",
+  "home.topFedimints.all": "Alla {n}-förbund →",
+  "reviews.validate.subject": "Det finns inget som denna recension kan riktas mot.",
+  "mint.warnings.fedimintOffline.lead": "Rapporterad som offline.",
+  "mint.warnings.fedimintOffline.body.since": "Den senaste inbetalningen som nådde denna sammanslutning gjordes till {date} (för {days} sedan). Dess förvaltare har inte svarat sedan dess. Betrakta de medel som finns där som utsatta för risk och sätt inte in nya medel där.",
+  "mint.warnings.fedimintOffline.body.never": "Ingen granskning av denna sammanslutning har någonsin genomförts, och den senaste misslyckades. Betrakta de medel som finns där som utsatta för risk och sätt inte in nya medel där.",
+  "mint.warnings.fedimintOffline.meta.since": "Har rapporterats vara offline sedan {date}",
+  "mint.warnings.fedimintOffline.meta.never": "Rapporterad som offline, har aldrig nåtts",
+  "mint.warnings.neverConfirmed.lead": "Tillkännagivet, men aldrig bekräftat.",
+  "mint.warnings.neverConfirmed.body.reviewed": "Denna sammanslutning tillkännagavs på Nostr för {date} och {days} sedan, och sedan dess har inget bekräftat att den är i drift. Recensionerna nedan är det enda tecknet på liv på denna sida; allt annat kommer från tillkännagivandet.",
+  "mint.warnings.neverConfirmed.body.quiet": "Denna sammanslutning tillkännagavs på Nostr för {date} och {days} sedan; sedan dess har inget bekräftat att den är i drift, och ingen har granskat den på senare tid. All information nedan hämtas från tillkännagivandet.",
+  "mint.warnings.neverConfirmed.meta": "{date} tillkännagavs, men bekräftades aldrig",
+  "footer.allFedimints": "Alla förbund",
+  "reviews.dialog.bodyPlaceholder.cashu": "Hur gick minting, melting och supporten? Var konkret.",
+  "reviews.dialog.bodyPlaceholder.fedimint": "Hur gick det med registreringen, betalningarna med Lightning och supporten? Var så detaljerad som möjligt.",
+  "fedimint.details.title": "Uppgifter om förbundet",
+  "nav.lnurlMints": "LNURL-mints",
+  "footer.allLnurlMints": "Alla LNURL-mints",
+  "lnurlMints.title": "LNURL-mints: mints för lnurlcash-innehavarsedlar, recenserade | Cashumints.space",
+  "lnurlMints.description": "Alla {total} LNURL-mints som indexerats från Nostr-nätverket: {online} online, {offline} offline. Betyg från gemenskapen, uttagsgränser och funktioner för var och en.",
+  "lnurlMints.heading": "LNURL-mints",
+  "lnurlMints.lede": "Varje LNURL-mint den här sajten känner till. En LNURL-mint ger ut lnurlcash-innehavarsedlar: Lightning-sedlar som du håller som en hemlighet och som kan roteras, delas, slås ihop eller smältas tillbaka till en Lightning-betalning. Var och en kontrolleras via HTTPS med några minuters mellanrum.",
+  "lnurlMints.search.label": "Sök LNURL-mints",
+  "lnurlMints.search.placeholder": "Sök på namn eller adress…",
+  "lnurlMints.sort.label": "Sortera LNURL-mints efter",
+  "lnurlMints.hideOffline": "Dölj offline",
+  "lnurlMints.showing": "Visar {total} LNURL-mints ({online} online, {offline} offline)",
+  "lnurlMints.showingFiltered": "Visar {shown} av {total} LNURL-mints ({online} online, {offline} offline)",
+  "lnurlMints.noResults": "Ingen LNURL-mint matchar det.",
+  "lnurlMints.emptyIndex": "Inga LNURL-mints är indexerade ännu.",
+  "lnurl.crumb": "LNURL-mints",
+  "lnurl.breadcrumb": "Brödsmulor",
+  "lnurl.copyAddress": "Kopiera adress",
+  "lnurl.more.title": "Fler LNURL-mints",
+  "lnurl.more.all": "Alla LNURL-mints →",
+  "lnurl.disclaimer": "En LNURL-mint förvarar dina sats medan du håller dess sedlar, så att använda en betyder att lita på dess operatör. Betyg är åsikter från gemenskapen, och online betyder nåbar, inte pålitlig.",
+  "lnurl.features.title": "Funktioner",
+  "lnurl.features.none": "Den här minten har inte annonserat vad den stöder.",
+  "lnurl.features.note": "Funktioner är vad mintens operatör annonserat på Nostr. Där sajten kan kontrollera en via HTTPS gör den det, och säger till när något annonserat inte är tillgängligt just nu.",
+  "lnurl.features.notListed": "inte annonserat",
+  "lnurl.features.unavailable": "otillgängligt",
+  "lnurl.feature.mint": "Minta via Lightning (LUD-06)",
+  "lnurl.feature.melt": "Smälta till Lightning",
+  "lnurl.feature.notes": "Rotera / dela / slå ihop sedlar",
+  "lnurl.feature.lud16": "Lightning-adress",
+  "lnurl.feature.lud21": "Betalningsverifiering (LUD-21)",
+  "lnurl.feature.signed-notes": "Signerade sedlar (offlineverifiering)",
+  "lnurl.feature.onion": "Tor-adress",
+  "lnurl.feature.rotate": "Rotera en sedel",
+  "lnurl.feature.split": "Dela en sedel",
+  "lnurl.feature.merge": "Slå ihop sedlar",
+  "lnurl.feature.lud06": "LUD-06 payRequest",
+  "lnurl.feature.lud03": "LUD-03 withdrawRequest",
+  "lnurl.limits.label": "Uttagsgränser",
+  "lnurl.limits.notPublished": "inte publicerat",
+  "lnurl.limits.withdrawRow": "Uttag",
+  "lnurl.limits.disabled": "avstängt",
+  "lnurl.limits.sats.one": "{n} sat",
+  "lnurl.limits.sats.other": "{n} sats",
+  "lnurl.details.title": "Uppgifter om minten",
+  "lnurl.details.address": "Lightning-adress",
+  "lnurl.details.mintPubkey": "Mintens publika nyckel",
+  "lnurl.details.onion": "Tor-adress",
+  "lnurl.details.fee": "Mintavgift",
+  "lnurl.details.node": "Nod",
+  "lnurl.details.capacity": "Annonserad kapacitet",
+  "lnurl.kind.lightningAddress": "Lightning-adress",
+  "lnurl.kind.mintPubkey": "mintens publika nyckel",
+  "lnurl.kind.onionAddress": "Tor-adress",
+  "lnurl.confirmed.label": "Senast bekräftad",
+  "lnurl.confirmed.when": "bekräftad {when}",
+  "lnurl.fee.base.one": "{n} sat",
+  "lnurl.fee.base.other": "{n} sats",
+  "lnurl.fee.percent": "{percent} %",
+  "home.topLnurl.title": "Toppade LNURL-mints",
+  "home.topLnurl.sub": "rankade efter recensioner och betyg",
+  "home.topLnurl.all": "Alla {n} LNURL-mints →",
+  "feed.ecosystem.lnurl": "LNURL",
+  "reviews.dialog.bodyPlaceholder.lnurl": "Hur gick mintning, smältning och rotering av sedlar? Var konkret.",
+  "reviews.byUrl.open": "Skriv en recension",
+  "reviews.byUrl.title": "Skriv en recension",
+  "reviews.byUrl.lede": "Klistra in adressen. Om sajten inte känner till den än kontrolleras och läggs den till nu.",
+  "reviews.byUrl.label.cashu": "Mint-URL",
+  "reviews.byUrl.label.fedimint": "Federationens invite code",
+  "reviews.byUrl.label.lnurl": "URL till LNURL-mint",
+  "reviews.byUrl.placeholder.cashu": "mint.example.com",
+  "reviews.byUrl.placeholder.fedimint": "fed11…",
+  "reviews.byUrl.placeholder.lnurl": "mint.example.com",
+  "reviews.byUrl.check": "Kontrollera adressen",
+  "reviews.byUrl.checking": "Kontrollerar…",
+  "reviews.byUrl.back": "Använd en annan adress",
+  "reviews.byUrl.existing": "Finns redan med",
+  "reviews.byUrl.indexed": "Nyss tillagd",
+  "reviews.byUrl.confirmClose": "Stänga? Adressen du skrev sparas inte.",
+  "reviews.byUrl.detected": "Adressen svarade som en {kind}-mint.",
+  "reviews.byUrl.switchTo": "Recensera den som {kind}-mint",
+  "reviews.byUrl.error.empty": "Skriv en adress först.",
+  "reviews.byUrl.error.badUrl": "Det ser inte ut som en mint-URL.",
+  "reviews.byUrl.error.badInvite": "Det är ingen Fedimint invite code. Koder börjar med fed11.",
+  "reviews.byUrl.error.badInput": "Sajten kan inte kontrollera den adressen.",
+  "reviews.byUrl.error.blocked": "Det är ingen offentlig adress, så den går inte att kontrollera.",
+  "reviews.byUrl.error.notAMint": "Adressen svarade, men inte som en mint av det här slaget.",
+  "reviews.byUrl.error.wrongType": "Adressen svarade, men som ett annat slags mint.",
+  "reviews.byUrl.error.unverifiable": "Inget svarade på den adressen, och det finns ännu inga spår av den på Nostr.",
+  "reviews.byUrl.error.rateLimited.one": "Det är många kontroller från en och samma anslutning. Försök igen om ungefär {n} minut.",
+  "reviews.byUrl.error.rateLimited.other": "Det är många kontroller från en och samma anslutning. Försök igen om ungefär {n} minuter.",
+  "reviews.byUrl.error.network": "Indexet gick inte att nå. Kontrollera din uppkoppling och försök igen.",
+  "seo.lnurl.titleNoReviews": "{name}: info och recensioner om LNURL-mint | Cashumints.space",
+  "seo.desc.statusWithdraw": "{status}, uttag {min}–{max} sat.",
+  "mint.chip.noFunding": "Ingen minting / melting",
+  "mint.warnings.lnurlWithdrawalsDisabled.lead": "Uttag är avstängda.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.online": "Den här minten annonserar ett maximalt uttag på noll, så ingen sedel den ger ut kan lösas in mot någonting. Minta inte här förrän det ändras.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.offline": "Den här minten annonserade ett maximalt uttag på noll när den senast nåddes, så ingen sedel den gav ut kunde lösas in mot någonting. Minta inte här förrän det ändras.",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.online": "Uttag är avstängda just nu",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.offline": "Uttag var avstängda när den senast sågs",
+  "mint.warnings.lnurlInvalid.lead": "Endpunkten svarar men är ogiltig.",
+  "mint.warnings.lnurlInvalid.body": "Värden svarar, men inte med en mint-annonsering som den här sajten kan läsa, så uttag kanske inte fungerar. Allt nedan är det senaste tillstånd som gick att läsa, och recensioner fungerar fortfarande.",
+  "mint.warnings.lnurlInvalid.meta": "Svarar, men inte med en giltig mint-annonsering",
+  "mint.warnings.lnurlNoFunding.lead": "Minting och melting är otillgängliga.",
+  "mint.warnings.lnurlNoFunding.body": "Befintliga sedlar kan fortfarande roteras, delas eller slås ihop, men just nu rör sig ingenting in eller ut via Lightning. Själva minten är uppe och svarar; Lightning-noden bakom den är inte nåbar därifrån.",
+  "mint.warnings.lnurlNoFunding.meta": "Minting och melting otillgängliga",
+  "mint.warnings.also.noFunding": "Dess Lightning-nod var också onåbar, så ingenting kunde mintas eller smältas."
+}

web/src/i18n/tr.json

@@ -0,0 +1,788 @@
+{
+  "site.name": "Cashumints.space",
+  "common.close": "Kapat",
+  "common.cancel": "İptal et",
+  "common.done": "Tamam",
+  "common.back": "Geri",
+  "common.retry": "Yeniden deneme",
+  "common.connect": "Bağlantı",
+  "common.copied": "Kopyalandı",
+  "common.copyFull": "Tam {kind}",
+  "common.previousPage": "Önceki sayfa",
+  "common.nextPage": "Sonraki sayfa",
+  "common.reviewPages": "İnceleme sayfaları",
+  "time.never": "Asla",
+  "time.justNow": "Az önce",
+  "time.none": "-",
+  "time.unknownDate": "bilinmeyen bir tarih",
+  "time.ago.minute": "{n}m önce",
+  "time.ago.hour": "{n}h önce",
+  "time.ago.day": "{n}d önce",
+  "time.ago.week": "{n}w az önce",
+  "time.ago.month": "{n}mo önce",
+  "time.ago.year": "{n}y önce",
+  "time.short.minute": "{n}m",
+  "time.short.hour": "{n}h",
+  "time.short.day": "{n}d",
+  "time.short.week": "{n}w",
+  "time.short.month": "{n}mo",
+  "time.short.year": "{n}y",
+  "status.online": "Çevrimiçi",
+  "status.offline": "Çevrimdışı",
+  "status.degraded": "Ulaşılamaz",
+  "status.unknown": "Henüz kontrol edilmedi",
+  "nav.skip": "İçeriğe geç",
+  "nav.main": "Ana",
+  "nav.mints": "Cashu mint'leri",
+  "nav.reviews": "İncelemeler",
+  "nav.wallets": "Cüzdanlar",
+  "nav.about": "Hakkında",
+  "nav.searchMints": "{n} mint araması",
+  "lang.label": "Dil",
+  "lang.switcher": "Bir dil seçin",
+  "footer.copyright": "© {year} Cashumints.space",
+  "footer.allMints": "Tüm Cashu mint'leri",
+  "footer.allReviews": "Tüm incelemeler",
+  "footer.wallets": "Cüzdanlar",
+  "footer.about": "Hakkında",
+  "footer.disclaimer": "Feragatname",
+  "footer.terms": "Koşullar",
+  "footer.privacy": "Gizlilik",
+  "footer.madeBy": "{azzamo} tarafından ❤️ ile yapıldı · Cashu ve NIP-87 ile güçlendirilmiştir",
+  "footer.warning": "Mint'ler emanetçidir. Bir mint paranızla birlikte kaybolabilir.",
+  "footer.tagline": "ecash mint'leri hakkında topluluk incelemeleri, Nostr üzerinde imzalanmış.",
+  "footer.col.explore": "Keşfet",
+  "footer.col.site": "Site",
+  "footer.nav": "Alt bilgi",
+  "home.title": "Cashumints.space · Güvenebileceğiniz bir Cashu mint bulun",
+  "home.description": "Güvenebileceğiniz bir Cashu minti bulun. Nostr'da imzalanmış {reviews} topluluk incelemesiyle {mints} mint indekslendi; ayrıca canlı çalışma durumu, desteklenen NUT'lar ve mint yazılımı bilgileri sunuluyor.",
+  "home.hero.title": "Bir Cashu mint bul",
+  "home.hero.titleEm": "Güvenebilirsin",
+  "home.hero.lede": "Nostr ağındaki her bir mint, gerçek topluluk incelemeleriyle. Kapı bekçisi yok, sadece imzalı incelemeler kendiniz doğrulayabilirsiniz.",
+  "home.search.label": "Mint'leri ada, alan adına veya URL'ye göre arayın",
+  "home.search.placeholder": "Ada veya alan adına göre arayın, ya da bir mint URL'si yapıştırın…",
+  "home.filters.mostReviewed": "En çok inceleme",
+  "home.filters.highestRated": "En yüksek puan",
+  "home.filters.recentlyActive": "Son zamanlarda aktif",
+  "home.filters.websockets": "WebSocket'leri Destekler",
+  "home.top.title": "En iyi Cashu mint ürünleri",
+  "home.top.sub": "İncelemeler ve puanlamaya göre sıralanır",
+  "home.top.all": "Tüm {n} mint →",
+  "home.latest.title": "Son incelemeler",
+  "home.latest.sub": "Nostr ağından canlı yayın",
+  "home.latest.prev": "Önceki incelemeler",
+  "home.latest.next": "Daha fazla inceleme",
+  "home.latest.all": "Tüm incelemeler →",
+  "home.latest.empty": "Şu anda rölelerden hiçbir yorum okunamadı. Herhangi bir mint sayfasını açın, doğrudan incelemeleri okuyup yazabilirsiniz.",
+  "home.why.title": "Neden bu incelemelere güveniyorsun?",
+  "home.why.signed.title": "İmzalandı, teslim edilmedi",
+  "home.why.signed.body": "Her inceleme, yazarının Nostr anahtarıyla imzalanan {link} bir olaydır. Buradaki hiçbir şey bizim tarafımızdan düzenlenmemiş, sıralanmamış veya kaldırılmamıştır.",
+  "home.why.signed.link": "NIP-87",
+  "home.why.verify.title": "Kendin doğrulayın",
+  "home.why.verify.body": "Yorumlar halka açık Nostr rölelerinde yayınlanıyor, veritabanımızda değil. Herhangi bir istemciyi aynı rölelere yönlendirirseniz, aynı veriyi görürsünüz.",
+  "home.why.checked.title": "Sürekli kontrol edildi",
+  "home.why.checked.body": "Tüm mintlerde çalışma süresi, yazılım sürümü, limitler ve desteklenen NUT'ları inceliyoruz, böylece gördüğünüz özellikler güncel ve kendi raporlarımız değil.",
+  "home.cta.title": "Mint mi düşünüyorsunuz? Önce oku.",
+  "home.cta.body": "Bir mint, ecash'inizi tutar. Sats yatırmadan önce başkalarının neler bulduğunu okuyun, kendiniz bir tanesini kullandığınızda da bir inceleme bırakın.",
+  "home.cta.explore": "Tüm mint'leri keşfedin",
+  "home.cta.learn": "Cashu hakkında bilgi edinin",
+  "pulse.mintsIndexed": "mint indekslendi",
+  "pulse.reviewsOnNostr": "Nostr'daki incelemeler",
+  "pulse.lastReview": "Son inceleme",
+  "pulse.mintsOnline": "mint çevrimiçi",
+  "pulse.indexer": "İndeksleyici",
+  "pulse.connected": "bağlantılı",
+  "pulse.stale": "bayat",
+  "mints.title": "Tüm Cashu mint'leri · Cashumints.space",
+  "mints.description": "Nostr ağından indekslenmiş {total} Cashu mint'inin tamamı, {online} çevrimiçi ve {offline} çevrimdışı, topluluk puanları, çalışma süresi ve mint yazılımıyla birlikte. Tam listeyi arayın ve sıralayın.",
+  "mints.heading": "Tüm Cashu mint'leri",
+  "mints.lede": "Nostr ağında bulunan her mint, artık var olmayanlar dahil. Çevrimdışı mint'ler listede kalır, böylece onları bulmaya ve incelemeye devam edebilirsiniz.",
+  "mints.search.label": "Mint'leri ada veya alan adına göre arayın",
+  "mints.search.placeholder": "İsim veya alan adına göre ara...",
+  "mints.sort.label": "Mint'leri sırala",
+  "mints.sort.score": "Genel olarak en iyi",
+  "mints.sort.rating": "En yüksek puan",
+  "mints.sort.reviews": "En çok inceleme",
+  "mints.sort.recent": "Son zamanlarda incelendi",
+  "mints.sort.seen": "Son zamanlarda internette görüldü",
+  "mints.hideOffline": "Çevrimdışı gizle",
+  "mints.showing": "{total} mint gösteriliyor ({online} çevrimiçi, {offline} çevrimdışı)",
+  "mints.showingFiltered": "{total} mint'in {shown} tanesi gösteriliyor ({online} çevrimiçi, {offline} çevrimdışı)",
+  "mints.noResults": "Eşleşen mint yok. Bir alan adı deneyin ya da bir mint URL'si yapıştırın.",
+  "mints.clearSearch": "Aramayı temizle",
+  "card.noRatings": "Henüz reytingler yok",
+  "card.reviews.one": "{n} inceleme",
+  "card.reviews.other": "{n} inceleme",
+  "card.lastSeen": "Son Görülme {when}",
+  "card.neverSeen": "Hiç çevrimiçi görünmedi",
+  "card.reviewed": "İnceleme {when}",
+  "card.noReviews": "Henüz inceleme yok",
+  "mint.title": "{name} · Cashu mint incelemeleri",
+  "mint.titleFedimint": "{name} · Fedimint federasyonu değerlendirmeleri",
+  "mint.titleLnurl": "{name} · LNURL mint değerlendirmeleri",
+  "mint.breadcrumb": "Gezinme yolu",
+  "mint.crumbMints": "Cashu mint'leri",
+  "mint.copyUrl": "Mint URL'sini kopyala",
+  "mint.qrButton": "Mint QR kodu",
+  "mint.writeReview": "Bir inceleme yaz",
+  "mint.rankByScore": "#{rank} skoru",
+  "mint.tagLightning": "Lightning",
+  "mint.summary": "Mint özeti",
+  "mint.rating.label": "Topluluk puanı",
+  "mint.rating.none": "Henüz puan yok",
+  "mint.rating.reviews.one": "{n} inceleme",
+  "mint.rating.reviews.other": "{n} inceleme",
+  "mint.rating.unrated.one": "{n} puan bırakmadı",
+  "mint.rating.unrated.other": "{n} puan bırakmadı",
+  "mint.activity.label": "Etkinlik",
+  "mint.activity.since": "Son incelemeden beri",
+  "mint.activity.noReviews": "Henüz inceleme yok",
+  "mint.activity.recent.one": "son 90 günde {n} inceleme",
+  "mint.activity.recent.other": "son 90 günde {n} inceleme",
+  "mint.limits.label": "Sınırlar",
+  "mint.limits.notPublished": "Yayınlanmadı",
+  "mint.limits.min": "min",
+  "mint.limits.max": "max",
+  "mint.limits.mintRow": "mint",
+  "mint.limits.meltRow": "melt",
+  "mint.limits.disabled": "devre dışı",
+  "mint.limits.range": "{min} ile {max} {unit} arası",
+  "mint.limits.upTo": "{max} {unit} kadar",
+  "mint.limits.from": "{min} {unit} itibaren",
+  "mint.software.label": "Mint yazılımı",
+  "mint.software.unknown": "bilinmeyen",
+  "mint.checked": "{when} kontrol edildi",
+  "mint.lastSeen": "Son Görülme {when}",
+  "mint.neverReached": "Hiç ulaşılmadı",
+  "mint.uptime.checks": "son {total} kontrolün {ok} tanesi ulaşılabilir",
+  "mint.uptime.percent": "%{percent} 30 gün boyunca ulaşılabilir",
+  "mint.uptime.description": "son {total} kontrolün {ok} tanesi başarılı",
+  "mint.operator.title": "Operatörden",
+  "mint.operator.motd": "Günün mesajı",
+  "mint.operator.beta": "Bu mint kendini deneysel ya da beta olarak tanımlıyor. Kaybetmeyi göze alamayacağınız bir şeyi burada tutmadan önce işletmecinin kendi sözlerini aşağıda okuyun.",
+  "mint.nuts.title": "Desteklenen NUT'lar",
+  "mint.nuts.noneOffline": "Bu mint için önbellek yapılmayan NUT listesi yoktu, kaydedilmeden önce çevrimdışı oldu.",
+  "mint.nuts.noneYet": "Bu mint için henüz önbelleğe alınmış bir NUT listesi yok.",
+  "mint.nuts.supported": "{n} bilinen {total} NUT'tan destekleniyor",
+  "mint.nuts.whatAre": "NUT'lar nedir?",
+  "mint.nutRow.disabled": "devre dışı",
+  "mint.nutRow.notSupported": "desteklenmiyor",
+  "mint.details.title": "Mint detayları",
+  "mint.details.pubkey": "Pubkey",
+  "mint.details.nostr": "Nostr",
+  "mint.details.email": "E-posta",
+  "mint.details.serverTime": "Sunucu zamanı",
+  "mint.details.firstSeen": "İlk kez görüldü",
+  "mint.details.terms": "Koşullar",
+  "mint.kind.identifier": "Tanımlayıcı",
+  "mint.kind.mintPubkey": "Mint Pubkey",
+  "mint.kind.nostrAddress": "Nostr adresi",
+  "mint.kind.emailAddress": "E-posta adresi",
+  "mint.kind.npub": "npub",
+  "mint.disclaimer": "Bu mint emanetçidir: paranızı tutar ve bunu istediği an bırakabilir. Puanlar topluluk görüşleridir ve çevrimiçi olmak ulaşılabilir demektir, güvenilir demek değil.",
+  "mint.disclaimerLink": "Tam feragatnameyi okuyun",
+  "mint.qr.title": "Cüzdanınıza {name} ekleyin",
+  "mint.qr.note": "Bunu bir Cashu cüzdanıyla tarayıp mint ekleyin ya da URL'yi kopyalayıp yapıştırın.",
+  "mint.qr.warn": "Bir mint eklemek, ona paranızı emanet etmek demektir.",
+  "mint.qr.whatMeans": "Bu ne anlama geliyor",
+  "mint.qr.wallets": "Cashu'yu destekleyen cüzdanlar",
+  "mint.chip.frozen": "Donmuş",
+  "mint.chip.noWithdrawals": "Çekim yok",
+  "mint.chip.meltOnly": "Sadece melt",
+  "mint.warnings.dayCount.one": "{n} gün",
+  "mint.warnings.dayCount.other": "{n} günler",
+  "mint.warnings.gone.lead": "Muhtemelen gitmiş.",
+  "mint.warnings.gone.body.since": "Bu mint {date} tarihinden beri ({days}) ulaşılamıyor. Orada tutulan fonları risk altında sayın ve yeni fon göndermeyin. Aşağıdaki detaylar son bilinen durumunu gösteriyor.",
+  "mint.warnings.gone.body.neverDated": "Bu mint, {month} yılında izlemeye başladığımızdan beri tek bir çeke bile cevap vermedi. Orada tutulan fonları risk altında olarak kabul edin ve yeni fonlar göndermeyin. Aşağıdaki her şey Nostr duyurusundan geliyor, mintten değil.",
+  "mint.warnings.gone.body.never": "Bu mint, izlemeye başladığımızdan beri tek bir çeke bile cevap vermedi. Orada tutulan fonları risk altında olarak kabul edin ve yeni fonlar göndermeyin. Aşağıdaki her şey Nostr duyurusundan geliyor, mintten değil.",
+  "mint.warnings.gone.meta.since": "{date} beri çevrimdışı",
+  "mint.warnings.gone.meta.never": "Keşfedildiğinden beri ulaşılamıyor",
+  "mint.warnings.meltDisabled.lead": "Yoksunluk durduruldu.",
+  "mint.warnings.meltDisabled.body.online": "Bu mint Lightning eritme (NUT-05) kapalı: sat koyabilirsiniz ama Lightning ile çekemezsiniz. Erime geri dönene kadar depozito yapmayın.",
+  "mint.warnings.meltDisabled.body.offline": "Bu mint Lightning eritme (NUT-05) kapalıydı: sat koyabilirsiniz ama Lightning ile çekemezsiniz. Erime geri dönene kadar depozito yapmayın.",
+  "mint.warnings.meltDisabled.meta.online": "Şu anda devre dışı bırakılan çekimler",
+  "mint.warnings.meltDisabled.meta.offline": "Son görüldüğünde çekimler devre dışı bırakılmıştı",
+  "mint.warnings.frozen.lead": "Mint dondurulmuş.",
+  "mint.warnings.frozen.body.online": "Hem minting hem melting devre dışı. Lightning üzerinden hiçbir sats girip çıkamaz.",
+  "mint.warnings.frozen.body.offline": "Hem minting hem melting devre dışı bırakılmıştı. Lightning üzerinden hiçbir sats girip çıkamaz.",
+  "mint.warnings.frozen.meta.online": "Şu anda donmuş, hiçbir şey girip çıkmıyor",
+  "mint.warnings.frozen.meta.offline": "Son kez görüldüğünde donmuştu",
+  "mint.warnings.offlineLong.lead": "{days} çevrimiçi, {date}'den beri.",
+  "mint.warnings.offlineLong.body": "Mint gitmiş olabilir. Aşağıdaki her şey son bilinen durumu ve incelemeler hâlâ çalışıyor.",
+  "mint.warnings.offlineLong.meta": "{date} beri çevrimdışı",
+  "mint.warnings.meltOnly.lead": "Sadece eriyecek.",
+  "mint.warnings.meltOnly.body.online": "Yeni minting (NUT-04) devre dışı: yatıramazsınız, ancak mevcut ecash hâlâ çekilebilir. Bu genellikle bir mint'in kapanmakta olduğu anlamına gelir, dolayısıyla onun ecash'ini tutuyorsanız melt etmeyi düşünün.",
+  "mint.warnings.meltOnly.body.offline": "Yeni minting (NUT-04) devre dışı bırakılmıştı: yatıramazsınız, ancak mevcut ecash hâlâ çekilebilir. Bu genellikle bir mint'in kapanmakta olduğu anlamına gelir, dolayısıyla onun ecash'ini tutuyorsanız melt etmeyi düşünün.",
+  "mint.warnings.meltOnly.meta.online": "Şu anda sadece melt",
+  "mint.warnings.meltOnly.meta.offline": "Sadece son görüldüğünde eriyip gider",
+  "mint.warnings.offline.lead": "{date}'dan beri çevrimdış.",
+  "mint.warnings.offline.body": "Detaylar en son o zaman doğrulandı. Yine de bir inceleme yazabilirsiniz.",
+  "mint.warnings.offline.meta": "{date} beri çevrimdışı",
+  "mint.warnings.also.meltDisabled": "Çevrimdışı olmadan önce para çekme işlemlerini de devre dışı bırakmıştı.",
+  "mint.warnings.also.mintDisabled": "Çevrimdışı olmadan önce yeni minting'i de devre dışı bırakmıştı.",
+  "mint.warnings.also.offline": "Ayrıca {date} ({days}) yılından beri çevrimdışıdır.",
+  "nut.0": "Notasyon ve modeller",
+  "nut.1": "Mint açık anahtar değişimi",
+  "nut.2": "Anahtar setleri ve ücretler",
+  "nut.3": "Token takası",
+  "nut.4": "Lightning ile minting",
+  "nut.5": "Lightningla Erime",
+  "nut.6": "Mint bilgileri",
+  "nut.7": "Token durum kontrolü",
+  "nut.8": "Fazla ödenen Lightning ücretleri",
+  "nut.9": "İmzaları geri getir",
+  "nut.10": "Harcama koşulları",
+  "nut.11": "Kamu anahtarına ödeme",
+  "nut.12": "DLEQ ispatları",
+  "nut.13": "Deterministik sırlar",
+  "nut.14": "Hash edilmiş zaman kilidi sözleşmeleri",
+  "nut.15": "Çok yollu ödemeler",
+  "nut.16": "Animasyonlu QR kodları",
+  "nut.17": "WebSocket abonelikleri",
+  "nut.18": "Ödeme talepleri",
+  "nut.19": "Önbelleğe alınmış yanıtlar",
+  "nut.20": "İmzalı mint quote'ları",
+  "nut.21": "Temiz kimlik doğrulama",
+  "nut.22": "Kör kimlik doğrulama",
+  "nut.23": "BOLT11 ödeme yöntemi",
+  "nut.24": "HTTP 402 ödemesi gereklidir",
+  "nut.25": "BOLT12 ödeme yöntemi",
+  "reviews.title": "İncelemeler",
+  "reviews.anon": "Anon",
+  "reviews.anonTitle": "Bu anahtar için halka açık Nostr profili bulunamadı.",
+  "reviews.nip05Title": "NIP-05 tanımlayıcısı (bu site tarafından doğrulanmamıştır)",
+  "reviews.filter.group": "Filtre incelemeleri",
+  "reviews.filter.all": "Hepsi",
+  "reviews.filter.five": "5★",
+  "reviews.filter.critical": "Kritik",
+  "reviews.filter.recent": "Son Dönemler",
+  "reviews.filter.hideAnon": "Anon gizle",
+  "reviews.anonHidden.other": "{n} {total} incelemesini gösteriyor: anonim gizli.",
+  "reviews.allAnon.one": "Buradaki tek inceleme anonim.",
+  "reviews.allAnon.other": "Buradaki tüm {n} yorumlar anonimdir.",
+  "reviews.allAnonShow.one": "Göster",
+  "reviews.allAnonShow.other": "Göster",
+  "reviews.loading.one": "Nostr rölays'tan {n} inceleme yükleniyor",
+  "reviews.loading.other": "Nostr rölelerinden {n} yorumları yükleniyor",
+  "reviews.empty": "Henüz inceleme yok. İlk yazan kişi ol.",
+  "reviews.emptyWritten": "Henüz yazılı bir inceleme yok. İlk yazan kişi ol.",
+  "reviews.emptyFilter": "Bu filtreyle eşleşen hiçbir yorum yok.",
+  "reviews.rate.cashu": "Bu mint'i puanla",
+  "reviews.rate.fedimint": "Bu federasyonu puanla",
+  "reviews.rate.lnurl": "Bu mint'i puanla",
+  "reviews.noscript": "İncelemeler Nostr'da imzalanır ve tarayıcınızda yüklenir, bu yüzden bu liste JavaScript gerektirir. Yukarıdaki puan ve sayımlar sitenin kendisinden geliyor.",
+  "reviews.relayError": "Röleye ulaşamadım. İncelemeler eksik olabilir.",
+  "reviews.srRating": "{rating} 5 üzerinden",
+  "reviews.srNoRating": "Derecelendirme verilmedi",
+  "reviews.readMore": "Daha fazlasını okuyun",
+  "reviews.readLess": "Daha az göster",
+  "reviews.actions.copyNpub": "Kopyala npub",
+  "reviews.actions.openNostr": "Bu etkinliği Nostr'da izleyin",
+  "reviews.actions.copyLink": "Bu incelemenin bağlantısını kopyala",
+  "reviews.anonNote": "Bu npub'dan ilk inceleme, başka bir faaliyet bulunmadı",
+  "reviews.published": "Yayınlandı.",
+  "reviews.publishedPartial": "{accepted} {total} rölesine yayımlandı.",
+  "reviews.propagating": "Nostr relay'lerine yayınlanıyor",
+  "reviews.summary.line.one": "{count} yorumsuz puan: {breakdown}",
+  "reviews.summary.line.other": "{count} yorumsuz puanlar: {breakdown}",
+  "reviews.summary.lineDay.one": "{when} yorumsuz {count} puanı: {breakdown}",
+  "reviews.summary.lineDay.other": "{count} yorum olmadan {when} puanları: {breakdown}",
+  "reviews.summary.showOne": "Göster",
+  "reviews.summary.showMany": "Göster",
+  "reviews.breakdown.5": "{n} beş yıldız",
+  "reviews.breakdown.4": "{n} dört yıldız",
+  "reviews.breakdown.3": "{n} üç yıldız",
+  "reviews.breakdown.2": "{n} iki yıldız",
+  "reviews.breakdown.1": "{n} bir yıldız",
+  "reviews.breakdown.none": "{n} puanı olmayan",
+  "reviews.dialog.title": "İnceleme {name}",
+  "reviews.dialog.lede.cashu": "Bu mint ile deneyiminizi paylaşın.",
+  "reviews.dialog.lede.fedimint": "Bu federasyon ile deneyiminizi paylaşın.",
+  "reviews.dialog.lede.lnurl": "Bu mint ile deneyiminizi paylaşın.",
+  "reviews.dialog.permanent": "Herkese açık Nostr relay'lerinde kalıcı olarak yayınlanır.",
+  "reviews.dialog.gate.title": "İnceleme yazmak için giriş yapın",
+  "reviews.dialog.gate.lead": "İncelemeler Nostr anahtarınızla imzalanır. Anahtar imzalayıcınızda kalır, bu site onu asla görmez.",
+  "reviews.dialog.ratingLegend": "Puanınız",
+  "reviews.dialog.starsSr.one": "{n} yıldızı",
+  "reviews.dialog.starsSr.other": "{n} yıldızlar",
+  "reviews.dialog.chooseRating": "Bir puan seçin",
+  "reviews.dialog.starLabel": "{n}: {phrase}",
+  "reviews.dialog.stars.1": "Kaçının",
+  "reviews.dialog.stars.2": "sorunlar yaşadı",
+  "reviews.dialog.stars.3": "işe yaradı, bazı şartlarla",
+  "reviews.dialog.stars.4": "iyi",
+  "reviews.dialog.stars.5": "Harika çalışıyor",
+  "reviews.dialog.bodyLabel": "Diğer insanlar ne bilmeli?",
+  "reviews.dialog.charCount": "{n} / {max}",
+  "reviews.dialog.submit": "İmza atma ve yayımlama",
+  "reviews.dialog.signing": "İmza...",
+  "reviews.dialog.publishing": "Yayıncılık...",
+  "reviews.dialog.publishingTo": "Yayın aktarıcılarına ({accepted}/{total})",
+  "reviews.dialog.waitingExtension": "Uzatmanızı bekliyorsunuz",
+  "reviews.dialog.waitingSigner": "İmzalanını bekliyorum",
+  "reviews.dialog.confirmClose": "Bu incelemeyi kapatmak mı? Taslağınız site terk edene kadar saklanır.",
+  "reviews.dialog.why.login": "Yayınlamak için giriş yapın",
+  "reviews.dialog.why.words": "Birkaç kelime yaz",
+  "reviews.dialog.why.more.one": "{n} daha karakter",
+  "reviews.dialog.why.more.other": "{n} daha fazla karakter",
+  "reviews.dialog.why.over.one": "{n} karakter sınırı aştı",
+  "reviews.dialog.why.over.other": "{n} sınırı aşan karakterler",
+  "reviews.dialog.identity.needSigner": "Yayınlamak için bir Nostr imzacısına ihtiyacınız var. Anahtarınız içinde kalır, bu site asla görmüyor.",
+  "reviews.dialog.identity.loginToPublish": "Yayınlamak için giriş yapın",
+  "reviews.dialog.identity.switch": "Değiştir",
+  "reviews.dialog.identity.extension": "Tarayıcı uzantınızla imzalama",
+  "reviews.dialog.identity.readingKey": "Açık anahtarını okurken...",
+  "reviews.dialog.identity.willAsk": "Uzantınızdan imzalaması istenecek",
+  "reviews.dialog.error.noRelay": "Hiçbir röle incelemeyi kabul etmedi. Bağlantınızı kontrol edin, sonra tekrar deneyin.",
+  "reviews.validate.rating": "1 ile 5 yıldız arasında bir değerlendirme seç.",
+  "reviews.validate.short": "En az {n} karakter yaz ki inceleme faydalı olsun.",
+  "reviews.validate.long": "İncelemeler {n} karakterle sınırlıdır.",
+  "feed.title": "En son mint ve federasyon incelemeleri · Cashumints.space",
+  "feed.description": "Her mint, federasyon ve LNURL mint değerlendirmesi yayımlandığı anda: {mints} Cashu mint'i, {federations} Fedimint federasyonu ve {lnurl} LNURL mint'i hakkında {reviews} değerlendirme, Nostr üzerinde imzalanmış ve burada en yeniden başlayarak okunabilir. Ekosisteme, puana veya isme göre filtreleyin.",
+  "feed.heading": "Son incelemeler",
+  "feed.lede": "Her Cashu mint'i ve Fedimint federasyonu hakkındaki her inceleme, en yenisi başta, Nostr rölelerinden canlı okunur. Her biri yazarı tarafından imzalanmıştır ve veritabanımızda değil, rölelerde durur.",
+  "feed.label": "İncelemeler",
+  "feed.showingBuild.one": "Son sürümden en güncel incelemeyi gösteriyor",
+  "feed.showingBuild.other": "Son sürümden {n} en son incelemeleri gösteriyor",
+  "feed.noscript": "Yorumlar Nostr'da imzalanır ve tarayıcınızda yüklenir, bu yüzden filtreleme ve tam liste JavaScript gerektirir. Aşağıdaki {n} incelemeler, bu sayfa oluşturulduğunda rölelerden okunmuştur.",
+  "feed.emptyBuild": "Bu sayfa oluşturulduğunda rölelerden hiçbir yorum okunamıyordu. Liste, tarayıcınızdaki rölelerden yeniden yüklenir.",
+  "feed.foot": "İncelemeler topluluk görüşleridir, doğrulanmış iddialar değil. Bir mint'e para emanet etmeden önce {link} okuyun.",
+  "feed.footLink": "Feragatname",
+  "feed.showing": "{total} incelemelerin {shown} gösterilmesi",
+  "feed.showingMatching": "{shown} {matching} eşleşen inceleme (toplamda {total}) gösteriliyor",
+  "feed.emptyRelays": "Rölelerden hiçbir yorum gelmedi. Herhangi bir mint sayfasını açın, oradaki incelemeleri okuyup yazabilirsiniz.",
+  "feed.emptyFilter": "Bu filtreyle eşleşen hiçbir yorum yok. Mint kutusunu temizleyin ya da hepsini deneyin.",
+  "feed.relayError": "Rölelere ulaşamadım. Son sürümden gelen incelemeleri gösteriyorum.",
+  "feed.relayEmpty": "Rölelerden hiçbir yorum gelmedi. Son sürümden gelen incelemeleri gösteriyorum.",
+  "feed.reading": "Röleleri okumak...",
+  "login.open": "Giriş",
+  "login.title": "Nostr'a giriş yapın",
+  "login.note": "Anahtarınız imzacınızda kalır. Bu site bunu asla göremez.",
+  "login.extension.name": "Tarayıcı uzantısı",
+  "login.extension.desc": "Alby, nos2x veya başka bir NIP-07 uzantısı ile imzala",
+  "login.extension.none": "Uzantı bulunmadı",
+  "login.extension.getOne": "Bir tane alın:",
+  "login.remote.name": "Uzaktan işaretleyici",
+  "login.remote.desc": "Bir imza uygulamasıyla bir kodu tarayın veya bir sığınak bağlantısı yapıştırın",
+  "login.primal.name": "İlkel",
+  "login.primal.desc": "Telefonunuzdaki Primal uygulamasında girişi onaylayın",
+  "login.paste.label": "Ya da imzalayanın verdiği bağlantı bağlantısını yapıştır",
+  "login.copyLink": "Bağlantı bağlantısını kopyala",
+  "login.whatIsNostr": "Nostr nedir?",
+  "login.connect.remote.title": "Bir uzaktan imzacıyı bağla",
+  "login.connect.remote.lead": "Bunu imza uygulamanızla tarayın ya da linki kopyalayıp oraya yapıştırın.",
+  "login.connect.remote.hint": "Her NIP-46 imzacısıyla çalışır: nsec.app, Amber, Nostrify, kendi sığınağınız.",
+  "login.connect.remote.open": "İmza uygulamanızda aç",
+  "login.connect.primal.title": "Primal ile bağlantı kur",
+  "login.connect.primal.lead": "Telefonunuzda Primal'ı açın, ayarlarında uzaktan imza sistemini bulun ve bu kodu tara.",
+  "login.connect.primal.hint": "Primal NIP-46 üzerinden diğer uygulamalar için işaret eder, yani bu bağlantı, herhangi bir imzacıyı kullanır ve anahtarınız Primal'da kalır. {link}",
+  "login.connect.primal.open": "Primal'da Açık",
+  "login.status.buildingLink": "Bağlantı Bağlantısı İnşası",
+  "login.status.waitingExtension": "Uzatmanızı bekliyorsunuz",
+  "login.status.waitingSigner": "İmzalanını bekliyorum",
+  "login.status.connecting": "İmzacınıza bağlanmak",
+  "login.status.connected": "Bağlantılı",
+  "login.toast.loggedIn": "Giriş yapıldı",
+  "login.toast.fetchingProfile": "Nostr profiliniz rölelerden alınıyor…",
+  "login.toast.profile": "Profil: {name}",
+  "login.toast.noProfile": "Rölelerde profil bulunamadı",
+  "login.method.extension": "Genişletme",
+  "login.method.remote": "Uzaktan",
+  "login.method.primal": "İlkel",
+  "login.account": "Nostr hesabınız",
+  "login.copyNpub": "Tam npub'unuzu kopyalayın",
+  "login.logout": "Çıkış",
+  "signer.status.waitingExtension": "Uzatmanızı bekliyorsunuz",
+  "signer.status.signed": "İmzalı",
+  "signer.status.reconnecting": "İşare Anınıza Yeniden Bağlantı Başlatmak",
+  "signer.status.approveWindow": "İmzacınızın bunu kendi penceresinde onaylamanız gerekiyor",
+  "signer.status.waitingSigner": "İmzalanını bekliyorum",
+  "signer.status.stillWaiting": "Hala işaret edeninizin cevap vermesini bekliyorum",
+  "signer.status.connected": "Bağlantılı",
+  "signer.error.noExtension": "İmza uzatması bulunamadı. Alby veya nos2x kur, sonra bu sayfayı yeniden yükleyin.",
+  "signer.error.privateKey": "Bu özel anahtar gibi görünüyor, bağlantı bağlantısı değil. Bu site hiç anahtar almıyor. İmzacınızın verdiği bunker:// bağlantıyı yapıştırın.",
+  "signer.error.badLink": "Bu sitenin anladığı bir bağlantı bağlantısı değil. İmzacınızdan bunker:// bağlantıyı yapıştırın.",
+  "signer.error.noAnswer": "İşaretçiniz cevap vermedi. Kapalı olabilir ya da rölesi kapalı olabilir. Aç ve tekrar dene.",
+  "signer.error.timeout": "İmzacınız zamanında cevap vermedi. Aç, hala bağlı olduğundan emin ol, sonra tekrar dene.",
+  "signer.error.cancelled": "Bağlantı iptal edildi.",
+  "signer.error.declined": "İmza talebi reddedildi",
+  "notfound.title": "Sayfa bulunmadı · Cashumints.space",
+  "notfound.description": "O sayfa Cashumints.space'da yok.",
+  "notfound.heading": "Bu sayfa mevcut değildir",
+  "notfound.lede": "Taşınmış olabilir ya da mint henüz indekslenmemiş olabilir. Bir mint'i adına veya alan adına göre arayın ya da bir mint URL'si yapıştırın.",
+  "notfound.browse": "Tüm mintlere göz atın",
+  "notfound.home": "Eve git",
+  "notfound.loading": "Yükleniyor {host}",
+  "notfound.fb.rating": "Puanlama",
+  "notfound.fb.reviews": "İncelemeler",
+  "notfound.fb.software": "Yazılım",
+  "notfound.fb.lastOnline": "Son çevrimiçi",
+  "notfound.fb.note": "Bu mint, site en son derlendikten sonra dizine eklendi; bu yüzden burada canlı API’den bir özet ve altında değerlendirmeleri var. Sayfanın tamamı bir sonraki derlemede görünür.",
+  "notfound.resolve.checking": "İlk ziyaret: bu mint şimdi kontrol ediliyor.",
+  "notfound.resolve.failed": "Bu mint eklenemedi",
+  "notfound.resolve.failedFedimint": "Bu federasyon eklenemedi",
+  "notfound.resolve.retry": "Başka bir adres dene",
+  "notfound.resolve.switch": "{kind} mint olarak aç",
+  "notfound.resolve.fedimint": "Bir federasyonun sayfa adresi davet kodunu taşımaz, bu yüzden bu federasyon yalnızca bağlantıyla bulunamaz. Davet kodunu yapıştır, federasyon eklenir.",
+  "notfound.resolve.ambiguous": "Bu adres yalnızca bağlantıdan çıkarılamıyor. Mintin tam URL’sini yapıştır, mint eklenir.",
+  "wallets.title": "Cashu cüzdanları · Cashumints.space",
+  "wallets.description": "Burada listelenen mintlerle mobil, web, tarayıcı ve komut satırı üzerinden çalışan Cashu cüzdanları, her birinin neye iyi olduğunu gösteriyor.",
+  "wallets.heading": "Cüzdanlar",
+  "wallets.lede": "Bu mint'lerin herhangi birinden ecash tutmak için bir cüzdana ihtiyacınız var. Çoğu cüzdan aynı anda birden fazla mint ile konuşur, yani ilk denediğinize bağlı kalmazsınız.",
+  "wallets.note": "Bu liste kapsamlı değildir ve bir onay değildir. Cashu projesi daha geniş bir endeksi {link} olarak tutuyor. Bir cüzdan anahtarları tutar, bir mint parayı tutar: satsların nerede yaşadığını seçmeden önce mint incelemelerini okuyun.",
+  "wallets.platform.android": "Android",
+  "wallets.platform.ios": "iOS",
+  "wallets.platform.web": "Web",
+  "wallets.platform.extension": "Tarayıcı uzantısı",
+  "wallets.platform.cli": "CLI",
+  "wallets.platform.python": "Python",
+  "wallets.item.minibits": "Kendi mint'i, Lightning adres desteği ve Nostr kişileri olan mobil ecash cüzdanı.",
+  "wallets.item.nutstash": "Birden fazla mint'i aynı anda yöneten ve ham tokenları içe ve dışa aktaran tarayıcı cüzdanı.",
+  "wallets.item.enuts": "Birden fazla mint'teki bakiyelere ve Nostr üzerinden ecash göndermeye odaklanan mobil cüzdan.",
+  "wallets.item.cashume": "Cashu projesinden referans web cüzdanı. Tamamen tarayıcıda çalışıyor, PWA olarak yüklenebilir.",
+  "wallets.item.boardwalk": "Lightning adresleri ve bağlantıyla ecash gönderme etrafında kurulmuş web cüzdanı.",
+  "wallets.item.coinos": "Kendi Cashu mint'ini de işleten Lightning cüzdanı ve satış noktası.",
+  "wallets.item.oxchat": "Sohbet içinde sats göndermek için yerleşik bir ecash cüzdanı bulunan Nostr messenger.",
+  "wallets.item.nutshell": "Referans uygulaması. Komut satırında cüzdan olarak ve mint yazılımı olarak çalışıyor.",
+  "about.title": "Hakkında Cashumints.space",
+  "about.description": "Cashu'nun ne olduğu, bir mint'in aslında ne tuttuğu, NIP-87'nin ne olduğu ve bu sitenin mint'leri nasıl indekslediği ve Nostr rölelerinden incelemeleri nasıl okuduğu.",
+  "about.heading": "Hakkında",
+  "about.lede": "Cashumints.space, Nostr ağında bulabildiğimiz tüm Cashu mintlerini listeliyor ve insanların onlar hakkında ne söylediğini gösteriyor. Azzamo tarafından üretilmiştir.",
+  "about.cashu.title": "Cashu Nedir",
+  "about.cashu.p1": "Cashu, Bitcoin için bir ecash protokolüdür. Bir mint, elinde tuttuğu sats ile desteklenen körleştirilmiş tokenlar çıkarır ve bu tokenlar, mint kimin kime ne gönderdiğini öğrenmeden insanlar arasında dolaşır. Gizlilik gerçektir ve mesele de budur: tokenlar hesap değildir ve mint, imzaladığı tokenı geri gelen tokenla ilişkilendiremez.",
+  "about.cashu.p2": "Protokolü ve teknik özellikleri {link} üzerinden okuyabilirsiniz. Teknik özelliklerin kendisi NUT olarak adlandırılır, her mint sayfasındaki NUT numaraları da buradan gelir.",
+  "about.mints.title": "Mint nedir ve bunun karşılığında",
+  "about.mints.p1": "Mint emanetçidir. Ecash mint ettiğinizde sats'ları o sunucuyu işleten kişiye verirsiniz ve tokenları geri melt ettiğinizde bunları karşılayacaklarına güvenmiş olursunuz. Dolandırıcılık kanıtı, emanet hesabı ve başvuru yolu yoktur. Bir mint işletmecisi bakiyeyle birlikte ortadan kaybolabilir, ve kaybolan mint'ler olmuştur.",
+  "about.mints.p2": "İşte bu yüzden burada incelemeler var. Bu site size bir mintin güvenli olduğunu asla söylemez. Bir mint sayfasındaki durum {code} yazıyor, \"güvenilen\" değil ve bu sadece sunucunun son sorduğumuzda cevap verdiği anlamına geliyor. E-nakit bakiyelerini bir ceket cebindeki nakit gibi ele alın: harcamalar için ceza, tasarruf için yanlış.",
+  "about.nip87.title": "NIP-87 nedir",
+  "about.nip87.p1": "NIP-87, ecash mint'lerini duyurmak ve önermek için kullanılan Nostr geleneğidir. Burada iki olay türü önemlidir:",
+  "about.nip87.li1": "{code} bir mint duyuruyor. Mint URL'si {tag} etiketinde. Site, daha önce hiç görmediği mint parçalarını böyle keşfediyor.",
+  "about.nip87.li2": "{code} bir incelemedir. Puanı ve inceleme metnini taşır ve konu olduğu mint'i bir {utag} etiketi (mint URL'si) ve bir {dtag} etiketi (mint'in kendi açık anahtarı) ile işaret eder.",
+  "about.nip87.p2": "Her inceleme, yazarının Nostr anahtarıyla imzalanır. Bir incelemeye asla \"doğrulanmış\" demiriz, çünkü kimse doğrulamadı: imzalanmıştır, bu da farklı ve daha faydalı bir iddiadır. Bu, kimin yazdığını ve değiştirilmediğini kontrol edebildiğiniz anlamına gelir. Bu, yazarın dürüst olduğu ya da mint kullandığı anlamına gelmez.",
+  "about.how.title": "Bu site nasıl çalışır",
+  "about.how.p1": "İki döngü ve bir kural var. Kural şu: meta veriler mint'in, incelemeler Nostr'undur, bu yüzden bu site ikisini de otorite olarak saklamaz.",
+  "about.how.li1": "{strong}, bilinen her mint'ten on dakikada bir {code} ister ve söylediklerini kaydeder: ad, açıklama, sürüm, desteklenen NUT'lar, limitler, iletişim bilgileri. Ayrıca mint'in yanıt verip vermediğini de kaydeder, çalışma süresi buradan gelir.",
+  "about.how.li1Label": "Prob döngüsü",
+  "about.how.li2": "{strong}, her saat Nostr rölelerine bağlanıyor, mint duyurularını ve incelemelerini okuyor, daha önce görmediği herhangi bir mint ekliyor.",
+  "about.how.li2Label": "Keşif döngüsü",
+  "about.how.p2": "Önemli olan, bir mint yanıt vermeyi bıraktığında ne olduğudur. Önbelleğe alınmış meta verileri başarısız bir yoklama tarafından asla üzerine yazılmaz, böylece ölü bir mint tam sayfasını korur: özellikleri, geçmişi ve incelemeleri, ne zaman sustuğunu söyleyen bir bant ile birlikte. Bu sitenin önceki sürümü bunun yerine bir hata sayfası gösteriyordu; bu da insanların birbirini en çok uyarması gereken mint'lerin incelenemeyen mint'ler olması demekti. Yeniden yazmanın ana nedeni buydu.",
+  "about.how.p3": "İnceleme metni bizim tarafımızda asla saklanmaz. Bir mint sayfası açtığınızda, tarayıcınız doğrudan rölelerle konuşur ve incelemeleri kendisi okur, bir sayfa yazdığınızda ise kendi Nostr uzantınızla imzalanır ve doğrudan o rölelere gönderilir. Sayfalar sıralanıp sıralanabilmesi için sayıyı tutuyoruz, başka bir şey yok. Buradaki hiçbir şey bizim tarafından düzenlenemeyebilir veya silinemez, istemediğimiz incelemeler dahil.",
+  "about.relays.title": "Okuduğumuz röleler",
+  "about.relays.p1": "İndeksleyicinin ve tarayıcınızın kullandığı röleler şunlardır:",
+  "about.relays.p2": "Herhangi bir Nostr istemcisini aynı rölelere yönlendirirseniz, aynı olayları göreceksiniz. Bütün söz budur: burada hiçbir şey sadece bizim söylediğimiz için doğru değildir.",
+  "about.nuts.title": "NUT'lar nedir?",
+  "about.nuts.p1": "NUT'lar, Bitcoin'deki BIP'ler gibi numaralandırılmış Cashu spesifikasyonlarıdır. Bir mint hangilerini uyguladığını duyurur ve bu size onun aslında ne yapabileceğini söyler: NUT-04 ve NUT-05 Lightning üzerinden minting ve melting'dir (bunlar olmadan bir mint pek işe yaramaz), NUT-07 bir cüzdanın tokenın zaten harcanıp harcanmadığını kontrol etmesini sağlar, NUT-17 cüzdanlara yoklama yerine WebSockets üzerinden canlı güncelleme verir, NUT-20 ise bir cüzdanın mint quote'unun gerçekten kendisine verildiğini kanıtlamasını sağlar. Tam liste {link} adresinde.",
+  "about.numbers.title": "Şu anda",
+  "about.numbers.p1": "{mints} mint indekslendi, bunların {online} tanesi yanıt veriyor, yukarıdaki rölelerden {reviews} inceleme sayıldı.",
+  "about.source.title": "Kaynak ve kredi",
+  "about.source.p1": "Site {github} adresinde açık kaynaklıdır. Tesis {azzamo} tarafından inşa edilip işletilmektedir. Bir mint sayfasında bir sorun varsa, kaynağında düzeltin: mint meta verileri kendi {code} gelir, incelemeler ise Nostr'den gelir.",
+  "terms.title": "Kullanım Şartları · Cashumints.space",
+  "terms.description": "Cashumints.space kullanım şartları: sitenin ne olduğu, ne yapmadığı ve kimin neden sorumlu olduğu. Hesap yok, garanti yok, hiçbir mint ile bağlantı yok.",
+  "terms.heading": "Kullanım Şartları",
+  "terms.lede": "Sadece halka açık verileri indeksleyen bir site için açık. Son güncelleme {date}.",
+  "terms.what.title": "Bu site nedir",
+  "terms.what.p1": "Cashumints.space, Cashu mint mintler hakkında halka açık verilerin bir dizinidir. İki tür veri, ikisi de başka bir yerden:",
+  "terms.what.li1": "Mint meta verileri, her mint'in kendi {code} uç noktasından okunur: ad, açıklama, yazılım sürümü, desteklenen NUT'lar, iletişim bilgileri ve son sorduğumuzda mint'in yanıt verip vermediği.",
+  "terms.what.li2": "Kamuya açık Nostr rölelerinden okunan incelemeler. Bunlar, yazarları tarafından herkesin sorgulayabileceği NIP-87 etkinlikleridir.",
+  "terms.what.p2": "O verileri topluyoruz, normalleştiriyoruz, sıralıyoruz ve gösteriyoruz. Biz yaratmıyoruz.",
+  "terms.noAccounts.title": "Hesap yok, garanti yok",
+  "terms.noAccounts.p1": "Kaydolacak bir şey yok. Site olduğu gibi sağlanmıştır, herhangi bir garanti yoktur: verilerin doğru olduğu anlamına gelmiyor, güncel olduğu anlamına gelmiyor, sitenin erişilebilir olacağı da yok. Mint verileri dakikalar veya saatler eski olabilir, bir mint son kontrol ettikten sonra değişebilir ve bir röle cevap vermeyebilir, bu durumda var olandan daha azını görmüş olursunuz.",
+  "terms.noAccounts.p2": "Kendi riskinizle kullanın. Bu siteyi kullanmaktan veya burada okuduklarınıza güvenmekten kaynaklanan herhangi bir kayıptan sorumlu değiliz. Cashu mint kullanımının özel riskleri için {link} bölümüne bakınız.",
+  "terms.noAccounts.link": "Feragatname",
+  "terms.noCustody.title": "Paranızı elimizde tutmuyoruz",
+  "terms.noCustody.p1": "Bu site fonları asla emanet almaz. Cüzdanı yoktur, ecash'e dokunmaz ve hiçbir şeyi taşıyamaz, donduramaz veya kurtaramaz. Bir mint ile sorununuz varsa size yardım edebilecek tek taraf mint işletmecisidir ve biz sizin adınıza onlarla iletişime geçemeyiz.",
+  "terms.noCustody.p2": "Burada listelenen hiçbir mint ile bağlantımız yok ve hiçbir mint listelenmesi, sırası veya puanı için ödeme yapmaz. Mint'ler kamuya açık Nostr duyurularından keşfedilir ve kamuya açık inceleme verileri üzerinden bir algoritma tarafından sıralanır.",
+  "terms.reviews.title": "İnceleler başkalarının sözleridir",
+  "terms.reviews.p1": "İncelemeler, yazarları tarafından kamuya açık Nostr aktarıcılarına yayımlanan kullanıcı tarafından oluşturulan içeriktir. Onları sergileriz, kontrol etmiyoruz. Onları biz yazmadık, düzenleyemeyiz ve onları tutan aktarıcılardan silemeyiz: bunlar bizim sahip olmadığımız bir ağda imzalanmış etkinliklerdir.",
+  "terms.reviews.p2": "Bir inceleme, bir kişinin deneyimidir, doğrulanmış bir gerçek değildir. Bir tane yayımlarsanız, ne yazdığından sorumlusunuz. Yasa dışı hiçbir şey yayınlamayın ve yayınladığınız şeyin kamuya açık ve kalıcı olduğunu unutmayın (bkz. {link}).",
+  "terms.reviews.link": "Gizlilik sayfası",
+  "terms.reviews.p3": "Bu sitede belirli bir incelemeyi göstermeyi durdurabiliriz ve bunu yasa dışı içerik için yapacağız. Bu sadece bu sayfalardan kaldırılıyor. Olay rölelerde kalır ve diğer Nostr istemcileri hâlâ okuyabilir.",
+  "terms.links.title": "Diğer sitelere bağlantılar",
+  "terms.links.p1": "Mint URL'leri, cüzdan bağlantıları, operatör bağlantıları ve bu siteyi gösteren diğer her şey verinin bir parçası olduğu için orada. Bir bağlantı onay değildir ve diğer uçta ne olduğunu kontrol etmiyoruz.",
+  "terms.changes.title": "Değişiklikler",
+  "terms.changes.p1": "Bu terimler değişebilir. Üstteki tarih en son ne zaman yaptıklarını gösteriyor. Site açık kaynaklıdır, bu yüzden bu sayfadaki her değişiklik commit geçmişinde yer alır.",
+  "terms.contact.title": "İletişim",
+  "terms.contact.p1": "Sorunlar ve kaldırma talepleri en iyisi {github} başvurulmaktadır. Site {azzamo} tarafından yönetilmektedir.",
+  "privacy.title": "Gizlilik · Cashumints.space",
+  "privacy.description": "Cashumints.space gizliliği: hesap yok, takip çerezleri yok, analitik yok. localStorage profil önbellekleme için kullanılır ve hiçbir şey hiçbir yere gönderilmez. İncelemeler kendi tarayıcınızda imzalanır.",
+  "privacy.heading": "Gizlilik",
+  "privacy.lede": "Bir web sitesi toplayabildiği kadar az şey topluyoruz. Son güncelleme {date}.",
+  "privacy.noAccounts.title": "Hesap yok",
+  "privacy.noAccounts.p1": "Kayıt yok, giriş yok ve profil yok. Bu sitede kim olduğunuzu soran hiçbir şey yok ve kullanıcı olmadığı için sızdıracak bir kullanıcı kaydı yok.",
+  "privacy.noTracking.title": "İzleme çerezleri yok, analitik yok",
+  "privacy.noTracking.p1": "Site, takip için çerezler belirlemez. Analitik script, etiket yöneticisi, piksel, oturum kaydı ve reklam ağı yok. Sayfadaki hiçbir şey davranışınızı bize veya başkasına bildirmiyor.",
+  "privacy.logs.title": "Sunucu kayıtları",
+  "privacy.logs.p1": "Web sunucusu standart erişim kayıtlarını tutar, ki bu varsayılan olarak herhangi bir web sunucusunun yaptığı şeydir. Bir log satırı, IP adresinizi, zamanı, istediğiniz sayfayı, yanıt durumunu ve tarayıcınızın gönderdiği kullanıcı temsilcisi ve yönlendiriciyi kaydeder. Kayıtlar hataları ayıklamak ve kötüye kullanımı tespit etmek için var. Başka hiçbir şeye bağlı değiller, satılmazlar veya paylaşılmazlar.",
+  "privacy.logs.operatorLabel": "Operatör notu:",
+  "privacy.logs.operator": "Bu siteyi yönetiyorsanız, gerçek tutunmanızı burada belirtin. README'deki dağıtım, nginx ile varsayılan erişim logu ve dağıtımınızın gönderdiği rotasyonu (Debian ve Ubuntu'da günlük logrotate, 14 gün tutar) kullanıyor. Sunucunuzun ne yaptığını doğrulayın ve bu paragrafı numarayla değiştirin.",
+  "privacy.storage.title": "Tarayıcınızda ne saklanıyor",
+  "privacy.storage.p1": "Site, localStorage için tam olarak iki şey kullanıyor, ikisi de cihazınızda kalır ve hiçbir yere gönderilmez:",
+  "privacy.storage.li1": "İnceleme yaptığınız incelemeciler için Nostr profil meta verilerinin (tür 0 olaylar: isimler, avatarlar, NIP-05 adresleri) önbellesi. Bu, her sayfada yeniden sorgulanan röleleri kaydeder. Kayıtlar süresi doluyor ve önbellek kapatılır ve ilk en yaşlı tahliye edilir.",
+  "privacy.storage.li2": "Arayüz tercihleri, böylece site bir dahaki sefere aynı şekilde davranır.",
+  "privacy.storage.p2": "Tarayıcınızın site verilerini temizlemek her ikisini de kaldırır. Hiçbir şey bozulmaz, profil aramaları tekrar çalışıyor.",
+  "privacy.thirdParties.title": "Tarayıcınızın ne ile iletişim kurduğu",
+  "privacy.thirdParties.p1": "Bir sayfa yüklemek, tarayıcınızı bu site dışında birkaç yere bağlar. Sunucu tarafı takibi olmayan bir site, hâlâ canlı verileri okumasının şeklidir:",
+  "privacy.thirdParties.li1Label": "Public Nostr röleleri",
+  "privacy.thirdParties.li1": "{strong}, WebSocket üzerinden, incelemeleri ve inceleme profillerini okumak için. Röle, bağlandığınız her sunucu gibi IP'nizi ve istediğiniz şeyi görür. İğneler {link} listelenmiştir.",
+  "privacy.thirdParties.li1Link": "Hakkında sayfası",
+  "privacy.thirdParties.li2Label": "İnceleyen avatar görselleri",
+  "privacy.thirdParties.li2": "{strong}, eleştirmenin profilinin gösterdiği yerden yükleniyor. Bunlar, yönlendirme politikası ile gönderilir, böylece sunucu hangi sayfada olduğunuzu öğrenmez.",
+  "privacy.publishing.title": "Bir inceleme yayımlama",
+  "privacy.publishing.p1": "Bir inceleme yazmak sunucumuzda değil, tarayıcınızda gerçekleşir. Etkinlik, NIP-07 uzantınız (Alby, nos2x veya benzeri) tarafından imzalanır ve tarayıcınızdan doğrudan rölelere yayınlanır. Özel anahtarınız uzantıdan hiç ayrılmaz ve bu site bunu hiç görmüyor. Özel anahtar yönetimi inşa etmiyoruz ve asla anahtar veya tohum ifadesi istemiyoruz.",
+  "privacy.permanent.title": "Nostr'a yayınladığınız her şey kamuya açık ve kalıcı",
+  "privacy.permanent.p1": "Bu kısmı iki kez okumaya değer. Değerlendirme, halka açık bayrak yarışlarında imzalı bir etkinliktir. Bir kez çıktıktan sonra dışarı çıkar:",
+  "privacy.permanent.li1": "Herkes, şimdi ve ileride herhangi bir Nostr istemcisiyle okuyabilir. Bu \"Cashumints.space'de kamuya açık\" değil, ağda kamuya açıktır.",
+  "privacy.permanent.li2": "Bu, Nostr kamu anahtarınıza kalıcı olarak bağlıdır ve bu anahtarın şimdiye kadar yayımladığı diğer her şeyin yanı sıra.",
+  "privacy.permanent.li3": "Silmek bir istek, bir komut değil. Bir silme etkinliği yayınlayabilirsiniz ve bazı röleler bunu onurlandırır, ancak bir röle bunu görmezden gelebilir ve etkinliği kopyalayan herkes hâlâ ona sahip. Yayınlanmış bir incelemeyi kalıcı olarak kabul edin.",
+  "privacy.permanent.li4": "Sizin için silemiyoruz. Burada sergilemeyi bırakabiliriz; Bu rölelerde hiçbir şeyi değiştirmez.",
+  "privacy.permanent.p2": "Bir namint incelemesi ana kimliğinizle bağlantılı olmadan incelemek istiyorsanız, ayrı bir Nostr anahtarı kullanın. Başka bir aktivitesi olmayan bir anahtarın sert incelemelerde böyle gösterildiğini unutmayın, çünkü yepyeni bir anahtar, bir yıldızlı inceleme yazıyor ve okuyucuların görmesi gereken bir desendir.",
+  "privacy.contact.title": "Sorular",
+  "privacy.contact.p1": "Site açık kaynaklıdır: yukarıdakilerden herhangi birini kontrol etmek isterseniz, {github} adresindeki kodu okuyun. Sorular ve düzeltmeler orada bir sayıya girebilir.",
+  "disclaimer.title": "Feragatname · Cashumints.space",
+  "disclaimer.description": "Cashu mint kullanmadan önce bilmeniz gerekenler: mint ürünleri koruma altındadır, bir mint paranizla birlikte kaybolabilir, incelemeler görüştür ve çevrimiçi olarak ulaşılabilir, güvenilir değildir.",
+  "disclaimer.heading": "Feragatname",
+  "disclaimer.lede": "Bir mint'e para koymadan önce bunu okuyun. Son güncelleme {date}.",
+  "disclaimer.callout": "Bir Cashu mint'i paranızı sizin için tutar. Kaybolursa ecash'iniz gider ve başvurabileceğiniz kimse olmaz. Yalnızca kaybetmeyi göze alabileceğiniz kadarını tutun.",
+  "disclaimer.custodial.title": "Mint'ler emanetçidir",
+  "disclaimer.custodial.p1": "E-cash bastığınızda, bitcoin'i mint operatörüne verirsiniz ve tokenları geri alırsınız. Bu tokenlar o operatör üzerinde bir hak hakkıdır. Bunlar sizin sahip olduğunuz bitcoin değildir ve onları takdir edip etmeyeceğinize karar veren operatördür.",
+  "disclaimer.custodial.p2": "Bu, her mint'in aynı riskleri taşıdığı anlamına gelir: işletmeci ortadan kaybolabilir, durdurulmaya zorlanabilir, bir hata veya saldırı yüzünden fonları kaybedebilir ya da sunucuyu kapatabilir. Mevduat sigortası yok, ters ibraz yok, destek hattı yok ve güvenmeye değer yasal bir yol yok. Bu, bu sitedeki en yüksek puanlı mint için de geçerlidir.",
+  "disclaimer.custodial.p3": "Cashu, küçük miktarların hızlı hareket etmesini sağlamak için tasarlanmıştır. Bunu şöyle kullanın: harcamak üzere olduğunuz şeyi tutun, birikimlerinizi değil, ve her şeyi bir arada park etmek yerine mint mağazalarına yayın.",
+  "disclaimer.reviews.title": "İncelemeler görüşdür, doğrulanmış iddialar değildir",
+  "disclaimer.reviews.p1": "Buradaki her inceleme Nostr'daki biri tarafından yazılmış ve anahtarıyla imzalanmıştır. İmzalı olması, hangi anahtarın yazdığını size söyleyebileceğimiz anlamına gelir. İncelemenin doğru olduğu, yazarın mint'i kullandığı ya da yazarın işletmeci, bir rakip veya on anahtarı olan tek bir kişi olmadığı anlamına gelmez.",
+  "disclaimer.reviews.p2": "İnceleme yapanları doğrulamayız ve katılmadığımız yorumları düzenlemez veya kaldırmıyoruz. Birkaçını okuyun, aslında ne söylediklerine bakın ve üç incelemeli bir mint tartı, üç yüz inceleme ile farklı bir tartı tartın.",
+  "disclaimer.status.title": "Çevrim, ulaşılabilir demektir, güvenilir değil",
+  "disclaimer.status.p1": "Her minti düzenli olarak kontrol ediyoruz ve cevap verip vermediğini gösteriyoruz. Yeşil durumun dediği tek şey budur: sunucu yanıt verdi. Operatörün ödeme yapıp etmediği, dürüst olup olmadığı ya da yarın tokenlarınızı hâlâ onurlandırmayı düşünüp düşünmediği hakkında hiçbir şey belirtmiyor.",
+  "disclaimer.status.p2": "Bir mint artık çevrimiçi olmayana kadar olabilir. Çalışma süresi geçmişi, desteklenen NUT'lar ve yazılım sürümleri bir mintin nasıl işletildiği hakkında bir şeyler söyler, ama hiçbiri paranizle ilgili bir söz değildir.",
+  "disclaimer.ranking.title": "Sıralama nasıl çalışır ve ne anlama gelmez",
+  "disclaimer.ranking.p1": "Mint'ler kamuya açık inceleme verileri üzerinden bir algoritma ile sıralanır: puan, inceleme sayısı ve son etkinlik; çevrimiçi mint'ler varsayılan olarak çevrimdışı olanların önünde gelir. Detaylar açık kaynak kodunda.",
+  "disclaimer.ranking.p2": "Kimse sıralama için ödeme yapmaz. Bu sitede sponsorlu alan, öne çıkarılmış liste veya herhangi bir mint ile anlaşma yoktur. Yüksek sıra, algoritmanın kamuya açık verileri beğendiği anlamına gelir, fazlası değil. Bu bir tavsiye değildir ve bir güvenlik puanı değildir.",
+  "disclaimer.notAdvice.title": "Bu finansal tavsiye değil",
+  "disclaimer.notAdvice.p1": "Bu sitedeki hiçbir şey finansal, yatırım, hukuki veya vergi tavsiyesi değildir. Durumunuzu bilmiyoruz ve size tavsiye vermiyoruz. Mint kullanmak ve hangisini seçmek sizin kararınız.",
+  "disclaimer.dyor.title": "Kendi araştırmanızı yapın",
+  "disclaimer.dyor.li1": "İşletmeciyi araştırın. Kaybedecek kamusal itibarı olan birinin işlettiği bir mint, anonim bir URL'den başka bir şeydir.",
+  "disclaimer.dyor.li2": "Mint'in kendi şartlarını ve MOTD'sini okuyun. Kendine test ya da beta diyen bir mint bunu ciddi söylüyordur.",
+  "disclaimer.dyor.li3": "Küçük başlayın. Biraz mint yap, harca, tekrar erit, ve daha fazlasını emanet etmeden önce ne olacağını gör.",
+  "disclaimer.dyor.li4": "Sınırlara dikkat et. Düşük maksimum genellikle dikkatli bir operatörün işaretidir, yüksek maksimum ise güvenli bir operatörün işareti değildir.",
+  "disclaimer.dyor.li5": "Tokenlarınızı yedeği tutun ve unutmayın ki token taşıyıcı varlıktır: kim varsa onu harcayabilir.",
+  "disclaimer.site.title": "Sitenin kendisi hakkında",
+  "disclaimer.site.p1": "Buradaki veriler yanlış veya güncel olmayabilir. Mint programları bir programa göre incelenir, röleler bazen cevap vermez ve okuduğunuz bir sayfa geçmişte bir noktada oluşturulmuştur. Site olduğu gibi sunulmuştur, garanti yoktur. Bak {link}.",
+  "disclaimer.site.link": "Kullanım Şartları",
+  "disclaimer.updated": "20 Ağustos 2026",
+  "login.getPrimal": "Primal'ı al",
+  "reviews.dialog.identity.extensionGone": "Tarayıcı uzantınız cevap vermiyor. Tekrar giriş yapın ya da uzaktan imzacıyı kullanın.",
+  "seo.orgDescription": "Her mint'in canlı durumu ve Nostr'da imzalanmış topluluk incelemeleriyle birlikte bir Cashu mint dizini.",
+  "seo.ogImageAlt": "Cashumints.space: güvenebileceğiniz bir Cashu mint'i bulun.",
+  "seo.mint.title.one": "{name} incelemeleri: {n} incelemeden {rating} | Cashumints.space",
+  "seo.mint.title.other": "{name} incelemeleri: {n} incelemeden {rating} | Cashumints.space",
+  "seo.mint.titleOffline.one": "{name}: {n} gün boyunca çevrimdışı | Cashumints.space",
+  "seo.mint.titleOffline.other": "{name}: {n} gün çevrimdışı | Cashumints.space",
+  "seo.mint.titleNoReviews": "{name}: Cashu mint bilgisi ve incelemeleri | Cashumints.space",
+  "seo.fedimint.titleNoReviews": "{name}: Fedimint federasyonu bilgileri ve incelemeleri | Cashumints.space",
+  "seo.desc.fallback": "{name} ({domain}) için topluluk incelemeleri.",
+  "seo.desc.fallbackDomain": "{domain} adresindeki Cashu mint'i için topluluk incelemeleri.",
+  "seo.desc.rated.one": "{n} imzalı Nostr incelemesinden {rating}/5 derecesi alındı.",
+  "seo.desc.rated.other": "{n} imzalı Nostr incelemelerinden {rating}/5 derecelendirildi.",
+  "seo.desc.noReviews": "Henüz inceleme yok.",
+  "seo.desc.status": "{status}.",
+  "seo.desc.statusLimits": "{status}, sınırlar {limits}.",
+  "seo.desc.fedModules": "{status}. Modüller: {modules}.",
+  "seo.desc.fedModulesNetwork": "{status}. Modüller: {network} üzerinde {modules}.",
+  "seo.mint.ogAlt.one": "{name}: Cashumints.space üzerinde {n} incelemeden {rating} yıldız",
+  "seo.mint.ogAlt.other": "{name}: Cashumints.space üzerinde {n} incelemeden {rating} yıldız",
+  "seo.mint.ogAltNoReviews": "Cashumints.space üzerinde {name}",
+  "nav.home": "Ana Sayfa",
+  "mint.more.title": "Daha fazla mint",
+  "mint.more.all": "Tüm mint ürünlerini gör",
+  "nav.fedimints": "Fedimints",
+  "status.announced": "Sadece duyuruldu",
+  "card.unnamedFederation": "İsimsiz federasyon",
+  "card.notChecked": "hiç kontrol edilmedi",
+  "fedimints.title": "Tüm Fedimint federasyonları · Cashumints.space",
+  "fedimints.description": "Nostr ağında açıklanan {total} Fedimint federasyonları: {online} dışarıdan yapılan bir kontrolle onaylandı, {announced} duyuruldu ve hiç onaylanmadı. Topluluk derecelendirmeleri, modülleri ve her biri için davet kodları.",
+  "fedimints.heading": "Tüm federasyonlar",
+  "fedimints.lede": "Her Fedimint federasyonu Nostr ağında duyuruyor. Bir federasyonun kendi kamu statüsü uç noktası yoktur, bu yüzden bazıları dışarıdan bir kontrol ile çalıştığı doğrulanır, diğerleri ise tam olarak duyurulduğu gibi listelenir.",
+  "fedimints.search.label": "Federasyonları isim veya kimlik ile arama",
+  "fedimints.search.placeholder": "İsim veya federasyon kimliğiyle ara...",
+  "fedimints.sort.label": "Federasyonları sıralama",
+  "fedimints.hideOffline": "Çevrimdışı gizle",
+  "fedimints.showing": "{total} federasyonları gösteriliyor ({online} doğrulandı, {announced} sadece duyuruldu)",
+  "fedimints.showingFiltered": "{total} federasyonun {shown} gösteriliyor ({online} doğrulandı, {announced} sadece duyuruldu)",
+  "fedimints.announcedNote.one": "Bunlardan biri Nostr'da duyuruldu ve o zamandan beri hiçbir şey doğrulanmadı. Çevrimiçi veya çevrimdışı olarak değil, duyurulmuş olarak listeleniyor, çünkü hiçbiri doğru olmaz.",
+  "fedimints.announcedNote.other": "{n} Nostr'da duyuruldu ve o zamandan beri devam ettikleri doğrulanmadı. Bunlar çevrimiçi veya çevrimdışı olarak değil, duyurulan olarak listeleniyor, çünkü hiçbiri doğru olmaz.",
+  "fedimints.noResults": "Federasyon maçı yok. Bir isim dene ya da federasyon kimliğini yapıştır.",
+  "fedimints.emptyIndex": "Bu sitede aktarma programlarında herhangi bir federasyon açıklanmadı. Liste, duyurular geldikçe doluyor.",
+  "fedimint.crumb": "Fedimintler",
+  "fedimint.breadcrumb": "Ekmek kırıntısı",
+  "fedimint.unnamed": "İsimsiz federasyon",
+  "fedimint.idLabel": "Federasyon",
+  "fedimint.kind.federationId": "Federasyon kimliği",
+  "fedimint.moduleCount.one": "{n} modülü",
+  "fedimint.moduleCount.other": "{n} modülleri",
+  "fedimint.copyInvite": "Davet kodunu kopyala",
+  "fedimint.confirmed.label": "Onaylandı",
+  "fedimint.confirmed.never": "Asla",
+  "fedimint.confirmed.by": "{source} tarafından",
+  "fedimint.confirmed.unattributed": "Son çek",
+  "fedimint.announcedOn": "duyurdu {when}",
+  "fedimint.announcedUnknown": "Duyuru tarihi yok",
+  "fedimint.modules.title": "Modüller",
+  "fedimint.modules.none": "Bu federasyonun duyurusunda modül listelenmiyor.",
+  "fedimint.modules.note": "Modüller, federasyonun işlettiği parçalardır. Duyuruda hangilerinin mevcut olduğu belirtilmiş, herhangi birinin depozito kabul edip etmediği hakkında hiçbir şey yok.",
+  "fedimint.modules.notListed": "Listelenmedi",
+  "fedimint.invite.title": "Davet kodu",
+  "fedimint.invite.count.one": "{n} kodu",
+  "fedimint.invite.count.other": "{n} kodları",
+  "fedimint.invite.note": "Bunu Fedimint cüzdanına yapıştırıp katılabilirsiniz. Federasyon kimliğini ve koruyucularının adreslerini taşır ve paylaşılmak üzere tasarlanmıştır.",
+  "fedimint.invite.kind": "Davet kodu",
+  "fedimint.invite.qr": "QR",
+  "fedimint.invite.qrCaption": "Katılmak için tarama {name}",
+  "fedimint.details.federationId": "Federasyon kimliği",
+  "fedimint.details.network": "Ağ",
+  "fedimint.details.announcedBy": "Duyurucu",
+  "fedimint.details.announced": "Duyuruldu",
+  "fedimint.more.title": "Daha fazla federasyon",
+  "fedimint.more.all": "Tüm federasyonları gör",
+  "fedimint.disclaimer": "Bir federasyona katılmak, paranızı koruyucularına emanet etmek demektir. Derecelendirmeler topluluk görüşleridir ve onaylanmış koşu ulaşılabilir demektir, güvenilir değil.",
+  "fedimint.module.lightning": "Lightning",
+  "fedimint.module.mint": "Ecash mint'i",
+  "fedimint.module.wallet": "Zincir içi cüzdan",
+  "fedimint.module.meta": "Meta veriler",
+  "fedimint.module.stability_pool": "Stabilite havuzu",
+  "fedimint.module.multi_sig_stability_pool": "Stabilite havuzu (multisig)",
+  "fedimint.module.fedi-social": "Sosyal toparlanma",
+  "fedimint.network.mainnet": "Bitcoin ana ağı",
+  "fedimint.network.signet": "Mühür",
+  "fedimint.network.testnet": "Testnet",
+  "fedimint.network.testnet4": "Testnet4",
+  "fedimint.network.regtest": "Regtest",
+  "feed.ecosystem.group": "Ekosistem",
+  "feed.ecosystem.all": "Hepsi",
+  "feed.ecosystem.cashu": "Cashu",
+  "feed.ecosystem.fedimint": "Fedimint",
+  "feed.filterBySubject": "Mint veya federasyona göre filtrele",
+  "feed.anySubject": "Herhangi bir mint veya federasyon",
+  "feed.clearSubject": "İsim filtresini temizle",
+  "home.topFedimints.title": "En İyi Fedimintler",
+  "home.topFedimints.sub": "İncelemeler ve puanlamaya göre sıralanır",
+  "home.topFedimints.all": "Tüm {n} federasyonları →",
+  "reviews.validate.subject": "Bu incelemeyi gösterecek hiçbir şey yok.",
+  "mint.warnings.fedimintOffline.lead": "Çevrimdışı bildirildi.",
+  "mint.warnings.fedimintOffline.body.since": "Bu federasyona ulaşan son kontrol {date} ({days} önceydi. Koruyucuları o zamandan beri cevap vermedi. Orada tutulan fonları risk altında olarak kabul edin ve yeni fonlarla birleştirmeyin.",
+  "mint.warnings.fedimintOffline.body.never": "Bu federasyonun hiçbir kontrolü ona ulaşmadı ve en son kontrol başarısız oldu. Orada tutulan fonları risk altında olarak kabul edin ve yeni fonlarla birleştirmeyin.",
+  "mint.warnings.fedimintOffline.meta.since": "{date} beri çevrimdışı bildiriliyor",
+  "mint.warnings.fedimintOffline.meta.never": "Çevrimdışı bildirildi, bir kez bile ulaşılmadı",
+  "mint.warnings.neverConfirmed.lead": "Açıklandı, hiç doğrulanmadı.",
+  "mint.warnings.neverConfirmed.body.reviewed": "Bu federasyon {days} {date} tarihinde Nostr'da duyuruldu ve o zamandan beri hiçbir şey onaylamadı. Aşağıdaki incelemeler bu sayfadaki hayat göstergesidir; Geri kalan her şey duyurudan geldi.",
+  "mint.warnings.neverConfirmed.body.quiet": "Bu federasyon {date} tarihinde Nostr'da duyuruldu, {days} önce, o zamandan beri hiçbir şey doğrulanmadı ve son zamanlarda kimse incelemedi. Aşağıdaki her şey duyurudan alındı.",
+  "mint.warnings.neverConfirmed.meta": "{date} duyuruldu, hiç doğrulanmadı",
+  "footer.allFedimints": "Tüm federasyonlar",
+  "reviews.dialog.bodyPlaceholder.cashu": "Minting, melting ve destek nasıl sonuçlandı? Spesifik olun.",
+  "reviews.dialog.bodyPlaceholder.fedimint": "Katılım, Lightning ödemeleri ve destek nasıl sonuçlandı? Spesifik olun.",
+  "fedimint.details.title": "Federasyon detayları",
+  "nav.lnurlMints": "LNURL mint'leri",
+  "footer.allLnurlMints": "Tüm LNURL mint'leri",
+  "lnurlMints.title": "LNURL mint'leri: lnurlcash hamiline senet mint'leri, değerlendirmelerle | Cashumints.space",
+  "lnurlMints.description": "Nostr ağından dizinlenen {total} LNURL mint'inin tamamı: {online} çevrimiçi, {offline} çevrimdışı. Her biri için topluluk puanları, çekim limitleri ve özellikler.",
+  "lnurlMints.heading": "LNURL mint'leri",
+  "lnurlMints.lede": "Bu sitenin bildiği her LNURL mint'i. Bir LNURL mint'i lnurlcash hamiline senetleri çıkarır: bir sır olarak sakladığınız, döndürülebilen, bölünebilen, birleştirilebilen veya bir Lightning ödemesine geri eritilebilen Lightning senetleri. Her biri birkaç dakikada bir HTTPS üzerinden kontrol edilir.",
+  "lnurlMints.search.label": "LNURL mint'lerinde ara",
+  "lnurlMints.search.placeholder": "İsme veya adrese göre ara…",
+  "lnurlMints.sort.label": "LNURL mint'lerini şuna göre sırala",
+  "lnurlMints.hideOffline": "Çevrimdışıları gizle",
+  "lnurlMints.showing": "{total} LNURL mint'i gösteriliyor ({online} çevrimiçi, {offline} çevrimdışı)",
+  "lnurlMints.showingFiltered": "{total} LNURL mint'inden {shown} tanesi gösteriliyor ({online} çevrimiçi, {offline} çevrimdışı)",
+  "lnurlMints.noResults": "Eşleşen LNURL mint'i yok.",
+  "lnurlMints.emptyIndex": "Henüz dizinlenmiş LNURL mint'i yok.",
+  "lnurl.crumb": "LNURL mint'leri",
+  "lnurl.breadcrumb": "Gezinti yolu",
+  "lnurl.copyAddress": "Adresi kopyala",
+  "lnurl.more.title": "Daha fazla LNURL mint'i",
+  "lnurl.more.all": "Tüm LNURL mint'leri →",
+  "lnurl.disclaimer": "Bir LNURL mint'i siz onun senetlerini tutarken sizin sat'larınızı tutar; yani birini kullanmak işletmecisine güvenmek demektir. Puanlar topluluk görüşüdür ve çevrimiçi, erişilebilir demektir, güvenilir değil.",
+  "lnurl.features.title": "Özellikler",
+  "lnurl.features.none": "Bu mint neyi desteklediğini duyurmadı.",
+  "lnurl.features.note": "Özellikler, mint işletmecisinin Nostr'da duyurduklarıdır. Bu site birini HTTPS üzerinden doğrulayabildiğinde doğrular ve duyurulan bir şey şu anda kullanılamıyorsa bunu belirtir.",
+  "lnurl.features.notListed": "duyurulmadı",
+  "lnurl.features.unavailable": "kullanılamıyor",
+  "lnurl.feature.mint": "Lightning ile mint (LUD-06)",
+  "lnurl.feature.melt": "Lightning'e erit",
+  "lnurl.feature.notes": "Senetleri döndür / böl / birleştir",
+  "lnurl.feature.lud16": "Lightning adresi",
+  "lnurl.feature.lud21": "Ödeme doğrulaması (LUD-21)",
+  "lnurl.feature.signed-notes": "İmzalı senetler (çevrimdışı doğrulama)",
+  "lnurl.feature.onion": "Tor adresi",
+  "lnurl.feature.rotate": "Bir seneti döndür",
+  "lnurl.feature.split": "Bir seneti böl",
+  "lnurl.feature.merge": "Senetleri birleştir",
+  "lnurl.feature.lud06": "LUD-06 payRequest",
+  "lnurl.feature.lud03": "LUD-03 withdrawRequest",
+  "lnurl.limits.label": "Çekim limitleri",
+  "lnurl.limits.notPublished": "yayımlanmadı",
+  "lnurl.limits.withdrawRow": "Çekim",
+  "lnurl.limits.disabled": "devre dışı",
+  "lnurl.limits.sats.one": "{n} sat",
+  "lnurl.limits.sats.other": "{n} sat",
+  "lnurl.details.title": "Mint ayrıntıları",
+  "lnurl.details.address": "Lightning adresi",
+  "lnurl.details.mintPubkey": "Mint açık anahtarı",
+  "lnurl.details.onion": "Tor adresi",
+  "lnurl.details.fee": "Mint ücreti",
+  "lnurl.details.node": "Düğüm",
+  "lnurl.details.capacity": "Duyurulan kapasite",
+  "lnurl.kind.lightningAddress": "Lightning adresi",
+  "lnurl.kind.mintPubkey": "mint açık anahtarı",
+  "lnurl.kind.onionAddress": "Tor adresi",
+  "lnurl.confirmed.label": "Son doğrulama",
+  "lnurl.confirmed.when": "{when} doğrulandı",
+  "lnurl.fee.base.one": "{n} sat",
+  "lnurl.fee.base.other": "{n} sat",
+  "lnurl.fee.percent": "%{percent}",
+  "home.topLnurl.title": "En iyi LNURL mint'leri",
+  "home.topLnurl.sub": "değerlendirme ve puana göre sıralandı",
+  "home.topLnurl.all": "{n} LNURL mint'inin tümü →",
+  "feed.ecosystem.lnurl": "LNURL",
+  "reviews.dialog.bodyPlaceholder.lnurl": "Mint etme, eritme ve senet döndürme nasıl gitti? Somut olun.",
+  "reviews.byUrl.open": "Bir değerlendirme yaz",
+  "reviews.byUrl.title": "Bir değerlendirme yaz",
+  "reviews.byUrl.lede": "Adresi yapıştır. Bu site adresi henüz bilmiyorsa şimdi kontrol eder ve ekler.",
+  "reviews.byUrl.label.cashu": "Mint URL’si",
+  "reviews.byUrl.label.fedimint": "Federasyonun davet kodu",
+  "reviews.byUrl.label.lnurl": "LNURL mint URL’si",
+  "reviews.byUrl.placeholder.cashu": "mint.example.com",
+  "reviews.byUrl.placeholder.fedimint": "fed11…",
+  "reviews.byUrl.placeholder.lnurl": "mint.example.com",
+  "reviews.byUrl.check": "Bu adresi kontrol et",
+  "reviews.byUrl.checking": "Kontrol ediliyor…",
+  "reviews.byUrl.back": "Başka bir adres kullan",
+  "reviews.byUrl.existing": "Zaten listede",
+  "reviews.byUrl.indexed": "Yeni eklendi",
+  "reviews.byUrl.confirmClose": "Kapatılsın mı? Yazdığın adres saklanmaz.",
+  "reviews.byUrl.detected": "Bu adres bir {kind} mint olarak yanıt verdi.",
+  "reviews.byUrl.switchTo": "{kind} mint olarak değerlendir",
+  "reviews.byUrl.error.empty": "Önce bir adres gir.",
+  "reviews.byUrl.error.badUrl": "Bu bir mint URL’sine benzemiyor.",
+  "reviews.byUrl.error.badInvite": "Bu bir Fedimint davet kodu değil. Kodlar fed11 ile başlar.",
+  "reviews.byUrl.error.badInput": "Bu site o adresi kontrol edemiyor.",
+  "reviews.byUrl.error.blocked": "Bu genel bir adres değil, bu yüzden kontrol edilemiyor.",
+  "reviews.byUrl.error.notAMint": "Bu adres yanıt verdi, ama bu türden bir mint olarak değil.",
+  "reviews.byUrl.error.wrongType": "Bu adres yanıt verdi, ama başka türden bir mint olarak.",
+  "reviews.byUrl.error.unverifiable": "Bu adreste hiçbir şey yanıt vermedi ve Nostr’da da henüz izine rastlanmadı.",
+  "reviews.byUrl.error.rateLimited.one": "Tek bağlantıdan çok fazla kontrol yapıldı. Yaklaşık {n} dakika sonra tekrar dene.",
+  "reviews.byUrl.error.rateLimited.other": "Tek bağlantıdan çok fazla kontrol yapıldı. Yaklaşık {n} dakika sonra tekrar dene.",
+  "reviews.byUrl.error.network": "Dizine ulaşılamadı. Bağlantını kontrol edip tekrar dene.",
+  "seo.lnurl.titleNoReviews": "{name}: LNURL mint bilgileri ve incelemeleri | Cashumints.space",
+  "seo.desc.statusWithdraw": "{status}, çekim {min}–{max} sat.",
+  "mint.chip.noFunding": "Mint / erit yok",
+  "mint.warnings.lnurlWithdrawalsDisabled.lead": "Çekimler devre dışı.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.online": "Bu mint azami çekimi sıfır olarak duyuruyor, yani çıkardığı hiçbir senet hiçbir şeye çevrilemez. Bu değişene kadar burada mint etmeyin.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.offline": "Bu mint'e en son ulaşıldığında azami çekimi sıfır olarak duyuruyordu, yani çıkardığı hiçbir senet hiçbir şeye çevrilemiyordu. Bu değişene kadar burada mint etmeyin.",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.online": "Çekimler şu anda devre dışı",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.offline": "En son görüldüğünde çekimler devre dışıydı",
+  "mint.warnings.lnurlInvalid.lead": "Uç nokta yanıt veriyor ama geçersiz.",
+  "mint.warnings.lnurlInvalid.body": "Sunucu yanıt veriyor, ancak bu sitenin okuyabileceği bir mint duyurusuyla değil; bu yüzden çekimler çalışmayabilir. Aşağıdakiler okunabilen son durumdur ve değerlendirmeler hâlâ çalışıyor.",
+  "mint.warnings.lnurlInvalid.meta": "Yanıt veriyor, ama geçerli bir mint duyurusuyla değil",
+  "mint.warnings.lnurlNoFunding.lead": "Mint etme ve eritme kullanılamıyor.",
+  "mint.warnings.lnurlNoFunding.body": "Mevcut senetler hâlâ döndürülebilir, bölünebilir veya birleştirilebilir, ancak şu anda Lightning üzerinden hiçbir şey girip çıkmıyor. Mint'in kendisi ayakta ve yanıt veriyor; arkasındaki Lightning düğümüne oradan erişilemiyor.",
+  "mint.warnings.lnurlNoFunding.meta": "Mint etme ve eritme kullanılamıyor",
+  "mint.warnings.also.noFunding": "Lightning düğümüne de erişilemiyordu, bu yüzden hiçbir şey mint edilemez veya eritilemezdi."
+}

web/src/i18n/uk.json

@@ -0,0 +1,834 @@
+{
+  "site.name": "Cashumints.space",
+  "common.close": "Закрити",
+  "common.cancel": "Скасувати",
+  "common.done": "Готово",
+  "common.back": "Назад",
+  "common.retry": "Повторити",
+  "common.connect": "Підключитися",
+  "common.copied": "Скопійовано",
+  "common.copyFull": "Скопіювати повний {kind}",
+  "common.previousPage": "Попередня сторінка",
+  "common.nextPage": "Наступна сторінка",
+  "common.reviewPages": "Сторінки відгуків",
+  "time.never": "ніколи",
+  "time.justNow": "щойно",
+  "time.none": "-",
+  "time.unknownDate": "невідома дата",
+  "time.ago.minute": "{n}m тому",
+  "time.ago.hour": "{n}h тому",
+  "time.ago.day": "{n}d тому",
+  "time.ago.week": "{n}w тому",
+  "time.ago.month": "{n} міс. тому",
+  "time.ago.year": "{n} р. тому",
+  "time.short.minute": "{n}m",
+  "time.short.hour": "{n}h",
+  "time.short.day": "{n}d",
+  "time.short.week": "{n}w",
+  "time.short.month": "{n} міс.",
+  "time.short.year": "{n} р.",
+  "status.online": "Онлайн",
+  "status.offline": "Офлайн",
+  "status.degraded": "Недоступний",
+  "status.unknown": "Ще не перевірено",
+  "nav.skip": "Перейти до змісту",
+  "nav.main": "Головна",
+  "nav.mints": "Мінти Cashu",
+  "nav.reviews": "Відгуки",
+  "nav.wallets": "Гаманці",
+  "nav.about": "Про сайт",
+  "nav.searchMints": "Шукати серед {n} мінтів",
+  "lang.label": "Мова",
+  "lang.switcher": "Виберіть мову",
+  "footer.copyright": "© {year} Cashumints.space",
+  "footer.allMints": "Усі мінти Cashu",
+  "footer.allReviews": "Усі відгуки",
+  "footer.wallets": "Гаманці",
+  "footer.about": "Про сайт",
+  "footer.disclaimer": "Відмова від відповідальності",
+  "footer.terms": "Умови",
+  "footer.privacy": "Конфіденційність",
+  "footer.madeBy": "Створено з ❤️ {azzamo} · Працює на Cashu та NIP-87",
+  "footer.warning": "Мінти є кастодіальними. Мінт може зникнути разом із вашими грошима.",
+  "footer.tagline": "Відгуки спільноти про ecash-мінти, підписані в Nostr.",
+  "footer.col.explore": "Огляд",
+  "footer.col.site": "Сайт",
+  "footer.nav": "Підвал сайту",
+  "home.title": "Cashumints.space · Знайдіть мінт Cashu, якому можна довіряти",
+  "home.description": "Знайдіть мінт Cashu, якому можна довіряти. Проіндексовано {mints} мінтів із {reviews} відгуками спільноти, підписаними в Nostr, а також актуальними даними про доступність, підтримувані NUT і програмне забезпечення мінтів.",
+  "home.hero.title": "Знайдіть мінт Cashu",
+  "home.hero.titleEm": "якому можна довіряти",
+  "home.hero.lede": "Усі мінти в мережі Nostr із реальними відгуками спільноти. Без посередників, лише підписані відгуки, які ви можете перевірити самостійно.",
+  "home.search.label": "Шукати мінти за назвою, доменом або URL",
+  "home.search.placeholder": "Шукайте за назвою чи доменом або вставте URL мінту…",
+  "home.filters.mostReviewed": "Найбільше відгуків",
+  "home.filters.highestRated": "Найвища оцінка",
+  "home.filters.recentlyActive": "Нещодавно активні",
+  "home.filters.websockets": "Підтримка WebSockets",
+  "home.top.title": "Найкращі мінти Cashu",
+  "home.top.sub": "за відгуками та оцінкою",
+  "home.top.all": "Усі {n} мінтів →",
+  "home.latest.title": "Останні відгуки",
+  "home.latest.sub": "наживо з мережі Nostr",
+  "home.latest.prev": "Попередні відгуки",
+  "home.latest.next": "Більше відгуків",
+  "home.latest.all": "Всі відгуки →",
+  "home.latest.empty": "Щойно не вдалося прочитати відгуки з relays. Відкрийте сторінку будь-якого мінту, щоб читати й писати відгуки безпосередньо.",
+  "home.why.title": "Чому варто довіряти цим відгукам?",
+  "home.why.signed.title": "Підписані, а не надіслані нам",
+  "home.why.signed.body": "Кожен відгук є подією {link}, підписаною Nostr-ключем автора. Ми нічого тут не редагуємо, не ранжуємо й не видаляємо.",
+  "home.why.signed.link": "NIP-87",
+  "home.why.verify.title": "Перевірте це самостійно",
+  "home.why.verify.body": "Відгуки зберігаються на публічних Nostr relays, а не в нашій базі даних. Підключіть будь-який клієнт до тих самих relays і побачите ті самі дані.",
+  "home.why.checked.title": "Перевіряється безперервно",
+  "home.why.checked.body": "Ми постійно перевіряємо доступність кожного мінту, версію програмного забезпечення, ліміти й підтримувані NUT. Тому показані характеристики актуальні, а не лише заявлені оператором.",
+  "home.cta.title": "Розглядаєте мінт? Спочатку прочитайте відгуки.",
+  "home.cta.body": "Мінт зберігає ваш ecash. Прочитайте досвід інших, перш ніж вносити sats, і залиште відгук після власного використання.",
+  "home.cta.explore": "Переглянути всі мінти",
+  "home.cta.learn": "Дізнатися про Cashu",
+  "pulse.mintsIndexed": "проіндексовано мінтів",
+  "pulse.reviewsOnNostr": "відгуків у Nostr",
+  "pulse.lastReview": "останній відгук",
+  "pulse.mintsOnline": "мінтів онлайн",
+  "pulse.indexer": "Індексер",
+  "pulse.connected": "підключено",
+  "pulse.stale": "застарілі дані",
+  "mints.title": "Усі мінти Cashu · Cashumints.space",
+  "mints.description": "Усі {total} мінтів Cashu, проіндексовані з мережі Nostr: {online} онлайн і {offline} офлайн. Є оцінки спільноти, доступність і програмне забезпечення мінтів. Шукайте та сортуйте повний список.",
+  "mints.heading": "Усі мінти Cashu",
+  "mints.lede": "Усі мінти, знайдені в мережі Nostr, зокрема ті, що вже зникли. Офлайн-мінти залишаються у списку, щоб ви могли знайти їх і залишити відгук.",
+  "mints.search.label": "Шукати мінти за назвою або доменом",
+  "mints.search.placeholder": "Шукати за назвою або доменом…",
+  "mints.sort.label": "Сортувати мінти",
+  "mints.sort.score": "Найкращі загалом",
+  "mints.sort.rating": "Найвища оцінка",
+  "mints.sort.reviews": "Найбільше відгуків",
+  "mints.sort.recent": "Нещодавно оцінені",
+  "mints.sort.seen": "Нещодавно були онлайн",
+  "mints.hideOffline": "Приховати офлайн",
+  "mints.showing": "Показано {total} мінтів ({online} онлайн, {offline} офлайн)",
+  "mints.showingFiltered": "Показано {shown} із {total} мінтів ({online} онлайн, {offline} офлайн)",
+  "mints.noResults": "Мінтів за запитом не знайдено. Спробуйте домен або вставте URL мінту.",
+  "mints.clearSearch": "Очистити пошук",
+  "card.noRatings": "Рейтингів поки що немає.",
+  "card.reviews.one": "{n} огляд",
+  "card.reviews.few": "{n} відгуки",
+  "card.reviews.many": "{n} відгуків",
+  "card.reviews.other": "{n} відгуки",
+  "card.lastSeen": "останній раз онлайн {when}",
+  "card.neverSeen": "ніколи не був онлайн",
+  "card.reviewed": "відгук {when}",
+  "card.noReviews": "Поки що немає відгуків",
+  "mint.title": "{name} · Відгуки про мінт Cashu",
+  "mint.titleFedimint": "{name} · Відгуки про федерацію Fedimint",
+  "mint.titleLnurl": "{name} · Відгуки про LNURL-мінт",
+  "mint.breadcrumb": "Навігаційний ланцюжок",
+  "mint.crumbMints": "Мінти Cashu",
+  "mint.copyUrl": "Скопіювати URL мінту",
+  "mint.qrButton": "QR-код мінту",
+  "mint.writeReview": "Напишіть відгук",
+  "mint.rankByScore": "#{rank} за рейтингом",
+  "mint.tagLightning": "Lightning",
+  "mint.summary": "Огляд мінту",
+  "mint.rating.label": "Рейтинг спільноти",
+  "mint.rating.none": "Рейтингів поки що немає.",
+  "mint.rating.reviews.one": "{n} огляд",
+  "mint.rating.reviews.few": "{n} відгуки",
+  "mint.rating.reviews.many": "{n} відгуків",
+  "mint.rating.reviews.other": "{n} відгуки",
+  "mint.rating.unrated.one": "{n} не залишив рейтингу",
+  "mint.rating.unrated.few": "{n} без рейтингу",
+  "mint.rating.unrated.many": "{n} без рейтингу",
+  "mint.rating.unrated.other": "{n} не залишив рейтингу",
+  "mint.activity.label": "Діяльність",
+  "mint.activity.since": "З останнього огляду",
+  "mint.activity.noReviews": "Поки що немає відгуків",
+  "mint.activity.recent.one": "{n} огляд за останні 90 днів",
+  "mint.activity.recent.few": "{n} відгуки за останні 90 днів",
+  "mint.activity.recent.many": "{n} відгуків за останні 90 днів",
+  "mint.activity.recent.other": "{n} відгуки за останні 90 днів",
+  "mint.limits.label": "Ліміти",
+  "mint.limits.notPublished": "Не опубліковано",
+  "mint.limits.min": "мін",
+  "mint.limits.max": "Макс",
+  "mint.limits.mintRow": "mint, внесення",
+  "mint.limits.meltRow": "melt, виведення",
+  "mint.limits.disabled": "вимкнено",
+  "mint.limits.range": "від {min} до {max} {unit}",
+  "mint.limits.upTo": "до {max} {unit}",
+  "mint.limits.from": "від {min} {unit}",
+  "mint.software.label": "Програмне забезпечення мінту",
+  "mint.software.unknown": "невідомо",
+  "mint.checked": "перевірено {when}",
+  "mint.lastSeen": "останній раз онлайн {when}",
+  "mint.neverReached": "жодного разу не відповів",
+  "mint.uptime.checks": "Успішні {ok} з останніх {total} перевірок",
+  "mint.uptime.percent": "Доступний {percent}% часу за 30 днів",
+  "mint.uptime.description": "Успішні {ok} з останніх {total} перевірок",
+  "mint.operator.title": "Від оператора",
+  "mint.operator.motd": "Послання дня",
+  "mint.operator.beta": "Цей мінт називає себе експериментальним або бета-версією. Прочитайте слова оператора нижче, перш ніж зберігати тут кошти, які не можете дозволити собі втратити.",
+  "mint.nuts.title": "Підтримувані NUT",
+  "mint.nuts.noneOffline": "Для цього мінту немає збереженого списку NUT: він перейшов в офлайн раніше, ніж список було отримано.",
+  "mint.nuts.noneYet": "Для цього мінту ще немає збереженого списку NUT.",
+  "mint.nuts.supported": "Підтримується {n} із {total} відомих NUT",
+  "mint.nuts.whatAre": "Що таке NUT?",
+  "mint.nutRow.disabled": "Вимкнений",
+  "mint.nutRow.notSupported": "не підтримується",
+  "mint.details.title": "Відомості про мінт",
+  "mint.details.pubkey": "Pubkey",
+  "mint.details.nostr": "Nostr",
+  "mint.details.email": "Електронна пошта",
+  "mint.details.serverTime": "Час сервера",
+  "mint.details.firstSeen": "Вперше помічено",
+  "mint.details.terms": "Умови",
+  "mint.kind.identifier": "ідентифікатор",
+  "mint.kind.mintPubkey": "pubkey мінту",
+  "mint.kind.nostrAddress": "Адреса Nostr",
+  "mint.kind.emailAddress": "Електронна адреса",
+  "mint.kind.npub": "npub",
+  "mint.disclaimer": "Цей мінт є кастодіальним: він зберігає ваші гроші й може припинити це робити будь-коли. Оцінки є думками спільноти, а статус онлайн означає лише доступність, не надійність.",
+  "mint.disclaimerLink": "Прочитайте повну відмову від відповідальності",
+  "mint.qr.title": "Додайте {name} до свого гаманця",
+  "mint.qr.note": "Відскануйте цей код гаманцем Cashu, щоб додати мінт, або скопіюйте та вставте URL.",
+  "mint.qr.warn": "Додаючи мінт, ви довіряєте йому свої гроші.",
+  "mint.qr.whatMeans": "Що це означає",
+  "mint.qr.wallets": "Гаманці, що підтримують Cashu",
+  "mint.chip.frozen": "Заморожено",
+  "mint.chip.noWithdrawals": "Виведення вимкнено",
+  "mint.chip.meltOnly": "Лише melt",
+  "mint.warnings.dayCount.one": "{n} день",
+  "mint.warnings.dayCount.few": "{n} дні",
+  "mint.warnings.dayCount.many": "{n} днів",
+  "mint.warnings.dayCount.other": "{n} днів",
+  "mint.warnings.gone.lead": "Імовірно, мінт зник.",
+  "mint.warnings.gone.body.since": "Цей мінт недоступний із {date} ({days}). Вважайте кошти в ньому під загрозою й не надсилайте нових. Нижче показано його останній відомий стан.",
+  "mint.warnings.gone.body.neverDated": "Цей мінт не відповів на жодну перевірку відтоді, як ми почали стежити за ним у {month}. Вважайте кошти в ньому під загрозою й не надсилайте нових. Усі дані нижче походять з оголошення Nostr, а не від мінту.",
+  "mint.warnings.gone.body.never": "Цей мінт не відповів на жодну перевірку відтоді, як ми почали стежити за ним. Вважайте кошти в ньому під загрозою й не надсилайте нових. Усі дані нижче походять з оголошення Nostr, а не від мінту.",
+  "mint.warnings.gone.meta.since": "Офлайн з {date}",
+  "mint.warnings.gone.meta.never": "Жодного разу не був доступний після виявлення",
+  "mint.warnings.meltDisabled.lead": "Виведення вимкнено.",
+  "mint.warnings.meltDisabled.body.online": "У цьому мінті вимкнено melt через Lightning (NUT-05): ви можете внести sats, але не можете вивести їх через Lightning. Не вносьте кошти, доки melt не відновиться.",
+  "mint.warnings.meltDisabled.body.offline": "У цьому мінті було вимкнено melt через Lightning (NUT-05): можна було внести sats, але не можна було вивести їх через Lightning. Не вносьте кошти, доки melt не відновиться.",
+  "mint.warnings.meltDisabled.meta.online": "Виведення зараз вимкнено",
+  "mint.warnings.meltDisabled.meta.offline": "Виведення було вимкнено під час останньої перевірки",
+  "mint.warnings.frozen.lead": "Мінт заморожено.",
+  "mint.warnings.frozen.body.online": "Випуск ecash через mint і виведення через melt вимкнено. Sats не можуть надходити або виводитися через Lightning.",
+  "mint.warnings.frozen.body.offline": "Випуск ecash через mint і виведення через melt були вимкнені. Sats не могли надходити або виводитися через Lightning.",
+  "mint.warnings.frozen.meta.online": "Зараз заморожено, кошти не надходять і не виводяться",
+  "mint.warnings.frozen.meta.offline": "Було заморожено під час останньої перевірки",
+  "mint.warnings.offlineLong.lead": "Офлайн протягом {days}, із {date}.",
+  "mint.warnings.offlineLong.body": "Мінт міг зникнути. Нижче наведено його останній відомий стан, а відгуки й далі працюють.",
+  "mint.warnings.offlineLong.meta": "Офлайн з {date}",
+  "mint.warnings.meltOnly.lead": "Доступний лише melt.",
+  "mint.warnings.meltOnly.body.online": "Випуск нового ecash через mint (NUT-04) вимкнено: ви не можете внести кошти, але наявний ecash ще можна вивести через melt. Це часто означає, що мінт завершує роботу. Якщо ви тримаєте його ecash, варто вивести кошти.",
+  "mint.warnings.meltOnly.body.offline": "Випуск нового ecash через mint (NUT-04) був вимкнений: ви не могли внести кошти, але наявний ecash ще можна було вивести через melt. Це часто означає, що мінт завершує роботу. Якщо ви тримаєте його ecash, варто вивести кошти.",
+  "mint.warnings.meltOnly.meta.online": "Зараз доступний лише melt",
+  "mint.warnings.meltOnly.meta.offline": "Під час останньої перевірки був доступний лише melt",
+  "mint.warnings.offline.lead": "Офлайн із {date}.",
+  "mint.warnings.offline.body": "Останні деталі підтверджувалися тоді. Ви все одно можете написати відгук.",
+  "mint.warnings.offline.meta": "Офлайн з {date}",
+  "mint.warnings.also.meltDisabled": "Перед переходом в офлайн мінт також вимкнув виведення.",
+  "mint.warnings.also.mintDisabled": "Перед переходом в офлайн мінт також вимкнув випуск нового ecash через mint.",
+  "mint.warnings.also.offline": "Також офлайн із {date} ({days}).",
+  "nut.0": "Нотація та моделі",
+  "nut.1": "Обмін публічними ключами мінту",
+  "nut.2": "Набори ключів і збори",
+  "nut.3": "Обмін токенами",
+  "nut.4": "Випуск ecash через Lightning (mint)",
+  "nut.5": "Виведення через Lightning (melt)",
+  "nut.6": "Інформація про мінт",
+  "nut.7": "Перевірка стану токена",
+  "nut.8": "Надмірно сплачені комісії Lightning",
+  "nut.9": "Відновлення підписів",
+  "nut.10": "Умови витрат",
+  "nut.11": "Оплата до відкритого ключа",
+  "nut.12": "Докази DLEQ",
+  "nut.13": "Детерміновані таємниці",
+  "nut.14": "Хешовані таймлок-контракти",
+  "nut.15": "Багатошляхові платежі",
+  "nut.16": "Анімовані QR-коди",
+  "nut.17": "Підписки на WebSocket",
+  "nut.18": "Запити на оплату",
+  "nut.19": "Кешовані відповіді",
+  "nut.20": "Підписані котирування мінту",
+  "nut.21": "Відкрита автентифікація",
+  "nut.22": "Сліпа автентифікація",
+  "nut.23": "Метод оплати BOLT11",
+  "nut.24": "Потрібна оплата за HTTP 402",
+  "nut.25": "Метод оплати BOLT12",
+  "reviews.title": "Відгуки",
+  "reviews.anon": "Анон",
+  "reviews.anonTitle": "Публічного профілю Nostr для цього ключа не знайдено",
+  "reviews.nip05Title": "Ідентифікатор NIP-05 (не підтверджений цим сайтом)",
+  "reviews.filter.group": "Фільтрувати відгуки",
+  "reviews.filter.all": "Усі",
+  "reviews.filter.five": "5★",
+  "reviews.filter.critical": "Критично",
+  "reviews.filter.recent": "Останні",
+  "reviews.filter.hideAnon": "Приховати анонімні",
+  "reviews.anonHidden.other": "Показано {n} із {total} відгуків: анонімні приховані.",
+  "reviews.allAnon.one": "Єдиний відгук тут анонімний.",
+  "reviews.allAnon.few": "Усі {n} відгуки тут: анонімні.",
+  "reviews.allAnon.many": "Усі {n} відгуків тут: анонімні.",
+  "reviews.allAnon.other": "Усі {n} відгуків тут анонімні.",
+  "reviews.allAnonShow.one": "Показати",
+  "reviews.allAnonShow.few": "Покажи їм",
+  "reviews.allAnonShow.many": "Покажи їм",
+  "reviews.allAnonShow.other": "Показати",
+  "reviews.loading.one": "Завантаження {n} відгуку з Nostr relays",
+  "reviews.loading.few": "Завантаження {n} відгуків з Nostr relays",
+  "reviews.loading.many": "Завантаження {n} відгуків з Nostr relays",
+  "reviews.loading.other": "Завантаження {n} відгуків із Nostr relays",
+  "reviews.empty": "Поки що відгуків немає. Будьте першими, хто напише такий.",
+  "reviews.emptyWritten": "Поки що немає письмових відгуків. Будьте першими, хто напише такий.",
+  "reviews.emptyFilter": "Жоден відгук не відповідає цьому фільтру.",
+  "reviews.rate.cashu": "Оцініть цей мінт",
+  "reviews.rate.fedimint": "Оцініть цю федерацію",
+  "reviews.rate.lnurl": "Оцініть цей мінт",
+  "reviews.noscript": "Відгуки підписуються на Nostr і завантажуються у вашому браузері, тому цей список потребує JavaScript. Вищезазначений рейтинг і підрахунок походять із самого сайту.",
+  "reviews.relayError": "Не вдалося підключитися до relay. Відгуки можуть бути неповними.",
+  "reviews.srRating": "{rating} з 5",
+  "reviews.srNoRating": "Оцінку не вказано",
+  "reviews.readMore": "Читати далі",
+  "reviews.readLess": "Показувати менше",
+  "reviews.actions.copyNpub": "Скопіювати npub",
+  "reviews.actions.openNostr": "Перегляньте цю подію на Nostr",
+  "reviews.actions.copyLink": "Скопіювати посилання на цей відгук",
+  "reviews.anonNote": "Перший відгук від цього npub, іншої активності не знайдено",
+  "reviews.published": "Опубліковано.",
+  "reviews.publishedPartial": "Опубліковано на {accepted} із {total} relays.",
+  "reviews.propagating": "Публікація на relays Nostr",
+  "reviews.summary.line.one": "{count} рейтинг без коментаря: {breakdown}",
+  "reviews.summary.line.few": "{count} оцінки без коментарів: {breakdown}",
+  "reviews.summary.line.many": "{count} оцінок без коментарів: {breakdown}",
+  "reviews.summary.line.other": "{count} рейтинги без коментарів: {breakdown}",
+  "reviews.summary.lineDay.one": "{count} рейтинг без коментаря до {when}: {breakdown}",
+  "reviews.summary.lineDay.few": "{count} оцінки без коментаря до {when}: {breakdown}",
+  "reviews.summary.lineDay.many": "{count} оцінок без коментарів на {when}: {breakdown}",
+  "reviews.summary.lineDay.other": "{count} рейтинги без коментаря до {when}: {breakdown}",
+  "reviews.summary.showOne": "Показати",
+  "reviews.summary.showMany": "Показати",
+  "reviews.breakdown.5": "{n} п'ятизірковий",
+  "reviews.breakdown.4": "{n} чотиризірковий",
+  "reviews.breakdown.3": "{n} три зірки",
+  "reviews.breakdown.2": "{n} двозірковий",
+  "reviews.breakdown.1": "{n} одну зірку",
+  "reviews.breakdown.none": "{n} без рейтингу",
+  "reviews.dialog.title": "Відгук про {name}",
+  "reviews.dialog.lede.cashu": "Розкажіть про свій досвід із цим мінтом.",
+  "reviews.dialog.lede.fedimint": "Розкажіть про свій досвід із цією федерацією.",
+  "reviews.dialog.lede.lnurl": "Розкажіть про свій досвід із цим мінтом.",
+  "reviews.dialog.permanent": "Публікується назавжди на загальнодоступних relays Nostr.",
+  "reviews.dialog.gate.title": "Увійдіть, щоб написати відгук",
+  "reviews.dialog.gate.lead": "Відгуки підписуються вашим ключем Nostr. Він залишається у вашому signer, сайт ніколи його не бачить.",
+  "reviews.dialog.ratingLegend": "Ваш рейтинг",
+  "reviews.dialog.starsSr.one": "{n} зірка",
+  "reviews.dialog.starsSr.few": "{n} зірки",
+  "reviews.dialog.starsSr.many": "{n} зірок",
+  "reviews.dialog.starsSr.other": "{n} зірок",
+  "reviews.dialog.chooseRating": "Виберіть рейтинг",
+  "reviews.dialog.starLabel": "{n}: {phrase}",
+  "reviews.dialog.stars.1": "Уникайте цього",
+  "reviews.dialog.stars.2": "мав проблеми",
+  "reviews.dialog.stars.3": "спрацювало, з застереженнями",
+  "reviews.dialog.stars.4": "Добре",
+  "reviews.dialog.stars.5": "Працює чудово",
+  "reviews.dialog.bodyLabel": "Що мають знати інші?",
+  "reviews.dialog.charCount": "{n} / {max}",
+  "reviews.dialog.submit": "Підписати й опублікувати",
+  "reviews.dialog.signing": "Підписання…",
+  "reviews.dialog.publishing": "Публікація…",
+  "reviews.dialog.publishingTo": "Публікація на relays ({accepted}/{total})",
+  "reviews.dialog.waitingExtension": "Очікування розширення",
+  "reviews.dialog.waitingSigner": "Очікування signer",
+  "reviews.dialog.confirmClose": "Закрити цей відгук? Чернетка зберігатиметься, доки ви не залишите сайт.",
+  "reviews.dialog.why.login": "Увійти для публікації",
+  "reviews.dialog.why.words": "Напишіть кілька слів",
+  "reviews.dialog.why.more.one": "Ще {n} символ",
+  "reviews.dialog.why.more.few": "Ще {n} символи",
+  "reviews.dialog.why.more.many": "Ще {n} символів",
+  "reviews.dialog.why.more.other": "Ще {n} символів",
+  "reviews.dialog.why.over.one": "{n} символ перевищує ліміт",
+  "reviews.dialog.why.over.few": "{n} символи перевищують ліміт",
+  "reviews.dialog.why.over.many": "{n} символів понад ліміт",
+  "reviews.dialog.why.over.other": "{n} символів понад ліміт",
+  "reviews.dialog.identity.needSigner": "Для публікації потрібен Nostr signer. Ваш ключ залишається в ньому, сайт ніколи його не бачить.",
+  "reviews.dialog.identity.loginToPublish": "Увійти для публікації",
+  "reviews.dialog.identity.switch": "Змінити",
+  "reviews.dialog.identity.extension": "Підписання за допомогою розширення браузера",
+  "reviews.dialog.identity.readingKey": "Читання публічного ключа…",
+  "reviews.dialog.identity.willAsk": "Розширення попросить вас підписати",
+  "reviews.dialog.error.noRelay": "Жоден relay не прийняв відгук. Перевірте з’єднання та повторіть спробу.",
+  "reviews.validate.rating": "Виберіть оцінку від 1 до 5 зірок.",
+  "reviews.validate.short": "Напишіть щонайменше {n} символів, щоб відгук був корисним.",
+  "reviews.validate.long": "Відгук може містити не більше {n} символів.",
+  "feed.title": "Останні відгуки про мінти та федерації · Cashumints.space",
+  "feed.description": "Кожен відгук про мінт, федерацію та LNURL-мінт одразу після публікації: {reviews} відгуків про {mints} мінтів Cashu, {federations} федерацій Fedimint і {lnurl} LNURL-мінтів, підписаних у Nostr і доступних тут від найновіших. Фільтруйте за екосистемою, оцінкою або назвою.",
+  "feed.heading": "Останні огляди",
+  "feed.lede": "Усі відгуки про кожен мінт Cashu і кожну федерацію Fedimint, від найновіших, читаються безпосередньо з Nostr relays. Кожен відгук підписаний автором і зберігається на relays, а не в нашій базі даних.",
+  "feed.label": "Відгуки",
+  "feed.showingBuild.one": "Показ найсвіжішого огляду з останньої збірки",
+  "feed.showingBuild.few": "Показ {n} найсвіжіших оглядів з останньої збірки",
+  "feed.showingBuild.many": "Показ {n} найсвіжіших оглядів останньої збірки",
+  "feed.showingBuild.other": "Показ {n} найновіших оглядів останньої збірки",
+  "feed.noscript": "Відгуки підписуються в Nostr і завантажуються у вашому браузері, тому для фільтрації та повного списку потрібен JavaScript. Наведені нижче {n} відгуків було прочитано з relays під час збірки сторінки.",
+  "feed.emptyBuild": "Під час збірки сторінки не вдалося прочитати відгуки з relays. Список повторно завантажиться з relays у вашому браузері.",
+  "feed.foot": "Відгуки: це думки спільноти, а не перевірені твердження. Прочитайте {link} перед тим, як довіряти мінту з грошима.",
+  "feed.footLink": "Відмова від відповідальності",
+  "feed.showing": "Показ {shown} {total} відгуків",
+  "feed.showingMatching": "Показано {shown} {matching} відповідних відгуків (загалом {total})",
+  "feed.emptyRelays": "Relays не повернули відгуків. Відкрийте сторінку будь-якого мінту, щоб читати й писати відгуки там.",
+  "feed.emptyFilter": "Жоден відгук не відповідає цьому фільтру. Очистьте поле мінту або виберіть «Усі».",
+  "feed.relayError": "Не вдалося підключитися до relays. Показано відгуки з останньої збірки.",
+  "feed.relayEmpty": "Relays не повернули відгуків. Показано відгуки з останньої збірки.",
+  "feed.reading": "Читання relays…",
+  "login.open": "Увійти",
+  "login.title": "Увійти за допомогою Nostr",
+  "login.note": "Ваш ключ залишається у signer. Цей сайт ніколи його не бачить.",
+  "login.extension.name": "Розширення браузера",
+  "login.extension.desc": "Підписуйте за допомогою Alby, nos2x або іншого розширення NIP-07",
+  "login.extension.none": "Розширення не знайдено",
+  "login.extension.getOne": "Установити:",
+  "login.remote.name": "Віддалений signer",
+  "login.remote.desc": "Відскануйте код у застосунку signer або вставте bunker-посилання",
+  "login.primal.name": "Primal",
+  "login.primal.desc": "Затвердіть вхід у додатку Primal на вашому телефоні",
+  "login.paste.label": "Або вставте посилання для підключення, надане вашим signer",
+  "login.copyLink": "Скопіюйте посилання на з'єднання",
+  "login.whatIsNostr": "Що таке Nostr?",
+  "login.connect.remote.title": "Підключити віддалений signer",
+  "login.connect.remote.lead": "Відскануйте цей код у застосунку signer або скопіюйте посилання й вставте його туди.",
+  "login.connect.remote.hint": "Працює з будь-яким NIP-46 signer: nsec.app, Amber, Nostrify або вашим bunker.",
+  "login.connect.remote.open": "Відкрити в застосунку signer",
+  "login.connect.primal.title": "Зв'яжіться з Primal",
+  "login.connect.primal.lead": "Відкрийте Primal на телефоні, знайдіть віддалений підпис у налаштуваннях і відскануйте цей код.",
+  "login.connect.primal.hint": "Primal підписує дані для інших застосунків через NIP-46. Це те саме з’єднання, яке використовує будь-який signer, а ваш ключ залишається у Primal. {link}",
+  "login.connect.primal.open": "Відкрити у Primal",
+  "login.status.buildingLink": "Побудова з'єднання",
+  "login.status.waitingExtension": "Очікування розширення",
+  "login.status.waitingSigner": "Очікування signer",
+  "login.status.connecting": "Підключення до signer",
+  "login.status.connected": "Підключено",
+  "login.toast.loggedIn": "Вхід виконано",
+  "login.toast.fetchingProfile": "Завантаження вашого профілю Nostr з relays…",
+  "login.toast.profile": "Профіль: {name}",
+  "login.toast.noProfile": "Профіль на relays не знайдено",
+  "login.method.extension": "Розширення",
+  "login.method.remote": "Віддалений",
+  "login.method.primal": "Primal",
+  "login.account": "Ваш обліковий запис Nostr",
+  "login.copyNpub": "Скопіюйте повний ваш npub",
+  "login.logout": "Вийти",
+  "signer.status.waitingExtension": "Очікування розширення",
+  "signer.status.signed": "Підписано",
+  "signer.status.reconnecting": "Повторне підключення до signer",
+  "signer.status.approveWindow": "Підтвердьте дію у вікні signer",
+  "signer.status.waitingSigner": "Очікування signer",
+  "signer.status.stillWaiting": "Signer ще не відповів",
+  "signer.status.connected": "Підключено",
+  "signer.error.noExtension": "Розширення для підпису не знайдено. Установіть Alby або nos2x і перезавантажте сторінку.",
+  "signer.error.privateKey": "Це схоже на приватний ключ, а не посилання для підключення. Сайт ніколи не приймає ключі. Вставте посилання bunker://, надане вашим signer.",
+  "signer.error.badLink": "Сайт не розпізнає це посилання для підключення. Вставте посилання bunker:// від вашого signer.",
+  "signer.error.noAnswer": "Signer не відповів. Можливо, його закрито або його relay недоступний. Відкрийте signer і повторіть спробу.",
+  "signer.error.timeout": "Signer не відповів вчасно. Відкрийте його, перевірте підключення та повторіть спробу.",
+  "signer.error.cancelled": "З'єднання скасовано.",
+  "signer.error.declined": "Запит на підпис було відхилено",
+  "notfound.title": "Сторінка не знайдена · Cashumints.space",
+  "notfound.description": "Цієї сторінки на Cashumints.space не існує.",
+  "notfound.heading": "Ця сторінка не існує",
+  "notfound.lede": "Сторінку могли перемістити або мінт ще не проіндексовано. Шукайте мінт за назвою чи доменом або вставте URL мінту.",
+  "notfound.browse": "Переглянути всі мінти",
+  "notfound.home": "На головну",
+  "notfound.loading": "Завантаження {host}",
+  "notfound.fb.rating": "Рейтинг",
+  "notfound.fb.reviews": "Відгуки",
+  "notfound.fb.software": "Програмне забезпечення",
+  "notfound.fb.lastOnline": "Востаннє онлайн",
+  "notfound.fb.note": "Цей мінт проіндексовано після останньої збірки сайту, тож тут зведення з живого API, а нижче його відгуки. Повна сторінка з’явиться під час наступної збірки.",
+  "notfound.resolve.checking": "Перший візит: перевіряємо цей мінт.",
+  "notfound.resolve.failed": "Не вдалося додати цей мінт",
+  "notfound.resolve.failedFedimint": "Не вдалося додати цю федерацію",
+  "notfound.resolve.retry": "Спробувати іншу адресу",
+  "notfound.resolve.switch": "Відкрити як мінт {kind}",
+  "notfound.resolve.fedimint": "Адреса сторінки федерації не містить її коду запрошення, тож знайти її лише за посиланням не вийде. Встав код запрошення, і її буде додано.",
+  "notfound.resolve.ambiguous": "Цю адресу не відновити лише за посиланням. Встав повний URL мінта, і його буде додано.",
+  "wallets.title": "Гаманці Cashu · Cashumints.space",
+  "wallets.description": "Гаманці Cashu, що працюють із переліченими тут мінтами на мобільних пристроях, у вебі, браузері та командному рядку, із зазначенням переваг кожного.",
+  "wallets.heading": "Гаманці",
+  "wallets.lede": "Вам потрібен гаманець, щоб зберігати ecash із цих мінтів. Більшість гаманців працюють із кількома мінтами одночасно, тому ви не прив’язані до першого обраного.",
+  "wallets.note": "Цей список не є вичерпним або рекомендацією. Проєкт Cashu підтримує ширший каталог за посиланням {link}. Гаманець зберігає ключі, мінт зберігає гроші. Прочитайте відгуки про мінт, перш ніж обирати, де тримати sats.",
+  "wallets.platform.android": "Android",
+  "wallets.platform.ios": "iOS",
+  "wallets.platform.web": "Веб",
+  "wallets.platform.extension": "Розширення браузера",
+  "wallets.platform.cli": "CLI",
+  "wallets.platform.python": "Python",
+  "wallets.item.minibits": "Мобільний гаманець ecash із власним мінтом, підтримкою Lightning-адрес і контактів Nostr.",
+  "wallets.item.nutstash": "Браузерний гаманець, який одночасно працює з кількома мінтами та імпортує та експортує сирі токени.",
+  "wallets.item.enuts": "Мобільний гаманець для балансів у кількох мінтах і надсилання ecash через Nostr.",
+  "wallets.item.cashume": "Еталонний вебгаманець проєкту Cashu. Повністю працює у браузері та встановлюється як PWA.",
+  "wallets.item.boardwalk": "Веб-гаманець, побудований навколо адрес Lightning та надсилання електронної кошти за посиланням.",
+  "wallets.item.coinos": "Гаманець Lightning і точка продажу, яка також має власний мінт Cashu.",
+  "wallets.item.oxchat": "Месенджер Nostr із вбудованим гаманцем ecash для надсилання sats у чатах.",
+  "wallets.item.nutshell": "Еталонна реалізація. Працює як гаманець командного рядка та як програмне забезпечення мінту.",
+  "about.title": "Про Cashumints.space",
+  "about.description": "Що таке Cashu, що насправді зберігає мінт, що таке NIP-87, і як цей сайт індексує мінти та читає відгуки з Nostr relays.",
+  "about.heading": "Про сайт",
+  "about.lede": "Cashumints.space перелічує всі мінти Cashu, які ми знаходимо в мережі Nostr, і показує відгуки людей про них. Сайт створив Azzamo.",
+  "about.cashu.title": "Що таке Cashu",
+  "about.cashu.p1": "Cashu є протоколом ecash для Bitcoin. Мінт випускає засліплені токени, забезпечені sats, які він зберігає. Ці токени переходять між людьми, а мінт не дізнається, хто, що й кому надіслав. У цьому полягає приватність: токени не є рахунками, і мінт не може пов’язати підписаний ним токен із токеном, який повертається.",
+  "about.cashu.p2": "Ви можете прочитати протокол і його характеристики за {link}. Самі специфікації називаються NUT, звідки беруться номери NUT на кожній сторінці мінту.",
+  "about.mints.title": "Що таке мінт і в чому компроміс",
+  "about.mints.p1": "Мінт є кастодіальним. Під час мінт ecash ви передаєте sats оператору сервера й довіряєте йому погасити токени під час melt. Немає доказу шахрайства, ескроу чи дієвого способу повернути кошти. Оператор мінту може зникнути з балансом, і таке вже траплялося.",
+  "about.mints.p2": "Саме тому тут є відгуки. Сайт ніколи не стверджує, що мінт безпечний. Статус на сторінці мінту показує {code}, а не «надійний», і означає лише, що сервер відповів під час останньої перевірки. Ставтеся до балансів ecash як до готівки в кишені: для витрат, не для заощаджень.",
+  "about.nip87.title": "Що таке NIP-87",
+  "about.nip87.p1": "NIP-87 є угодою Nostr для оголошення та рекомендації мінтів ecash. Тут важливі два типи подій:",
+  "about.nip87.li1": "{code} оголошує мінт. URL мінту міститься в тегу {tag}. Так сайт знаходить мінти, яких раніше не бачив.",
+  "about.nip87.li2": "{code}: це огляд. Він містить рейтинг і текст відгуку, а також вказує на мінт, про який йдеться, тегом {utag} (URL мінт) та тегом {dtag} (публічний ключ мінту).",
+  "about.nip87.p2": "Кожен відгук підписаний Nostr-ключем автора. Ми не називаємо відгуки «перевіреними», бо їх ніхто не перевіряв. Підпис дає змогу встановити, який ключ створив відгук, і переконатися, що текст не змінено. Він не доводить чесність автора або те, що автор користувався мінтом.",
+  "about.how.title": "Як працює цей сайт",
+  "about.how.p1": "Є два цикли й одне правило. Метадані належать мінту, а відгуки зберігаються в Nostr, тому сайт не вважає власну копію жодного з них першоджерелом.",
+  "about.how.li1": "{strong} кожні десять хвилин запитує {code} у кожного відомого мінту й записує назву, опис, версію, підтримувані NUT, ліміти та контактні дані. Також фіксується, чи відповів мінт. На цьому ґрунтуються дані про доступність.",
+  "about.how.li1Label": "Цикл перевірки",
+  "about.how.li2": "{strong} щогодини підключається до Nostr relays, читає оголошення мінтів і відгуки та додає нові мінти.",
+  "about.how.li2Label": "Цикл виявлення",
+  "about.how.p2": "Головне: що відбувається, коли мінт перестає відповідати. Його кешовані метадані ніколи не перезаписуються невдалим пробуванням, тому мертвий мінт зберігає повну сторінку: характеристики, історію та відгуки, з банером із вказівкою, коли він вийшов з ефіру. Попередня версія цього сайту показувала сторінку з помилкою, що означало, що ті, про які люди найбільше мали попереджати одне одного, були тими, які не можна було перевірити. Це була головна причина перебудови.",
+  "about.how.p3": "Текст відгуків ніколи не зберігається на нашому боці. Коли ви відкриваєте сторінку мінт, ваш браузер безпосередньо спілкується з relays і читає самі відгуки, а коли ви пишете огляд, він підписується вашим власним розширенням Nostr і надсилається безпосередньо цим relayм. Ми ведемо рахунок, щоб сторінки можна було ранжувати та сортувати, нічого більше. Тут ми не можемо нічого редагувати чи видаляти, включно з оглядами, яких ми б воліли уникати.",
+  "about.relays.title": "Relays, які ми читаємо",
+  "about.relays.p1": "Ці relays використовують і індексатор, і ваш браузер:",
+  "about.relays.p2": "Наведіть будь-який клієнт Nostr на ті ж relays: і ви побачите ті ж події. Ось у чому вся обіцянка: нічого тут не є правдою лише тому, що ми так кажемо.",
+  "about.nuts.title": "Що таке NUT?",
+  "about.nuts.p1": "NUT є нумерованими специфікаціями Cashu, подібними до BIP у Bitcoin. Мінт повідомляє, які з них реалізує. NUT-04 описує випуск ecash через Lightning (mint), а NUT-05 виведення через Lightning (melt). NUT-07 дає гаманцю перевірити, чи токен уже витрачено, NUT-17 забезпечує оновлення через WebSockets, а NUT-20 дає гаманцю довести, що котирування справді видав мінт. Повний список доступний за посиланням {link}.",
+  "about.numbers.title": "Зараз",
+  "about.numbers.p1": "Проіндексовано {mints} мінтів, із них {online} відповідають. На зазначених вище relays знайдено {reviews} відгуків.",
+  "about.source.title": "Джерело та авторство",
+  "about.source.p1": "Сайт має відкритий код за адресою {github}. Вона будується та управляється {azzamo}. Якщо на сторінці мінт щось не так, виправте це з джерела: метадані мінт надходять із власного {code} мінт, а відгуки: з Nostr.",
+  "terms.title": "Умови використання · Cashumints.space",
+  "terms.description": "Умови використання Cashumints.space: що таке сайт, чого він не робить і хто за що відповідає. Без облікових записів, без гарантій, без зв'язку з жодним мінтом.",
+  "terms.heading": "Умови використання",
+  "terms.lede": "Прості терміни для сайту, який індексує лише публічні дані. Останнє оновлення {date}.",
+  "terms.what.title": "Що це за сайт",
+  "terms.what.p1": "Cashumints.space: це індекс загальнодоступних даних про мінти Cashu. Два типи даних, обидва з іншого місця:",
+  "terms.what.li1": "Метадані мінту, прочитані з його власної кінцевої точки {code}: назва, опис, версія програмного забезпечення, підтримувані NUT, контактні дані й результат останньої перевірки.",
+  "terms.what.li2": "Відгуки з публічних Nostr relays. Це події NIP-87, опубліковані авторами на relays, які доступні для запитів усім.",
+  "terms.what.p2": "Ми збираємо ці дані, нормалізуємо їх, ранжуємо і показуємо. Ми її не створюємо.",
+  "terms.noAccounts.title": "Без рахунків, без гарантій",
+  "terms.noAccounts.p1": "Реєстрації немає. Сайт надається як є, без жодних гарантій щодо точності чи актуальності даних або доступності сайту. Дані мінту можуть відставати на хвилини чи години, мінт може змінитися після перевірки, а relay може не відповісти. У такому разі ви бачите не всі наявні дані.",
+  "terms.noAccounts.p2": "Використовуйте це на свій страх і ризик. Ми не несемо відповідальності за будь-які збитки, що виникають через використання цього сайту або покладаючись на те, що ви тут прочитали. Дивіться {link} щодо конкретних ризиків використання мінту Cashu.",
+  "terms.noAccounts.link": "Відмова від відповідальності",
+  "terms.noCustody.title": "Ми не тримаємо ваші гроші",
+  "terms.noCustody.p1": "Цей сайт ніколи не зберігає кошти. Він не має гаманця, не торкається ecash і не може переміщувати, заморожувати або відновлювати кошти. У разі проблеми допомогти може лише оператор мінту, а ми не можемо зв’язатися з ним від вашого імені.",
+  "terms.noCustody.p2": "Ми не пов'язані з жодним мінтом, зазначеним тут, і жоден мінт не платить за його розміщення, ранг чи рейтинг. Мінти виявляються з публічних оголошень Nostr і ранжуються алгоритмом на основі даних публічного огляду.",
+  "terms.reviews.title": "Відгуки: це слова інших людей",
+  "terms.reviews.p1": "Відгуки є створеним користувачами вмістом, який автори публікують на публічних Nostr relays. Ми лише показуємо їх і не контролюємо. Ми не писали їх, не можемо редагувати й не можемо видалити з relays: це підписані події в мережі, яка нам не належить.",
+  "terms.reviews.p2": "Відгук: це досвід однієї людини, а не підтверджений факт. Якщо ви публікуєте його, ви відповідаєте за те, що там написано. Не публікуйте нічого незаконного і майте на увазі, що те, що ви публікуєте, є публічним і постійним (див. {link}).",
+  "terms.reviews.link": "Сторінка конфіденційності",
+  "terms.reviews.p3": "Ми можемо припинити показувати конкретний відгук на цьому сайті, і зробимо це для контенту, який є незаконним. Це видаляє його лише з цих сторінок. Подія залишається на relays, і будь-який інший клієнт Nostr все одно може її прочитати.",
+  "terms.links.title": "Посилання на інші сайти",
+  "terms.links.p1": "URL мінтів, посилання на гаманці, контакти операторів та інші зовнішні посилання є частиною даних. Посилання не означає схвалення, і ми не перевіряємо вміст за ним.",
+  "terms.changes.title": "Зміни",
+  "terms.changes.p1": "Ці терміни можуть змінюватися. Дата вгорі вказує, коли вони востаннє це робили. Сайт є відкритим кодом, тому кожна зміна цієї сторінки є в історії комітів.",
+  "terms.contact.title": "Контакт",
+  "terms.contact.p1": "Питання та запити на видалення найкраще подавати {github}. Сайтом керує {azzamo}.",
+  "privacy.title": "Приватність · Cashumints.space",
+  "privacy.description": "Конфіденційність на Cashumints.space: без облікових записів, трекінгових cookie та аналітики. localStorage використовується для кешування профілів, і ці дані нікуди не надсилаються. Відгуки підписуються у вашому браузері.",
+  "privacy.heading": "Приватність",
+  "privacy.lede": "Ми збираємо мінімально можливий обсяг даних. Останнє оновлення: {date}.",
+  "privacy.noAccounts.title": "Без акаунтів",
+  "privacy.noAccounts.p1": "Реєстрації немає, немає входу чи профілю. На цьому сайті нічого не запитує, хто ви, і немає жодного запису користувача, який можна було б розкрити, бо користувачів немає.",
+  "privacy.noTracking.title": "Жодних файлів cookie для відстеження, жодної аналітики",
+  "privacy.noTracking.p1": "Сайт не встановлює файлів cookie для відстеження. Немає скриптів аналітики, менеджера тегів, пікселя, запису сесії та рекламної мережі. На сторінці нічого не повідомляє про вашу поведінку нам чи комусь іншому.",
+  "privacy.logs.title": "Логи серверів",
+  "privacy.logs.p1": "Веб-сервер веде стандартні журнали доступу, що за замовчуванням робить будь-який веб-сервер. Лог-лінія фіксує вашу IP-адресу, час, сторінку, яку ви запитали, статус відповіді, а також користувацького агента та реферера, які надіслав браузер. Журнали існують для налагодження помилок і виявлення зловживань. Вони не з'єднуються ні з чим іншим і не продаються і не діляться.",
+  "privacy.logs.operatorLabel": "Примітка оператора:",
+  "privacy.logs.operator": "Якщо ви керуєте цим сайтом, укажіть тут фактичний строк зберігання журналів. Конфігурація з README використовує nginx зі стандартним журналом доступу та ротацією вашого дистрибутива. У Debian і Ubuntu це logrotate: щоденна ротація зі зберіганням 14 днів. Перевірте налаштування сервера й замініть цей абзац фактичним строком.",
+  "privacy.storage.title": "Що зберігається у вашому браузері",
+  "privacy.storage.p1": "Сайт використовує localStorage лише для двох речей, які залишаються на вашому пристрої і ніколи не надсилаються нікуди:",
+  "privacy.storage.li1": "Кеш метаданих профілів Nostr, тобто подій kind 0: імена, аватари й адреси NIP-05 авторів переглянутих вами відгуків. Це усуває повторні запити до relays на кожній сторінці. Записи мають строк дії, розмір кешу обмежений, а найстаріші записи видаляються першими.",
+  "privacy.storage.li2": "Налаштування інтерфейсу, щоб сайт поводився так само наступного разу.",
+  "privacy.storage.p2": "Очищення даних сайту вашого браузера видаляє обидва варіанти. Нічого не ламається, пошуки профілів просто запускаються знову.",
+  "privacy.thirdParties.title": "З чим спілкується ваш браузер",
+  "privacy.thirdParties.p1": "Завантаження сторінки підключає ваш браузер до кількох місць, окрім цього сайту. Ось як сайт без відстеження на сервері все одно читає живі дані:",
+  "privacy.thirdParties.li1Label": "Публічні Nostr relays",
+  "privacy.thirdParties.li1": "{strong} через WebSocket для читання відгуків і профілів авторів. Relay бачить вашу IP-адресу та запит, як і будь-який сервер, до якого ви підключаєтеся. Перелік relays наведено на {link}.",
+  "privacy.thirdParties.li1Link": "Сторінка про",
+  "privacy.thirdParties.li2Label": "Зображення аватарів рецензентів",
+  "privacy.thirdParties.li2": "{strong}, завантажений звідти, де вказує профіль рецензента. Ці повідомлення надсилаються за політикою відсутності реферера, тому хост не дізнається, на якій сторінці ви були.",
+  "privacy.publishing.title": "Публікація огляду",
+  "privacy.publishing.p1": "Відгук створюється у вашому браузері, не на нашому сервері. Подію підписує ваше розширення NIP-07, наприклад Alby або nos2x, і браузер надсилає її безпосередньо на relays. Приватний ключ ніколи не залишає розширення, а сайт його не бачить. Ми не створюємо власного керування ключами й ніколи не просимо ключ або seed phrase.",
+  "privacy.permanent.title": "Все, що ви публікуєте на Nostr, є публічним і постійним",
+  "privacy.permanent.p1": "Цю частину варто прочитати двічі. Відгук є підписаною подією на публічних relays. Після публікації повернути його назад неможливо:",
+  "privacy.permanent.li1": "Будь-хто може прочитати її зараз і пізніше, використовуючи будь-який клієнт Nostr. Вона не є «публічною на Cashumints.space», вона є публічною в мережі.",
+  "privacy.permanent.li2": "Він постійно пов'язаний з вашим публічним ключем Nostr, разом із усім іншим, що цей ключ коли-небудь публікував.",
+  "privacy.permanent.li3": "Видалення: це запит, а не наказ. Ви можете опублікувати подію видалення, і деякі relays її визнають, але реле може ігнорувати це, і ті, хто вже скопіював подію, все одно мають його. Вважайте опублікований відгук постійним.",
+  "privacy.permanent.li4": "Ми не можемо видалити відгук за вас. Ми можемо припинити показувати його тут, але це нічого не змінить на relays.",
+  "privacy.permanent.p2": "Якщо ви хочете оглядати мінт, не пов'язавши це з вашою основною ідентичністю, використовуйте окремий ключ Nostr. Зверніть увагу, що ключ без іншої активності показується таким у жорстких відгуках, адже новий ключ, який пише однозірковий відгук,: це патерн, який заслуговують бачити читачі.",
+  "privacy.contact.title": "Питання",
+  "privacy.contact.p1": "Код сайту відкритий: усе описане вище можна перевірити за адресою {github}. Запитання й виправлення можна подати там як issue.",
+  "disclaimer.title": "Відмова від відповідальності · Cashumints.space",
+  "disclaimer.description": "Що варто знати перед використанням мінту Cashu: мінти є кастодіальними, мінт може зникнути з вашими грошима, відгуки є думками, а онлайн означає доступність, не надійність.",
+  "disclaimer.heading": "Відмова від відповідальності",
+  "disclaimer.lede": "Прочитайте це, перш ніж вносити гроші в мінт. Останнє оновлення: {date}.",
+  "disclaimer.callout": "Мінт Cashu зберігає ваші гроші. Якщо він зникне, ваш ecash буде втрачено й звернутися буде нікуди. Тримайте лише суму, яку можете дозволити собі втратити.",
+  "disclaimer.custodial.title": "Мінти є кастодіальними",
+  "disclaimer.custodial.p1": "Під час мінт ecash ви передаєте bitcoin оператору мінту й отримуєте токени. Ці токени є вимогою до оператора, а не bitcoin у вашому володінні. Саме оператор вирішує, чи погашати їх.",
+  "disclaimer.custodial.p2": "Кожен мінт має однакові ризики: оператор може зникнути, бути змушений припинити роботу, втратити кошти через помилку чи злам або просто вимкнути сервер. Немає страхування депозитів, повернення платежу, служби підтримки чи надійного правового захисту. Це стосується навіть мінту з найвищою оцінкою на сайті.",
+  "disclaimer.custodial.p3": "Cashu створено для швидкого обігу невеликих сум. Тримайте те, що збираєтеся витратити, не заощадження, і розподіляйте кошти між мінтами, а не зберігайте все в одному.",
+  "disclaimer.reviews.title": "Відгуки: це думки, а не підтверджені твердження",
+  "disclaimer.reviews.p1": "Кожен відгук написаний у Nostr і підписаний ключем автора. Підпис показує лише, який ключ створив відгук. Він не доводить правдивість відгуку, використання мінту автором або те, що автор не є оператором, конкурентом чи однією людиною з десятьма ключами.",
+  "disclaimer.reviews.p2": "Ми не перевіряємо авторів і не редагуємо або видаляємо відгуки через незгоду з ними. Прочитайте кілька відгуків і зважайте на їхній зміст. Мінт із трьома відгуками слід оцінювати інакше, ніж мінт із трьомастами.",
+  "disclaimer.status.title": "Онлайн означає доступний, а не надійний",
+  "disclaimer.status.p1": "Ми регулярно перевіряємо кожен мінт і показуємо, чи він відповів. Зелений статус означає лише, що сервер відповів. Він нічого не говорить про платоспроможність або чесність оператора чи його намір погасити ваші токени завтра.",
+  "disclaimer.status.p2": "Мінт може бути онлайн аж до миті, коли перестане відповідати. Історія доступності, підтримувані NUT і версія програмного забезпечення дещо показують про роботу мінту, але не гарантують збереження ваших грошей.",
+  "disclaimer.ranking.title": "Як працює рейтинг і що він не означає",
+  "disclaimer.ranking.p1": "Мінти впорядковуються алгоритмом на основі даних публічного огляду: рейтинг, кількість відгуків та остання активність, причому онлайн-мінти за замовчуванням випереджаються офлайн. Деталі містяться в відкритому коді.",
+  "disclaimer.ranking.p2": "Ніхто не платить за позицію. На сайті немає спонсорованих місць, рекламних списків або домовленостей із мінтами. Високе місце означає лише, що алгоритм високо оцінив публічні дані. Це не рекомендація й не оцінка безпеки.",
+  "disclaimer.notAdvice.title": "Це не фінансова порада",
+  "disclaimer.notAdvice.p1": "На цьому сайті немає фінансових, інвестиційних, юридичних чи податкових консультацій. Ми не знаємо вашої ситуації і не консультуємо. Використовувати мінт і обирати, який саме: це ваш вибір.",
+  "disclaimer.dyor.title": "Проведіть власне дослідження",
+  "disclaimer.dyor.li1": "Пошукайте оператора. Мінт, яким керує людина з публічною репутацією, яку можна втратити,: це інше рішення, ніж анонімна URL.",
+  "disclaimer.dyor.li2": "Прочитайте умови самого мінту та його MOTD. мінт, який називає себе тестом або бета, означає це.",
+  "disclaimer.dyor.li3": "Почніть із малого. Виконайте мінт невеликої суми, витратьте її, виведіть через melt і перевірте результат, перш ніж довіряти більше.",
+  "disclaimer.dyor.li4": "Слідкуй за межами. Низький максимум часто є ознакою обережного оператора, а високий: не ознакою безпечного рівня.",
+  "disclaimer.dyor.li5": "Зберігайте резервні копії токена і памінтйте, що токен: це актив носії: хто його володіє, може його витратити.",
+  "disclaimer.site.title": "Про сам сайт",
+  "disclaimer.site.p1": "Дані тут можуть бути помилковими або застарілими. Мінти перевіряються за розкладом, relays іноді не відповідають, а сторінку було зібрано раніше. Сайт надається як є, без гарантій. Дивіться {link}.",
+  "disclaimer.site.link": "Умови використання",
+  "disclaimer.updated": "20 серпня 2026",
+  "login.getPrimal": "Отримати Primal",
+  "reviews.dialog.identity.extensionGone": "Ваше розширення браузера не відповідає. Увійдіть знову або скористайтеся віддаленим signer.",
+  "seo.orgDescription": "Каталог мінтів Cashu з актуальним статусом кожного мінту та відгуками спільноти, підписаними у Nostr.",
+  "seo.ogImageAlt": "Cashumints.space: знайдіть мінт Cashu, якому можна довіряти.",
+  "seo.mint.title.one": "{name} відгуки: оцінено {rating} за {n} оглядом | Cashumints.space",
+  "seo.mint.title.few": "{name} відгуки: рейтинг {rating} з {n} відгуків | Cashumints.space",
+  "seo.mint.title.many": "{name} відгуки: оцінено {rating} з {n} відгуків | Cashumints.space",
+  "seo.mint.title.other": "{name} відгуки: оцінено {rating} за {n} відгуками | Cashumints.space",
+  "seo.mint.titleOffline.one": "{name}: офлайн {n} день | Cashumints.space",
+  "seo.mint.titleOffline.few": "{name}: офлайн протягом {n} днів | Cashumints.space",
+  "seo.mint.titleOffline.many": "{name}: офлайн протягом {n} днів | Cashumints.space",
+  "seo.mint.titleOffline.other": "{name}: офлайн {n} днів | Cashumints.space",
+  "seo.mint.titleNoReviews": "{name}: Інформація та відгуки про Cashu мінт | Cashumints.space",
+  "seo.fedimint.titleNoReviews": "{name}: Інформація та відгуки про федерацію Fedimint | Cashumints.space",
+  "seo.desc.fallback": "Відгуки спільноти для {name} ({domain}).",
+  "seo.desc.fallbackDomain": "Відгуки спільноти про мінт Cashu на {domain}.",
+  "seo.desc.rated.one": "Оцінено {rating}/5 за {n} підписаним відгуком Nostr.",
+  "seo.desc.rated.few": "Оцінено {rating}/5 з {n} підписаних відгуків на Nostr.",
+  "seo.desc.rated.many": "Оцінено {rating}/5 з {n} підписаних відгуків на Nostr.",
+  "seo.desc.rated.other": "Оцінено {rating}/5 за {n} підписаних відгуків на Nostr.",
+  "seo.desc.noReviews": "Поки що відгуків немає.",
+  "seo.desc.status": "{status}.",
+  "seo.desc.statusLimits": "{status}, обмеження {limits}.",
+  "seo.desc.fedModules": "{status}. Модулі: {modules}.",
+  "seo.desc.fedModulesNetwork": "{status}. Модулі: {modules} на {network}.",
+  "seo.mint.ogAlt.one": "{name}: {rating} зірок з огляду {n} на Cashumints.space",
+  "seo.mint.ogAlt.few": "{name}: {rating} зірок з {n} відгуків на Cashumints.space",
+  "seo.mint.ogAlt.many": "{name}: {rating} зірок з {n} відгуків на Cashumints.space",
+  "seo.mint.ogAlt.other": "{name}: {rating} зірок із {n} відгуків на Cashumints.space",
+  "seo.mint.ogAltNoReviews": "{name} на Cashumints.space",
+  "nav.home": "Головна",
+  "mint.more.title": "Інші мінти",
+  "mint.more.all": "Переглянути всі мінти",
+  "nav.fedimints": "Fedimints",
+  "status.announced": "Лише оголошено",
+  "card.unnamedFederation": "Безіменна федерація",
+  "card.notChecked": "ніколи не перевірено",
+  "fedimints.title": "Усі федерації Fedimint · Cashumints.space",
+  "fedimints.description": "Усі {total} федерацій Fedimint, оголошені в мережі Nostr: {online} підтверджено зовнішньою перевіркою, {announced} лише оголошено й ніколи не підтверджено. Для кожної є оцінки спільноти, модулі та коди запрошення.",
+  "fedimints.heading": "Усі федерації",
+  "fedimints.lede": "Усі федерації Fedimint, оголошені в мережі Nostr. Федерація не має власної публічної кінцевої точки статусу, тому роботу деяких підтверджено зовнішньою перевіркою, а решту наведено саме так, як їх оголосили.",
+  "fedimints.search.label": "Пошук федерації за назвою або ідентифікатором",
+  "fedimints.search.placeholder": "Пошук за ім'ям або ідентифікатором федерації...",
+  "fedimints.sort.label": "Сортування федерацій",
+  "fedimints.hideOffline": "Приховати офлайн",
+  "fedimints.showing": "Показано {total} федерацій ({online} підтверджено, {announced} лише оголошено)",
+  "fedimints.showingFiltered": "Показано {shown} із {total} федерацій ({online} підтверджено, {announced} лише оголошено)",
+  "fedimints.announcedNote.one": "Один із них був анонсований на Nostr, і з того часу нічого не підтверджено, що він працює. Це вказано як оголошене, а не як онлайн чи офлайн, бо жоден із них не відповідає дійсності.",
+  "fedimints.announcedNote.few": "{n} з них були анонсовані на Nostr, і з того часу нічого не підтверджено, що вони працюють. Вони вказані як оголошені, а не онлайн чи офлайн, бо жоден із них не відповідає дійсності.",
+  "fedimints.announcedNote.many": "{n} з них було анонсовано на Nostr, і з того часу нічого не підтверджено, що вони працюють. Вони вказані як оголошені, а не онлайн чи офлайн, бо жоден із них не відповідає дійсності.",
+  "fedimints.announcedNote.other": "{n} з них були анонсовані на Nostr, і з того часу нічого не підтверджено, що вони проводяться. Вони вказані як оголошені, а не онлайн чи офлайн, бо жоден із них не відповідає дійсності.",
+  "fedimints.noResults": "Федерацій за запитом не знайдено. Спробуйте назву або вставте id федерації.",
+  "fedimints.emptyIndex": "На relays, які читає сайт, ще не оголошено жодної федерації. Список поповнюється автоматично з надходженням оголошень.",
+  "fedimint.crumb": "Fedimint",
+  "fedimint.breadcrumb": "Навігаційний ланцюжок",
+  "fedimint.unnamed": "Безіменна федерація",
+  "fedimint.idLabel": "Федерація",
+  "fedimint.kind.federationId": "id федерації",
+  "fedimint.moduleCount.one": "{n} модуль",
+  "fedimint.moduleCount.few": "{n} модулі",
+  "fedimint.moduleCount.many": "{n} модулів",
+  "fedimint.moduleCount.other": "{n} модулі",
+  "fedimint.copyInvite": "Скопіювати код запрошення",
+  "fedimint.confirmed.label": "Підтверджено",
+  "fedimint.confirmed.never": "Ніколи",
+  "fedimint.confirmed.by": "джерело: {source}",
+  "fedimint.confirmed.unattributed": "остання перевірка",
+  "fedimint.announcedOn": "Оголошено {when}",
+  "fedimint.announcedUnknown": "дата оголошення невідома",
+  "fedimint.modules.title": "Модулі",
+  "fedimint.modules.none": "Оголошення цієї федерації не містить жодних модулів.",
+  "fedimint.modules.note": "Модулі є компонентами федерації. В оголошенні вказано лише наявні модулі, але не сказано, чи приймає якийсь із них депозити.",
+  "fedimint.modules.notListed": "Не зазначено",
+  "fedimint.invite.title": "Код запрошення",
+  "fedimint.invite.count.one": "{n} код",
+  "fedimint.invite.count.few": "{n} коди",
+  "fedimint.invite.count.many": "{n} кодів",
+  "fedimint.invite.count.other": "{n} коди",
+  "fedimint.invite.note": "Вставте цей код у гаманець Fedimint, щоб приєднатися. Він містить id федерації та адреси її guardians і призначений для поширення.",
+  "fedimint.invite.kind": "Код запрошення",
+  "fedimint.invite.qr": "QR",
+  "fedimint.invite.qrCaption": "Скануйте, щоб приєднатися до {name}",
+  "fedimint.details.federationId": "Ідентифікатор Федерації",
+  "fedimint.details.network": "Мережа",
+  "fedimint.details.announcedBy": "Оголошено",
+  "fedimint.details.announced": "Оголошено",
+  "fedimint.more.title": "Більше федерацій",
+  "fedimint.more.all": "Переглянути всі федерації",
+  "fedimint.disclaimer": "Приєднання до федерації означає, що ви довіряєте гроші її guardians. Оцінки є думками спільноти, а підтверджена робота означає доступність, не надійність.",
+  "fedimint.module.lightning": "Lightning",
+  "fedimint.module.mint": "Мінт ecash",
+  "fedimint.module.wallet": "Ончейн-гаманець",
+  "fedimint.module.meta": "Метадані",
+  "fedimint.module.stability_pool": "Пул стабільності",
+  "fedimint.module.multi_sig_stability_pool": "Пул стабільності (мультипідпис)",
+  "fedimint.module.fedi-social": "Соціальне відновлення",
+  "fedimint.network.mainnet": "Bitcoin mainnet",
+  "fedimint.network.signet": "Signet",
+  "fedimint.network.testnet": "Testnet",
+  "fedimint.network.testnet4": "Testnet4",
+  "fedimint.network.regtest": "Regtest",
+  "feed.ecosystem.group": "Екосистема",
+  "feed.ecosystem.all": "Усі",
+  "feed.ecosystem.cashu": "Cashu",
+  "feed.ecosystem.fedimint": "Fedimint",
+  "feed.filterBySubject": "Фільтрувати за мінтом або федерацією",
+  "feed.anySubject": "Будь-який мінт або федерація",
+  "feed.clearSubject": "Очистити фільтр імен",
+  "home.topFedimints.title": "Найкращі Fedimint",
+  "home.topFedimints.sub": "за відгуками та оцінкою",
+  "home.topFedimints.all": "Усі {n} федерацій →",
+  "reviews.validate.subject": "Немає об’єкта, до якого можна прив’язати цей відгук.",
+  "mint.warnings.fedimintOffline.lead": "Повідомлено про офлайн.",
+  "mint.warnings.fedimintOffline.body.since": "Остання успішна перевірка цієї федерації була {date} ({days} тому). Відтоді її guardians не відповідають. Вважайте кошти в ній під загрозою й не приєднуйтеся з новими коштами.",
+  "mint.warnings.fedimintOffline.body.never": "Жодна перевірка цієї федерації не була успішною, а остання завершилася невдало. Вважайте кошти в ній під загрозою й не приєднуйтеся з новими коштами.",
+  "mint.warnings.fedimintOffline.meta.since": "Повідомляється про офлайн з {date}",
+  "mint.warnings.fedimintOffline.meta.never": "Повідомлено про офлайн, жодного разу не була доступна",
+  "mint.warnings.neverConfirmed.lead": "Оголошено, але не підтверджено.",
+  "mint.warnings.neverConfirmed.body.reviewed": "Федерацію оголосили в Nostr {date}, {days} тому, і відтоді ніщо не підтвердило, що вона працює. Відгуки нижче є єдиною ознакою активності на цій сторінці. Решта даних походить з оголошення.",
+  "mint.warnings.neverConfirmed.body.quiet": "Федерацію оголосили в Nostr {date}, {days} тому, але відтоді ніщо не підтвердило, що вона працює, і останнім часом ніхто не залишав відгуків. Усі дані нижче походять з оголошення.",
+  "mint.warnings.neverConfirmed.meta": "Оголошено {date}, ніколи не підтверджено",
+  "footer.allFedimints": "Усі федерації",
+  "reviews.dialog.bodyPlaceholder.cashu": "Як працювали внесення через mint, виведення через melt і підтримка? Пишіть конкретно.",
+  "reviews.dialog.bodyPlaceholder.fedimint": "Як працювали приєднання, платежі Lightning і підтримка? Пишіть конкретно.",
+  "fedimint.details.title": "Деталі федерації",
+  "nav.lnurlMints": "LNURL-мінти",
+  "footer.allLnurlMints": "Усі LNURL-мінти",
+  "lnurlMints.title": "LNURL-мінти: мінти пред'явницьких нот lnurlcash з відгуками | Cashumints.space",
+  "lnurlMints.description": "Усі {total} LNURL-мінтів, проіндексованих із мережі Nostr: {online} онлайн, {offline} офлайн. Оцінки спільноти, ліміти виведення та можливості кожного.",
+  "lnurlMints.heading": "LNURL-мінти",
+  "lnurlMints.lede": "Кожен LNURL-мінт, про який знає цей сайт. LNURL-мінт випускає пред'явницькі ноти lnurlcash: ноти Lightning, які ви тримаєте як секрет і які можна прокрутити, розділити, об'єднати або розплавити назад у платіж Lightning. Кожен перевіряється по HTTPS кожні кілька хвилин.",
+  "lnurlMints.search.label": "Пошук LNURL-мінтів",
+  "lnurlMints.search.placeholder": "Пошук за назвою або адресою…",
+  "lnurlMints.sort.label": "Сортувати LNURL-мінти за",
+  "lnurlMints.hideOffline": "Сховати офлайн",
+  "lnurlMints.showing": "Показано {total} LNURL-мінтів ({online} онлайн, {offline} офлайн)",
+  "lnurlMints.showingFiltered": "Показано {shown} із {total} LNURL-мінтів ({online} онлайн, {offline} офлайн)",
+  "lnurlMints.noResults": "Жоден LNURL-мінт не збігається.",
+  "lnurlMints.emptyIndex": "LNURL-мінти ще не проіндексовані.",
+  "lnurl.crumb": "LNURL-мінти",
+  "lnurl.breadcrumb": "Хлібні крихти",
+  "lnurl.copyAddress": "Скопіювати адресу",
+  "lnurl.more.title": "Інші LNURL-мінти",
+  "lnurl.more.all": "Усі LNURL-мінти →",
+  "lnurl.disclaimer": "LNURL-мінт зберігає ваші сати, поки ви тримаєте його ноти, тож користуватися ним означає довіряти його оператору. Оцінки — це думки спільноти, а «онлайн» означає доступний, а не надійний.",
+  "lnurl.features.title": "Можливості",
+  "lnurl.features.none": "Цей мінт не оголошував, що він підтримує.",
+  "lnurl.features.note": "Можливості — це те, що оператор мінта оголосив у Nostr. Там, де сайт може перевірити їх по HTTPS, він це робить і повідомляє, якщо оголошене зараз недоступне.",
+  "lnurl.features.notListed": "не оголошено",
+  "lnurl.features.unavailable": "недоступно",
+  "lnurl.feature.mint": "Карбування через Lightning (LUD-06)",
+  "lnurl.feature.melt": "Плавлення в Lightning",
+  "lnurl.feature.notes": "Прокрутка / поділ / об'єднання нот",
+  "lnurl.feature.lud16": "Lightning-адреса",
+  "lnurl.feature.lud21": "Перевірка платежу (LUD-21)",
+  "lnurl.feature.signed-notes": "Підписані ноти (офлайн-перевірка)",
+  "lnurl.feature.onion": "Tor-адреса",
+  "lnurl.feature.rotate": "Прокрутити ноту",
+  "lnurl.feature.split": "Розділити ноту",
+  "lnurl.feature.merge": "Об'єднати ноти",
+  "lnurl.feature.lud06": "LUD-06 payRequest",
+  "lnurl.feature.lud03": "LUD-03 withdrawRequest",
+  "lnurl.limits.label": "Ліміти виведення",
+  "lnurl.limits.notPublished": "не опубліковано",
+  "lnurl.limits.withdrawRow": "Виведення",
+  "lnurl.limits.disabled": "вимкнено",
+  "lnurl.limits.sats.one": "{n} сат",
+  "lnurl.limits.sats.few": "{n} сати",
+  "lnurl.limits.sats.many": "{n} сатів",
+  "lnurl.limits.sats.other": "{n} сатів",
+  "lnurl.details.title": "Дані мінта",
+  "lnurl.details.address": "Lightning-адреса",
+  "lnurl.details.mintPubkey": "Публічний ключ мінта",
+  "lnurl.details.onion": "Tor-адреса",
+  "lnurl.details.fee": "Комісія за карбування",
+  "lnurl.details.node": "Вузол",
+  "lnurl.details.capacity": "Оголошена ємність",
+  "lnurl.kind.lightningAddress": "Lightning-адреса",
+  "lnurl.kind.mintPubkey": "публічний ключ мінта",
+  "lnurl.kind.onionAddress": "Tor-адреса",
+  "lnurl.confirmed.label": "Останнє підтвердження",
+  "lnurl.confirmed.when": "підтверджено {when}",
+  "lnurl.fee.base.one": "{n} сат",
+  "lnurl.fee.base.few": "{n} сати",
+  "lnurl.fee.base.many": "{n} сатів",
+  "lnurl.fee.base.other": "{n} сатів",
+  "lnurl.fee.percent": "{percent}%",
+  "home.topLnurl.title": "Найкращі LNURL-мінти",
+  "home.topLnurl.sub": "за відгуками та оцінкою",
+  "home.topLnurl.all": "Усі {n} LNURL-мінтів →",
+  "feed.ecosystem.lnurl": "LNURL",
+  "reviews.dialog.bodyPlaceholder.lnurl": "Як пройшли карбування, плавлення та прокрутка нот? Пишіть конкретно.",
+  "reviews.byUrl.open": "Написати відгук",
+  "reviews.byUrl.title": "Написати відгук",
+  "reviews.byUrl.lede": "Встав адресу. Якщо сайт її ще не знає, він перевірить її й додасть зараз.",
+  "reviews.byUrl.label.cashu": "URL мінта",
+  "reviews.byUrl.label.fedimint": "Код запрошення федерації",
+  "reviews.byUrl.label.lnurl": "URL LNURL-мінта",
+  "reviews.byUrl.placeholder.cashu": "mint.example.com",
+  "reviews.byUrl.placeholder.fedimint": "fed11…",
+  "reviews.byUrl.placeholder.lnurl": "mint.example.com",
+  "reviews.byUrl.check": "Перевірити цю адресу",
+  "reviews.byUrl.checking": "Перевіряємо…",
+  "reviews.byUrl.back": "Інша адреса",
+  "reviews.byUrl.existing": "Уже в списку",
+  "reviews.byUrl.indexed": "Щойно додано",
+  "reviews.byUrl.confirmClose": "Закрити? Введена адреса не збережеться.",
+  "reviews.byUrl.detected": "Ця адреса відповіла як мінт {kind}.",
+  "reviews.byUrl.switchTo": "Оцінити як мінт {kind}",
+  "reviews.byUrl.error.empty": "Спочатку введи адресу.",
+  "reviews.byUrl.error.badUrl": "Це не схоже на URL мінта.",
+  "reviews.byUrl.error.badInvite": "Це не код запрошення Fedimint. Коди починаються з fed11.",
+  "reviews.byUrl.error.badInput": "Сайт не може перевірити цю адресу.",
+  "reviews.byUrl.error.blocked": "Це не публічна адреса, тож перевірити її не можна.",
+  "reviews.byUrl.error.notAMint": "Адреса відповіла, але не як мінт цього типу.",
+  "reviews.byUrl.error.wrongType": "Адреса відповіла, але як мінт іншого типу.",
+  "reviews.byUrl.error.unverifiable": "За цією адресою ніщо не відповіло, і в Nostr про неї поки що немає й сліду.",
+  "reviews.byUrl.error.rateLimited.one": "Забагато перевірок з одного з’єднання. Спробуй ще раз приблизно через {n} хвилину.",
+  "reviews.byUrl.error.rateLimited.other": "Забагато перевірок з одного з’єднання. Спробуй ще раз приблизно через {n} хвилин.",
+  "reviews.byUrl.error.network": "Не вдалося зв’язатися з індексом. Перевір з’єднання і спробуй ще раз.",
+  "seo.lnurl.titleNoReviews": "{name}: інформація та відгуки про LNURL-мінт | Cashumints.space",
+  "seo.desc.statusWithdraw": "{status}, виведення {min}–{max} сат.",
+  "mint.chip.noFunding": "Без карбування / плавлення",
+  "mint.warnings.lnurlWithdrawalsDisabled.lead": "Виведення вимкнено.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.online": "Цей мінт оголошує максимальне виведення в нуль, тож жодну випущену ним ноту не можна ні на що обміняти. Не карбуйте тут, доки це не зміниться.",
+  "mint.warnings.lnurlWithdrawalsDisabled.body.offline": "Під час останнього контакту цей мінт оголошував максимальне виведення в нуль, тож жодну випущену ним ноту не можна було ні на що обміняти. Не карбуйте тут, доки це не зміниться.",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.online": "Виведення зараз вимкнено",
+  "mint.warnings.lnurlWithdrawalsDisabled.meta.offline": "Під час останнього контакту виведення було вимкнено",
+  "mint.warnings.lnurlInvalid.lead": "Ендпоінт відповідає, але некоректно.",
+  "mint.warnings.lnurlInvalid.body": "Хост відповідає, але не оголошенням мінта, яке сайт може прочитати, тож виведення може не працювати. Нижче — останній стан, який вдалося розібрати, а відгуки й далі працюють.",
+  "mint.warnings.lnurlInvalid.meta": "Відповідає, але не коректним оголошенням мінта",
+  "mint.warnings.lnurlNoFunding.lead": "Карбування та плавлення недоступні.",
+  "mint.warnings.lnurlNoFunding.body": "Наявні ноти й далі можна прокрутити, розділити або об'єднати, але зараз через Lightning нічого не входить і не виходить. Сам мінт працює й відповідає; вузол Lightning за ним для нього недоступний.",
+  "mint.warnings.lnurlNoFunding.meta": "Карбування та плавлення недоступні",
+  "mint.warnings.also.noFunding": "Його вузол Lightning теж був недоступний, тож нічого не можна було відкарбувати чи розплавити."
+}