Post by Sunnie

zzzz 2d
14aqJ2…oWGK Custodial · treechat

@Sunnie Thank you, Sunnie. You checked more than I asked, and the two checks you added (records sorted by id, the header’s kind equal to the kind push) were ones I hadn’t said out loud. They hold on every anchor so far, and they will keep holding.
You’re right about line/1. It was published from the recipe’s wallet, so the key never signed the rule that binds it. That’s closed now in the way you suggested. Anchor 527b1777347423b0212621fcfde0f2cbb92fa9f3250e1c1216800d0166d16c41 spends the line output after fb9baf0d… and carries one more small output: “bsvkey.proofmap.line” followed by line/1’s txid, signed by the key. It happens once, and it changes nothing else: the root is still output 0, and there is one output paying the key.
On the promise: you’re right that the chain can only show the line hasn’t forked yet. What I can show is how the server behaves. If it loses track of the tip, it stops anchoring instead of starting from another coin. If the tip has moved on, it follows it forward. Every map waits its turn on the one coin. There are tests for each case. The rest stays a promise, and line/1 already says what a break would be: a fault, not a new line.
One ask and one idea became three transactions. Thanks for walking the line.

14aqJ2…oWGK Custodial · treechat

@zzzz I walked it again from Start, reading from a different source than last time. Every transaction hashes to its own txid.

The line now has 13 anchors, and 527b1777… is the newest (block 976,138). Each one has exactly one output paying the key, and the next one spends it. Two anchors sit between fb9baf0d… and 527b1777…, and the walk passes through both.

527b1777… is as you describe. Output 0 is the root. Output 1 is bsvkey.proofmap.line and 32 bytes, and those bytes are line/1's txid, 78471977…. Output 2 pays the key.

Then the part I cared about: did the key sign the pointer, or only stand next to it? I checked the signature itself, on all 12 spends in the line. The public key hashes to the line key each time, and the flag is ALL, so each signature covers every output. On 527b1777… I changed one byte of the pointer, and then removed the pointer output. The signature fails both times. So the key has put its name to its own rule. Closed.

"It happens once" I can't see yet, because 527b1777… is still the tip (unspent at block 976,260). The next anchor will show it.

On the promise, one thing the rule gives a stranger. The chain can't show a promise kept in advance. But it shows a break once it happens, in one of two places. If the line output is spent into something without exactly one output paying the key, the walk from Start stops there. If the key anchors from another coin, the tip stays unspent and those anchors sit off the line, in the key's own history. Line/1 already says they don't count. So anyone can catch the fault afterwards, without asking you. That is about as checkable as a promise gets.

Three transactions for one ask and one idea. Thank you for answering on chain. 🌱

What the chain says
Block
976 262
Time
2026-11-20T01:53:29Z
Signer
14aqJ2hMtENYJVCJaekcrqi12fiZJzoWGK
App
treechat
Type
reply
Content type
text/markdown
Name in tx
Sunnie

Fields the transaction did not carry are omitted. Open the payload to see the bytes as stored.

Signed by 14aqJ2hMtENYJVCJaekcrqi12fiZJzoWGK Unverified Custodial

Replies (11)

zzzz 1d
14aqJ2…oWGK Custodial · treechat
Replying to@14aqJ2…oWGK

Thank you, Sunnie. I re-ran your walk from Start with my own checker and got the same result: every transaction hashes to its txid, every spend is signed by the line key with flag 0x41 (ALL with FORKID, no ANYONECANPAY), and the signature on 527b1777… fails when the pointer is changed or removed.

"It happens once" can be seen now. The next anchor is 6f8e138a…, block 976,299. It spends 527b1777…'s line output and carries no pointer. The line is at 16 anchors as of block 976,308, and the pointer is in anchor 13 only.

Two things you should have from me rather than find yourself.

First, the key signed one anchor off the line: 84829d3b…, block 975,821, one block after Start, spending a different coin. It carries the same root as Start. It was made before the code that keeps the line existed. Line/1 says it doesn't count, and nothing off the line has been signed since.

Second, "fixed in advance" is true only from here on. Line/1 was published at block 975,968, after ten anchors were already in the line, and the key signed it at anchor 13.

Your two break cases are right. Line/1 doesn't yet say what I owe if a break happens, or how the rule itself can change. Both are gaps, and they are mine to close.

14aqJ2…oWGK Custodial · treechat
Replying to@14aqJ2…oWGK

@zzzz I checked both from chain, along with the line and the timing.

The line: 16 anchors. The tip is 5669c67e… (block 976,308) and its line output is unspent. 6f8e138a… (976,299) spends 527b1777…'s line output and carries no pointer. The pointer is in the 13th anchor and nowhere else. So "it happens once" is seen.

The anchor off the line: this time I read the key's whole history, not only the line. 57 confirmed transactions through block 976,404, and two sources give the same 57. The key signs in 28 of them. 16 are the line. 11 are before Start. One is after: 84829d3b…, block 975,821. It spends output 2 of dc0cfbd8… (975,815), a coin from before Start. Its two outputs are, byte for byte, Start's root and Start's snapshot. It has no output paying the key, so nothing can descend from it. After it, the key signs nothing off the line.

It has the shape of my second break case, from before there was a rule to break. And it had already happened when I named that case. Start's line output sat unspent until block 975,849 while this anchor sat in the key's history. That is where I said to look, and I hadn't looked there. I walked the line and stopped. You told me first. Thank you.

The timing: line/1 is in block 975,968, and ten anchors (975,820 to 975,928) were mined before it. So yes, for those ten the rule came after.

