Draw funders to the left of the seed, where money comes from

"I still cannot see who transferred to that address on the front end." The
funders were on screen the whole time. They were drawn in the *rightmost*
column, which on a left-to-right flow diagram is where the money ends up.

`layer_nodes` walked forwards only. An address that paid the seed is not
reachable by following edges forwards, so it fell through to the "unreachable,
put it in the last column" clause --- past every address the money actually
reached. Both addresses that staked the LpdFi attacker, one of them 689,529
USDC, sat downstream of him in the position a reader takes to mean "where it
went". That is worse than leaving them out: an absent funder is a gap somebody
notices, a funder drawn as a recipient is a wrong answer shaped like a picture.

Depth is now signed --- negative upstream, positive downstream --- and the
frontend needed no change, because it already sorted depths numerically before
laying them out.

Upstream wins a tie, which the first version got backwards. Both of those
funders were also paid by the attacker (689,429 back to one, 116,495 to the
other), so with downstream winning they landed on the right again and the
funding was still invisible. For an address on both sides no column is true:
the arrows carry the direction and the column carries the emphasis, and the
emphasis belongs to the half a reader cannot otherwise see. Outbound is
already obvious --- it is the direction a trace fans out in.

The key now says which side means what, since a picture whose encoding is
undocumented gets read wrong, confidently.

Three of the new tests fail against the old function, checked by reverting it.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FXWQ25VgFeMuuMhGWjvdof

Author: Toby1009

src/chainscope/render/flow.py

@@ -67,15 +67,41 @@
 
 
 def layer_nodes(graph: Graph) -> dict[str, int]:
-    """Hop distance from the nearest seed, for every node.
+    """Signed hop distance from the nearest seed, for every node.
 
     Breadth-first over directed edges, so a column is "how many hops the money
     travelled", not "how far apart these are in the drawing".
 
-    Nodes unreachable from any seed get the last column rather than being
-    dropped. They are usually inbound counterparties of a seed --- money coming
-    *in* --- and a flow view that silently omits them shows an address that only
-    ever sent.
+    **Negative upstream, positive downstream, and the sign is the fix.** A
+    renderer lays these out left to right, so the sign is what puts the people
+    who *paid* the seed on its left and the people it paid on its right --- the
+    way money is read on every diagram anybody has seen.
+
+    Without it, a funder is not reachable from the seed by following edges
+    forwards, so it fell through to the ``furthest + 1`` clause below and was
+    drawn in the **rightmost** column: the picture said the seed's money ended
+    up at the address that had started it. Verified on the LpdFi case, where
+    both addresses that staked the attacker --- one of them 689,529 USDC --- sat
+    to the right of him, in the position a reader takes to mean "where it went".
+    That is worse than omitting them. An absent funder is a gap somebody can
+    notice; a funder drawn as a recipient is a wrong answer that looks like a
+    picture.
+
+    **Upstream wins a tie**, and the LpdFi case is why. Both addresses that
+    staked the attacker were also paid by him --- 689,429 USDC back to one,
+    116,495 to the other --- so with forward winning they both landed
+    downstream again and the funding was still invisible. For an address on
+    both sides no single column is true; the *arrows* carry the direction and
+    the column carries the emphasis, and the emphasis belongs to the half a
+    reader cannot otherwise see. Outbound is already obvious --- it is the
+    direction a trace fans out in --- while "who paid this address" is the
+    question that goes unanswered. So a box on the left paid the seed at least
+    once, and may also have been paid by it.
+
+    Anything reachable in neither direction still gets the last column. That is
+    now genuinely rare --- the graph is built from the seed's own edges --- and
+    it stays rather than being dropped, because a node with no path to the seed
+    is exactly the thing a reader should be able to see and ask about.
     """
     # Keyed by `address_key`, matching `_node_payload`'s ids. These were
     # `.lower()`, which on Solana, Sui or Bitcoin produced depth keys that
@@ -86,23 +112,30 @@ def layer_nodes(graph: Graph) -> dict[str, int]:
         for s in graph.seeds
     ]
     outgoing: dict[str, list[str]] = defaultdict(list)
+    incoming: dict[str, list[str]] = defaultdict(list)
     for edge in graph.edges.values():
-        outgoing[address_key(edge.chain, edge.source)].append(
-            address_key(edge.chain, edge.target)
-        )
+        source = address_key(edge.chain, edge.source)
+        target = address_key(edge.chain, edge.target)
+        outgoing[source].append(target)
+        incoming[target].append(source)
 
     depth: dict[str, int] = {}
-    queue: deque[tuple[str, int]] = deque()
-    for seed in seeds:
-        depth[seed] = 0
-        queue.append((seed, 0))
-
-    while queue:
-        address, level = queue.popleft()
-        for nxt in outgoing.get(address, ()):
-            if nxt not in depth:
-                depth[nxt] = level + 1
-                queue.append((nxt, level + 1))
+
+    def walk(adjacent: dict[str, list[str]], step: int) -> None:
+        queue: deque[tuple[str, int]] = deque()
+        for seed in seeds:
+            depth[seed] = 0
+            queue.append((seed, 0))
+        while queue:
+            address, level = queue.popleft()
+            for nxt in adjacent.get(address, ()):
+                if nxt not in depth:
+                    depth[nxt] = level + step
+                    queue.append((nxt, level + step))
+
+    # Upstream first, so it wins the tie described above.
+    walk(incoming, -1)
+    walk(outgoing, 1)
 
     furthest = max(depth.values(), default=0)
     for node in graph.nodes.values():

tests/unit/test_flow_render.py

@@ -237,3 +237,83 @@ def test_dragged_positions_survive_a_redraw(self):
         arranged."""
         html = to_flow_html(chain_graph())
         assert "keeps what the reader arranged" in html
