-
Morphit v1.24.3
StableAll checks were successfulmorphit-ci / Supply-chain audit gate (every advisory triaged, none fixable in range) (push) Successful in 1m8smorphit-ci / TypeScript typecheck (sweep all workspaces) (push) Successful in 1m35smorphit-ci / apps/web svelte-check (svelte-kit sync + svelte-aware tsc) (push) Successful in 1m4smorphit-ci / Integration tests (real Postgres 16) (push) Successful in 8m16smorphit-ci / ansible-lint (playbook quality gate) (push) Successful in 50smorphit-ci / Smoke suite (run-smokes.sh, pulses 1–2 of 3) (push) Successful in 1h17m16smorphit-ci / Smoke suite (run-smokes.sh, pulse 3 of 3) (push) Successful in 38m4smorphit-release / Build + publish release tarball (push) Successful in 51m0sreleased this
2026-11-15 18:42:45 +00:00 | 0 commits to main since this releaseMorphit v1.24.3
The relay's payment queue can no longer send one payment twice, however long a send takes to get
going.This release contains everything in v1.24.2. The deadline v1.23.5 set still stands: every site must
run v1.23.5 or later (so this release is fine) before 2026-11-22 00:00 UTC.For people using the site
Nothing changes on the site. Welcome bonuses and loyalty rewards are paid as before.
For operators
Upgrade as usual. Nothing to configure.
The payment queue's never-pay-twice guarantee no longer depends on running one relay. An
outside security report, sent to the address indocs/SECURITY.md, showed that two relays sharing
one database could both send the same welcome bonus or reward. It took a slow chain: more than a
minute between the relay taking a payment and signing it. A standard site runs one relay per
database, so this could not happen on it. The queue now stays correct even with two.A payout held for review keeps the record of a payment that may already be on the chain. When
the indexer finds database code Morphit never creates, it holds every unsent payout for you to
review. It used to write its reason over a payout's record of a signed payment, so
morphit-ops failed-broadcastsshowed such a payout as "not sent" instead of "may have been sent",
and without its transaction id. Re-queuing it could have paid it twice. The record is now kept, and
the list shows the payout as "may have been sent", with the way to look it up first.A relay that finds another relay has taken a payment it was about to sign now logs
row_claim_lostand leaves the payment to that relay. Nothing is counted against the payment.For developers
apps/relay/src/queue/drainer.ts:- The claim compares the whole row as it was read (
broadcast_attempt_atandlast_error), and
takes it only whileerror_countis below the retry limit. It returns the stamp it wrote. onSignedrecords the signed transaction only while the row still carries that stamp and is
not stopped. Otherwise nothing is sent, the drainer logsrow_claim_lost, and the row is left
as it is (no failure counted).- Why both: the drain query takes a row again once its stamp is older than the retry backoff
(1 minute at first), and the head read before signing walks the nodes one after another
(10 s each, 60 s over Tor or I2P). A second drainer could then claim with the first one's stamp
and send; and one that read the row before the first recorded its transaction could still
claim after it. Tying onlyonSignedto the claim would close the first case, not the second. - The file's header no longer says the claim alone keeps two drainers off one row.
- The claim compares the whole row as it was read (
apps/indexer/src/indexer/foreignCodeHeal.ts: the hold keeps alast_errorthat starts
withoutcome_unknownorin_flight trx_id=, and writes its reason over every other one.- Tests:
drainer-no-double-pay-smoke(real Postgres, two real drainers, each paused at the exact
statement): a second drainer taking the row while the first reads the head; both drainers
before signing; a second drainer that read the row before the first signed and claims after;
a row stopped before the claim; a row stopped during the head read. All five failed before
the fix (two payments, or a held row paid).foreign-code-heal-attempts.test.ts(real Postgres): a signed record survives the hold, an
unsigned row gets the reason, a sent row is not touched.- Every part, undone on its own, fails a test: 8 mutations.
- Dependencies:
@sveltejs/adapter-static3.0.10 → 3.0.11 (GHSA-jf9x-2fg2-hx4w: prerendered
paths read as regular expressions in the route config it writes for Vercel). That config is
written only when the build runs on Vercel (VERCELset), which a Morphit build never does, so
the built site is the same.apps/web/package.jsonnow requires^3.0.11, and the lockfile
changes only that package.
Downloads
-
Source code (ZIP)
1 download
-
Source code (TAR.GZ)
1 download
-
Morphit v1.24.2
StableAll checks were successfulmorphit-ci / Supply-chain audit gate (every advisory triaged, none fixable in range) (push) Successful in 57smorphit-ci / TypeScript typecheck (sweep all workspaces) (push) Successful in 1m17smorphit-ci / apps/web svelte-check (svelte-kit sync + svelte-aware tsc) (push) Successful in 55smorphit-ci / Integration tests (real Postgres 16) (push) Successful in 8m34smorphit-ci / ansible-lint (playbook quality gate) (push) Successful in 51smorphit-ci / Smoke suite (run-smokes.sh, pulses 1–2 of 3) (push) Successful in 1h12m46smorphit-ci / Smoke suite (run-smokes.sh, pulse 3 of 3) (push) Successful in 37m37smorphit-release / Build + publish release tarball (push) Successful in 49m49sreleased this
2026-11-13 06:08:38 +00:00 | 1 commits to main since this releaseMorphit v1.24.2
A chat message no longer fails with a frightening red error when the Blurt network is slow to answer.
Morphit deals with it in the background: it asks again by itself, keeps your messages in order, and
sends a waiting message as soon as the network answers. The person sending has nothing to do.This release contains everything in v1.24.1. The deadline v1.23.5 set still stands: every site must
run v1.23.5 or later (so this release is fine) before 2026-11-22 00:00 UTC.For people using the site
Sending a message no longer fails on a slow network answer. Before a message is sent, Morphit
looks up the other person's keys on the Blurt chain, through your site. If that lookup didn't
answer in time, the message showed at once in red as "Failed", with a long warning about the
blockchain, though you had done nothing wrong. A message sent soon after opening the conversation
could even fail without asking at all, because it reused an earlier miss.Now all of this happens out of sight:
- The lookup starts when you open the conversation, while you type, and quietly asks again if it
missed. The keys are usually in before you press Send. - A send that still has to wait shows "sending…" while Morphit asks again.
- A message that had to wait is sent before the ones you write after it.
- If the network still doesn't answer, the message shows as "Not sent yet", in its usual colour
and without any red, with a short note that it is tried again automatically while the chat is
open. It is: about half a minute after each attempt, as soon as your device is back online, and
before any newer message you send. Retry sends it at once. - Sharing an address or recording a payment works the same way: the window closes normally, and the
message goes out by itself. "Share your address" doesn't come back while your address waits, so
you can't end up sending it twice. - After Pay now, if the receipt has to wait, the confirmation says that the BLURT was sent and
that its receipt goes to the chat as soon as the network answers. It also shows the transaction
id, in case you leave the chat first: you can then mark the funds sent with it.
Every other place that looks up an account's keys (Verify peer, sharing an address, leaving a review,
pairing your phone, an order's details) now also asks a second time, quietly, before it reports a
problem.For operators
Upgrade as usual. Nothing to configure.
Two web-server libraries are updated in the indexer, the relay and the MCP server:
@hono/node-server1.19.19 (GHSA-jpvv-r467-5p4w). The older version read a backslash in a
request's path as a slash, so a path the reverse proxy in front of a node lets through could reach a
route the proxy is meant to block. A request whose path holds a raw backslash is now refused, with
status 400. No Morphit address contains one.hono4.13.18 (GHSA-h7mg-cq63-vhpq, GHSA-4m76-xfj5-7975, GHSA-3gg2-335m-rxc6). With the older
version, a path holding an encoded line break (such as%0A) skipped the middleware set for every
path. It got its "not found" answer without the security headers. Every request now passes through
that middleware.
When your indexer cannot answer a key lookup, it now logs why:
account_keys_unansweredwith a
reasonand the time it took (ms). The account looked up is never logged. The reasons:deadline: no two node operators gave the same keys before the deadline (nodes slow, down or
resting);no_quorum: the read ended before the deadline without two operators giving the same keys (they
disagreed, or too few answered);unreachable: the read itself failed;incomplete: a node sent an account without all its keys.
A browser now asks for an account's keys up to twice per lookup (never again after a refused
request), and a chat with a waiting message asks again about every half minute while it is open. A
site whose Blurt nodes are slow sees a few more of these requests, never a flood.For developers
-
blurt/accountKeys.ts:fetchAccountKeysasks once more after a failure, afterACCOUNT_KEYS_RETRY_WAIT_MS(1.5 s),
inside the shared, de-duplicated request.- A 404 is an answer, and a 4xx (
AccountKeysStatusError) would be refused again: neither is
asked again. fetchAccountKeysForSigningis now the plain lookup (it used to be the only one that asked
twice).
-
chatService.ts:-
The warm-up asks again in the background after each of
WARM_UP_KEY_LOOKUP_WAITS_MS(5 s,
15 s, 30 s) while the conversation is open. -
A send looks up the keys through
postingPubsForSend.- It never takes a cached miss for an answer.
- It asks again after each of
SEND_KEY_LOOKUP_WAITS_MS(3 s, 8 s), the messagepending
meanwhile. - It stops waiting once a single try took
SEND_KEY_LOOKUP_SLOW_TRY_MS(20 s). - A pin verdict is an answer.
- Closing the conversation stops it.
-
One network verdict per round: within
NETWORK_VERDICT_HOLD_MSof a send that used up its
waits, the sends queued behind it fail at once instead of each waiting again. Retry clears it. -
Order: sends pass the key lookup and encryption one at a time, in order (
sealInOrder).
Their broadcasts then start in that order. -
A lock while a send waited its turn or looked up keys ends it as
session_locked; it is not
kept as unsent. -
Background resend: a message failed on
chain_unreachableis sent again by itself, oldest
first (retryNotYetSent):NOT_YET_SENT_RETRY_MS(30 s) after each attempt while the conversation is open;- on
deps.onOnline(default: the window'sonlineevent); - ahead of any new message.
Only with a live session. Like any unsent message, it is kept in memory for this tab (not in
"destroy" mode) and forgotten on a lock.
-
-
ChatMessage.svelte: a message failed onchain_unreachableisisNotYetSent: its usual
colours, dimmed as while sending,chat.message.not_sent_label, the reason in grey, and Retry.
Every other failure stays red (isHardFailed). The message list'srole="log"live region
announces the change. -
ConversationView.svelte:waitingToSend: a waiting message counts as still sending for "Share your address"
(myAddressSharedHere) and in a two-leg trade's money facts.sendFromModalreturns whether the message went out, and does not throw onchain_unreachable:
the modal closes, and the message waits in the chat.- "Pay now" shows
chat.pay_blurt.success_toast_receipt_pending, with the txid. Any other failure
still showssuccess_toast_no_chat_with_txid. - A send scrolls to the new message when it starts, not when it ends.
-
Copy, all 10 languages:
chat.security.chain_unreachableis rewritten: calm, no Tor/I2P aside, no claim about charges
(a payment receipt's money has already left), tried again automatically while the chat is open.chat.message.not_sent_labelandchat.pay_blurt.success_toast_receipt_pendingare new.
-
Server:
api/accountKeys.tslogsaccount_keys_unanswered(reason and ms, never the account) for each 502.- The quorum read decides nothing when fewer than two operators agree, whether they disagreed or
too few answered (the pool swallows a node's failure). Only the deadline's signal can be told
apart:deadlineversusno_quorum.
-
Tests:
postingChat.test.ts: the old "a failed lookup is asked again only after a pause" test pinned
the cached miss a send hit. It is replaced by 17 tests covering the send, the warm-up, order,
the per-round verdict, the background and online resend, locks during a wait, a lookup and a
retry, the 20 s cap, closing, pin verdicts and Retry.accountKeys.test.ts: the deadlines across both tries, the quiet second try, and a refused
request not asked again.chatMessageGuards.test.ts: the calm state, and a real failure staying red.ConversationView.auditFlows.test.ts:- "Pay now" for each outcome;
- "Mark sent" closing on a network miss;
- the scroll at send;
- the live log;
- "Share your address" staying hidden for a waiting card, in a one-leg and in a two-leg trade.
accountKeysQuorum.test.ts: each log reason, never naming the account.- Every part, undone on its own, fails a test or a smoke: 26 mutations.
-
Dependencies:
@hono/node-server1.19.17 → 1.19.19 (GHSA-jpvv-r467-5p4w, a backslash in the path read as a
separator). The indexer's and the relay'spackage.jsonnow require^1.19.18. The update also
refuses a%in aserveStaticpath, which Morphit does not use.hono4.13.12 → 4.13.18 (GHSA-h7mg-cq63-vhpq: RegExpRouter skipped wildcard middleware, as for a
path with an encoded line terminator; GHSA-4m76-xfj5-7975,mount(), and GHSA-3gg2-335m-rxc6,
thecsshelper, neither used here). The root's, the indexer's and the relay'spackage.jsonnow
require^4.13.16. The setup-time checks 4.13.16 adds (/x*routes, duplicate parameter names,
patterns that match an empty string) find nothing in Morphit's routes. The validator, CSRF, JWT and
serveStaticchanges do not touch Morphit, which does not use them.- The lockfile changes only those two packages, one shared copy each. The new floors keep any
install off an affected version.
-
Smokes:
chat-sent-state-smokerequires the not-yet-sent bubble to be dimmed, and still never
a sent one.
Downloads
-
Source code (ZIP)
2 downloads
-
Source code (TAR.GZ)
3 downloads
- The lookup starts when you open the conversation, while you type, and quietly asks again if it
-
Morphit v1.24.1
StableAll checks were successfulmorphit-ci / Supply-chain audit gate (every advisory triaged, none fixable in range) (push) Successful in 1m2smorphit-ci / TypeScript typecheck (sweep all workspaces) (push) Successful in 1m22smorphit-ci / apps/web svelte-check (svelte-kit sync + svelte-aware tsc) (push) Successful in 56smorphit-ci / Integration tests (real Postgres 16) (push) Successful in 7m56smorphit-ci / ansible-lint (playbook quality gate) (push) Successful in 47smorphit-ci / Smoke suite (run-smokes.sh, pulses 1–2 of 3) (push) Successful in 1h10m23smorphit-ci / Smoke suite (run-smokes.sh, pulse 3 of 3) (push) Successful in 35m52smorphit-release / Build + publish release tarball (push) Successful in 49m30sreleased this
2026-11-11 03:48:45 +00:00 | 3 commits to main since this releaseMorphit v1.24.1
The browser tab no longer shows unread messages you have already read.
This release contains everything in v1.24.0. The deadline v1.23.5 set still stands: every site must
run v1.23.5 or later (so this release is fine) before 2026-11-22 00:00 UTC.For people using the site
A tab left open in the background shows only what is really unread. A Morphit tab left open
could show "(2)" in its title, with a red dot on its icon, for messages you had already read on your
phone or that were not new at all. The count went away the moment you looked at the tab, and there
was nothing new in your inbox. Three things caused it, and all three are fixed:- A message you read on your phone or in another tab stayed counted. A new message lights
the badge as soon as it arrives, before the site's records have it. The tab then waits for those
records to catch up. It dated the message by your computer's clock when the alert arrived, a
moment after the message's real time on the chain, so the records never seemed to catch up.
Every alert now carries the message's own time. - A tab in the background checked for news only when a new message came in. Reading a message
elsewhere isn't news, so the tab never found out. It now also checks about once a minute, and
drops a message the site's records still don't confirm after 10 minutes. - A tab that had locked itself still counted. When the Start button says "Unlock", the tab
knows nothing of what you have read, so every new message counted, read or not. A locked tab now
shows no chat count, as it was meant to, and unlocking brings back the right count at once.
A message you read on your phone stays read on your computer. A message often reaches you
before it is written to the chain. If you opened the conversation and read it then, your other
devices showed it as unread once it was written, until you opened it there too. Your site now
recognises that read and counts it for the message, on every device. It never does so when another
message from the same person, which you have not seen, was written alongside it."Mark all read" holds for a conversation that so far only an alert knows about. It used to show
as unread again once the message was written to the chain. As for every conversation, "Mark all
read" marks it on that device; for such a conversation the mark lasts until the page is reloaded.A message you haven't read still shows on the tab as soon as it arrives, in the background too.
An alert that reaches a computer late, such as one waking from sleep, no longer lights the tab for a
message you have already read.Three limits remain:
- If someone sends two messages within the same three seconds and you leave the conversation after
seeing only the first, the second shows as unread only once it is written to the chain, about a
minute later. The site keeps your place by time, and the two share it. - For the same reason, a second alert for a message you have just read, such as one arriving late,
can show it as unread on that device for a minute or two, until your site's answer about the read
comes back. - The alert's timing works once your browser runs this version's background helper. The site
offers it with its usual "Load it now".
For operators
Upgrade as usual. The indexer applies migration v74 when it starts: one new column,
chat_messages.sent_at, filled for messages indexed from now on. It changes nothing for an older
indexer, so rolling back stays possible.A Morphit tab left open in the background, signed in and unlocked, now asks your indexer for its
conversations and read state about once a minute (/v1/conversations/<account>and
/v1/chat-read-state/<account>), besides when a message arrives. A locked or signed-out tab still
asks nothing. Nothing to configure.For developers
- The message's time travels with every alert. The indexer's live
chat_activityping now
carriesat: the message's time (createdAt, the head block's time or the sender's signed
time), as the replay always did. The service worker forwards the Web Push'seventAtto the
tabs asat, throughchatPushTabMessage(notifications/chatThread.ts), and the tab passes it
on to the badge. chatUnread.ts.- A pending push is
{ at, seen }:atis the newest pushed message's time,seenis when
its push reached this device. - The durable row reconciles it once
last_message_at >= at, and the read cursor judges it by
at, both on the chain's clock. This device's own acknowledgement and the 10-minute TTL use
seen, the device clock. - A time that is missing, invalid or far in the future (
sanitizeBlockTime) counts as now. An
older message announced late does not replace a newer one. recount()uses the same live-session gate aspoll().- The channel re-polls when the session locks or unlocks.
- A hidden tab polls about every
HIDDEN_POLL_MS(60 s). Each poll recounts, which also drops an
expired push.
- A pending push is
- The read ack of a fast copy (migration v74). The chat handler stores each message's signed
time inchat_messages.sent_at: the expiration less the client's 60 s lead, capped at the block
time. It usessentAtFromExpiry, the rule the fast path dates its copy with, now in
indexer/chatSentAt.tsand re-exported bychatFastFederation.ts. Rows indexed before v74, and
messages applied without their transaction, keepNULL./v1/chat-read-stategives a thread's ack as a message's block time when all of these hold:- a message of the thread was signed at exactly the ack's time and landed within 75 s of it;
- no message of the thread has the ack's time as its block time;
- no other message of the peer's landed between the ack and that message's block signed at or
after the ack, or at an unknown time.
- The second condition matters because the signed time is a head block's time, so an ack of an
earlier message's row can carry the same instant. - The third matters because a message can miss a block and land with the peer's next message,
which the reader has not seen. The rule is never to hide a message to cure a phantom. - The earliest such message is the one read. Legacy peer-wide acks (
'*') are left alone. - Every lookup uses
chat_pair_idx. - The mapping applies to acks sent on chain (the thread view's). The relay's offline notices
still read the raw ack.
- The fast-copy cover (
readState.noteThreadActivity) now ends on a push of the SAME time as
the message read. Every push carries its time now, and one at the read message's time may be
another message signed in the same head block. Keeping the cover would hide that message on this
device for good; ending it can show the read message as unread until the mapped ack arrives.
fastCopyAck.test.tspins both sides. - "Mark all read" acks a pushed-only thread at the message's own time when its push carried
one, with this device's fast-copy cover, as the thread view does. It skips threads the badge does
not count (archived, hidden, blocked), so it never moves their cursor back. The inbox's
placeholder cards do the same (timedAt).listFastPendingsays whether its time istimed, and
ackThreadReadtakes afastCopyflag. Like the rest of "Mark all read", these are acks on this
device only, and the cover is in memory. - Tests.
chatUnread.test.tshas 18 new tests: a read on another device, before and after the durable
row lands; a hidden tab learning of it; a hidden tab dropping an expired push; an unread
control; a locked tab; two messages in a row; an older message announced late; a push
delivered hours late; a device clock running fast; far-future and invalid times; a push before
the first poll answers; the inbox card's verdict in the same cases; and "Mark all read" on a
pushed-only thread, an archived one, and one read further already.test/integration/chat-read-fast-copy.test.tsis new (10 tests, real Postgres).fastCopyAck.test.ts: a push of the same time now ends the cover, one of an older time keeps
it.ackWiring.test.tspins that a placeholder card'stimedAtcomes from a timed push only.test/handlers/chat.test.tshas 2 more, onsent_at.chatThread.test.tsis new.globalChatActivityStream.test.tsdelivers a service-worker message.chatActivityStream.test.tsrequires the live ping's time.- Each part of the fix, undone on its own, fails a test or a smoke: 31 mutations. The one
exception is the inbox card's own reconcile, which is written as the badge's is; no sequence
of reads makes the two differ.
- Smokes.
fastchat-instance-matrix-smokenow tells a replay by its coming beforeready, and requires a
numericat.fast-badge-push-contract-smokeandchat-fast-notification-smokefollow the service worker's
message intochatPushTabMessage.chat-bg-notify-v148-smokeacceptspollNow().schema-migration-coverage-smokepins schema head 74.
For monitoring scripts: changed JSON
- The
chat_activityevent of/v1/chat-activity/:account/streamcarries the message's time in
at(milliseconds) on a live ping too; it wasnullthere before. /v1/chat-read-state/:accountmay give a thread'slast_read_atup to 75 seconds later than the
ack written on chain: the block time of the message whose fast copy the ack read.
Downloads
-
Source code (ZIP)
1 download
-
Source code (TAR.GZ)
3 downloads
- A message you read on your phone or in another tab stayed counted. A new message lights
-
Morphit v1.24.0
StableAll checks were successfulmorphit-ci / Supply-chain audit gate (every advisory triaged, none fixable in range) (push) Successful in 1m1smorphit-ci / TypeScript typecheck (sweep all workspaces) (push) Successful in 1m27smorphit-ci / apps/web svelte-check (svelte-kit sync + svelte-aware tsc) (push) Successful in 55smorphit-ci / Integration tests (real Postgres 16) (push) Successful in 8m20smorphit-ci / ansible-lint (playbook quality gate) (push) Successful in 55smorphit-ci / Smoke suite (run-smokes.sh, pulses 1–2 of 3) (push) Successful in 1h13m55smorphit-ci / Smoke suite (run-smokes.sh, pulse 3 of 3) (push) Successful in 37m37smorphit-release / Build + publish release tarball (push) Successful in 51m11sreleased this
2026-11-10 16:03:06 +00:00 | 4 commits to main since this releaseMorphit v1.24.0
Three new coins: Hive (HIVE), Steem (STEEM) and BitShares (BTS), with HIVE and STEEM
payments checked live in the chat. And BLURT's price now comes from the Cexius exchange as well as
from Blurt's own price service.This release contains everything in v1.23.5. The deadline v1.23.5 set still stands: every site must
run v1.23.5 or later (so this release is fine) before 2026-11-22 00:00 UTC.For people using the site
You can buy and sell HIVE, STEEM and BTS. They are trade-only, like every coin added after BLURT,
BTC and XMR: you can trade them, but listing fees are still paid in BLURT, BTC or XMR.These three chains are cousins of Blurt, and four things about them matter when you trade:
- The address is the account name (like
alice), as on Blurt. The same name can belong to
someone else on Blurt, Hive, Steem or BitShares, so the chat card always names the coin. - Pay with the trade's memo. The account is the same in every trade, so when a seller shares
it, the chat adds a short random memo for that trade (as it does for BLURT), and the buyer puts it
on the transfer. That is what ties the payment to the trade. - Share your own account, never an exchange's. An exchange credits a deposit only by its own
memo, and the trade's memo takes its place. The chat card, the FAQ and the order form say so. - Send the coin itself. Liquid HIVE or STEEM, not HIVE Power, Steem Power, HBD or SBD; BTS
itself, not bitUSD or another BitShares token.
HIVE and STEEM payments are checked in the chat, as BTC and XMR payments are. When the buyer
records the payment with its transaction id, the seller's screen shows it arriving and how deep it
is: it must reach the account shared in the chat, with the trade's memo and the amount asked, in a
block newer than the account share. A payment into that account without the memo, such as someone
else's, is shown as not this trade's. Blocks come every 3 seconds, so the chat asks every few seconds; a payment counts as
confirmed only once its block can no longer be undone (a few seconds on Hive, about a minute on
Steem), and only then does the chat offer to send the other side. A BTS payment is not checked: the
seller checks in his wallet that it carries the trade's memo. The FAQ entries say so for each coin, and the Hive and Steem privacy guides
say that the site's server (never the browser) asks those chains' public nodes about the
transaction. The FAQ's tip on reaching other coin communities names Hive, Steem and BitShares too.In a coin-for-coin trade, a seller paid in one of these coins can give the same account again (for
other coins the site asks for an address never shared before, since a payment to an old address
cannot be told apart from an earlier one). For HIVE and STEEM the window says the chat checks the
payment by its transaction id and memo; for BTS it says to check in the wallet that the payment came
in now, with the memo and the amount asked. A buyer sharing his own account to receive is not shown
these seller notes.Transaction links open hivescan.info for Hive (run by Hive's core developers), steemscan.com for
Steem and bitshareschain.com for BitShares. No Tor or I2P explorer of these chains is known, so a
page opened over Tor or I2P shows no link for them. The amount jitter adds up to 0.099 HIVE or
STEEM, and up to 0.00999 BTS. Each coin has a FAQ entry and a privacy guide in all 10 languages. An order in another coin
can also name Hive, Steem or BitShares as a way to pay. Hive and Steem account names are checked by
the chains' own rule (each part between dots has at least 3 characters).
Their dollar values come from CoinGecko and CryptoCompare, so a site reached only over Tor and I2P
shows them without one.BLURT's price. It used to come from api.blurt.blog alone whenever that answered. Now the site
also asks the Cexius exchange, which trades BLURT for USDT, and uses the average of the two (either
one alone when the other is down, and api.blurt.blog's alone when the two are more than 50% apart,
so one odd trade on a small market cannot move it). The FAQ "Where does the BLURT price come from?" says so. The
price only shapes the BLURT fee quote and the dollar figures: every site still checks fees against
the minimum set on the Blurt chain.For operators
Upgrade as usual. The three coins are on by default; to hide them on your site, add them to
MORPHIT_INDEXER_DISABLED_ASSETS(for example"HIVE,STEEM,BTS"). Their explorer links can be
changed withMORPHIT_FRONTEND_HIVE_CHAT_LINK_URL,MORPHIT_FRONTEND_STEEM_CHAT_LINK_URLand
MORPHIT_FRONTEND_BTS_CHAT_LINK_URL(point each only at an explorer of that chain: the three share
Blurt's transaction-id format);morphit-ops initasks for them with the other explorers.Until a site upgrades, it does not show HIVE, STEEM or BTS orders, and its chat shows such an
address message as plain text. When it upgrades, its indexer picks up the orders it refused, as it
did for eCash (ECX) in v1.22.0. So upgrade before these orders appear; then announce the coins.HIVE and STEEM payment checks. Your indexer answers the chat's payment check for these two coins
by asking their public API nodes:MORPHIT_INDEXER_HIVE_PAYMENT_NODES(five HAfAH services, plain
GET) andMORPHIT_INDEXER_STEEM_PAYMENT_NODES(five JSON-RPC nodes);docs/OPERATIONS.mdlists
the defaults. Two operators must agree. If you firewall the indexer's outbound traffic, allow those
hosts; set one empty to turn that coin's check off. A site reached only over Tor and I2P asks none of
them (no hidden Hive or Steem node is known): there the chat says after a few minutes that it can't
check the payment, and the seller checks his wallet.Cexius. Your indexer now asks
https://cexius.com/api/v2/markets/BLURT-USDT/tickerswith
api.blurt.blogevery price cycle (USD sites only; a site reached only over Tor and I2P asks
neither). To leave Cexius out, setMORPHIT_INDEXER_CEXIUS_BASE_URL=(empty) in the indexer's env
file. If you firewall the indexer's outbound traffic, allowcexius.com.morphit-ops health
shows BLURT's source asprimary_avgwhile both answer, and each one's own price on its own line;
two markets a few percent apart is normal, so that shows no warning. When the two are more than 50%
apart, api.blurt.blog's price is used alone (blurt_price_feed).The cross-source disagreement monitor (defense C, advisory only) now compares the native price
against a price from these primary sources and from the BTC/XMR pricenodes too. Before, it compared
only while the aggregator median was serving, which on a healthy node was almost never, so it could
not see anything.New signups can no longer take the account name
bitshares(hiveandsteemwere already
protected).For developers
- ADR-0054 records the decisions, with the facts checked in each chain's code (account-name rules,
decimals) and on the explorers named, and the owner's survey of BitShares markets and explorers. - The registry has HIVE and STEEM (3 decimals, Blurt's account-name shape) and BTS (5 decimals,
bitshares-core'sis_valid_name: 1-63 characters), eachtransparent,account-reuse,
trade-only.address-shape-overlap-smokedocuments their overlaps: Blurt, Hive and Steem accept
the same names, and the BTS rule also accepts every all-lowercase bech32 or CashAddr string. - Hive and Steem names follow
is_valid_account_name(steemit/steem
libraries/protocol/authority.cpp, kept by Hive): parts of at least 3 between dots. The registry,
the chat validators and/v1/payment-checkuse it. - The chat:
isValidHiveSteemAccount,isValidBtsAccount, 40-hex transaction ids,
jitterHiveSteemAmountandjitterBtsAmount, and the bare account name as the payment link
(wallets agree on no payment URI). Each such address card carries
chat.address.account_coin_warning.ACCOUNT_NAME_COIN(a full map over the chat tickers) names
the coins whose address is an account name; the address-share window exempts them, as it did
BLURT, from the never-shared rule of v1.21.17, and shows their invalid-name error from 3
characters on. The payload'smemo(BLURT-only before) is accepted for everyACCOUNT_NAME_COIN;
the window generates it for all four and requires it where a crypto-for-crypto seller is paid;
the card shows it as the required memo (memo_required_explainnow names the coin). COIN_QUOTE_IDShas the three (CoinGeckohive,steem,bitshares; CryptoCompareHIVE,
STEEM,BTS); they are not inPRICENODE_COINS.CompositeCachedPriceSourcetakes aprimaryBlend: sources asked together first, their plausible
answers combined withaggregateRobustand committed asprimary_avg(or under the one that
answered);primaryUpstreamskeep their one-by-one order after it. BLURT's blend is
blurt_price_feedandcexius(cexiusFetcher.ts: the market'slastprice, only from a ticker
that names the market asked for and quotes USDT). Answers more thanBLEND_MAX_SPREAD(50%)
apart are not averaged: the first source in the list is committed alone. A hidden-only node does
not use the blend.fee/grapheneTxCheck.ts: the HIVE / STEEM payment lookup behind/v1/payment-check. Hive over
HAfAH (/transactions/<id>,/headblock,/sync-status), Steem over condenser JSON-RPC
(get_transaction,get_dynamic_global_properties,get_block_header);EndpointPool.quorumCall
over operators, the quorum lowered by URLs, never by operators; onlytransferoperations to the
account in the coin itself carrying the ask'smemo(otherMemo/memo_mismatchfor one
without it); the depth counted to 3 only from an irreversible block. A node that cannot be
reached, is too slow (the answer is read in full within the timeout) or answers 408 / 429 / 5xx
throwsTRANSPORT_FAILURE/HTTP <status>, so the pool cools it; "not found" is an agreed value
that ends the round; HAfAH is asked for the head and the irreversible block only when it has the
transaction. The web watcher sends the ask's memo, marks a HIVE / STEEM payment short of that
depthpending(verdictchecking), an ask without a memounbound(verdictunasked) and a
transfer without itwrongMemo(chat.payment_check.wrong_memo); it asks every 6 s, and after 3
minutes of "not found" (5 for BTC / XMR) lets the seller settle it from his wallet. The
address-share window showschat.address.reuse_account_checked_body(HIVE / STEEM) or
reuse_account_body(BTS) only where a crypto-for-crypto seller is paid.- The coin pickers showed "Hive (HIVE) (HIVE)", and since v1.21 / v1.22 "Ripple (XRP) (XRP)" and
"eCash (ECX) (ECX)": those display names no longer carry the ticker the pickers add, and
asset-select-coverage-smokechecks it. price-primary-fallback-smokenow runs the real factory against stubbed price hosts and checks
the precedence; it used to match the factory's source text.- New tests:
apps/web/src/lib/chat/grapheneCoins.test.ts(13),
apps/web/src/lib/components/chatMessageGraphene.test.ts(4),
apps/web/src/lib/components/AddressShareModal.account.test.ts(7),
apps/indexer/test/indexer/price/cexiusBlend.test.ts(13),
apps/indexer/test/indexer/fee/grapheneTxCheck.test.ts(28);paymentChecks.test.tshas 8 more
andConversationView.auditFlows.test.tstwo (a HIVE payment through the chat, with someone
else's payment cited; a BTS payment settled from the wallet); the round-trip and hidden-explorer
tests cover the three coins.
For monitoring scripts: changed JSON
GET /v1/instancechat_link_urlsgainshive,steemandbts(a template, ornullfor the
bundled default).- Orders, the orderbook and RSS can carry
"asset": "HIVE","STEEM"or"BTS"; a barter
listing'saccepted_assetscan include them. GET /v1/payment-checktakesasset=hive|steemwith a 40-hextxid, the account name as
addressand the ask'smemo; itsassetcan behiveorsteem, and afoundanswer can
carrymemo_mismatch: true.- An order's
payment_methodscan includepay_hive,pay_steemandpay_bts. GET /v1/listing-feeasset_prices_usdcan includeHIVE,STEEMandBTS.- The BLURT price's
source(the verbose health endpoint'sdiagnostics.price, andmorphit-ops health --json) can beprimary_avgorcexius, besidesblurt_price_feed.
Downloads
-
Source code (ZIP)
2 downloads
-
Source code (TAR.GZ)
4 downloads
- The address is the account name (like
-
Morphit v1.23.5
StableAll checks were successfulmorphit-ci / Supply-chain audit gate (every advisory triaged, none fixable in range) (push) Successful in 1m0smorphit-ci / TypeScript typecheck (sweep all workspaces) (push) Successful in 1m20smorphit-ci / apps/web svelte-check (svelte-kit sync + svelte-aware tsc) (push) Successful in 51smorphit-ci / Integration tests (real Postgres 16) (push) Successful in 8m34smorphit-ci / ansible-lint (playbook quality gate) (push) Successful in 49smorphit-ci / Smoke suite (run-smokes.sh, pulses 1–2 of 3) (push) Successful in 1h12m59smorphit-ci / Smoke suite (run-smokes.sh, pulse 3 of 3) (push) Successful in 38m10smorphit-release / Build + publish release tarball (push) Successful in 50m1sreleased this
2026-11-09 19:27:09 +00:00 | 5 commits to main since this releaseMorphit v1.23.5
Trading with the same person again now builds your reputation, a branded site's links show its
own name, and Vigilante Trading's logo can be bigger.v1.23.4 was tagged but never published on chain, so no site installed it. This release contains
everything in it: see RELEASE-NOTES-v1.23.4.md.For people using the site
Trading again with the same person counts. Until now, only the latest review from a person
counted toward your rating, however many times you two traded. Now each earlier trade with them
counts too, at half the weight of a new partner. It counts when the trade is proven: you reviewed
each other for that order within a week of it being completed, its owner marked it completed
naming the other, and its listing fee was paid in BLURT (or it was a free first buy; a BTC or XMR
fee is checked by each site at its own pace, so it cannot prove a trade the same way everywhere).
And the trades that count are at least 3 days apart. Nobody has to type anything
for this: it follows from the two reviews and the completion. So when a trade goes well, review
your partner back. The reminder to review back now also shows for a review that does not count
yet, since reviewing back is what makes it count.A pile of reviews from one side still counts once: someone who reviews you again and again, on
order after order, without you reviewing them back, still counts only with their latest review.Two people who trade with each other often are no longer flagged as a review ring for it.
Links to a branded site show its name. A link to vigilante.trading sent in a text message or a
chat app showed "Morphit — No-KYC P2P Marketplace…" as its title. The bare address, and links to a
profile, an order or a chat, now show the site's own name and its preview picture, as its other
pages already did.For operators
Upgrade before 2026-11-22 00:00 UTC. From that time (by block timestamp) the review and
partner-name check stops treating a proven repeat trade as ring evidence: an indexer still on an
older release would refuse reviews the others accept and disagree with them from then on. A
snapshot from an older release, exported on or after that time, is refused on restore, and an
indexer that an older release ran past that time does not start on v1.23.5 (its log says
repeat_trades_gap;docs/UPGRADING.mdhas the two ways on).- The upgrade (database schema v73) adds the new columns. Then, at every start, before it applies
a block, the indexer records when each order's partner was named where that is missing (from
the completion ops it holds:order_naming_times_setin the log), which order admitted each
review that has none recorded (review_order_accounts_set), and what each review weighs
(review_weights_worked_out); at the first start, and after an older version has applied
blocks, it also re-checks the review-ring flags a proven trade could make wrong
(review_signals_redone). All of it reads only what your indexer already holds and gives
the same result as indexing afresh; until the first start finishes, ratings count each
reviewer's latest review only, as before. - The web server now answers
/and the app's own pages (profiles, orders, chats) with
spa-shell.html, a copy ofindex.htmlthat branding names your site in, and falls back to
index.htmlwhen a build has none./index.htmlitself is still served as is: visitors'
browsers check it against the on-chain record, and now also check thatspa-shell.htmlloads and
runs exactly whatindex.htmldoes. A BunkerWeb box gets the new web server config
with the upgrade, and the upgrade switches a hand-copied bare-metalweb.conftoo. - A bigger logo for a logo that reads small:
sudo morphit-ops branding apply --logo-size 120
shows the header and homepage logo at 120 % of the standard height (50–200;--logo-size 100
goes back). It is saved asMORPHIT_INSTANCE_LOGO_SIZEand re-applied on every upgrade. The
footer logo keeps its size. On vigilante.trading, run that once after this upgrade (120 is
what we recommend there; Morphit's own sites need nothing).
For developers
- Repeat trades (
indexer/reputation/repeatTrades.ts):- Proven (
provenTradeSql): the other party reviewed back citing the same permlink, both
reviews were admitted by the same order (feedback.order_account), that order was completed
naming the other, and both reviews fall within 168 hours of itscompleted_at. The recorded
order is the citation rule's first choice among the orders whose fee verdict is the same on
every node from the block that posted them (pinnableOrderSql: a BLURT fee on an order
posted from the consensus v2 activation time on, or a first-buy waiver): a BTC or XMR fee
becomes verified when each node's explorer check gets to it, and the BLURT re-check may still
raise an older order on its legacy grace whenever it runs, so either would let two nodes
record different orders. A review admitted only by such an order records
none and proves nothing (its admission is unchanged). So a fee-free order posted under the
same permlink, or an old paid order completed with someone else, proves nothing, and neither
does naming a partner on an order completed long ago (G7). Worked out fromfeedbackand
orderswhenever it is needed, never stored. WithasOf, only the back review and a partner
named (orders.counterparty_named_at, the completion time when not recorded) by then count;
withsince, only reviews stamped from then on. citationCandidatesSql(indexer/reviewCitation.ts) is the citation rule as one SQL text,
used by the handler and byhealOrderAccounts, which at every start records the admitting
order of each review from before the activation time without one, as of the review's own
time (the order completed naming the other is preferred only if it was named by then); what a
later review recorded live, none included, is final.healNamingTimesfills in
counterparty_named_atat every start, before any block (the upgrade replay included), from
the latest applied completion op naming that partner, else the completion time.feedback.review_weight: 1 for the reviewer's latest order-bound review of the subject (as
before), 0.5 for an earlier one that is proven and spaced (walking the pair's reviews in
(created_at, id) order: proven and at least 72 hours after the last spaced one, an unproven
review using up nothing) and at least 72 hours before the latest one, else 0
(pairWeights). Worked out again for both directions of a pair on each review and completion
between them (rewalkPairsOfTrade, in a savepoint) and for every review at start
(rewalkAllPairs, one read, bulk writes of what changed). Display only. The aggregates
(countedFeedbackFrom), the profile summary and lists (reviewWeightSql) and the receipt read
it; a review not worked out yet weighs by the latest-review rule (a partial index keeps that
branch free once all are worked out). The weighted rating multiplies each decay weight by the
review weight, and the composite score's count is the weight sum (feedback_weighton the
order rows; the receipt'scount_weighted, and each row'sreview_weightandproven).- Signals B and D leave a pair's proven reviews out of the pair's own count only (the
averages, the reviewer's other subjects and the totals are as before), so they only ever flag
less.reciprocityEverHeldtakesignoreProventhe same way, whichhasVerifiedChat(the
review and partner-name gate) always passes, counting as proven only trades whose two reviews
are both stamped at or afterCONSENSUS_V3_ACTIVATION_TIME(2026-11-22T00:00:00Z; each such
review recorded its order live on every node): before that time the verdict is exactly the
old one, and from then the gate accepts more, never less. The fee-attestation quorum is
unchanged. redoReviewSignals(indexer/reviewSignalsRedo.ts), when due
(indexer_state.review_signals_redo_due: the first start, and wheneverrepeatTradesGuard
finds blocks an older version applied): each Signal B flag on a pair with a proven review,
and each Signal D flag on a reviewer with one, is dropped and its detector run again at each
review time live indexing ran it, as of that time, in one transaction. That reproduces exactly what live indexing under the new rule raises, partners
named late included.checkRepeatTradesRule(indexer/repeatTradesGuard.ts, the waiver-evidence guard's
pattern):indexer_state.repeat_trades_through_blockfollows the applied block, and if an
older release applied blocks stamped at or after the activation time the indexer stops with
RepeatTradesGapError. The snapshot check refuses a pre-v73 snapshot exported at or after
that time./v1/accounts/:account/feedbackitems carrypair_flagged(the pair is flagged by the
anti-ring signals); the review-back reminder skips only those, not every review that does
not count yet.- Migration v73 adds
feedback.order_account,feedback.review_weight,
orders.counterparty_named_at,indexer_state.repeat_trades_through_blockand
review_signals_redo_due, andfeedback_weight_unworked_idx. - The FAQ (10 languages),
docs/API.md,docs/ARCHITECTURE.md,docs/OPERATIONS.mdand
docs/UPGRADING.mdsay how repeat trades count.
- Proven (
- The brandable app shell:
scripts/build-brand-slots.mjswritesbuild/spa-shell.htmlfrom the
freshindex.html(with.gz/.br), adds the link-preview picture (og:image,
twitter:image, their alt text) after app.html's static preview tags with the build origin
taken from the prerendered pages, and records its brand, theme and origin slots like any
prerendered page. Both nginx configs:location /istry_files $uri $uri.html @spa(it had
$uri/index.html, which answered/), and@spatries/spa-shell.htmlbefore
/index.html.nginxVhostHealrewrites exactly those two lines as shipped in a bare-metal
vhost with the app's@spa, and flags them in what nginx loaded. The in-page build-integrity
check (lib/net/releaseHashCheck.ts,lib/net/shellIntegrity.ts), onceindex.htmlmatches
its signed hash, fetches/spa-shell.htmland requires it to be the signed bytes but for what
the build and branding write, where they write it: the brand attributes before the first
<html>tag's>, the first theme-color meta's colour, the naming metas' content, the
link-preview picture tags right after the first twitter:description meta (exactly as the build
writes them), and one numeric custom-property<style id="morphit-theme">right before the
first</head>. Those values hold no quote of either kind, no angle bracket and no entity but
&, and
none sits inside a script or style of the signed page, so no parser — the page's, with
scripting on, included — reads the copy differently but for them. A server without the copy
(it answers withindex.html, or 404) passes. - Logo size:
MORPHIT_INSTANCE_LOGO_SIZE(INSTANCE_ENV.LOGO_SIZE, 50–200, 100 is no setting),
--logo-sizeonbranding apply(and instatus), written to/brand/theme.cssas
html:root{--brand-logo-scale:…}.MorphitLogoBlingmultiplies the header logo's height by it
(not the footer's, not an explicitwordmarkSrc); the homepage hero's height classes carry the
same factor. - Tests: on real Postgres,
repeat-trades(24: the weights on the profile, the receipt and the
orderbook card; the 7-day window each way; old orders named late; the 72 hours; an unproven
review in between; a late review back; both parties owning the permlink; old paid orders
recycled through a fee-free order; the one-sided pile; Signals B and D; the flag redo, partners
named late included, and only when due; the gate before and after the activation time, across
it, and never stricter; two nodes, a BTC fee verified on one and not yet on the other; a node
that ran an older version for a while; what a review from the activation time on recorded
staying final; BLURT orders from before v2),migration-v73-upgrade(5: an upgraded node equals a
fresh one review by review, the admitting order chosen as of each review and never a BTC-fee
one, the naming times from the ops, and the latest-review rule until the start-up steps),
repeat-trades-guard(7),reputation-scale(3: both states at 50,000 reviews);
consensusActivationTime, the snapshot-manifest smoke (4 new), the review-back reminder smoke
(2 new),waiver-evidence-guard-wiring-smoke(4 new: the repeat-trade guard and the start-up
steps before any block), the feedback handler mocks. 50 mutations of the repeat-trade rules,
all caught (conditions that could never change a result were removed instead).
shellIntegrity.test.ts(60, every bypass the reviews found among them) and 17 mutations of
the shell check, all caught;branding-contract-smokeC-10d brands app.html's shell copy with
the real build and branding code and runs the browser check on it.nginx-served-hardening-smokeruns both shipped configs in a real nginx and checks/, the
app's pages and/index.htmlwith and withoutspa-shell.html(14 new);branding.test.ts
(the shell copy, the logo size,--logo-size),nginxVhostHeal.test.ts,
branding-contract-smokeC-10,MorphitLogoBling.test.ts; 15 mutations, all caught. Checked
end to end: the build branded as Vigilante Trading with its own origin, served by the shipped
frontend nginx config, answers/with "Vigilante Trading — No-KYC P2P Marketplace…" and its
own preview picture while/index.htmlis unchanged; in a browser the bare address goes on
to the homepage and a profile page loads, without errors, on a desktop and a phone; at 120 %
the header logo is 38.4 px and the homepage logo 115.2 px (52.8 px on a phone), the footer
40 px; an unbranded build keeps 32, 96 and 40. - CI: the smoke pulses now start after the integration tests (
needs: integrationinci.yml).
The runner runs two jobs at a time, and beside a smoke pulse it ran the quorum read-ahead test
nine times slower than a quiet machine, failing its wall-clock bound.
chat-block-quorum-prefetch.test.tsalso simulates 300 ms quorum reads instead of 100 ms, so
the gap it measures (9 s one read after another against about 1.2 s eight at a time) outweighs
the machine's own time; it still fails when the reads go one at a time. - CI and installs:
scripts/fetch-matrix-bot-natives.mjstries a GitHub download again after a
server error, a 429 or a dropped connection (after 5, 15, 30 and 60 s) instead of failing on
the first: a 504 from GitHub failed CI. Any other answer is still final, and every download is
still checked against its pinned SHA-256. - Test fix:
certbot-monitor-renewal-due-smoke's certificate-age cases sat within a second of a
whole day of age (Let's Encrypt's 90 days less a second), so the age read 83 or 84 days by
whether the clock ticked mid-check, and it failed on a loaded machine. They are now an hour off
the boundary, and still fail when the monitor's stall comparison is off by one. - Performance: with each review's weight stored, the orderbook's rating aggregate over 300,000
reviews takes about 90 ms (about 400 ms in v1.23.4); right after the upgrade, before the
start-up walk, about 230 ms. That start-up work over 300,000 reviews takes about 20 s the
first time and about 2 s at each later start;reputation-scaleholds a page under its 600 ms
bound at 50,000 reviews in both states.
Downloads
-
Source code (ZIP)
4 downloads
-
Source code (TAR.GZ)
6 downloads
- The upgrade (database schema v73) adds the new columns. Then, at every start, before it applies
-
Morphit v1.23.4
StableAll checks were successfulmorphit-ci / Supply-chain audit gate (every advisory triaged, none fixable in range) (push) Successful in 1m4smorphit-ci / TypeScript typecheck (sweep all workspaces) (push) Successful in 1m26smorphit-ci / apps/web svelte-check (svelte-kit sync + svelte-aware tsc) (push) Successful in 54smorphit-ci / Integration tests (real Postgres 16) (push) Successful in 8m2smorphit-ci / ansible-lint (playbook quality gate) (push) Successful in 51smorphit-ci / Smoke suite (run-smokes.sh, pulses 1–2 of 3) (push) Successful in 1h12m54smorphit-ci / Smoke suite (run-smokes.sh, pulse 3 of 3) (push) Successful in 38m31smorphit-release / Build + publish release tarball (push) Successful in 50m9sreleased this
2026-11-08 17:32:53 +00:00 | 7 commits to main since this releaseMorphit v1.23.4
The chat keeps up with your wallet, and a few rough edges from a live trade are smoothed out.
For people using the site
"Share a receiving address" points at the address field. The border of the address field
glows three times, the same pulse as your instance's card on the Instances page when you
arrive from the footer's Contact link. Your eye goes straight to where you paste your address.
It stops as soon as you type, paste or click there, and it never glows around an address shown
in red as wrong.It glows when the field is on screen. For most coins that's as the window opens. For USDT,
USDC and DAI, the warning and the network choice come first, above the field, on purpose: you
read the one and pick the other before you paste an address. On a small screen the field is
further down there, and it glows once you scroll to it. Pick another coin before typing, and it
glows again for that one.If your device asks for reduced motion, it doesn't glow.
"Share your … address" goes away once you've shared it. The button disappears the moment your
address is in the chat, instead of waiting for the payment. A small "Share a different address"
stays in its place, for another of the coins you accept or to fix a typo.Confirmations keep up with your wallet. While a payment is confirming, the chat checks it
every 15 seconds instead of once a minute, and your instance brings the new count back on the same
check, as soon as the explorers it asks have seen the block. (A payment still unconfirmed after
half an hour goes back to once a minute until its first confirmation.)"Verify on block explorer" opens in a new tab, and finds a fresh payment. Right after a
BLURT payment, some Blurt nodes don't know the transaction yet; the explorer now looks for it in
the block the receipt names, so it's found at once.The avatar badge clears. Clicking Orders or Feedback under Notifications clears that count.
Opening the page a notification points to (the chat about an order, or My orders) clears it too,
and while My orders is open its order and feedback counts stay cleared. A tab in the background
still counts.A new order slides into the orderbook. When an order is posted while you're looking at the
orderbook, its card slides down into place over a second, and the cards below glide down to make
room. It used to blink twice and pop in. With reduced motion, it simply appears.Type /about to get to "About this instance".
/about(and/en/about,/es/aboutand so
on) now opens the About this instance page in your language, instead of "page not found".For operators
Upgrade as usual. Nothing to configure.
GET /v1/chain/tx/:id?block=N(optional): when a node's transaction index does not hold the
transaction (not yet, or never), it is read from block N: oneget_blockmore, only then. An
unreadable block answers 502 ("could not check"), never 404.GET /v1/payment-check: a confirming answer is reused 15 s (was 30), and a request holding a
stale answer waits up to 3 s for the re-check. Explorers are asked about a confirming payment at
most every 15 s per instance.- The TLS certificate alert no longer goes off at 30 days left. certbot renews a 90-day
certificate by itself once fewer than 30 days are left (its timer tries twice a day), so that
warning came the day before certbot was due, on every certificate, every time; and its "last
successful renewal 999 days ago" was wrong too (certbot starts its log afresh on every run). It
now warns only when a renewal is a week overdue (23 days left on a 90-day certificate), with the
certificate's real age, and is critical at 7 days left — and, whatever the settings, with a day
left and once expired.MORPHIT_CERTBOT_RENEWAL_GRACE_DAYS(7) sets that week; a
MORPHIT_CERTBOT_EXPIRY_WARN_DAYSat or above that point is ignored. To see for yourself that a
box renews:sudo certbot renew --dry-run.
For developers
AddressShareModal: the address input (data-testid="address-share-address") gets
flash-address, the Instances page'sflash-instance-borderpulse copied into the
component (2 s,ease-in-out, 3 times, brand emerald), forADDRESS_FLASH_MS= 6,200 ms.
It starts once 90 % of the field is on screen (IntersectionObserver, thresholds 0 and 0.9;
where there is none, at once). A change of coin arms it again until something has been
typed;inputends it for good,focusends it (review: the pulse hid the focus ring),
and it is not shown while the address is invalid. The Instances page's own flash is
unchanged.$i18n/pageAliases.ts(new):PAGE_ALIASES(about→about-this-instance) and
resolvePageAlias.routes/[lang]/+layout.tsresolves it in its locale redirect, so
/aboutis one hop to/<locale>/about-this-instance(query and fragment kept).
routes/[lang]/about/+page.ts(new) forwards/<lang>/aboutwith a 301, prerendered for
every locale as SvelteKit's forwarding page (script and meta refresh, so it works without
JavaScript too). That page's target is fixed:/<lang>/about?x#yloaded straight from the
server lands without the?x#y(review: accepted; inside the app, and for bare/about, they
are kept).- Share buttons:
twoLegButtonshidessharePaymentAddressonce his address for a payment coin
is in the thread (back forno_address) andshareAssetAddressonce his asset address is;
the one-coin button usesiSharedAddressover the thread (pending counts, failed does not).
Review: a small "Share a different address" (shareAgain,showShareAddressAgain,
chat.address.share_anotherin 10 locales) keeps another coin or a corrected address possible.
"Record shipment" now derives fromiReceiveCryptoUnpaid, not the share button. - Confirmations:
PAYMENT_CHECK_CONFIRMING_INTERVAL_MS(15 s) in the browser while seen and
under the required depth — forPAYMENT_CHECK_CONFIRMING_FAST_FOR_MS(30 min) at 0
confirmations, then from the first confirmation on (review: a low-fee payment can sit for
hours); indexerPAYMENT_CHECK_FRESH_MS.confirming15 s,PAYMENT_CHECK_STALE_WAIT_MS3 s.
The depth is still the lowest of the agreeing explorers, so one explorer that has not seen the
block yet still holds it at 0 — deliberately: one explorer must not be able to confirm alone. - Explorer:
txFromBlockinapi/chainExplorer.ts;$lib/explorer/blockNumber.ts;
morphitExplorerTxUrl(txid, block?),fetchChainTx(…, block?); the tx page reads?block=;
the receipt's link hastarget="_blank"and the receipt's block. - Orderbook:
$lib/orderbook/slideIn.ts(new) —measureTopsbefore a live order is inserted,
playSlideInafter it renders: Web Animations,NEW_ORDER_SLIDE_MS= 1,000 ms, the new card
from opacity 0 and 24 px above, every card it pushed from its old position (FLIP). The blink
was two entrances:order-slide-in(0.32 s) overrode each card'sanimate-fade-up, and
removing the class restarted the fade-up. That class, its CSS andjustArrivedare gone;
OrderCardtakesorderKey(data-order-key). Review: a second order while the first still
slid made the cards it pushed jump (the new glide replaced the running one); the pushes now
usecomposite: 'add', so they add up. Tests:slideIn.test.ts(5), 7 mutations.
Replayed in a browser against the production build with a stream pushing a new order: before,
the new card's opacity went 0 → 0.97 → 0.18 → 1 and the next card jumped 205 px at once; after,
one entrance over ~1.07 s and the next card gliding the 205 px; reduced motion on a phone: in
place at once, no errors. - Certificate monitor (
ops/scripts/morphit-certbot-monitor.sh): the age and expiry come from
the certificate (notBefore, notAfter; the lifetime rounded to whole days, as Let's Encrypt's
is 90 days less a second), notletsencrypt.log(certbot'slog.pyrolls it over on every
run). The renewal point is the renewal file'srenew_before_expiry(N, or days, weeks or
months; quoted or not; above the first section, as certbot reads it), else the earlier of
certbot 2.x's 30 days and certbot 4+'s third of the lifetime (half under 10 days).
cert_expiry_warnfires at the renewal point minus the grace (at most half the window, at
least a day); the critical events at the critical days, capped at the warning point, and
always with a day left (certificates of 3 weeks or more) and once expired. Thresholds are
plain whole numbers: leading zeros are dropped (dash reads08as bad octal, which stopped the
check or broke the alert's JSON), anything else falls back to its default. Payload:
issued_days_ago,renew_due_days_leftandoverdue_daysreplace
last_renewal_success_age_days; the bot's text follows (and namescertbot.service, not the
snap's unit). Tests:certbot-monitor-renewal-due-smoke(49) runs the real script under dash
on certificates issued with exact dates (openssl ca -selfsign), through a certificate's life
and with each setting, and renders each alert through the classifier; the v1.23.3 script fails
17 checks before its invalid JSON stops the run; 26 mutations, all caught. Checked against the
certbot 2.9.0 (Ubuntu 24.04) and 5.9.0 sources. An independent review found 2 medium (a
leading zero stopped the check or broke the JSON; no grace on the critical events and no floor
at expiry) and 3 low (certbot 2.9's fixed 30 days and the 90-days-less-a-second lifetime; the
forms ofrenew_before_expiry; test gaps), all fixed as above. - Notifications:
keepReadWhileShown(['order', 'feedback'])on My orders (visible only);
AvatarMenu.openCategory(path, category)marks the category read; review: each counted order
or feedback notification remembers its link, andmarkSeenAt(the[lang]layout, on each
page and when the tab comes back into view) reads those pointing to the page shown
(pageKey: no query, fragment or locale). - Tests:
AddressShareModal.flash.test.ts(13) andpageAliases.test.ts(4), each rule
removed once to see a test fail (24 mutations); for the rest,cryptoLegs.test.ts,
ConversationView.auditFlows.test.ts(3 new),paymentChecks.test.ts,
paymentCheck.test.ts,chainTxLookup.test.ts(7 new),chainExplorer.test.ts,
blockNumber.test.ts,chatMessageVerify.test.ts,keepReadWhileShown.test.ts,
AvatarMenu.notifications.test.ts— each rule removed once to see a test fail. Checked in a
browser:- the flash, phone and desktop, light and dark: on screen as the modal opens for every coin
but USDT, USDC and DAI, three pulses gone by 6.3 s, a paste ends it, reduced motion shows
none, the stablecoins glow once scrolled to; /about, against the production build served the way nginx serves it, with its CSP: bare
(an English and a Spanish browser), with a query and fragment, with a trailing slash,
/en/,/es/and/zh-CN/about, and/en/aboutwith JavaScript off./faqand an
unknown/aboutxare unchanged.
- the flash, phone and desktop, light and dark: on screen as the modal opens for every coin
- Independent reviews before release. The address-field flash: 2 medium (a coin changed inside
the modal never got its flash; the observer's threshold was untested) and 4 low, all fixed as
above. The live-trade fixes: 1 medium (no way to share a second or corrected address) and
low ones (404 for an unreadable block; quick polling of a stuck payment; an order
notification's chat not clearing it), fixed as above. The whole release, the orderbook slide-in
above all: no high or medium; 3 low (the slide-in's second order; a smoke check that no longer
pinned the explorer link's return;/<lang>/aboutloaded straight from the server dropping its
query), the first two fixed, the third written down. - Not in this release: counting every repeat trade between the same two people toward their
ratings (owner's request after the live trade). Three independent reviews found ways to fake a
repeat trade with each rule tried, and two of the anti-ring signals (B, D) would undo honest
repeat trades anyway. The owner chose to ship these fixes first; the rule comes in its own
release, designed with the cited order's owner recorded on each review, a few days' spacing,
the signals aware of proven trades, and repeat trades weighted less than new partners. Ratings
are unchanged in v1.23.4: only a reviewer's latest review of a trader counts.
Downloads
-
Source code (ZIP)
5 downloads
-
Source code (TAR.GZ)
5 downloads
-
Morphit v1.23.3
StableAll checks were successfulmorphit-ci / Supply-chain audit gate (every advisory triaged, none fixable in range) (push) Successful in 1m5smorphit-ci / TypeScript typecheck (sweep all workspaces) (push) Successful in 1m28smorphit-ci / apps/web svelte-check (svelte-kit sync + svelte-aware tsc) (push) Successful in 55smorphit-ci / Integration tests (real Postgres 16) (push) Successful in 7m38smorphit-ci / ansible-lint (playbook quality gate) (push) Successful in 46smorphit-ci / Smoke suite (run-smokes.sh, pulses 1–2 of 3) (push) Successful in 1h9m34smorphit-ci / Smoke suite (run-smokes.sh, pulse 3 of 3) (push) Successful in 36m24smorphit-release / Build + publish release tarball (push) Successful in 47m35sreleased this
2026-11-07 18:28:21 +00:00 | 8 commits to main since this releaseMorphit v1.23.3
Profile pictures across the whole site.
For people using the site
One picture per person, everywhere. Wherever the site shows someone — their profile
page, the explorer, the orderbook, chat, payment badges, reviews and feedback, your orders,
the Blurt Nodes page, the avatar menu — it shows, in this order:- the Morphit avatar they set in Settings. It is on chain, so it shows on every Morphit
instance, and it always wins; - else their Blurt profile picture — once you have turned pictures on;
- else their identicon, as before.
While the site is still finding out which one to show, it shows a quiet circle — never one
picture and then another.Blurt pictures are off until you turn them on. Click display on the Blurt Nodes page,
or tick Show Blurt profile pictures in Settings → Profile pictures. Either one turns them on
across the whole site, in every tab, and this browser remembers it; hide (or the same
switch) turns them off again.Still private. Your browser never fetches a picture from the site that hosts it: your
Morphit instance fetches it and shows it to you, so those sites never see you. The private
list of accounts you hid (Settings) never asks for pictures at all. Tor-only instances don't
fetch Blurt pictures and offer no switch; Morphit avatars show there as everywhere.A few places that showed only the identicon — payment badges in chat, the leave-feedback
reminder, the peers under each of your orders, your blocked accounts in Settings — now show
the person's Morphit avatar too.For operators
Upgrade as usual. Nothing to configure. OPERATIONS.md §57.
- New
GET /v1/avatars/<account>: the account's Blurt profile picture, fetched by your
server exactly like the witnesses' pictures (the same guarded fetch, limits and Blurt image
proxy fallback); 404 for an account with a Morphit avatar (pages show that one from the
profile) or with no picture. The picture addresses are read from the chain in batches (one
get_accountsfor the accounts a page asks about at once) and kept an hour. At most 4
fetches run at once and 64 wait. Nothing is fetched while nobody looks, and nothing for
visitors who leave pictures off. - A zero-clearnet instance never fetches Blurt pictures;
/v1/instancesays
"blurt_pictures": falsethere, and the pages offer no switch. - Picture fetches now say
User-Agent: morphit-indexer/account-picture(the witnesses'
pictures said…/witness-avatar), and their log lines are underaccount-pictures:
journalctl -u morphit-indexer | grep -E 'witnesses|account-pictures'.
For developers
indexer/accountPictures.ts(new):AccountPictures— the picture fetcher, its caches,
concurrency and proxy fallback, moved out ofwitnessService.ts(which re-exports the
limits and helpers and uses the one shared instancemain.tspasses in), plus
urlOf(account)(micro-batchedget_accounts,PICTURE_URL_TTL_MS= 1 h, up to
PICTURE_URL_CACHE_MAX= 20,000 accounts, "no picture" kept too),noteUrl(fed by the
witness list's bulk read) andpictureOf(account). Bounded:AVATAR_QUEUE_MAX= 64
waiting (beyond it "nothing now", no failure noted),AVATAR_FAILED_MAX= 10,000
failures remembered. Tests:accountPictures.test.ts(10), each guard removed once to see
a test fail.api/accountPictures.ts(new):GET /v1/avatars/:who(:who, not one of the security
middleware's account parameters, so the public picture is cacheable), rate tier
account-avatar.hasMorphitAvatar(json_metadata)→ 404; a database error → 404 (never a
Blurt picture that might stand in for a Morphit avatar); picture and 404 both
public, max-age=900. The stored Morphit avatar is never served from here: raw, an SVG
skips the browser sanitizer's bounds (<use>nesting, filters, timing), and one the
sanitizer refuses must not come back through another door. Tests:
test/api/accountPictures.test.ts(6), mutation-checked./v1/instancegainsblurt_pictures(!clearnetRefused());@morphit/indexer-client
InstanceResponse.blurt_pictures?; the webinstancestore carries it (false until
loaded). Test:instanceBlurtPictures.test.ts, seen failing with the flag forced true.- Web:
stores/blurtPictures.ts(morphit.showBlurtPictures, device tier, registered — the
storage-key smoke's device-tier cap goes 10 → 11 for it; cross-tab through thestorage
event).avatar/blurtPicture.ts:blurtPicturesActive(switch on ∧ instance can),
blurtPicturesUnknown(switch on, instance not heard from yet → wait), a miss
remembered for 2 minutes.indexer/client.tsaccountPictureUrl.
indexer/profileSoon.ts: the profile reads of one moment in onegetProfilesBatch.IdentityLabel: Morphit avatar →pending(the quiet circle; also whilehydratereads
the profile, while your own profile is not read yet, and while pictures are on but
unknown) → the Blurt picture → the identicon. New propshydrate(read the Morphit
avatar here; used byPaymentStatusBadge,PendingFeedbackReminderBanner, my orders'
peers and Settings' blocked list) andnoPicture(Settings' hidden list, which must not
reach the operator).ChatMessagepassespendingwhile the peer's profile is read.AvatarMenu, the profile page's hero and the explorer account header: the same order,
waiting for the account's profile and the instance's answer.- The witnesses page: its "display" is the shared switch; its witnesses' Morphit avatars
are read in one batch and always shown; Blurt pictures only once that batch has
answered (review: before it, a Morphit avatar was preceded by the Blurt picture);
non-producing witnesses get theirs from/v1/avatars; a broken Morphit avatar falls
back. - Settings: a "Profile pictures" card (signed in; only when the instance can), badge
"only this device". Stringssettings.blurt_pictures.*in the 10 locales. - Tests:
IdentityLabel.blurtPicture.test.ts(10) andprofileSoon.test.ts(2), the new
rules mutation-checked. Checked in a browser against a stubbed instance: the witnesses
page (Morphit avatar shown with pictures off and first when on — with the profile batch
held back, no Blurt picture is drawn first; the check saw the swap without the fix),
the profile hero (off: identicon; on: the picture, the identicon on a 404, the Morphit
avatar first) and the switch following across tabs. The Settings card, shown only when
signed in, by the type check.
- Independent review before release: 1 high, 5 medium, 6 low, all fixed as above.
- Tests: the
vitest-must-passsmoke reads up to 32 MiB of a suite's output
(MORPHIT_VITEST_OUTPUT_MAX_BYTES; Node's default was 1 MiB, and the indexer's passing
suite, at 1.03 MiB, read as "could not parse") and names an overflow as one. The failure-cap
test keeps its ten thousand log lines instead of printing them, and checks each was logged.
settings-visibility-scopesmoke: the Profile pictures card, "only this device".
Downloads
-
Source code (ZIP)
4 downloads
-
Source code (TAR.GZ)
5 downloads
- the Morphit avatar they set in Settings. It is on chain, so it shows on every Morphit
-
Morphit v1.23.2
StableAll checks were successfulmorphit-ci / Supply-chain audit gate (every advisory triaged, none fixable in range) (push) Successful in 1m5smorphit-ci / TypeScript typecheck (sweep all workspaces) (push) Successful in 1m42smorphit-ci / apps/web svelte-check (svelte-kit sync + svelte-aware tsc) (push) Successful in 52smorphit-ci / Integration tests (real Postgres 16) (push) Successful in 7m24smorphit-ci / ansible-lint (playbook quality gate) (push) Successful in 46smorphit-ci / Smoke suite (run-smokes.sh, pulses 1–2 of 3) (push) Successful in 1h12m57smorphit-ci / Smoke suite (run-smokes.sh, pulse 3 of 3) (push) Successful in 43m29smorphit-release / Build + publish release tarball (push) Successful in 49m58sreleased this
2026-11-07 02:29:23 +00:00 | 9 commits to main since this releaseMorphit v1.23.2
v1.23.1 was never released: everything in its notes ships here (the Blurt Nodes table's
heading row that stays in view, and witnesses' pictures from the Blurt image proxy), together
with a round of trade-chat fixes asked for after a real trade.For people using the site
In a trade chat
Amounts are filled in, with what they are worth. "Send BLURT" opens with the amount
already there and its value beside it —2752.096 BLURT (≈11 BRL)— and the value follows
what you type. Before, after a chat had been open a while the window could open with 0.000:
the price it used had gone stale. It now fetches a fresh price as the window opens (for
market-price orders; it never waits more than a moment on a slow connection — the button
shows it is busy meanwhile — and a value it cannot work out stays blank rather than guessed).
When the other side has shared the Blurt account they want to be paid on, with an amount,
"Send BLURT" pays exactly that: their account, their amount and their memo, which is what
both screens check the payment against.Sharing an address is quicker. In "Share address":
- the separate "For order: order-…" box is gone; that text is now the note's default, which
you can change. The note travels with the address in the chat, encrypted on the chain like
every chat message, so both of you can read it later. - "Amount you ask to be paid" is filled in for the coin you pick — 11 BRL of BTC is
0.0000266 BTC (≈11 BRL)— so "Share address" is ready as soon as the address is in. Pick
another coin and its own amount appears; type your own and it is never overwritten. Only
numbers can be typed in the field; picking another coin after typing fills in that coin's
amount (a figure typed for BTC is no amount of XMR). - This works for every coin with a live price: BLURT, BTC and XMR as before, and now also ETH,
LTC, BCH, DASH, DOGE, ZEC, ARRR, DCR, SOL, XRP, USDT, USDC and DAI (see "Prices for the other
coins" below). For eCash the amount stays for you to type.
Real confirmation counts. A payment check now says how many confirmations the payment
has — "0.0000266 BTC received · 7 confirmations" — instead of jumping from "0/3" straight to
"confirmed". When your instance could not reach a block explorer for a couple of minutes, the
line says when it last checked ("last checked 4 minutes ago"), so an old answer is not
mistaken for a fresh one. That age is measured by your instance, so a computer whose clock
is off does not make a fresh answer look old."Sent as expected" for BLURT in seconds. A BLURT payment's receipt now carries the block
the transfer went into, so both screens check it straight away instead of waiting for the
block to become irreversible. In a coin-for-coin trade, the other coin is still only asked
for once that block is irreversible (under a minute): until then a chain fork could, rarely,
drop the transfer. A receipt from an older instance (without the block) is checked the old
way; older instances read the new receipts and ignore the block.Less noise. The "Waiting for @… to pay you in XMR, BTC, BLURT, … Send nothing until the
payment shows up here." line is gone from the chat.Chat Security means something simpler. It now asks: "This chat is encrypted on-chain so
it's never lost, but if you share this computer with someone, they might be able to see this
unencrypted copy. Do you want this chat deleted from this computer after you leave the chat?"
— Yes, delete it / No, keep it.- Morphit never saves chat text on your computer; it is decrypted into the open tab's memory
only. With Yes, leaving that chat (another page, another chat, closing or reloading the
tab) locks Morphit on this computer, in every tab, and wipes the decrypted chat from memory:
nobody can reopen any chat there without your password. - An unsent message you were typing in that chat is not kept as a draft either.
- It is set per chat, on this computer only.
- Your own messages are now always readable to you later, on any device: each one carries an
encrypted copy for you. The old setting that left out that copy (so you could not reread
your own side after leaving) is gone; if you had chosen it, your chats lock when you leave
them instead, until you answer No in a chat.
Elsewhere
Re-list. In My orders, the re-list hint now reads "Pre-fills the form for you with
original values that you can edit."Stars reward merit, not age or votes. On the Blurt Nodes page:
- Two years of producing blocks now earns full marks for time (it took five), and a clean
record shows early: a witness with no misses can reach 3⅓ stars after a year and 4 after
eighteen months. Past two years, a witness is judged only on how well it does the job. A
witness two years in that rarely misses had 1⅔ stars, below founders missing thousands of
blocks; it now has 4, above them. - Missing blocks costs more: an average of 25 missed a week halves the stars (it took 50).
- A witness who starts missing loses stars the same day. Blocks missed in the last day
count extra: one costs about a third of a star, 5 a star, 20 halve the stars. Once the
witness stops missing, they come back within a day. The red "missed" pill still shows the
count.
The Blurt Nodes page (/witnesses). On a computer or a large tablet, the table's heading
row stays pinned just under the main menu as you scroll, so you can still see which column is
which; scroll back up and it settles back into the table. Every heading still sorts the table.
Witnesses whose pictures were on image hosts that no longer exist get their picture from the
Blurt image proxy (imgp.blurt.blog), still fetched by the instance, never by your browser.Stablecoin prices on order cards. Orders in USDT, USDC or DAI now show the coin's live
price ("1 USDT = $1.00 live") under the amount: the line existed but had no price to show.For operators
Upgrade as usual. Nothing to configure.
- Prices for the other coins (OPERATIONS.md §56). Your indexer now keeps a USD price for
ETH, LTC, BCH, DASH, DOGE, ZEC, ARRR, DCR, SOL, XRP, USDT, USDC and DAI — display only, never
used for a fee or a check. Over Tor nothing new is asked: the Bisq and Haveno price nodes
already quote these coins in the answer your instance fetches for BTC and XMR. Where your
instance may use clearnet, it also sends one CoinGecko and one CryptoCompare request per
price refresh, each for all thirteen coins together; a hidden-only instance sends neither.
MORPHIT_INDEXER_PRICE_FEED_ENABLED=falseturns it off with the rest of the price feed. See
them on the server:curl -s http://127.0.0.1:8080/v1/listing-fee | jq .asset_prices_usd. - Your own row in the instance directory (
/v1/instances) now carries your own indexed
block and chain lag. It never did: your own origin is never probed, so the row kept whatever
an old probe had left (morphit.io listed itself about 1.6 million blocks behind). Peers'
rows were always right. - From the first day of v1.23.0 (OPERATIONS.md §55):
-
The "missed in the last day" flag starts after an hour. The chain only gives each
witness's lifetime total of missed blocks, so an instance writes the totals down every 10
minutes and compares. A newly installed or newly upgraded-to-v1.23 instance shows no flags
for its first hour, then counts the misses since it started watching, and covers a full
day after 24 hours. Upgrades and restarts keep the samples; only restoring an indexer
snapshot empties them, and the hour starts again. To see it working, on the server:sudo -u postgres psql -d morphit_indexer -c "SELECT COUNT(*) AS samples, COUNT(DISTINCT owner) AS witnesses, MIN(sampled_at) AS first, MAX(sampled_at) AS last FROM witness_missed_samples" -
[witnesses] avatar_unavailable … has no DNS recordsin the indexer log: the
witness's picture was on a host name that no longer exists in DNS. On 2026-11-05 the
blurt.worlddomain moved to parking nameservers, takingimg.blurt.worldwith it, and
images.blurt.buzzdoes not exist; most witnesses' pictures were on one of the two. The
indexer now asks the Blurt image proxy,
https://imgp.blurt.blog/profileimage/<witness>/64x64, and logsavatar_via_proxy;
avatar_unavailablenow means both failed (its reason names both). The proxy sees your
server's address and the witness's name; a zero-clearnet instance still fetches no
pictures at all.
-
For developers
Trade chat
chat/cryptoLegs.ts: thewaiting_paymenthint is gone (paymentState === 'unpaid'→
no hint);chat.legs.waiting_paymentremoved from the 10 locales.- Chat Security (
stores/chatSecurity.ts):readChatSecurityModealways answers'keep'
(the self-copy is always attached);writeChatSecurityModeis gone. New
readLockOnLeave(account, peer, order)/writeLockOnLeave(…), key
morphit.chatSecurity.lockOnLeave.<account>\0<peer>\0<order>; unset falls back to the
legacymorphit.chatSecurity.mode.<account> === 'destroy'.stores/identity.ts:
holdLockOnLeave()— while held,handlePageHidedrops the reload stash, tells the other
tabs to lock and resets, instead of stashing.ConversationView.svelteholds it while the
chat's setting is on and callslockAllTabs()when the view leaves that chat. The PDF
reminder modal and thecurrent_keep/current_destroy/pdf_reminder.*strings are
gone. - BLURT receipts:
FundsSentPayload.block?(BLURT only; a safe integer in (0, 2³¹); the
encoder throws and the decoder returns null otherwise). It is carried through
chatService→listenerDispatch→tradeVerify→blurtLegCheck→
blurtVerify.verifyBlurtTransfer, which, given a block, asksget_blockthrough the
indexer relay and checks the transaction found by its txid in that block; a block not
there yet is anrpc_error(retried, not cached); a txid not in the block falls back to
get_transaction. The verify cache key includes the block. Checked against the v1.23.0
decoder: it decodes the new receipt and ignoresblock. - Review fixes (each test seen failing first):
- A transfer found in a block above
last_irreversible_block_num
(get_dynamic_global_properties, also through the relay) is
{kind: 'verified', provisional: true}: shown, never cached;blurtLegCheckkeeps it
"checking" and looks again until it is final, so a coin-for-coin trade's other coin waits
for it. The receipt's label records it at once (phases are first-wins, so a later fork
would not undo it there; the gate that releases a coin is what waits). - A block the node does not have (or a bogus number) falls back to
get_transaction
instead of answering "try again" forever. - The toolbar "Send BLURT" pays the peer's newest BLURT ask in the thread (account, amount,
memo; the amount then fixed) when there is one — read from the messages, since the
two-legmoneyFactsis empty for a one-leg trade. Before, with the share window now
filling in (and jittering) the ask, the order-price pre-fill paid a different amount and
both screens showed an amount mismatch. A two-leg BLURT leg keeps its old rule (no
pre-fill, no fiat value: the order's price is for the other coin). - "Send …" shows
aria-busy/disabled while it waits for the price, and does not replace a
pay window opened meanwhile. ChatComposertakespersistDraft(false while the chat locks on leaving): no draft
written, an existing one wiped at once./v1/payment-checkanswers carryage_seconds(the instance's clock);
paymentChecks.checkOncederives the age from it and no longer compares the device clock
withchecked_at. No age is shown once confirmed (the instance keeps a confirmed answer
for 10 minutes on purpose).- The address card hides its "For order" line only when the note is exactly the reader's
"For order: ", not whenever the note mentions the permlink. - Picking another coin in the share window after typing an amount refills it.
- A transfer found in a block above
- Pay prefill:
startPayNowawaitsrefreshPayPrefill()(market-price orders only: a fresh
getPriceand the FX table, raced againstPAY_PREFILL_WAIT_MS= 2500). The bug it fixes
was reproduced inConversationView.auditFlows.test.ts(a quote older than
MAX_QUOTE_AGE_MS→ 0.000) and the test was seen to fail without the fix. PayBlurtModal.sveltetakesfiatPerUnitand shows(≈<fiat>)(formatFiatCodein
i18n/formatters.ts: locale digits, 0–2 decimals, then the code).AddressShareModal.sveltetakesorderValueandcoinValue(coin); new PURE
orders/coinValue.ts(fiatPerCoin,coinAmountForFiat), amounts capped at 8 decimals.
ChatMessage.sveltehides the address card's "For order" line when the note already names
the order.- Payment checks:
paymentChecks.tskeepscheckedAtMs;confirmationLine(c, now)gives
{confirmed, n, required, staleMinutes}(stale after
PAYMENT_CHECK_STALE_AFTER_MS= 2 minutes).chat.payment_check.confirmedis an ICU plural
onn; newchat.payment_check.checked_ago. my_orders.order.action_relist_hintupdated in the 10 locales (pl had been out of date).- The native-translations snapshot was rebuilt for the removed keys.
Prices for the other coins
indexer/price/pricenodes.ts:PRICENODE_COINS(the 13 coins);parseAllMarketPrices
also returnscoinsUsd— BisqcurrencyCodeentries are BTC per coin, Haveno
<COIN>/XMRpairs XMR per coin, each times that node's own BTC/USD or XMR/USD;
PricenodeConsensus.coinUsd(code)is their consensus (same rule as BTC/XMR).- New
indexer/price/coinQuotes.ts:CoinQuoteSourcecombines the pricenode consensus with
one CoinGecko/simple/price?ids=…&vs_currencies=usdand one CryptoCompare
/data/pricemulti?fsyms=…&tsyms=USDrequest per refresh (only while
sourceClearnetAllowed), withaggregateRobust; plausibility bounds (stablecoins
0.5–1.5 USD); a provider's answer is served for two refreshes plus a margin, then dropped.
ECX is excluded (ticker collision). Started and stopped inmain.ts. /v1/listing-feegainsasset_prices_usd(always USD; absent when empty;
ListingFeeResponsein@morphit/indexer-client).lib/prices/providers/indexer.ts
reads it for those 13 coins only, whatever the denomination.- Tests:
onionPricenodes.test.ts(2 new),coinQuotes.test.ts(9),
listingFeeCoinPrices.test.ts(3),prices.test.ts(1 new); each seen failing first, and
each guard incoinQuotes.tsremoved once to see a test fail.
Witness stars
witnessRanking.ts:score = 5 × time × reliability × lately × version.time = √(min(weeks ÷ FULL_TIME_WEEKS, 1)),FULL_TIME_WEEKS= 104 (was linear over 260).MISSES_PER_WEEK_HALVING= 25 (was 50).- New
lately = 1 ÷ (1 + missed_recent ÷ RECENT_MISSES_HALVING),RECENT_MISSES_HALVING=
20 (1 whilemissed_recentis null, i.e. under an hour of samples).witnessScoretakes
recentMissed;rankWitnessespasses the 24 h count it already computed.
- Chosen against all 31 producing witnesses on the live list (2026-11-06): the two cleanest
(about 1.5 missed a week, vote ranks 24 and 48) stay on top at 4⅔; witnesses missing
thousands drop to about 2; a half-year-old witness with a clean record gets 2⅓. - Tests in
witnessRanking.test.ts(3 new, seen failing first; the expected order updated):
on the 2026-11-05 chain fixture, agorise-witness (108 weeks, 3.9 missed a week) goes from
1⅔ to 4 and passes saboin and khrom; joviansummer 4⅔ → 4⅓ with one miss that day, 3⅔ with
5, 2⅓ with 20.
Instance directory
federationProbe.tspersistSelfReachablewritescached_indexed_blockand
cached_chain_lag_sec(lag blocks × 3) from the newlocalIndexedBlock(poller);COALESCE
keeps the stored values when unknown. Test infederationProbeSelfBranding.test.ts.
The Blurt Nodes page
routes/[lang]/witnesses/+page.svelte: each header cell isposition: sticky(.wit-th;
cells rather than the<thead>, which not every browser sticks), at--wit-sticky-top=
the main menu's measured height (aResizeObserveron the layout's
<header data-site-header>and on the row). The cells get the header row's colours made
opaque from the theme tokens, so rows pass under them and branded instances keep their
colours; the row's bottom line moved from the<thead>border onto the cells.- The table's card is
overflow-clipinstead ofoverflow-hidden(hiddenmakes the card a
scroll box of its own, so the row would stick inside the card, that is, never). - Review fixes, each checked in a browser and seen to fail without the fix: keyboard focus
never lands under the stuck row (lib/utils/stickyTableHead.ts, PURE, with tests; the
page'sscroll-padding-topis the menu + the row + 8 px while the table shows); the
notification banner publishes its bottom edge (lib/stores/stickyBanner.ts) and the row
sticks below it; the menu is measured to the fraction of a pixel; forced colours get an
outline; withoutoverflow: clip(Safari before 16) the corner cells round themselves. - Picture fallback (
indexer/witnessService.ts): when the own picture URL fails,getAvatar
asksavatarProxyUrl(owner)=https://imgp.blurt.blog/profileimage/<owner>/64x64, whose
answer must pass the same checks (PNG/JPEG/GIF/WebP, at most 1 MiB and 4096 px a side).
Only for a witness with a picture URL; never twice when the picture is on the proxy
already; a failure of both is remembered for the hour. fetchPublicBytes(indexer/federationProbe.ts) takessameOriginRedirects(default 0:
a redirect is a failure). Above 0 it follows a 3xx ONLY to the same https origin, each hop
through every check again (fresh lookup, public-address check, pinning); the proxy fallback
allows 3 (AVATAR_PROXY_REDIRECTS), no caller more than 5
(FETCH_PUBLIC_MAX_REDIRECTS), one timeout for the whole chain, each hop closing its
connection before the next. Tests:fetchPublicBytesRedirect.test.ts(7) and 5 in
witnessService.test.ts, each guard removed once to see its test fail.
Downloads
-
Source code (ZIP)
4 downloads
-
Source code (TAR.GZ)
6 downloads
- the separate "For order: order-…" box is gone; that text is now the note's default, which
-
Morphit v1.23.0
StableAll checks were successfulmorphit-ci / Supply-chain audit gate (every advisory triaged, none fixable in range) (push) Successful in 58smorphit-ci / TypeScript typecheck (sweep all workspaces) (push) Successful in 1m26smorphit-ci / apps/web svelte-check (svelte-kit sync + svelte-aware tsc) (push) Successful in 1m3smorphit-ci / Integration tests (real Postgres 16) (push) Successful in 7m29smorphit-ci / ansible-lint (playbook quality gate) (push) Successful in 47smorphit-ci / Smoke suite (run-smokes.sh, pulses 1–2 of 3) (push) Successful in 1h11m21smorphit-ci / Smoke suite (run-smokes.sh, pulse 3 of 3) (push) Successful in 35m55smorphit-release / Build + publish release tarball (push) Successful in 47m50sreleased this
2026-11-06 02:50:04 +00:00 | 11 commits to main since this releaseMorphit v1.23.0
A new page: Blurt Nodes (
/witnesses), where anyone can see every Blurt witness and vote
for the ones that keep the chain running well. Nothing about fees, prices or trades changes.For people using the site
The Blurt Nodes page. The Blurt network is run by hundreds of independent people, each
running a "witness node" that produces the chain's blocks. The new page lists all of them,
linked at the bottom of the footer's Federation column. Unlike the usual witness list, it is
not ordered by vote rank: the witnesses that have produced blocks the longest, missed the
fewest and run a current version come first, and gold stars (in thirds) show how reliable
each one is. Every row shows:- how long the witness has produced blocks, with a link to its own announcement;
- how many blocks it has missed since it started;
- its vote rank and its stars;
- how much more vote it needs to move up one place ("#1 right now" for the first);
- the version it runs (in amber only when it is a whole version behind, like 0.8.x).
A witness that missed blocks in the last day gets a red flag saying how many. Click any
column's heading to sort by it, and again to reverse; on a phone or a small tablet each witness
is a compact card instead, with a sort menu and a reverse button at the top. Witnesses that
are switched off or have not produced a block in 30 days are hidden behind a link at the bottom.Voting. Signed in, click the arrow next to a witness and confirm to vote for it; click
the lit arrow and confirm to take the vote back. The heading shows how many of your 30 votes
are left. A witness vote is signed
with your Active key, in your browser, like Power Up: with a password-protected Active key
you enter your password; signed in with your Posting key only, you paste your Active key for
that one vote. A vote moves no BLURT; Blurt splits your Blurt Power evenly across the
witnesses you vote for, so a few good votes count for more than many. Signed out, the arrow
takes you to sign in and straight back to the page — also when you sign in on a new device with
your Posting key, by QR code from a signed-in phone, or by just unlocking a locked session (a
seed or key file import first asks for your account name, as before).Pictures stay off until you ask. Each witness shows a plain head by default. "display"
shows their pictures, which your own instance fetches and serves: your browser still talks
to nobody but the site you are on. On a Tor/I2P-only site there is no "display" link.For operators
Nothing to set up. Your indexer now:
- reads the witness list from the chain at most once a minute while people look at the page,
and every 10 minutes writes down each producing witness's total of missed blocks for the
"missed in the last day" flag (a new local table,witness_missed_samples, schema v72:
about 30 rows every 10 minutes, kept 26 hours, never in a snapshot). A newly upgraded
instance shows the flag after its first hour, as "missed in N h", and "in 24 h" after a
day; - on a clearnet instance, fetches a witness's picture from the host the witness chose — only
after a visitor clicks "display", at most once a day per picture — through the federation
probe's guarded fetch (https only, every DNS answer checked public and the connection
pinned, no redirects, 1 MiB at most, only PNG/JPEG/GIF/WebP kept). The host sees your
server andUser-Agent: morphit-indexer/witness-avatar. A zero-clearnet instance never
does this; - relays
account_witness_votethrough/v1/broadcast(added to the allow-list: it changes
only the signer's own vote and moves no funds).
OPERATIONS §55 has the details and the log lines to look for.
For developers
apps/indexer/src/indexer/witnessRanking.ts(pure): the stars —5 × time × reliability × version, rounded down to a third; time = weeks ÷ 260 (at most 1), reliability =
1 ÷ (1 + missed per week ÷ 50), version = 0.75 a whole major.minor behind the newest one at
least three producing witnesses run (0.9.0 counts as 0.9.1; the chain records whatever version a
witness's blocks claim, so one witness reporting "0.255.0" cannot put everyone else behind). The factors multiply: an additive draft put
a witness missing ~456 blocks a week above most others. Only producing witnesses (signing
key set, a block within 864 000 blocks) are scored; the rest are listed by rank after them.
Also: BP from votes, "needs" to the next rank, safe announcement links (http(s) only, no
credentials), picture URLs (https on 443, never a hidden-service name), the missed-in-24-h
baseline.test/indexer/witnessRanking.test.ts(16, on real chain rows from 2026-11-05,
the numbers blurtwallet shows: khrom 16.54 M BP, agorise-witness "507 K to level up");
4 mutations caught (additive score, rounding to nearest, comparing patch versions, the
30-day window off by one).apps/indexer/src/indexer/witnessService.ts: the cached, coalesced list (paged
get_witnesses_by_vote, 1000 a page), the 10-minute sampler, the hourly accounts read for
picture URLs, and the picture cache (per witness and URL; a day; failures an hour; 48 MiB in
all, oldest dropped; 4 fetches at once; one fetch for many askers; only for an account in
the list; never whenclearnetRefused()).test/indexer/witnessService.test.ts(16);
6 mutations caught, one of them only after a test was added for an instance that stops
reaching clearnet after picture URLs were already known.fetchPublicByteslifted out offetchJson(indexer/federationProbe.ts), so the pictures
go through the same SSRF-guarded code, not a copy;fetchJsonis now a thin JSON wrapper over
it. Its deadline now starts before the DNS lookup and covers it (it used to start after); the
pictures resolve through c-ares (resolvePublicIpCares: own timeout, every A/AAAA record
public) instead ofdns.lookup, whose 4 shared threads a host that never answers could hold.- Review fixes (each with a test that fails without it): pictures only for producing witnesses
(anyone can register a witness; a producing one has real votes), and both gates tested on their
own; the fetch limit handed from a finishing fetch straight to the next (a new request in
between used to make it 5); expired failures dropped; the last list served while the chain
cannot be read; pictures over 4096 px a side refused (read from the PNG/GIF/JPEG/WebP header,
real Pillow-made fixtures); the route's parameter is:witness, becauseowneris one of the
security middleware's account parameters and forcedno-storeon the pictures; pictures have
their own rate-limit bucket (witness-avatar), so a page of them cannot push a vote to 429;
needs_bp0 (tied votes) shows "tied with #N".test/indexer/witnessReviewFixes.test.ts;
test/integration/witness-missed-samples.test.tsruns the sampler's SQL on PostgreSQL. apps/indexer/src/api/witnesses.ts:GET /v1/witnesses,/v1/witnesses/votes/:account,
/v1/witnesses/avatar/:witness(pictures cached an hour,nosniff,default-src 'none').
test/api/witnesses.test.ts(3). Documented indocs/API.md.- Migration 72 +
schema.sql;witness_missed_samplesis inLOCAL_ONLY_TABLES. /v1/broadcastallowsaccount_witness_vote;broadcast-op-allowlist-smokechecks it
passes (and fails without it).- Web:
routes/[lang]/witnesses/+page.svelte,PartialStars.svelte(SVG stars clipped to
thirds;PartialStars.test.ts, 4),WitnessVoteModal.svelte(PowerModal's active-key
flow),prepareUnsignedAccountWitnessVoteinblurt/sign.ts,formatMonthYearShort
("Nov '25"), the route inseo/routes.tsand the sitemap, the footer link.
UnlockActiveKeyModaltakespurpose="vote"so it no longer calls a vote a payment. ?next=: the same-origin check moved from/loginintolib/utils/safeNext.ts
(safeNext.test.ts, 5), and the import flow honours it once the account name is known.- 10 locales: the page, the footer link, the page's SEO title and description, and the
Active-key box's vote wording. Counts are ICU plurals carrying the number, so Persian shows
its own digits and Polish/Russian get the right word forms. The native-translations floor
snapshot is rebuilt (533 new native pairs, none lost). - Web review fixes (each checked in a browser or with a test that fails without it):
- Layout: the table starts at
lg(it overflowed the card by 70–220 px on 768–820 px
tablets); below that, three-line cards with short forms under 400 px ("↑568K") and the
"needs" text dropped under 360 px. A layout script measured 10 locales × 8 widths (320–1280
px) for overflow, clipped versions and the vote button leaving the card, and was confirmed
to catch the oldmdbreakpoint. - Announcement links go through
lib/utils/safeWitnessLinkUrl.ts(http(s) only, no
credentials, 512 characters at most; registered withhref-xss-smoke); picture paths
throughwitnessAvatarUrl()inlib/indexer/client.ts, which accepts only the indexer's
own/v1/witnesses/avatar/<name>?v=<hex>shape. - Your votes: a loading/failed/ready state tied to the account it was read for, so an answer
for a previous account (or a slow first answer) can never light the wrong arrows; buttons
wait while loading; a failed read shows a Retry. The proxy and 30-votes notices are toasts.
A session without an account name is sent to Settings instead of a dead end. - Sorting: every column, the phone sort menu and a reverse button; by stars, producing
witnesses stay above the rest in either direction. formatMonthYearShort: French/Spanish/Italian/Polish/Russian/German use the locale's
short month ("juil. '21"), Chinese "21年7月", Persian its own calendar and digits.- Right-to-left: stars fill from the right, names and versions in
<bdi>, logical
padding, the row's hover bar on the reading side. - Accessibility: the vote dialog traps focus and gives it back to the arrow; every arrow,
sort heading and the reverse button has a name that says what it does; the table has a
caption; the vote arrow's "take back" look also shows on keyboard focus, not only on hover. ?next=:safeNextPathalso refuses a path that normalises to//host
(/.//evil.example);/loginhonoursnextwhen only unlocking, and the QR sign-in passes
it on (unlock-redirect-next-smokecheckssafeNextPathitself).@sveltejs/kit2.70.4 (npm-audit gate); the schema-head smoke pins v72; the media kit zip
is rebuilt.
- Layout: the table starts at
For monitoring scripts: new JSON
GET /v1/witnesses(new)./v1/healthis unchanged apart fromversion.Downloads
-
Source code (ZIP)
4 downloads
-
Source code (TAR.GZ)
6 downloads
-
Morphit v1.22.1
StableAll checks were successfulmorphit-ci / Supply-chain audit gate (every advisory triaged, none fixable in range) (push) Successful in 1m9smorphit-ci / TypeScript typecheck (sweep all workspaces) (push) Successful in 1m31smorphit-ci / apps/web svelte-check (svelte-kit sync + svelte-aware tsc) (push) Successful in 1m2smorphit-ci / Integration tests (real Postgres 16) (push) Successful in 8m5smorphit-ci / ansible-lint (playbook quality gate) (push) Successful in 55smorphit-ci / Smoke suite (run-smokes.sh, pulses 1–2 of 3) (push) Successful in 1h20m31smorphit-ci / Smoke suite (run-smokes.sh, pulse 3 of 3) (push) Successful in 38m57smorphit-release / Build + publish release tarball (push) Successful in 50m15sreleased this
2026-11-04 18:35:32 +00:00 | 12 commits to main since this releaseMorphit v1.22.1
A fix release for servers: the two problems left open in v1.22.0, and chain replies that were
downloaded several times. Nothing changes for people using the site, and nothing about fees,
prices or trades changes.eCash (ECX) added!
For operators
The fee re-check now judges every fee as the indexer judged it when it came in. Since
v1.20.0 an indexer checks some BLURT fees a second time, from the chain: orders it stored as
underpaid and first-contact (stranger) fees it rejected, when they were paid through another
instance. It does this so that an instance that judged them before it knew the other
instance's fees account still ends up agreeing with everyone else. That second check read the
user's other orders and fees as they are NOW, not as they were at the fee's place in the
chain:- an order the user ended in the same block as a new one did not count toward the new
order's listing tier, though it counted when the order came in: the tier came out one too
low, and an order that paid too little could be shown; - an order ended before the new one but changed later (for example, its trade partner named
afterwards) counted as if still open: the tier came out one too high, and an order that
paid in full could stay hidden; - a first-contact fee that paid too little was marked as paid when the user paid for the
same person later; - a first-contact fee paid later in the same block raised the price of an earlier one, and
fees were re-checked newest first, so a fee could be priced without an earlier one that
was still waiting for its own check; - when the check found a first-contact fee paid after all, and the same person had been paid
for again later, the record of the payment stayed with the later fee, so the fees in
between were priced as if the earlier one had not been paid; - first-contact fees older than 30 days were never checked, so whether one was depended on
when an instance upgraded.
The result also depended on when an instance happened to run its check, so two instances
could disagree. Now every fee is judged as of its own place in the chain, with the same
counting the upgrade replay uses since v1.22.0. First-contact fees are re-checked in chain
order, at any age, and a sender's later fee waits while an earlier one cannot be checked
yet; the record of a payment moves to the earliest fee that paid it. A fee whose check keeps
failing no longer holds up other people's fees.After the upgrade, results of the old check that the new one can correct are checked again,
once: an order it left hidden, a first-contact fee it left rejected, and a first-contact fee
it marked as paid only because of a later payment (that one goes back to rejected; the
person stays reachable through the later payment). The last kind is found from the chain
data itself, so an instance restored from another one's snapshot finds it too. Two things
the old check did cannot be taken back: an order it wrongly showed stays shown (the payer's
loyalty credit, and any payout it led to, followed at once), and a first-contact fee it
wrongly accepted stays accepted (the person has been reachable since). Both need unusual
timing (an order ended in the same block as a new one paid at the lower tier; two
first-contact fees within five minutes, re-checked in the wrong order), so they are rare.The new rule applies at once, with no switch-over date. An instance that has not upgraded
keeps the old check for fees re-checked meanwhile, and corrects what it can once it upgrades.A lost database connection no longer stops the indexer or the relay. When PostgreSQL
restarted, or the connection dropped, while the indexer or the relay was between two steps
of a transaction (waiting on the chain, for example), Node stopped the whole process. Nothing
was lost: nothing had been committed and systemd started it again. Now only that transaction
fails, the usual retry follows, and the broken connection is closed instead of being reused.
This includes a connection that dies the moment it is handed out. The error the transaction
fails with now carries the connection's own error as its cause, and the journal shows
checked_out_client_error.morphit-ops upgradeno longer stops either when its check of
the database role loses its connection (a reset, or a backend killed): the check reports the
failure.A chain reply is downloaded once. The library the indexer and the relay read the chain with
gives each try 500 ms, then 1 s, then 1.5 s and so on, to get a first answer from the node, and
asks again when the time runs out. Since every reply has been checked for its size before it is
used, that time limit also ran over the download of the whole reply: a reply that took longer
than half a second to arrive was cut off and asked for again, and one that took a few seconds
(a long account history, a 100-account batch from a distant or busy node) was downloaded
several times and could fail at the end. Now the limit stops once the node has started to
answer, as the library meant, and every reply is downloaded once; its size limit still applies.
This is also what turned the CI smoke suite red:rpc-reply-budget-smokecounted the extra
requests.Upgrade as usual.
For developers
blurtFeeReverify.ts: the Sybil tier comes fromcountForSybilTierAtPosition(shared with
the upgrade replay);countForSybilTierAsOfis gone. Stranger fees are re-run with
judgedOutOfOrder: true, so the handler's "pair already paid" check and the escalating
price (getStrangerFeeQuote(…, before),strangerFeeRowBefore) see only fees whose op came
before. Candidates in chain order. Outcomes infee_reverify_donehave new spellings
(underpaid_as_of_position,applied_as_of_position,rejected_as_of_position:…,
unapplied_as_of_position:…); the old rule'sstill_underpaidandstill_rejected:…are
re-judged once (the row is updated in place). A stranger fee that is applied with no
stranger_feesrow of its own or from before it is a candidate whatever the bookkeeping
says. When a fee judged out of order is valid and the pair's row is a later fee's, the
handler moves the row to it. No 30-day window for stranger fees; a sender's fees wait
behind an earlier one that could not be judged; ops given up on are left out of the
selection; a throw while judging counts as a failure of that op. No schema change.db/pool.ts(indexer and relay): the listener is attached in pg-pool'sconnect
callback, so no 'error' can fall between the hand-out and the listener; a checked-out
client keeps it until released, a client that reported an error is released with it (so
the pool drops it), andwithTxsets that error as thecauseof the one it rethrows.
The relay'sconnect()does the same through the client'srelease. ops-cli
pgRoleHeal.ts: itspg.Clienthas an'error'listener.@morphit/hidden-transport/rpc-fetch:guardedRpcFetch(base, max, { signalUntilHeaders }).
The global wrapper behindguardDblurtClientsets it: dblurt's per-attemptAbortSignal
(500 ms × (attempt + 1)) can abort a request only until its headers arrive, as it did before
the guard read the body insidefetch. Direct callers that pass their own deadline keep it
over the whole reply.rpc-reply-budget-smokenow serialises its replies before they are
asked for, checks that every reply is requested once, and adds a node whose body arrives
after 2 s (asked five times before) and two checks of the signal's scope.- New tests:
test/integration/blurt-fee-reverify-as-of-position.test.ts(20),
db-pools.test.ts(+3), relaytest/dbPoolLostConnection.test.ts(4), ops-cli
test/pgRoleHealLostConnection.test.ts(2). They wait on the connection's own events
('end', the socket's'close'), not on timers. - ops-cli test network guard (
test/setup/noInternet.ts): a test'snet.connect(port, name)
to a name (CI'spostgres) failed withERR_MISSING_ARGS, because the guard's copy of
net's already normalised arguments lost their mark. The copy keeps it now
(noInternetGuard.test.ts, +1). The drop test also checks that the statement reached the
proxy, so a proxy that cannot reach Postgres fails the test instead of passing it.
Downloads
-
Source code (ZIP)
4 downloads
-
Source code (TAR.GZ)
6 downloads
- an order the user ended in the same block as a new one did not count toward the new