Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
40 changes: 40 additions & 0 deletions client/e2e/block-states.spec.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,40 @@
import { expect, test } from '@playwright/test';
import { stubApi } from './apiStub';

// The block page tells a block that does not exist apart from one it could not load.

test('a block the explorer does not have is reported as not found @smoke', async ({ page }) => {
await stubApi(page);
let requests = 0;
await page.route('**/api/block/123', (route) => {
requests += 1;
return route.fulfill({ status: 404, json: { success: false, error: { code: 'NOT_FOUND', message: 'Block not found' } } });
});

await page.goto('/block/123');

await expect(page.getByText('Block not found', { exact: true })).toBeVisible();
await expect(page.getByText('Block "123" was not found. It may not be synced yet.')).toBeVisible();
await expect(page.getByRole('link', { name: 'Browse Blocks' })).toHaveAttribute('href', '/blocks');
await expect(page.getByText('Block could not be loaded')).toHaveCount(0);
// A "not found" answer does not change on a retry.
expect(requests).toBe(1);
});

test('a block that fails to load is reported as an error, not as missing @smoke', async ({ page }) => {
await stubApi(page);
let requests = 0;
await page.route('**/api/block/123', (route) => {
requests += 1;
return route.fulfill({ status: 500, json: { success: false, error: { code: 'INTERNAL', message: 'Failed to fetch block' } } });
});

await page.goto('/block/123');

const panel = page.locator('.state-panel[data-tone="danger"]');
await expect(panel.getByText('Block could not be loaded')).toBeVisible();
await expect(panel).toContainText('Failed to fetch block');
await expect(page.getByText('Block not found', { exact: true })).toHaveCount(0);
// A server error is tried once more before the page gives up.
expect(requests).toBe(2);
});
14 changes: 10 additions & 4 deletions client/e2e/fonts.spec.ts
Original file line number Diff line number Diff line change
Expand Up @@ -49,11 +49,11 @@ test('the site fonts load from this origin under the production content security
expect(fontPolicyViolations).toEqual([]);
});