+
+
+class TestWhichSideOfTheSeedAFunderLandsOn:
+    """A funder drawn to the right of the seed is a wrong answer, not a gap.
+
+    `layer_nodes` walked forwards only, so an address that *paid* the seed was
+    unreachable and fell through to the "put it in the last column" clause ---
+    the rightmost one, which on a left-to-right flow diagram is where the money
+    ended up. On the LpdFi case both addresses that staked the attacker, one of
+    them with 689,529 USDC, were drawn downstream of him.
+
+    An omitted funder is something a reader can notice is missing. A funder in
+    the recipient's position is a picture that reads cleanly and says the
+    opposite of what happened.
+    """
+
+    def _funded(self):
+        """F → A → B. A is the seed; F paid it; B was paid by it."""
+        funder = "0x" + "f" * 40
+        g = chain_graph()
+        g.add_node(Node(address=funder, chain=str(ETHEREUM), expanded=True))
+        g.add_edge(
+            Edge(
+                source=funder,
+                target=A,
+                chain=str(ETHEREUM),
+                symbol="ETH",
+                decimals=18,
+                total_raw=10**20,
+                transfer_count=1,
+            )
+        )
+        return g, funder
+
+    def test_a_funder_sits_upstream_of_the_seed(self):
+        g, funder = self._funded()
+        depth = layer_nodes(g)
+        assert depth[funder] < depth[A], (
+            "the address that paid the seed has to be drawn on the side a "
+            "reader takes to mean 'before'"
+        )
+
+    def test_a_funder_is_not_parked_in_the_last_column(self):
+        """The specific old behaviour, pinned so it cannot come back."""
+        g, funder = self._funded()
+        depth = layer_nodes(g)
+        assert depth[funder] < max(depth.values()), (
+            "it used to get `furthest + 1`, which put it further downstream "
+            "than every address the money actually reached"
+        )
+
+    def test_hop_distance_is_still_the_magnitude(self):
+        g, funder = self._funded()
+        depth = layer_nodes(g)
+        assert depth[funder] == -1
+        assert [depth[x] for x in (A, B, C, D)] == [0, 1, 2, 3]
+
+    def test_an_address_on_both_sides_is_placed_upstream(self):
+        """B is paid by the seed and also pays it.
+
+        No column is true for such an address --- the arrows carry the
+        direction, the column carries the emphasis --- and the emphasis goes to
+        the half a reader cannot otherwise see. This is not hypothetical: both
+        of the LpdFi attacker's funders were also paid by him, so with
+        downstream winning they landed on the right again and the funding
+        stayed invisible, which is the whole complaint this fixes.
+        """
+        g = chain_graph()
+        g.add_edge(
+            Edge(
+                source=B,
+                target=A,
+                chain=str(ETHEREUM),
+                symbol="ETH",
+                decimals=18,
+                total_raw=10**18,
+                transfer_count=1,
+            )
+        )
+        assert layer_nodes(g)[B] == -1

web/src/components/graph.tsx

@@ -398,8 +398,9 @@ export function Graph({
             </dd>
             <dt className="wide" />
             <dd className="wide">
-              Columns are <b>hops</b>, not time. A box further right is further
-              from the seed, not later.
+              <b>Left of the seed paid it; right of it was paid.</b> Columns are{" "}
+              <b>hops</b>, not time — a box further out is further from the seed,
+              not later.
             </dd>
           </dl>
         ) : null}

web/src/lib/layout.ts

@@ -27,7 +27,16 @@ export const GUTTER = 300;
 export type Placed = GraphNode & { x: number; y: number };
 
 /**
- * Columns by hop depth, left to right.
+ * Columns by signed hop depth, left to right.
+ *
+ * The sign carries the direction of the money: `layer_nodes` gives an address
+ * that **paid** the seed a negative depth and one the seed paid a positive one,
+ * so sorting numerically puts funders to the left of the seed and recipients to
+ * the right. That is the only arrangement in which the picture agrees with how
+ * everybody already reads a flow diagram — and before the sign existed, a
+ * funder was unreachable going forwards and landed in the *rightmost* column,
+ * so the graph showed the address that staked an attacker 689,529 USDC sitting
+ * where the money ended up.
  *
  * Deliberately not a force layout. Force arranges by connectivity, and then a
  * five-hop laundering chain and a five-way split look identical — the one