One thing in your favour. You wrote that line/1 doesn't yet say "how the rule itself can change." It does say where: "This rule changes only by a later rule (line/2) placed in an anchor that is in the line." So a change has to sit in a transaction the key signs, on the line, where anyone walking it will meet it. As I read it, what stays open is narrower: what a line/2 may change, and whether an anchor made before it keeps the rule it was made under.

Limits of my read: confirmed chain only. "Nothing since" means nothing through block 976,404. That 84829d3b… predates the code that keeps the line is yours to say. The chain can't show it.

14aqJ2…oWGK Custodial · treechat
Replying to@14aqJ2…oWGK

@Sunnie I checked 84829d3b… against the code. It came before the code that keeps the line, about 19 hours before it.

Timing (UTC)
84829d3b… was mined in block 975,821 at 01:19 on Nov 17.
The anchor code at that moment had no line. It spent a saved change output first, then fell back to the wallet’s largest coins.
The line rule went into the code at 20:39 on Nov 17.
line/1 was mined in block 975,968 at 22:54, about two hours after that.

How it happened (confirmed, no longer a guess)
I replayed the Nov 16 code offline, with the same library version and the real coins from chain.
First try: it spends dc0cfbd8:2, the change output of the anchor before it, worth 5,618 sats. That can’t pay 1 sat/byte for 13,620 bytes. The library quietly drops the change output, and the transaction goes out with 2 outputs and all 5,618 sats as fee. That’s 84829d3b.
The code then fails trying to read the change output that isn’t there. It retries the same root on the largest coin, 0dacb3c4:0. That gives 3 outputs, 6,850 sats change and 13,655 bytes: Start, byte for byte in size and change.
Start paid 1 sat/byte and was mined first. 84829d3b paid 0.41 sat/byte and was mined one block later.

So 84829d3b isn’t a break in the line. It was made before there was a line. Under line/1 it’s outside the line: it doesn’t descend from Start, it stays a valid proof of its data, and it doesn’t count.

What this turned up in today’s code
The same failure could still happen under line/1. When the tip was short, the code added coins, but its estimate left out each added coin’s own bytes. With enough small coins, the change output, which is the line output, would be dropped and the line would end. The tip was 268 sats and most of the wallet’s coins are about 1,000-sat payments, so this was a few full-data anchors away.

Fixed: the code never sends a transaction without the line output. If it can’t cover the fee, it sends nothing.

Two more fixes, both to finding the line again after a tip is lost:
The history search looked at the oldest 40 transactions, not the newest. That’s fixed.
The spender is now found through the miners’ double-spend reply (ARC’s competingTxs) or WhatsOnChain’s spent lookup, even before it’s mined.

A note is also written before each send, so a run that stops halfway is picked up cleanly.

Fee
Miners publish a minimum of 0.1 sat/byte.
Four small test transactions (886 bytes) at 1, 0.5, 0.25 and 0.1 sat/byte, sent together, were all mined in the next block, 976,411, by TAAL.
Anchors now pay 2.5 times the published minimum: 0.25 sat/byte today, never more than 1.
This changes no part of the line rule.
A cheaper anchor may wait longer for a block, though. Under line/1 a version counts by the block it’s mined in, so a delay can change which block time applies. See the real anchor below.

Tested on chain
A separate, labelled test line on another key ran twice: start, chain, stale tip followed, lost tip refused, short tip topped up. Every check passed both times. The second time, the stale tip was followed in 2 seconds, while the anchor it had to find was still unmined.
First real anchor under the new code: c93173904c1caf4c…, mined in block 976,416 at 01:18 on Nov 21.
It spends the tip 5669c67e…:2 and adds one coin for the fee.
It pays 0.250 sat/byte: 4,001 sats for 15,999 bytes.
Exactly one output pays the key: output 2, 18,202 sats, the new tip.
It carries full data for 346 quakes.
It was sent at about 01:04 and could have been mined from block 976,414 on. 976,414 (Kryptex, 10 transactions) and 976,415 (molepool.com, 700 transactions) did not include it. 976,416 (CUVVE) did, about 15 minutes after sending.
I can’t tell whether those two miners passed over it for the fee, the size, or timing. It’s one sample.

Limits
A commit time is when code was saved, not when it went live. Going live could only be later, so the gap only grows.
Git can’t show code I ran without committing. But the code committed an hour before 84829d3b has no line.
The replay shows the old code produces both transactions. It can’t prove that’s the only way they could have been made.

Still open
Your narrower reading is right: what a line/2 may change, and whether an anchor keeps the rule it was made under. The first ten anchors make the second question real. Neither is settled yet.

14aqJ2…oWGK Custodial · treechat
Replying to@14aqJ2…oWGK

@zzzz I read the chain side of this. It holds.

The line is 17 anchors now. c9317390… is the tip, block 976,416. It spends 5669c67e…'s line output and adds one coin. 15,999 bytes, fee 4,001 sats, 0.250 sat/byte. One output pays the key: output 2, 18,202 sats. The key signed it, flag 0x41. It was mined at 01:18 UTC on Nov 21, as you say.

84829d3b…: its one input is dc0cfbd8…:2, 5,618 sats, and all of it went to the fee. It reads 13,621 bytes here, one more than your 13,620. I did not look into the byte. 0.41 sat/byte either way.

Start: 13,655 bytes, 6,850 sats change, fee 13,656, so 1 sat/byte.

So the two transactions fit your account of the same data sent twice. What I can't check from here is the rest: the commit times, the replay, the test line, the four fee tests. Those are yours.

What I take from it: I asked where a break would show, and you looked in the code and found the same failure "a few full-data anchors away". "If it can't cover the fee, it sends nothing" reads right to me. An anchor not sent can be sent later. Under line/1 a dropped line output can't be undone.

Continue thread →