chore: escrow fixes

Author: sphamjoli

packages/ui/src/lib/escrowStatus.test.ts

@@ -5,6 +5,7 @@ import {
   isRefundClaimable,
   totalEscrowAmount,
   isRefundableDeposit,
+  isAccountPosition,
   cooldownRemainingSeconds,
   formatCooldown,
 } from "./escrowStatus";
@@ -18,6 +19,32 @@ describe("isRefundableDeposit", () => {
   });
 });
 
+describe("isAccountPosition", () => {
+  const recipient = "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd";
+  const other = "0x2222222222222222222222222222222222222222";
+
+  it("accepts a funded position whose recipient matches", () => {
+    expect(isAccountPosition({ recipient, amount: 5n }, recipient)).toBe(true);
+  });
+
+  it("ignores letter case in the recipient comparison", () => {
+    const upperBody = `0x${recipient.slice(2).toUpperCase()}`;
+    expect(isAccountPosition({ recipient: upperBody, amount: 5n }, recipient)).toBe(true);
+  });
+
+  it("rejects a null read so a missing or failed lookup never qualifies", () => {
+    expect(isAccountPosition(null, recipient)).toBe(false);
+  });
+
+  it("rejects a position that rebound to a different recipient", () => {
+    expect(isAccountPosition({ recipient: other, amount: 5n }, recipient)).toBe(false);
+  });
+
+  it("rejects a zero-amount position", () => {
+    expect(isAccountPosition({ recipient, amount: 0n }, recipient)).toBe(false);
+  });
+});
+
 describe("totalEscrowAmount", () => {
   it("is zero for no positions", () => {
     expect(totalEscrowAmount([])).toBe(0n);

packages/ui/src/lib/escrowStatus.ts

@@ -1,4 +1,5 @@
 // Time-gated escrow rules kept pure and out of the component so they can be tested.
+import { isSameEvmAddress } from "./address";
 
 export type ReleaseState = {
   amount: bigint;
@@ -32,6 +33,21 @@ export function isRefundableDeposit(position: { amount: bigint }): boolean {
   return position.amount > 0n;
 }
 
+// A read position belongs to `recipient` when the escrow still names them as the
+// refund recipient and the deposit is refundable. A null read (missing or failed)
+// never qualifies. Shared by the UI store and mirrors the CLI's filter so both
+// surface the same set of positions.
+export function isAccountPosition<T extends { recipient: string; amount: bigint }>(
+  position: T | null,
+  recipient: string,
+): position is T {
+  return (
+    position !== null &&
+    isSameEvmAddress(position.recipient, recipient) &&
+    isRefundableDeposit(position)
+  );
+}
+
 // Total still locked across positions. Withdrawn positions carry amount 0 (the
 // contract zeroes it on withdraw), so they fall out of the sum naturally.
 export function totalEscrowAmount(positions: readonly { amount: bigint }[]): bigint {

packages/ui/src/store/useEscrowStore.ts

@@ -3,8 +3,7 @@ import { zeroAddress, type Address, type Hash } from "viem";
 import { getContract, getEscrowContract, withContractRecovery } from "@/composables/useContracts";
 import { NAME_ESCROW_ADDRESS } from "@/lib/abis/nameEscrow";
 import { useContractWrite } from "@/lib/contractWrite";
-import { isRefundableDeposit } from "@/lib/escrowStatus";
-import { isSameEvmAddress } from "@/lib/address";
+import { isAccountPosition } from "@/lib/escrowStatus";
 import { computeDomainTokenId, normalizeDomainName, ZERO_SUBSTRATE_ADDRESS } from "../utils";
 
 export type EscrowPosition = {
@@ -84,19 +83,25 @@ export const useEscrowStore = defineStore("useEscrowStore", () => {
   // by the escrow contract) still resolves through the caller's own label set;
   // the recipient filter drops names transferred away whose position rebound to
   // someone else.
+  //
+  // Reads run sequentially, mirroring the CLI. A parallel burst overruns the
+  // chainHead_follow subscription, and every read that then sees "No active
+  // follow" races to reset the shared client out from under the others, so the
+  // retries fail too and those positions silently vanish. Pacing the reads keeps
+  // the subscription alive and a single recovery serves the whole list.
   async function listAccountPositions(
     recipient: Address,
     domains: string[],
   ): Promise<EscrowPosition[]> {
-    const results = await Promise.all(
-      domains.map((domain) => getPosition(domain).catch(() => null)),
-    );
-    return results.filter(
-      (position): position is EscrowPosition =>
-        position !== null &&
-        isSameEvmAddress(position.recipient, recipient) &&
-        isRefundableDeposit(position),
-    );
+    const positions: EscrowPosition[] = [];
+    for (const domain of domains) {
+      const position = await getPosition(domain).catch((error) => {
+        console.warn(`[useEscrowStore] failed to read escrow position for ${domain}`, error);
+        return null;
+      });
+      if (isAccountPosition(position, recipient)) positions.push(position);
+    }
+    return positions;
   }
 
   // pendingRefunds returns ids and entries together, so one read covers the page.