const delayedStats = () => ({
const statsWithLastBlockAgo = (seconds: number) => ({
success: true,
data: {
blockHeight: 130_000,
lastBlockTime: Math.floor(Date.now() / 1000) - 11 * 60,
lastBlockTime: Math.floor(Date.now() / 1000) - seconds,
difficulty: 1,
hashrate: 1,
connections: 8,
Expand All @@ -69,17 +69,21 @@ const delayedStats = () => ({
},
});

const delayedStats = () => statsWithLastBlockAgo(11 * 60);

// The longest status labels leave the least room next to them. Every case must fit on one row
// without sideways scrolling, with 40px search and menu buttons. Up to 520px the header shows the
// logo without the title (which stays the link's name); below 360px the block height moves to the
// menu while the status is not "Live".
// menu while the status is not "Live". "Polling" is healthy but as long as "Delayed".
const NARROW_HEADER_CASES = [
{ width: 600, label: 'Disconnected', titleShown: true, heightInTopBar: true },
{ width: 521, label: 'Disconnected', titleShown: true, heightInTopBar: true },
{ width: 360, label: 'Delayed', titleShown: false, heightInTopBar: true },
{ width: 360, label: 'Disconnected', titleShown: false, heightInTopBar: true },
{ width: 360, label: 'Polling', titleShown: false, heightInTopBar: true },
{ width: 320, label: 'Delayed', titleShown: false, heightInTopBar: false },
{ width: 320, label: 'Disconnected', titleShown: false, heightInTopBar: false },
{ width: 320, label: 'Polling', titleShown: false, heightInTopBar: false },
];

const disconnectedSync = {
Expand All @@ -90,9 +94,11 @@ const disconnectedSync = {
for (const { width, label, titleShown, heightInTopBar } of NARROW_HEADER_CASES) {
test(`a ${width}px screen fits the header on one row beside "${label}" @smoke`, async ({ page }) => {
await page.unroute('**/api/**');
// A closed realtime connection with a current chain is "Polling".
if (label === 'Polling') await page.routeWebSocket('**/ws', (socket) => socket.close());
await stubApi(page, label === 'Disconnected'
? { '/api/stats': delayedStats(), '/api/sync': disconnectedSync }
: { '/api/stats': delayedStats() });
: { '/api/stats': label === 'Polling' ? statsWithLastBlockAgo(60) : delayedStats() });
await page.setViewportSize({ width, height: 780 });

await page.goto('/');
Expand Down
218 changes: 218 additions & 0 deletions client/e2e/live-details.spec.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,218 @@
import { expect, test, type Page, type WebSocketRoute } from '@playwright/test';
import { stubApi } from './apiStub';

// An open transaction, block or address page follows the chain: when the realtime connection
// announces a new block, the page asks again and shows the new state without a reload.

const BLOCK_TIME = 1_788_609_600; // 2026-09-05 12:00:00 UTC
const TIP = 123_456;
const HASH = 'a'.repeat(64);
const NEXT_HASH = 'c'.repeat(64);
const TXID = `d${'e'.repeat(62)}f`;
const NEW_TXID = `7${'6'.repeat(62)}5`;
const ADDRESS = 'DGK3yNxxedc2pvaPPwTbVBey2NmFC8FUGZ';
const OTHER = `D${'R'.repeat(33)}`;

/**
* A realtime connection that stays open and the chain tip it reports. `newBlock()` moves the tip
* one block on and announces it the way the server does, with the next sequence number.
*/
async function followChain(page: Page) {
let socket: WebSocketRoute | null = null;
let seq = 1;
const chain = {
tip: TIP,
async newBlock() {
await expect.poll(() => socket !== null).toBe(true);
chain.tip += 1;
seq += 1;
socket!.send(JSON.stringify({
type: 'block:new', ts: new Date().toISOString(), seq,
data: { hash: chain.tip === TIP + 1 ? NEXT_HASH : 'f'.repeat(64), height: chain.tip, time: BLOCK_TIME + 150, txCount: 2 },
}));
},
};
await page.routeWebSocket('**/ws', (ws) => {
socket = ws;
ws.send(JSON.stringify({ type: 'hello', ts: new Date().toISOString(), seq: 1, data: {} }));
});
return chain;
}

function transaction(txid: string, height: number, tip: number) {
const output = (n: number, value: number, address: string) => ({
n, value, valueSat: String(Math.round(value * 1e8)), scriptPubKey: { asm: '', hex: '', type: 'pubkeyhash', addresses: [address] },
});
return {
txid, blockhash: HASH, blockheight: height, blocktime: BLOCK_TIME, version: 3, size: 225, locktime: 0,
vin: [{ txid: 'f'.repeat(64), vout: 0, sequence: 0, address: ADDRESS, value: 15, valueSat: '1500000000' }],
vout: [output(0, 10, OTHER), output(1, 4.9999, ADDRESS)],
totalValueIn: 15, totalValueOut: 14.9999, fee: 0.0001,
totalValueInSat: '1500000000', totalValueOutSat: '1499990000', feeSat: '10000',
isCoinbase: false, confirmations: tip - height + 1,
};
}

test('an open transaction page shows the new confirmation count after a block @smoke', async ({ page }) => {
await stubApi(page);
const chain = await followChain(page);
await page.route(`**/api/tx/${TXID}`, (route) =>
route.fulfill({ json: { success: true, data: transaction(TXID, TIP - 2, chain.tip) } }));

await page.goto(`/tx/${TXID}`);
const confirmations = page.locator('.detail-row')
.filter({ has: page.locator('.detail-label', { hasText: /^Confirmations$/ }) })
.locator('.detail-value');
await expect(confirmations).toHaveText('3');

await chain.newBlock();
await expect(confirmations).toHaveText('4');
});

test('an open block page at the chain tip gains its link to the next block @smoke', async ({ page }) => {
await stubApi(page, {
[`/api/block/${TIP}/txs`]: { success: true, data: [], pagination: { page: 1, limit: 20, total: 0, pages: 1 } },
});
const chain = await followChain(page);
await page.route(`**/api/block/${TIP}`, (route) => route.fulfill({ json: { success: true, data: {
hash: HASH, height: TIP, confirmations: chain.tip - TIP + 1, size: 538, version: 0x20000000, merkleroot: 'b'.repeat(64),
time: BLOCK_TIME, mediantime: BLOCK_TIME, nonce: 0, bits: '190a969d', difficulty: 400_000_000, chainwork: '0', nTx: 0,
rewardSat: 1_050_000_000_000, totalValueOutSat: 0, txids: [], reward: 10_500, totalValueOut: 0,
previousblockhash: 'e'.repeat(64), ...(chain.tip > TIP ? { nextblockhash: NEXT_HASH } : {}),
} } }));

await page.goto(`/block/${TIP}`);
const nav = page.getByRole('navigation', { name: 'Neighbouring blocks' });
await expect(page.getByText('1 Confirmations')).toBeVisible();
await expect(nav.getByRole('link', { name: 'Block #123,455' })).toBeVisible();
await expect(nav.getByRole('link', { name: 'Block #123,457' })).toHaveCount(0);

await chain.newBlock();
await expect(nav.getByRole('link', { name: 'Block #123,457' })).toHaveAttribute('href', `/block/${TIP + 1}`);
await expect(page.getByText('2 Confirmations')).toBeVisible();
});

/**
* An address page whose answers follow the chain tip. `options.fail` makes every answer after the
* new block a server error; otherwise the list answer after the new block waits until `release()`.
*/
async function openAddress(page: Page, chain: Awaited<ReturnType<typeof followChain>>, options: { fail?: boolean } = {}) {
await stubApi(page);
let release = () => {};
const held = new Promise<void>((resolve) => { release = resolve; });
const seen = { summaryAfterBlock: 0, listAfterBlock: 0 };
const txs = () => chain.tip > TIP
? [transaction(NEW_TXID, chain.tip, chain.tip), transaction(TXID, TIP - 2, chain.tip)]
: [transaction(TXID, TIP - 2, chain.tip)];
const failure = { status: 500, json: { success: false, error: { code: 'INTERNAL', message: 'Failed to fetch address' } } };
await page.route(`**/api/address/${ADDRESS}`, (route) => {
if (chain.tip > TIP) seen.summaryAfterBlock += 1;
if (chain.tip > TIP && options.fail) return route.fulfill(failure);
return route.fulfill({ json: { success: true, data: {
address: ADDRESS, balance: 4.9999, totalReceived: 19.9999, totalSent: 15, txCount: txs().length,
balanceSat: '499990000', totalReceivedSat: '1999990000', totalSentSat: '1500000000',
} } });
});
await page.route(`**/api/address/${ADDRESS}/txs?*`, async (route) => {
if (chain.tip > TIP) {
seen.listAfterBlock += 1;
if (options.fail) return route.fulfill(failure);
await held;
}
return route.fulfill({ json: {
success: true, data: txs(), pagination: { page: 1, limit: 20, total: txs().length, pages: 1 },
} });
});

await page.goto(`/address/${ADDRESS}`);
await expect(page.locator('.searchv2-address-total')).toHaveText('1 total transaction');
await expect(page.locator(`a[href="/tx/${TXID}"]`).first()).toBeVisible();
await expect(page.locator(`a[href="/tx/${NEW_TXID}"]`)).toHaveCount(0);
return { seen, release: () => release() };
}

test('an open address page lists a transaction from the new block @smoke', async ({ page }) => {
const chain = await followChain(page);
const address = await openAddress(page, chain);

await chain.newBlock();
// While the new list is on its way, the current one stays on screen instead of a loading line.
await expect.poll(() => address.seen.listAfterBlock).toBeGreaterThan(0);
await expect(page.locator(`a[href="/tx/${TXID}"]`).first()).toBeVisible();
await expect(page.getByText('Loading transactions for this address...')).toHaveCount(0);

address.release();
await expect(page.locator(`a[href="/tx/${NEW_TXID}"]`).first()).toBeVisible();
await expect(page.locator('.searchv2-address-total')).toHaveText('2 total transactions');
});

// A refresh after a new block that fails keeps what the page already shows; the next block or
// poll tries again. Each page retries a failed request once, so two failed answers mean it gave up.

test('an open transaction page keeps the transaction when the refresh after a block fails @smoke', async ({ page }) => {
await stubApi(page);
const chain = await followChain(page);
let afterBlock = 0;
await page.route(`**/api/tx/${TXID}`, (route) => {
if (chain.tip === TIP) return route.fulfill({ json: { success: true, data: transaction(TXID, TIP - 2, chain.tip) } });
afterBlock += 1;
return route.fulfill({ status: 500, json: { success: false, error: { code: 'INTERNAL', message: 'Failed to fetch transaction' } } });
});

await page.goto(`/tx/${TXID}`);
const confirmations = page.locator('.detail-row')
.filter({ has: page.locator('.detail-label', { hasText: /^Confirmations$/ }) })
.locator('.detail-value');
await expect(confirmations).toHaveText('3');

await chain.newBlock();
await expect.poll(() => afterBlock, { timeout: 10_000 }).toBe(2);
await page.waitForTimeout(300);
await expect(confirmations).toHaveText('3');
await expect(page.getByText('Transaction could not be loaded')).toHaveCount(0);
});

test('an open block page keeps the block when the refresh after a block fails @smoke', async ({ page }) => {
await stubApi(page, {
[`/api/block/${TIP}/txs`]: { success: true, data: [], pagination: { page: 1, limit: 20, total: 0, pages: 1 } },
});
const chain = await followChain(page);
let afterBlock = 0;
await page.route(`**/api/block/${TIP}`, (route) => {
if (chain.tip > TIP) {
afterBlock += 1;
return route.fulfill({ status: 500, json: { success: false, error: { code: 'INTERNAL', message: 'Failed to fetch block' } } });
}
return route.fulfill({ json: { success: true, data: {
hash: HASH, height: TIP, confirmations: 1, size: 538, version: 0x20000000, merkleroot: 'b'.repeat(64),
time: BLOCK_TIME, mediantime: BLOCK_TIME, nonce: 0, bits: '190a969d', difficulty: 400_000_000, chainwork: '0', nTx: 0,
rewardSat: 1_050_000_000_000, totalValueOutSat: 0, txids: [], reward: 10_500, totalValueOut: 0,
previousblockhash: 'e'.repeat(64),
} } });
});

await page.goto(`/block/${TIP}`);
await expect(page.getByText('1 Confirmations')).toBeVisible();

await chain.newBlock();
await expect.poll(() => afterBlock, { timeout: 10_000 }).toBe(2);
await page.waitForTimeout(300);
await expect(page.getByRole('heading', { name: 'Block #123,456' })).toBeVisible();
await expect(page.getByText('1 Confirmations')).toBeVisible();
await expect(page.getByText('Block could not be loaded')).toHaveCount(0);
});

test('an open address page keeps its summary and list when the refresh after a block fails @smoke', async ({ page }) => {
const chain = await followChain(page);
const address = await openAddress(page, chain, { fail: true });

await chain.newBlock();
// Both the summary and the list are retried once.
await expect.poll(() => address.seen.summaryAfterBlock, { timeout: 10_000 }).toBe(2);
await expect.poll(() => address.seen.listAfterBlock, { timeout: 10_000 }).toBe(2);
await page.waitForTimeout(300);
await expect(page.locator(`a[href="/tx/${TXID}"]`).first()).toBeVisible();
await expect(page.locator('.searchv2-address-total')).toHaveText('1 total transaction');
await expect(page.getByText('Address details could not be loaded')).toHaveCount(0);
await expect(page.getByText('Failed to fetch address')).toHaveCount(0);
});
46 changes: 46 additions & 0 deletions client/e2e/navigation.spec.ts
Original file line number Diff line number Diff line change
Expand Up @@ -224,6 +224,52 @@ test('header does not report live when the indexed chain is delayed @smoke', asy
await expect(status).toHaveAttribute('title', /Latest indexed block is .*old/);
});

test('header shows a current chain without realtime connection as healthy polling, not as a warning @smoke', async ({ page }) => {
await page.routeWebSocket('**/ws', (socket) => socket.close());
await page.unroute('**/api/**');
await stubApi(page, {
'/api/stats': {
success: true,
data: {
blockHeight: 130_000,
lastBlockTime: Math.floor(Date.now() / 1000) - 60,
difficulty: 1,
hashrate: 1,
connections: 8,
mempool: { size: 0, bytes: 0 },
supply: { circulating: 1, max: null },
blockReward: 1,
stakingReward: 0,
avgBlockTime: 150,
totalTransactions: 1,
totalAddresses: 1,
masternodes: 1,
stakingWallets: 1,
},
},
});

await page.goto('/');
const status = page.locator('.status-chip-live').first();
await expect(status).toContainText('Polling');
await expect(status).toHaveAttribute('title', /Indexed chain is current/);
await expect(status).not.toHaveClass(/degraded/);
// The chip keeps the healthy (green) colour of "Live".
const colours = await status.evaluate((chip) => ({
label: getComputedStyle(chip.querySelector('.status-chip-label') as Element).color,
success: getComputedStyle(document.documentElement).getPropertyValue('--success').trim(),
}));
const probe = await page.evaluate((value) => {
const element = document.createElement('span');
element.style.color = value;
document.body.append(element);
const rgb = getComputedStyle(element).color;
element.remove();
return rgb;
}, colours.success);
expect(colours.label).toBe(probe);
});

test('mobile drawer exposes the same top-level navigation @smoke', async ({ page }, testInfo) => {
test.skip(testInfo.project.name !== 'mobile-chromium', 'Mobile navigation is covered in the mobile project.');

Expand Down
14 changes: 10 additions & 4 deletions client/src/components/flow/AddressFlow.tsx
Original file line number Diff line number Diff line change
Expand Up @@ -32,9 +32,11 @@ export default function AddressFlow({ address }: { address: string }) {
retry: retryFailedRequestOnce,
});
const summary = summaryQuery.data ?? null;
const summaryNotFound = isNotFoundError(summaryQuery.error);
// A refresh that fails after a new block keeps what is on screen: the error states are only for
// a summary or a list that never loaded.
const summaryNotFound = !summary && isNotFoundError(summaryQuery.error);
const summaryError =
summaryQuery.error != null && !summaryNotFound
!summary && summaryQuery.error != null && !summaryNotFound
? getErrorMessage(summaryQuery.error, 'Address details could not be loaded.')
: null;

Expand All @@ -44,9 +46,13 @@ export default function AddressFlow({ address }: { address: string }) {
});
const txs = (txsQuery.data?.data || []) as TxView[];
const pages = txsQuery.data?.pagination?.pages || 1;
const txsLoading = txsQuery.isPending || txsQuery.isFetching;
// Loading means no list of this page yet: the first load, or another page while the previous one
// stands in. A refresh of the list on screen keeps it visible.
const txsLoading = txsQuery.isPending || (txsQuery.isFetching && txsQuery.isPlaceholderData);
const txsError =
txsQuery.error != null ? getErrorMessage(txsQuery.error, 'Address transactions could not be loaded.') : null;
txsQuery.error != null && !txsQuery.data
? getErrorMessage(txsQuery.error, 'Address transactions could not be loaded.')
: null;
const txTotal = summary?.txCount ?? txsQuery.data?.pagination?.total ?? txs.length;

// Neither a summary nor a single indexed transaction: the explorer has never seen this address.
Expand Down
Loading
Loading