• v1.24.3 421b2f97ee

    Morphit v1.24.3
    All checks were successful
    morphit-ci / Supply-chain audit gate (every advisory triaged, none fixable in range) (push) Successful in 1m8s
    morphit-ci / TypeScript typecheck (sweep all workspaces) (push) Successful in 1m35s
    morphit-ci / apps/web svelte-check (svelte-kit sync + svelte-aware tsc) (push) Successful in 1m4s
    morphit-ci / Integration tests (real Postgres 16) (push) Successful in 8m16s
    morphit-ci / ansible-lint (playbook quality gate) (push) Successful in 50s
    morphit-ci / Smoke suite (run-smokes.sh, pulses 1–2 of 3) (push) Successful in 1h17m16s
    morphit-ci / Smoke suite (run-smokes.sh, pulse 3 of 3) (push) Successful in 38m4s
    morphit-release / Build + publish release tarball (push) Successful in 51m0s
    Stable

    Ghost released this 2026-11-15 18:42:45 +00:00 | 0 commits to main since this release

    Signed by agorise
    GPG key ID: 53524E1F1017EB9C

    Morphit 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 in docs/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-broadcasts showed 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_lost and 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_at and last_error), and
        takes it only while error_count is below the retry limit. It returns the stamp it wrote.
      • onSigned records the signed transaction only while the row still carries that stamp and is
        not stopped. Otherwise nothing is sent, the drainer logs row_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 only onSigned to 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.
    • apps/indexer/src/indexer/foreignCodeHeal.ts: the hold keeps a last_error that starts
      with outcome_unknown or in_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-static 3.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 (VERCEL set), which a Morphit build never does, so
      the built site is the same. apps/web/package.json now requires ^3.0.11, and the lockfile
      changes only that package.
    Downloads
  • v1.24.2 a46480d2f6

    Morphit v1.24.2
    All checks were successful
    morphit-ci / Supply-chain audit gate (every advisory triaged, none fixable in range) (push) Successful in 57s
    morphit-ci / TypeScript typecheck (sweep all workspaces) (push) Successful in 1m17s
    morphit-ci / apps/web svelte-check (svelte-kit sync + svelte-aware tsc) (push) Successful in 55s
    morphit-ci / Integration tests (real Postgres 16) (push) Successful in 8m34s
    morphit-ci / ansible-lint (playbook quality gate) (push) Successful in 51s
    morphit-ci / Smoke suite (run-smokes.sh, pulses 1–2 of 3) (push) Successful in 1h12m46s
    morphit-ci / Smoke suite (run-smokes.sh, pulse 3 of 3) (push) Successful in 37m37s
    morphit-release / Build + publish release tarball (push) Successful in 49m49s
    Stable

    Ghost released this 2026-11-13 06:08:38 +00:00 | 1 commits to main since this release

    Signed by agorise
    GPG key ID: 53524E1F1017EB9C

    Morphit 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-server 1.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.
    • hono 4.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_unanswered with a
    reason and 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:

      • fetchAccountKeys asks once more after a failure, after ACCOUNT_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.
      • fetchAccountKeysForSigning is 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 message pending
          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_MS of 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_unreachable is 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's online event);
        • 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 on chain_unreachable is isNotYetSent: 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's role="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.
      • sendFromModal returns whether the message went out, and does not throw on chain_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 shows success_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_unreachable is 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_label and chat.pay_blurt.success_toast_receipt_pending are new.
    • Server:

      • api/accountKeys.ts logs account_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: deadline versus no_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-server 1.19.17 → 1.19.19 (GHSA-jpvv-r467-5p4w, a backslash in the path read as a
        separator). The indexer's and the relay's package.json now require ^1.19.18. The update also
        refuses a % in a serveStatic path, which Morphit does not use.
      • hono 4.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,
        the css helper, neither used here). The root's, the indexer's and the relay's package.json now
        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
        serveStatic changes 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-smoke requires the not-yet-sent bubble to be dimmed, and still never
      a sent one.

    Downloads
  • v1.24.1 67000382ff

    Morphit v1.24.1
    All checks were successful
    morphit-ci / Supply-chain audit gate (every advisory triaged, none fixable in range) (push) Successful in 1m2s
    morphit-ci / TypeScript typecheck (sweep all workspaces) (push) Successful in 1m22s
    morphit-ci / apps/web svelte-check (svelte-kit sync + svelte-aware tsc) (push) Successful in 56s
    morphit-ci / Integration tests (real Postgres 16) (push) Successful in 7m56s
    morphit-ci / ansible-lint (playbook quality gate) (push) Successful in 47s
    morphit-ci / Smoke suite (run-smokes.sh, pulses 1–2 of 3) (push) Successful in 1h10m23s
    morphit-ci / Smoke suite (run-smokes.sh, pulse 3 of 3) (push) Successful in 35m52s
    morphit-release / Build + publish release tarball (push) Successful in 49m30s
    Stable

    Ghost released this 2026-11-11 03:48:45 +00:00 | 3 commits to main since this release

    Signed by agorise
    GPG key ID: 53524E1F1017EB9C

    Morphit 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_activity ping now
      carries at: 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's eventAt to the
      tabs as at, through chatPushTabMessage (notifications/chatThread.ts), and the tab passes it
      on to the badge.
    • chatUnread.ts.
      • A pending push is { at, seen }: at is the newest pushed message's time, seen is 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 as poll().
      • 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.
    • The read ack of a fast copy (migration v74). The chat handler stores each message's signed
      time in chat_messages.sent_at: the expiration less the client's 60 s lead, capped at the block
      time. It uses sentAtFromExpiry, the rule the fast path dates its copy with, now in
      indexer/chatSentAt.ts and re-exported by chatFastFederation.ts. Rows indexed before v74, and
      messages applied without their transaction, keep NULL.
      • /v1/chat-read-state gives 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.ts pins 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). listFastPending says whether its time is timed, and
      ackThreadRead takes a fastCopy flag. Like the rest of "Mark all read", these are acks on this
      device only, and the cover is in memory.
    • Tests.
      • chatUnread.test.ts has 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.ts is 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.ts pins that a placeholder card's timedAt comes from a timed push only.
      • test/handlers/chat.test.ts has 2 more, on sent_at.
      • chatThread.test.ts is new.
      • globalChatActivityStream.test.ts delivers a service-worker message.
      • chatActivityStream.test.ts requires 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-smoke now tells a replay by its coming before ready, and requires a
        numeric at.
      • fast-badge-push-contract-smoke and chat-fast-notification-smoke follow the service worker's
        message into chatPushTabMessage.
      • chat-bg-notify-v148-smoke accepts pollNow().
      • schema-migration-coverage-smoke pins schema head 74.

    For monitoring scripts: changed JSON

    • The chat_activity event of /v1/chat-activity/:account/stream carries the message's time in
      at (milliseconds) on a live ping too; it was null there before.
    • /v1/chat-read-state/:account may give a thread's last_read_at up to 75 seconds later than the
      ack written on chain: the block time of the message whose fast copy the ack read.
    Downloads
  • v1.24.0 04cae92f93

    Morphit v1.24.0
    All checks were successful
    morphit-ci / Supply-chain audit gate (every advisory triaged, none fixable in range) (push) Successful in 1m1s
    morphit-ci / TypeScript typecheck (sweep all workspaces) (push) Successful in 1m27s
    morphit-ci / apps/web svelte-check (svelte-kit sync + svelte-aware tsc) (push) Successful in 55s
    morphit-ci / Integration tests (real Postgres 16) (push) Successful in 8m20s
    morphit-ci / ansible-lint (playbook quality gate) (push) Successful in 55s
    morphit-ci / Smoke suite (run-smokes.sh, pulses 1–2 of 3) (push) Successful in 1h13m55s
    morphit-ci / Smoke suite (run-smokes.sh, pulse 3 of 3) (push) Successful in 37m37s
    morphit-release / Build + publish release tarball (push) Successful in 51m11s
    Stable

    Ghost released this 2026-11-10 16:03:06 +00:00 | 4 commits to main since this release

    Signed by agorise
    GPG key ID: 53524E1F1017EB9C

    Morphit 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 with MORPHIT_FRONTEND_HIVE_CHAT_LINK_URL, MORPHIT_FRONTEND_STEEM_CHAT_LINK_URL and
    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 init asks 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) and MORPHIT_INDEXER_STEEM_PAYMENT_NODES (five JSON-RPC nodes); docs/OPERATIONS.md lists
    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/tickers with
    api.blurt.blog every price cycle (USD sites only; a site reached only over Tor and I2P asks
    neither). To leave Cexius out, set MORPHIT_INDEXER_CEXIUS_BASE_URL= (empty) in the indexer's env
    file. If you firewall the indexer's outbound traffic, allow cexius.com. morphit-ops health
    shows BLURT's source as primary_avg while 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 (hive and steem were 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's is_valid_name: 1-63 characters), each transparent, account-reuse,
      trade-only. address-shape-overlap-smoke documents 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-check use it.
    • The chat: isValidHiveSteemAccount, isValidBtsAccount, 40-hex transaction ids,
      jitterHiveSteemAmount and jitterBtsAmount, 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's memo (BLURT-only before) is accepted for every ACCOUNT_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_explain now names the coin).
    • COIN_QUOTE_IDS has the three (CoinGecko hive, steem, bitshares; CryptoCompare HIVE,
      STEEM, BTS); they are not in PRICENODE_COINS.
    • CompositeCachedPriceSource takes a primaryBlend: sources asked together first, their plausible
      answers combined with aggregateRobust and committed as primary_avg (or under the one that
      answered); primaryUpstreams keep their one-by-one order after it. BLURT's blend is
      blurt_price_feed and cexius (cexiusFetcher.ts: the market's last price, only from a ticker
      that names the market asked for and quotes USDT). Answers more than BLEND_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; only transfer operations to the
      account in the coin itself carrying the ask's memo (otherMemo / memo_mismatch for 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
      throws TRANSPORT_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
      depth pending (verdict checking), an ask without a memo unbound (verdict unasked) and a
      transfer without it wrongMemo (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 shows chat.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-smoke checks it.
    • price-primary-fallback-smoke now 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.ts has 8 more
      and ConversationView.auditFlows.test.ts two (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/instance chat_link_urls gains hive, steem and bts (a template, or null for the
      bundled default).
    • Orders, the orderbook and RSS can carry "asset": "HIVE", "STEEM" or "BTS"; a barter
      listing's accepted_assets can include them.
    • GET /v1/payment-check takes asset=hive|steem with a 40-hex txid, the account name as
      address and the ask's memo; its asset can be hive or steem, and a found answer can
      carry memo_mismatch: true.
    • An order's payment_methods can include pay_hive, pay_steem and pay_bts.
    • GET /v1/listing-fee asset_prices_usd can include HIVE, STEEM and BTS.
    • The BLURT price's source (the verbose health endpoint's diagnostics.price, and morphit-ops health --json) can be primary_avg or cexius, besides blurt_price_feed.
    Downloads
  • v1.23.5 7fb3023f0d

    Morphit v1.23.5
    All checks were successful
    morphit-ci / Supply-chain audit gate (every advisory triaged, none fixable in range) (push) Successful in 1m0s
    morphit-ci / TypeScript typecheck (sweep all workspaces) (push) Successful in 1m20s
    morphit-ci / apps/web svelte-check (svelte-kit sync + svelte-aware tsc) (push) Successful in 51s
    morphit-ci / Integration tests (real Postgres 16) (push) Successful in 8m34s
    morphit-ci / ansible-lint (playbook quality gate) (push) Successful in 49s
    morphit-ci / Smoke suite (run-smokes.sh, pulses 1–2 of 3) (push) Successful in 1h12m59s
    morphit-ci / Smoke suite (run-smokes.sh, pulse 3 of 3) (push) Successful in 38m10s
    morphit-release / Build + publish release tarball (push) Successful in 50m1s
    Stable

    Ghost released this 2026-11-09 19:27:09 +00:00 | 5 commits to main since this release

    Signed by agorise
    GPG key ID: 53524E1F1017EB9C

    Morphit 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.md has 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_set in 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 of index.html that branding names your site in, and falls back to
      index.html when a build has none. /index.html itself is still served as is: visitors'
      browsers check it against the on-chain record, and now also check that spa-shell.html loads and
      runs exactly what index.html does. A BunkerWeb box gets the new web server config
      with the upgrade, and the upgrade switches a hand-copied bare-metal web.conf too.
    • 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 as MORPHIT_INSTANCE_LOGO_SIZE and 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 its completed_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 from feedback and
        orders whenever it is needed, never stored. With asOf, only the back review and a partner
        named (orders.counterparty_named_at, the completion time when not recorded) by then count;
        with since, only reviews stamped from then on.
      • citationCandidatesSql (indexer/reviewCitation.ts) is the citation rule as one SQL text,
        used by the handler and by healOrderAccounts, 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. healNamingTimes fills in
        counterparty_named_at at 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_weight on the
        order rows; the receipt's count_weighted, and each row's review_weight and proven).
      • 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. reciprocityEverHeld takes ignoreProven the same way, which hasVerifiedChat (the
        review and partner-name gate) always passes, counting as proven only trades whose two reviews
        are both stamped at or after CONSENSUS_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 whenever repeatTradesGuard
        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_block follows 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/feedback items carry pair_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_block and
        review_signals_redo_due, and feedback_weight_unworked_idx.
      • The FAQ (10 languages), docs/API.md, docs/ARCHITECTURE.md, docs/OPERATIONS.md and
        docs/UPGRADING.md say how repeat trades count.
    • The brandable app shell: scripts/build-brand-slots.mjs writes build/spa-shell.html from the
      fresh index.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 / is try_files $uri $uri.html @spa (it had
      $uri/index.html, which answered /), and @spa tries /spa-shell.html before
      /index.html. nginxVhostHeal rewrites 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), once index.html matches
      its signed hash, fetches /spa-shell.html and 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
      &amp;, 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 with index.html, or 404) passes.
    • Logo size: MORPHIT_INSTANCE_LOGO_SIZE (INSTANCE_ENV.LOGO_SIZE, 50–200, 100 is no setting),
      --logo-size on branding apply (and in status), written to /brand/theme.css as
      html:root{--brand-logo-scale:…}. MorphitLogoBling multiplies the header logo's height by it
      (not the footer's, not an explicit wordmarkSrc); 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-smoke C-10d brands app.html's shell copy with
      the real build and branding code and runs the browser check on it. nginx-served-hardening-smoke runs both shipped configs in a real nginx and checks /, the
      app's pages and /index.html with and without spa-shell.html (14 new); branding.test.ts
      (the shell copy, the logo size, --logo-size), nginxVhostHeal.test.ts,
      branding-contract-smoke C-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.html is 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: integration in ci.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.ts also 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.mjs tries 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-scale holds a page under its 600 ms
      bound at 50,000 reviews in both states.
    Downloads
  • v1.23.4 d80a0a6371

    Morphit v1.23.4
    All checks were successful
    morphit-ci / Supply-chain audit gate (every advisory triaged, none fixable in range) (push) Successful in 1m4s
    morphit-ci / TypeScript typecheck (sweep all workspaces) (push) Successful in 1m26s
    morphit-ci / apps/web svelte-check (svelte-kit sync + svelte-aware tsc) (push) Successful in 54s
    morphit-ci / Integration tests (real Postgres 16) (push) Successful in 8m2s
    morphit-ci / ansible-lint (playbook quality gate) (push) Successful in 51s
    morphit-ci / Smoke suite (run-smokes.sh, pulses 1–2 of 3) (push) Successful in 1h12m54s
    morphit-ci / Smoke suite (run-smokes.sh, pulse 3 of 3) (push) Successful in 38m31s
    morphit-release / Build + publish release tarball (push) Successful in 50m9s
    Stable

    Ghost released this 2026-11-08 17:32:53 +00:00 | 7 commits to main since this release

    Signed by agorise
    GPG key ID: 53524E1F1017EB9C

    Morphit 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/about and 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: one get_block more, 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_DAYS at 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's flash-instance-border pulse copied into the
      component (2 s, ease-in-out, 3 times, brand emerald), for ADDRESS_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; input ends it for good, focus ends 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.ts resolves it in its locale redirect, so
      /about is one hop to /<locale>/about-this-instance (query and fragment kept).
      routes/[lang]/about/+page.ts (new) forwards /<lang>/about with 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#y loaded straight from the
      server lands without the ?x#y (review: accepted; inside the app, and for bare /about, they
      are kept).
    • Share buttons: twoLegButtons hides sharePaymentAddress once his address for a payment coin
      is in the thread (back for no_address) and shareAssetAddress once his asset address is;
      the one-coin button uses iSharedAddress over the thread (pending counts, failed does not).
      Review: a small "Share a different address" (shareAgain, showShareAddressAgain,
      chat.address.share_another in 10 locales) keeps another coin or a corrected address possible.
      "Record shipment" now derives from iReceiveCryptoUnpaid, not the share button.
    • Confirmations: PAYMENT_CHECK_CONFIRMING_INTERVAL_MS (15 s) in the browser while seen and
      under the required depth — for PAYMENT_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); indexer PAYMENT_CHECK_FRESH_MS.confirming 15 s, PAYMENT_CHECK_STALE_WAIT_MS 3 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: txFromBlock in api/chainExplorer.ts; $lib/explorer/blockNumber.ts;
      morphitExplorerTxUrl(txid, block?), fetchChainTx(…, block?); the tx page reads ?block=;
      the receipt's link has target="_blank" and the receipt's block.
    • Orderbook: $lib/orderbook/slideIn.ts (new) — measureTops before a live order is inserted,
      playSlideIn after 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's animate-fade-up, and
      removing the class restarted the fade-up. That class, its CSS and justArrived are gone;
      OrderCard takes orderKey (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
      use composite: '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), not letsencrypt.log (certbot's log.py rolls it over on every
      run). The renewal point is the renewal file's renew_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_warn fires 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 reads 08 as 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_left and overdue_days replace
      last_renewal_success_age_days; the bot's text follows (and names certbot.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 of renew_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, and markSeenAt (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) and pageAliases.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/about with JavaScript off. /faq and an
        unknown /aboutx are unchanged.
    • 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>/about loaded 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
  • v1.23.3 2d331712ad

    Morphit v1.23.3
    All checks were successful
    morphit-ci / Supply-chain audit gate (every advisory triaged, none fixable in range) (push) Successful in 1m5s
    morphit-ci / TypeScript typecheck (sweep all workspaces) (push) Successful in 1m28s
    morphit-ci / apps/web svelte-check (svelte-kit sync + svelte-aware tsc) (push) Successful in 55s
    morphit-ci / Integration tests (real Postgres 16) (push) Successful in 7m38s
    morphit-ci / ansible-lint (playbook quality gate) (push) Successful in 46s
    morphit-ci / Smoke suite (run-smokes.sh, pulses 1–2 of 3) (push) Successful in 1h9m34s
    morphit-ci / Smoke suite (run-smokes.sh, pulse 3 of 3) (push) Successful in 36m24s
    morphit-release / Build + publish release tarball (push) Successful in 47m35s
    Stable

    Ghost released this 2026-11-07 18:28:21 +00:00 | 8 commits to main since this release

    Signed by agorise
    GPG key ID: 53524E1F1017EB9C

    Morphit 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:

    1. the Morphit avatar they set in Settings. It is on chain, so it shows on every Morphit
      instance, and it always wins;
    2. else their Blurt profile picture — once you have turned pictures on;
    3. 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_accounts for 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/instance says
      "blurt_pictures": false there, 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 under account-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 of witnessService.ts (which re-exports the
      limits and helpers and uses the one shared instance main.ts passes in), plus
      urlOf(account) (micro-batched get_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) and pictureOf(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/instance gains blurt_pictures (!clearnetRefused()); @morphit/indexer-client
      InstanceResponse.blurt_pictures?; the web instance store 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 the storage
        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.ts accountPictureUrl.
        indexer/profileSoon.ts: the profile reads of one moment in one getProfilesBatch.
      • IdentityLabel: Morphit avatar → pending (the quiet circle; also while hydrate reads
        the profile, while your own profile is not read yet, and while pictures are on but
        unknown) → the Blurt picture → the identicon. New props hydrate (read the Morphit
        avatar here; used by PaymentStatusBadge, PendingFeedbackReminderBanner, my orders'
        peers and Settings' blocked list) and noPicture (Settings' hidden list, which must not
        reach the operator). ChatMessage passes pending while 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". Strings settings.blurt_pictures.* in the 10 locales.
      • Tests: IdentityLabel.blurtPicture.test.ts (10) and profileSoon.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-pass smoke 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-scope smoke: the Profile pictures card, "only this device".
    Downloads
  • v1.23.2 7224da6388

    Morphit v1.23.2
    All checks were successful
    morphit-ci / Supply-chain audit gate (every advisory triaged, none fixable in range) (push) Successful in 1m5s
    morphit-ci / TypeScript typecheck (sweep all workspaces) (push) Successful in 1m42s
    morphit-ci / apps/web svelte-check (svelte-kit sync + svelte-aware tsc) (push) Successful in 52s
    morphit-ci / Integration tests (real Postgres 16) (push) Successful in 7m24s
    morphit-ci / ansible-lint (playbook quality gate) (push) Successful in 46s
    morphit-ci / Smoke suite (run-smokes.sh, pulses 1–2 of 3) (push) Successful in 1h12m57s
    morphit-ci / Smoke suite (run-smokes.sh, pulse 3 of 3) (push) Successful in 43m29s
    morphit-release / Build + publish release tarball (push) Successful in 49m58s
    Stable

    Ghost released this 2026-11-07 02:29:23 +00:00 | 9 commits to main since this release

    Signed by agorise
    GPG key ID: 53524E1F1017EB9C

    Morphit 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=false turns 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 records in the indexer log: the
        witness's picture was on a host name that no longer exists in DNS. On 2026-11-05 the
        blurt.world domain moved to parking nameservers, taking img.blurt.world with it, and
        images.blurt.buzz does 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 logs avatar_via_proxy;
        avatar_unavailable now 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: the waiting_payment hint is gone (paymentState === 'unpaid' →
      no hint); chat.legs.waiting_payment removed from the 10 locales.
    • Chat Security (stores/chatSecurity.ts): readChatSecurityMode always answers 'keep'
      (the self-copy is always attached); writeChatSecurityMode is gone. New
      readLockOnLeave(account, peer, order) / writeLockOnLeave(…), key
      morphit.chatSecurity.lockOnLeave.<account>\0<peer>\0<order>; unset falls back to the
      legacy morphit.chatSecurity.mode.<account> === 'destroy'. stores/identity.ts:
      holdLockOnLeave() — while held, handlePageHide drops the reload stash, tells the other
      tabs to lock and resets, instead of stashing. ConversationView.svelte holds it while the
      chat's setting is on and calls lockAllTabs() when the view leaves that chat. The PDF
      reminder modal and the current_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, asks get_block through the
      indexer relay and checks the transaction found by its txid in that block; a block not
      there yet is an rpc_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 ignores block.
    • 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; blurtLegCheck keeps 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-leg moneyFacts is 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.
      • ChatComposer takes persistDraft (false while the chat locks on leaving): no draft
        written, an existing one wiped at once.
      • /v1/payment-check answers carry age_seconds (the instance's clock);
        paymentChecks.checkOnce derives the age from it and no longer compares the device clock
        with checked_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.
    • Pay prefill: startPayNow awaits refreshPayPrefill() (market-price orders only: a fresh
      getPrice and the FX table, raced against PAY_PREFILL_WAIT_MS = 2500). The bug it fixes
      was reproduced in ConversationView.auditFlows.test.ts (a quote older than
      MAX_QUOTE_AGE_MS → 0.000) and the test was seen to fail without the fix.
    • PayBlurtModal.svelte takes fiatPerUnit and shows (≈<fiat>) (formatFiatCode in
      i18n/formatters.ts: locale digits, 0–2 decimals, then the code).
    • AddressShareModal.svelte takes orderValue and coinValue(coin); new PURE
      orders/coinValue.ts (fiatPerCoin, coinAmountForFiat), amounts capped at 8 decimals.
      ChatMessage.svelte hides the address card's "For order" line when the note already names
      the order.
    • Payment checks: paymentChecks.ts keeps checkedAtMs; confirmationLine(c, now) gives
      {confirmed, n, required, staleMinutes} (stale after
      PAYMENT_CHECK_STALE_AFTER_MS = 2 minutes). chat.payment_check.confirmed is an ICU plural
      on n; new chat.payment_check.checked_ago.
    • my_orders.order.action_relist_hint updated 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 returns coinsUsd — Bisq currencyCode entries are BTC per coin, Haveno
      <COIN>/XMR pairs 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: CoinQuoteSource combines the pricenode consensus with
      one CoinGecko /simple/price?ids=…&vs_currencies=usd and one CryptoCompare
      /data/pricemulti?fsyms=…&tsyms=USD request per refresh (only while
      sourceClearnetAllowed), with aggregateRobust; 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 in main.ts.
    • /v1/listing-fee gains asset_prices_usd (always USD; absent when empty;
      ListingFeeResponse in @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 in coinQuotes.ts removed 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 while missed_recent is null, i.e. under an hour of samples). witnessScore takes
        recentMissed; rankWitnesses passes 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.ts persistSelfReachable writes cached_indexed_block and
      cached_chain_lag_sec (lag blocks × 3) from the new localIndexedBlock (poller); COALESCE
      keeps the stored values when unknown. Test in federationProbeSelfBranding.test.ts.

    The Blurt Nodes page

    • routes/[lang]/witnesses/+page.svelte: each header cell is position: sticky (.wit-th;
      cells rather than the <thead>, which not every browser sticks), at --wit-sticky-top =
      the main menu's measured height (a ResizeObserver on 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-clip instead of overflow-hidden (hidden makes 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's scroll-padding-top is 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; without overflow: clip (Safari before 16) the corner cells round themselves.
    • Picture fallback (indexer/witnessService.ts): when the own picture URL fails, getAvatar
      asks avatarProxyUrl(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) takes sameOriginRedirects (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
  • v1.23.0 09e4f5977f

    Morphit v1.23.0
    All checks were successful
    morphit-ci / Supply-chain audit gate (every advisory triaged, none fixable in range) (push) Successful in 58s
    morphit-ci / TypeScript typecheck (sweep all workspaces) (push) Successful in 1m26s
    morphit-ci / apps/web svelte-check (svelte-kit sync + svelte-aware tsc) (push) Successful in 1m3s
    morphit-ci / Integration tests (real Postgres 16) (push) Successful in 7m29s
    morphit-ci / ansible-lint (playbook quality gate) (push) Successful in 47s
    morphit-ci / Smoke suite (run-smokes.sh, pulses 1–2 of 3) (push) Successful in 1h11m21s
    morphit-ci / Smoke suite (run-smokes.sh, pulse 3 of 3) (push) Successful in 35m55s
    morphit-release / Build + publish release tarball (push) Successful in 47m50s
    Stable

    Ghost released this 2026-11-06 02:50:04 +00:00 | 11 commits to main since this release

    Signed by agorise
    GPG key ID: 53524E1F1017EB9C

    Morphit 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 and User-Agent: morphit-indexer/witness-avatar. A zero-clearnet instance never
      does this;
    • relays account_witness_vote through /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 when clearnetRefused()). 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.
    • fetchPublicBytes lifted out of fetchJson (indexer/federationProbe.ts), so the pictures
      go through the same SSRF-guarded code, not a copy; fetchJson is 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 of dns.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, because owner is one of the
      security middleware's account parameters and forced no-store on the pictures; pictures have
      their own rate-limit bucket (witness-avatar), so a page of them cannot push a vote to 429;
      needs_bp 0 (tied votes) shows "tied with #N". test/indexer/witnessReviewFixes.test.ts;
      test/integration/witness-missed-samples.test.ts runs 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 in docs/API.md.
    • Migration 72 + schema.sql; witness_missed_samples is in LOCAL_ONLY_TABLES.
    • /v1/broadcast allows account_witness_vote; broadcast-op-allowlist-smoke checks 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), prepareUnsignedAccountWitnessVote in blurt/sign.ts, formatMonthYearShort
      ("Nov '25"), the route in seo/routes.ts and the sitemap, the footer link.
      UnlockActiveKeyModal takes purpose="vote" so it no longer calls a vote a payment.
    • ?next=: the same-origin check moved from /login into lib/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 old md breakpoint.
      • Announcement links go through lib/utils/safeWitnessLinkUrl.ts (http(s) only, no
        credentials, 512 characters at most; registered with href-xss-smoke); picture paths
        through witnessAvatarUrl() in lib/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=: safeNextPath also refuses a path that normalises to //host
        (/.//evil.example); /login honours next when only unlocking, and the QR sign-in passes
        it on (unlock-redirect-next-smoke checks safeNextPath itself).
      • @sveltejs/kit 2.70.4 (npm-audit gate); the schema-head smoke pins v72; the media kit zip
        is rebuilt.

    For monitoring scripts: new JSON

    GET /v1/witnesses (new). /v1/health is unchanged apart from version.

    Downloads
  • v1.22.1 23c77078dd

    Morphit v1.22.1
    All checks were successful
    morphit-ci / Supply-chain audit gate (every advisory triaged, none fixable in range) (push) Successful in 1m9s
    morphit-ci / TypeScript typecheck (sweep all workspaces) (push) Successful in 1m31s
    morphit-ci / apps/web svelte-check (svelte-kit sync + svelte-aware tsc) (push) Successful in 1m2s
    morphit-ci / Integration tests (real Postgres 16) (push) Successful in 8m5s
    morphit-ci / ansible-lint (playbook quality gate) (push) Successful in 55s
    morphit-ci / Smoke suite (run-smokes.sh, pulses 1–2 of 3) (push) Successful in 1h20m31s
    morphit-ci / Smoke suite (run-smokes.sh, pulse 3 of 3) (push) Successful in 38m57s
    morphit-release / Build + publish release tarball (push) Successful in 50m15s
    Stable

    Ghost released this 2026-11-04 18:35:32 +00:00 | 12 commits to main since this release

    Signed by agorise
    GPG key ID: 53524E1F1017EB9C

    Morphit 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 upgrade no 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-smoke counted the extra
    requests.

    Upgrade as usual.

    For developers

    • blurtFeeReverify.ts: the Sybil tier comes from countForSybilTierAtPosition (shared with
      the upgrade replay); countForSybilTierAsOf is 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 in fee_reverify_done have new spellings
      (underpaid_as_of_position, applied_as_of_position, rejected_as_of_position:…,
      unapplied_as_of_position:…); the old rule's still_underpaid and still_rejected:… are
      re-judged once (the row is updated in place). A stranger fee that is applied with no
      stranger_fees row 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's connect
      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), and withTx sets that error as the cause of the one it rethrows.
      The relay's connect() does the same through the client's release. ops-cli
      pgRoleHeal.ts: its pg.Client has an 'error' listener.
    • @morphit/hidden-transport/rpc-fetch: guardedRpcFetch(base, max, { signalUntilHeaders }).
      The global wrapper behind guardDblurtClient sets it: dblurt's per-attempt AbortSignal
      (500 ms × (attempt + 1)) can abort a request only until its headers arrive, as it did before
      the guard read the body inside fetch. Direct callers that pass their own deadline keep it
      over the whole reply. rpc-reply-budget-smoke now 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), relay test/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's net.connect(port, name)
      to a name (CI's postgres) failed with ERR_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