@geeqdev/geeq-sdk 0.1.0 → 0.2.0

package/example/scripts/browser-check.mjs

@@ -0,0 +1,1421 @@
+/**
+ * End-to-end browser check.
+ *
+ * Builds nothing and mocks nothing: it serves the production build, drives it in a
+ * real Chromium, and asserts the full path works — the ~2 MB WebAssembly engine
+ * loads over HTTP, a recovery phrase is generated, and a keypair and address
+ * are derived from it in the page.
+ *
+ *   npm run build && node scripts/browser-check.mjs
+ *
+ * The server also stubs a Geeq node: it serves a synthetic validation layer ledger on
+ * `GET /api/blocks?type=vll` and accepts transactions on `POST /api/blocks/process`, so
+ * the whole path — read the ledger, derive chain state, sign, submit — is driven end to
+ * end without a live node. The ledger is built with the same Cap'n Proto schema the SDK
+ * decodes with, and submitted transactions are decoded back and asserted field by field.
+ *
+ * The node's socket is stubbed in the page with Playwright's routeWebSocket, which swaps
+ * the page's WebSocket for an in-page stand-in: the SDK's socket code runs unchanged
+ * against frames this script sends and records, and no network handshake happens. That
+ * also lets a step make the socket unreachable without a browser error for it. Status
+ * events are keyed by a refHash the check computes from the bytes the node received, the
+ * way the node computes it — so a transaction id the SDK got wrong would never settle.
+ */
+import { chromium } from 'playwright-core'
+import { createServer } from 'node:http'
+import { readFile, stat } from 'node:fs/promises'
+import { dirname, extname, join, normalize } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import assert from 'node:assert/strict'
+import { createRequire } from 'node:module'
+import { loadEnv } from 'vite'
+
+const root = join(dirname(dirname(fileURLToPath(import.meta.url))), 'dist')
+const TYPES = {
+  '.html': 'text/html', '.js': 'text/javascript', '.css': 'text/css',
+  '.wasm': 'application/wasm', '.map': 'application/json',
+}
+
+// Resolved through the SDK so the fixture is built with exactly the schema it decodes.
+const sdkRoot = dirname(createRequire(import.meta.url).resolve('@geeqdev/geeq-sdk/package.json'))
+const sdkRequire = createRequire(join(sdkRoot, 'package.json'))
+const { Message, Uint64 } = sdkRequire('capnp-ts')
+const {
+  ValLayLedger,
+  AppLayLedger,
+  UserAppTx,
+  Payload,
+  UserValTx,
+  NetActorStatus,
+  NetActorType,
+} = loadSchemas()
+const { blake3 } = sdkRequire('@noble/hashes/blake3')
+const wasm = sdkRequire('./src/wasm/nodejs/geeq_core.js')
+
+/**
+ * The SDK's vendored Cap'n Proto schemas (src/capnp), compiled for this script with the
+ * SDK's own esbuild. capnp-ts stays external so the classes share the `Message` above.
+ */
+function loadSchemas() {
+  const { buildSync } = sdkRequire('esbuild')
+  const { outputFiles } = buildSync({
+    stdin: {
+      contents: [
+        "export { ValLayLedger } from './valLayLedger.capnp'",
+        "export { AppLayLedger } from './appLayLedger.capnp'",
+        "export { UserAppTx } from './userAppTx.capnp'",
+        "export { Payload } from './payload.capnp'",
+        "export { UserValTx } from './userValTx.capnp'",
+        "export { NetActorStatus, NetActorType } from './netActorRec.capnp'",
+      ].join('\n'),
+      resolveDir: join(sdkRoot, 'src', 'capnp'),
+      loader: 'ts',
+    },
+    bundle: true,
+    write: false,
+    format: 'cjs',
+    platform: 'node',
+    external: ['capnp-ts'],
+    logLevel: 'silent',
+  })
+  const module = { exports: {} }
+  new Function('require', 'module', 'exports', outputFiles[0].text)(sdkRequire, module, module.exports)
+  return module.exports
+}
+
+/**
+ * The refHash a node files a posted transaction under, computed as the node does it
+ * (geeq_node_core wrappers): an application-layer transaction is hashed WITH its
+ * signature, a validation-layer one WITHOUT. Independent of the SDK on purpose.
+ */
+function nodeRefHash(posted) {
+  const packed = Buffer.from(posted.data.transaction, 'base64')
+  const handle =
+    posted.type === 'uat'
+      ? wasm.UserAppTx.fromUserAppTxCapnp(packed)
+      : wasm.UserValTxData.fromUserValTxCapnp(packed)
+  const flat = handle.flatten()
+  handle.free()
+  return Buffer.from(blake3(flat, { dkLen: 32 })).toString('base64')
+}
+
+const geeqSdk = await import('@geeqdev/geeq-sdk')
+
+// The demo's pennies-per-Geeq, read from .env as Vite read it for the build under test.
+// Every figure here is written in geeq and converted with it, so the check holds whatever
+// the setting is.
+const penniesPerGeeq = BigInt(loadEnv('production', dirname(root), 'VITE_').VITE_PENNIES_PER_GEEQ)
+const geeq = (figure) => geeqSdk.toPennies({ geeq: figure }, penniesPerGeeq)
+const shown = (pennies) => geeqSdk.formatGeeq(pennies, penniesPerGeeq)
+/** A shown figure, escaped to go inside a RegExp. */
+const shownPattern = (pennies) => shown(pennies).replace('.', '\\.')
+
+/** The stub ledger's geeqNorm, which the minimum transfer and every fee are multiples of. */
+const GEEQ_NORM = 1n
+/** minTxAmt x geeqNorm is 0.1 geeq, as on the live chain; the minimum is one penny more. */
+const MIN_TX_AMT = geeq('0.1') / GEEQ_NORM
+const MINIMUM = MIN_TX_AMT * GEEQ_NORM + 1n
+
+/**
+ * The fee a node charges for a posted transaction, in pennies, worked out as the node does it
+ * (geeq_node_core wrappers/base.ts, calculateTransactionFee): geeqNorm per byte of the
+ * flatten WITH the signature — plus the payload's, for a uat — and a quarter of a percent of
+ * the amount, capped at geeqNorm x 10^7. Independent of the SDK on purpose.
+ */
+function nodeFee(posted, amount) {
+  const handle =
+    posted.type === 'uat'
+      ? wasm.UserAppTx.fromUserAppTxCapnp(Buffer.from(posted.data.transaction, 'base64'))
+      : wasm.UserValTx.fromUserValTxCapnp(Buffer.from(posted.data.transaction, 'base64'))
+  let bytes = handle.flatten().length
+  handle.free()
+  if (posted.type === 'uat') {
+    const payload = wasm.Payload.fromPayloadCapnp(Buffer.from(posted.data.payload, 'base64'))
+    bytes += payload.flatten().length
+    payload.free()
+  }
+  const cap = GEEQ_NORM * 10_000_000n
+  return BigInt(bytes) * GEEQ_NORM + (amount / 400n < cap ? amount / 400n : cap)
+}
+
+// Driven by the checks below to exercise the failure paths from inside the browser.
+const ledger = {
+  mode: 'ok',
+  block: 41,
+  nonce: 7,
+  accountId: new Uint8Array(32),
+  host: '127.0.0.1',
+  balance: geeq('1000'),
+  // The id of the account's authority account, once a block has confirmed one.
+  authorityId: null,
+  // The digital assets the account holds: base64 id, content hash and labels.
+  assets: [],
+}
+
+/** A uint64 of pennies, little-endian, as the protocol writes amounts. */
+function pennies(value) {
+  const view = new DataView(new ArrayBuffer(8))
+  view.setBigUint64(0, value, true)
+  return Uint64.fromDataView(view)
+}
+
+// What the stubbed directory lists. The SDK picks from this; the page never names a node.
+const directory = [
+  { ip: '10.9.9.9', type: 'listener', status: 'ready' },
+  { ip: '127.0.0.1', type: 'active', status: 'ready' },
+]
+
+function buildLedger() {
+  const message = new Message()
+  const vll = message.initRoot(ValLayLedger)
+  vll.setChainNum(1)
+  vll.setBlockNum(ledger.block)
+
+  const actors = vll.initNetActorList().initNetActorRecs(2)
+  const self = actors.get(0)
+  self.setIpAddr(ledger.host)
+  self.setPortNum(2082)
+  self.setNodeNumSelf(3)
+  self.setNodeNumSponsor(99)
+  // A real ledger sets this 100-355 blocks ahead on promotion; the capnp zero would
+  // read as a node already rotating out, which the SDK refuses to select.
+  self.setBlockNumRemove(ledger.block + 200)
+  self.setNetActorType(
+    ledger.mode === 'listener'
+      ? NetActorType.NET_ACTOR_TYPE_ANCHOR_NODE
+      : NetActorType.NET_ACTOR_TYPE_ANON_NODE,
+  )
+  self.setRecStatus(
+    ledger.mode === 'listener'
+      ? NetActorStatus.NET_ACTOR_STATUS_LISTENING
+      : NetActorStatus.NET_ACTOR_STATUS_NODE,
+  )
+  self.initAcctNumVal(32)
+  self.getAcctNumVal().copyBuffer(new Uint8Array(32).fill(0xa0))
+
+  // A second processing node, so the UI has a real alternative to offer.
+  const peer = actors.get(1)
+  peer.setIpAddr('10.9.9.9')
+  peer.setPortNum(2082)
+  peer.setNodeNumSelf(4)
+  peer.setBlockNumRemove(ledger.block + 200)
+  peer.setNetActorType(NetActorType.NET_ACTOR_TYPE_ANON_NODE)
+  peer.setRecStatus(NetActorStatus.NET_ACTOR_STATUS_NODE)
+  peer.initAcctNumVal(32)
+  peer.getAcctNumVal().copyBuffer(new Uint8Array(32).fill(0xb0))
+
+  const params = vll.initParamAcctList().initParamAcctRecs(4)
+  params.get(0).initParamType().initMetadataVarNum().setCurrentValue(
+    ledger.mode === 'tight-metadata' ? 1 : 4,
+  )
+  params.get(1).initParamType().initMetadataVarBytes().setCurrentValue(64)
+  // A chain's minimum transfer is minTxAmt x geeqNorm + 1. Fees are multiples of geeqNorm too.
+  params.get(2).initParamType().initMinTxAmt().setCurrentValue(pennies(MIN_TX_AMT))
+  params.get(3).initParamType().initGeeqNorm().setCurrentValue(pennies(GEEQ_NORM))
+
+  const wanted = ledger.mode === 'no-account' ? 0 : 1
+  const accounts = vll.initCoinAcctRecs(wanted)
+  if (wanted === 1) {
+    const account = accounts.get(0)
+    account.initAcctNumVal(32)
+    account.getAcctNumVal().copyBuffer(ledger.accountId)
+    account.setAmtCoin(pennies(ledger.balance))
+    if (ledger.mode === 'hashlock') account.getRecType().initHl()
+    else {
+      const asset = account.getRecType().initAsset()
+      asset.setNonce(ledger.nonce)
+      const held = asset.initNftAssetSubgroups(ledger.assets.length)
+      ledger.assets.forEach(({ id }, index) => held.get(index).initAcctNumApp(32).copyBuffer(Buffer.from(id, 'base64')))
+    }
+  }
+
+  if (ledger.authorityId !== null) {
+    const authority = vll.initProxyAcctRecs(1).get(0)
+    authority.initAcctNumVal(32)
+    authority.getAcctNumVal().copyBuffer(Buffer.from(ledger.authorityId, 'base64'))
+    authority.setAmtCoin(pennies(geeq('20')))
+    // The node starts every new authority account at nonce 1; only creating a digital
+    // asset through it moves it.
+    authority.setNonce(1)
+    const recType = authority.getRecType().initNftMint()
+    recType.initAcctNumAdminUser(32)
+    recType.getAcctNumAdminUser().copyBuffer(ledger.accountId)
+  }
+
+  return Buffer.from(message.toPackedArrayBuffer()).toString('base64')
+}
+
+/** The application layer ledger, where what each digital asset stands for is kept. */
+function buildAppLedger() {
+  const message = new Message()
+  const all = message.initRoot(AppLayLedger)
+  all.setChainNum(1)
+  all.setBlockNum(ledger.block)
+  const records = all.initAppLayRecs(ledger.assets.length)
+  ledger.assets.forEach((asset, index) => {
+    const record = records.get(index)
+    record.initAcctNumApp(32).copyBuffer(Buffer.from(asset.id, 'base64'))
+    const data = record.getRecType().initNft().initAttestationSubgroup().initData()
+    data.initAttestHash(32).copyBuffer(asset.attestHash)
+    const labels = data.initMetadata(asset.metadata.length)
+    asset.metadata.forEach((label, position) => {
+      labels.get(position).setPosition(position + 1)
+      labels.get(position).initItem(Buffer.byteLength(label)).copyBuffer(Buffer.from(label))
+    })
+  })
+  return Buffer.from(message.toPackedArrayBuffer()).toString('base64')
+}
+
+function ledgerBody() {
+  if (ledger.mode === 'empty') return JSON.stringify({ result: '' })
+  if (ledger.mode === 'garbage') return JSON.stringify({ result: 'not base64!!' })
+  return JSON.stringify({ result: buildLedger() })
+}
+
+const submitted = []
+let ledgerReads = 0
+// The stubbed block explorer: what it has indexed, by hex refHash, and what it was asked.
+const indexed = new Map()
+const explorerAsked = []
+// 'refuse' makes the next submission come back 400, as a node refusing it would.
+let submitMode = 'ok'
+
+const server = createServer(async (req, res) => {
+  // Stubbed node directory: which chains exist, and which nodes serve them.
+  if (req.method === 'GET' && (req.url ?? '').startsWith('/api/admin/simulation/chains')) {
+    res.writeHead(200, { 'content-type': 'application/json' })
+    // Two chains, so the page has to name one — exactly as a real simulator would.
+    res.end(
+      JSON.stringify({
+        result: [
+          { id: 4, chainNumber: 7, name: 'another-chain' },
+          { id: 9, chainNumber: 1, name: 'browser-check' },
+        ],
+      }),
+    )
+    return
+  }
+  if (req.method === 'GET' && (req.url ?? '').startsWith('/api/nodes')) {
+    // Nodes are listed per chain, keyed by the directory's own row id. Answering only
+    // for chain 1's id proves the SDK resolved the requested chain rather than the
+    // first one listed.
+    const systemId = new URL(req.url, base).searchParams.get('systemId')
+    res.writeHead(200, { 'content-type': 'application/json' })
+    res.end(
+      JSON.stringify({
+        result: (systemId === '9' ? directory : []).map((node) => ({
+          ip: node.ip,
+          port: 3000,
+          protocol: 'http',
+          systemId: 9,
+          publicKey: '',
+          type: node.type,
+          status: node.status,
+        })),
+      }),
+    )
+    return
+  }
+
+  // Stubbed node: serve the application layer ledger, and the validation layer one.
+  if (req.method === 'GET' && (req.url ?? '').startsWith('/api/blocks?type=all')) {
+    res.writeHead(200, { 'content-type': 'application/json' })
+    res.end(JSON.stringify({ result: buildAppLedger() }))
+    return
+  }
+  if (req.method === 'GET' && (req.url ?? '').startsWith('/api/blocks?')) {
+    ledgerReads += 1
+    res.writeHead(200, { 'content-type': 'application/json' })
+    res.end(ledgerBody())
+    return
+  }
+
+  // Stubbed node: accept a uat and record it.
+  if (req.method === 'POST' && (req.url ?? '').startsWith('/api/blocks/process')) {
+    const chunks = []
+    for await (const chunk of req) chunks.push(chunk)
+    submitted.push(JSON.parse(Buffer.concat(chunks).toString()))
+    if (submitMode === 'refuse') {
+      submitMode = 'ok'
+      res.writeHead(400, { 'content-type': 'application/json' })
+      res.end(JSON.stringify({ details: 'Receive uat, reason: refused by the browser check' }))
+      return
+    }
+    res.writeHead(200, { 'content-type': 'application/json' })
+    res.end(JSON.stringify({ result: true }))
+    return
+  }
+
+  // Stubbed block explorer: answers as the real one does, including a 500 for a refHash it
+  // does not have.
+  if (req.method === 'GET' && (req.url ?? '').startsWith('/api/transactions/byRefHash?')) {
+    const refHash = new URL(req.url, 'http://stub').searchParams.get('refHash')
+    explorerAsked.push(refHash)
+    const tx = indexed.get(refHash)
+    res.writeHead(tx ? 200 : 500, { 'content-type': 'application/json' })
+    res.end(
+      JSON.stringify(
+        tx
+          ? { result: tx }
+          : { error: 'internal manager error', details: ['Transaction does not exist'] },
+      ),
+    )
+    return
+  }
+
+  const rel = normalize(decodeURIComponent((req.url ?? '/').split('?')[0])).replace(/^(\.\.[/\\])+/, '')
+  let file = join(root, rel === '/' ? 'index.html' : rel)
+  try {
+    if ((await stat(file)).isDirectory()) file = join(file, 'index.html')
+  } catch {
+    file = join(root, 'index.html')
+  }
+  try {
+    const body = await readFile(file)
+    res.writeHead(200, { 'content-type': TYPES[extname(file)] ?? 'application/octet-stream' })
+    res.end(body)
+  } catch {
+    res.writeHead(404).end('not found')
+  }
+})
+await new Promise((r) => server.listen(0, '127.0.0.1', r))
+const base = `http://127.0.0.1:${server.address().port}`
+
+const executablePath = process.env.CHROME_PATH ?? '/usr/bin/google-chrome'
+const browser = await chromium.launch({ executablePath, args: ['--no-sandbox'] })
+const page = await browser.newPage()
+
+const consoleErrors = []
+// Console lines a step provokes on purpose, each allowed exactly once.
+const expectedConsoleErrors = []
+const failedRequests = []
+page.on('console', (m) => { if (m.type() === 'error') consoleErrors.push(m.text()) })
+page.on('pageerror', (e) => consoleErrors.push(String(e)))
+page.on('requestfailed', (r) => failedRequests.push(`${r.url()} ${r.failure()?.errorText}`))
+
+const wasmResponses = []
+page.on('response', (r) => {
+  if (r.url().endsWith('.wasm')) wasmResponses.push({ url: r.url(), status: r.status() })
+})
+
+let n = 0
+const ok = (label) => { n += 1; console.log(`  ok  ${label}`) }
+
+// The node socket. Every connection the page opens lands here; the newest is the live one
+// (reconnecting the chain in step 3 replaces it). Each frame the page sends is stamped
+// with how many transactions had been posted when it arrived, so ordering is checkable.
+//
+// While `socketDown` is set, a connection is closed before it opens — what a page sees
+// when the node's certificate is untrusted or the node is gone.
+let socketDown = false
+const sockets = []
+await page.routeWebSocket(
+  (url) => url.pathname === '/ws/',
+  async (route) => {
+    if (socketDown) {
+      await route.close()
+      return
+    }
+    const connection = { url: route.url(), route, frames: [], pings: 0 }
+    sockets.push(connection)
+    route.onMessage((message) => {
+      if (message === 'ping') {
+        connection.pings += 1
+        return
+      }
+      connection.frames.push({ ...JSON.parse(String(message)), postedBefore: submitted.length })
+    })
+  },
+)
+const nodeSocket = () => sockets[sockets.length - 1]
+const push = (event, payload) => nodeSocket().route.send(JSON.stringify({ event, payload }))
+const uutStatus = (refHash, status, extra = {}) =>
+  push('uut_status', {
+    refHash,
+    publicKeys: [publicKeyB64],
+    blockNumber: 42,
+    vlbBlock: 43,
+    isValid: status === 'valid',
+    status,
+    error: status === 'valid' ? '' : `${status} (browser check)`,
+    type: 'outgoing',
+    createdAt: `Date:${new Date().toString()}`,
+    ...extra,
+  })
+/** Resolves once the live socket has been told to subscribe `key`. */
+const subscribedTo = async (key) => {
+  for (let i = 0; i < 100; i += 1) {
+    const frame = nodeSocket()?.frames.find(
+      (f) => f.event === 'client' && f.payload.publicKeys.includes(key),
+    )
+    if (frame) return frame
+    await new Promise((resolve) => setTimeout(resolve, 100))
+  }
+  throw new Error(`the page never subscribed ${key}`)
+}
+let publicKeyB64 = ''
+
+await page.goto(base, { waitUntil: 'networkidle' })
+
+// 1. The engine actually loaded in the browser.
+await page.waitForSelector('.dot.ready', { timeout: 30_000 })
+ok('WebAssembly engine loaded in-browser')
+assert.ok(wasmResponses.length > 0, 'the .wasm was requested')
+assert.equal(wasmResponses[0].status, 200)
+ok(`engine served over HTTP (${wasmResponses[0].url.split('/').pop()})`)
+
+// Steps 1–8 are each wrapped in a gate, in order; the explorer needs nothing and is not.
+// A held step names the first unfinished step it builds on, and cannot be used.
+const gate = (index) => page.locator('.gate').nth(index)
+const heldBy = async (index) => {
+  const note = gate(index).locator('[data-testid=step-locked]')
+  return (await note.count()) === 0 ? null : (await note.textContent()).trim()
+}
+assert.equal(await page.locator('.gate').count(), 8, 'steps 1–8 are gated, the explorer is not')
+assert.equal(await heldBy(0), null, 'step 1 is open from the start')
+assert.match(await heldBy(1), /step 1/, 'step 2 waits for a phrase')
+assert.match(await heldBy(2), /step 1/, 'step 3 names the first unfinished step, not its own')
+assert.match(await heldBy(7), /step 1/, 'and so does step 8')
+assert.equal(await gate(1).locator('[inert]').count(), 1, 'a held step cannot be used')
+ok('later steps wait for the first unfinished one, and say which')
+
+// 2. Generate a recovery phrase.
+await page.getByRole('button', { name: 'Generate phrase' }).click()
+await page.waitForSelector('.word')
+const words = await page.locator('.word').allTextContents()
+assert.equal(words.length, 12, 'twelve words rendered')
+ok(`generated a 12-word phrase (${words[0].replace(/^\d+\s*/, '')} …)`)
+assert.equal(await heldBy(1), null, 'a phrase opens step 2')
+assert.match(await heldBy(2), /step 2/, 'step 3 now waits for a keypair')
+ok('a phrase opens step 2, and step 3 waits on it')
+
+// 3. Derive a keypair from it.
+await page.getByRole('button', { name: 'Derive keypair' }).click()
+await page.waitForSelector('.field', { timeout: 20_000 })
+const values = await page.locator('.field .v').allTextContents()
+const [address, publicKey, accountId] = values
+
+assert.ok(address.length > 40, 'address looks like an address')
+assert.match(publicKey, /^[A-Za-z0-9+/]{43}=$/, 'public key is 32 bytes of base64')
+assert.match(accountId, /^[A-Za-z0-9+/]{43}=$/, 'account id is 32 bytes of base64')
+ok(`derived address ${address.slice(0, 20)}…`)
+ok('public key and account id rendered')
+assert.equal(await heldBy(2), null, 'a keypair opens step 3')
+assert.match(await heldBy(3), /step 3/, 'transactions wait for a node')
+ok('a keypair opens step 3, and the transaction steps wait for a node')
+
+// 4. The private key is masked until explicitly revealed.
+assert.ok(values[3].startsWith('•'), 'private key masked by default')
+ok('private key hidden until revealed')
+
+// 5. Changing the chain re-derives the address.
+await page.locator('#chain').fill('2')
+await page.locator('#chain').dispatchEvent('input')
+await page.waitForFunction(
+  (previous) => document.querySelector('.field .v')?.textContent !== previous,
+  address,
+  { timeout: 5000 },
+)
+const chain2 = (await page.locator('.field .v').first().textContent()) ?? ''
+assert.notEqual(chain2, address, 'address changes with the chain number')
+ok('address re-derives when the chain number changes')
+
+// 6. Restore mode validates a phrase live.
+const phraseCard = page.locator('section.card').first()
+await page.getByRole('button', { name: 'Restore existing' }).click()
+// Leaving the phrase drops the keypair derived from it, so step 2 waits again.
+assert.match(await heldBy(1), /step 1/, 'step 2 waits for a phrase again')
+await phraseCard.locator('textarea').fill('not a real recovery phrase at all')
+await page.waitForSelector('.invalid')
+ok('rejects an invalid phrase')
+await phraseCard.locator('textarea').fill(
+  'legal winner thank year wave sausage worth useful legal winner thank yellow',
+)
+await page.waitForSelector('.valid')
+ok('accepts a valid phrase')
+
+// 7. Evidence. Step 6 switched to restore mode, which clears the phrase and with
+// it the keypair, so take the restored phrase through to a fresh key first.
+await page.getByRole('button', { name: 'Use this phrase' }).click()
+await page.getByRole('button', { name: 'Derive keypair' }).click()
+await page.waitForSelector('.field', { timeout: 20_000 })
+
+// The stub ledger must contain the account the page actually derived, so read it from
+// the page rather than recomputing it and hoping the derivation options still match.
+const accountIdB64 = (
+  await page
+    .locator('section.card')
+    .nth(1)
+    .locator('.field')
+    .filter({ hasText: 'Account id' })
+    .locator('.v')
+    .textContent()
+).trim()
+ledger.accountId = new Uint8Array(Buffer.from(accountIdB64, 'base64'))
+assert.equal(ledger.accountId.length, 32, 'scraped a 32-byte account id from the page')
+publicKeyB64 = (
+  await page
+    .locator('section.card')
+    .nth(1)
+    .locator('.field')
+    // Anchored: the account id's label mentions "the public key" too.
+    .filter({ hasText: /^Public key/ })
+    .locator('.v')
+    .textContent()
+).trim()
+
+const chainCard = page.locator('section.card').nth(2)
+const evidenceCard = page.locator('section.card').nth(3)
+const transferCard = page.locator('section.card').nth(4)
+
+// The page never names a node: it names the directory, and the SDK picks an active one
+// from it. The listener in the directory must not be chosen.
+await chainCard.locator('[data-testid=simulator-url]').fill(base)
+// The stub is not behind the standard TLS front door, so the harness override applies.
+await chainCard.locator('[data-testid=dev-options]').click()
+await chainCard.locator('[data-testid=node-port]').fill(String(new URL(base).port))
+// Step 3 searches for the chain step 2 derived for, and only shows it: it is set there.
+const shownChain = chainCard.locator('[data-testid=chain-number]')
+assert.equal((await shownChain.textContent()).trim(), '2', 'step 5 left chain 2')
+assert.equal(
+  await shownChain.evaluate((el) => el.matches('input, select, textarea, [contenteditable]')),
+  false,
+  'the chain number cannot be edited in step 3',
+)
+// A number the directory does not carry must say so, and say what it does carry — that
+// is a real deployment mistake and the message is all that stands between it and a shrug.
+await chainCard.locator('[data-testid=connect]').click()
+await chainCard.locator('[data-testid=connect-error]').waitFor({ timeout: 20_000 })
+const missing = await chainCard.locator('[data-testid=connect-error]').textContent()
+assert.match(missing, /does not list chain 2/, 'names the chain it could not find')
+assert.match(
+  missing,
+  /another-chain \(chain 7\), browser-check \(chain 1\)/,
+  'lists the chains it does have, with their numbers',
+)
+ok('an unknown chain number is reported with the available ones')
+
+// A number the directory does carry, set where it belongs: in step 2.
+await page.locator('#chain').fill('1')
+assert.equal((await shownChain.textContent()).trim(), '1', 'step 3 follows step 2')
+await chainCard.locator('[data-testid=connect]').click()
+await chainCard.locator('[data-testid=selected-node]').waitFor({ timeout: 20_000 })
+
+assert.match(
+  await chainCard.locator('[data-testid=selected-node] .v').textContent(),
+  /chain 1 \(browser-check\)/,
+  'shows the simulator\'s name for the chain it found',
+)
+ok('the node was found by chain number')
+
+assert.equal(await heldBy(3), null, 'a node opens the transaction steps')
+ok('a node opens the transaction steps')
+
+// Moving step 2 to another chain lets the node go: it serves chain 1 only, so the steps
+// after it wait again until a node is found for the chain step 2 now names.
+await page.locator('#chain').fill('2')
+await chainCard.locator('[data-testid=chain-changed]').waitFor({ timeout: 5_000 })
+assert.equal(await chainCard.locator('[data-testid=selected-node]').count(), 0, 'the node is let go')
+assert.match(await heldBy(3), /step 3/, 'the transaction steps wait again')
+await page.locator('#chain').fill('1')
+await chainCard.locator('[data-testid=connect]').click()
+await chainCard.locator('[data-testid=selected-node]').waitFor({ timeout: 20_000 })
+assert.equal(await chainCard.locator('[data-testid=chain-changed]').count(), 0, 'the notice clears')
+assert.equal(await heldBy(3), null, 'and a new node opens them again')
+ok('an address moved to another chain lets its node go until one is found again')
+
+const selected = await chainCard.locator('[data-testid=selected-node] .v').textContent()
+assert.match(selected, /127\.0\.0\.1/, 'picked the active node from the directory')
+assert.doesNotMatch(selected, /10\.9\.9\.9/, 'did not pick the listener')
+assert.match(selected, /chain 1/, 'picked the chain the page named, not the first listed')
+assert.match(selected, /2 listed, 1 active/, 'reported what it chose from')
+ok('the SDK chose an active node from the directory')
+
+// The node's socket opens alongside the chain, on the node's own origin at /ws/.
+await chainCard.locator('[data-testid=socket][data-state=open]').waitFor({ timeout: 10_000 })
+assert.equal(nodeSocket().url, `ws://127.0.0.1:${new URL(base).port}/ws/`, 'socket URL derived from the node')
+ok('the node socket opened on the chosen node, at /ws/')
+
+// The account is subscribed as soon as there is an account and a socket, under
+// both the forms a node files events by.
+const accountFrame = await subscribedTo(accountIdB64)
+assert.ok(accountFrame.payload.publicKeys.includes(publicKeyB64), 'and under its public key')
+ok('the account is subscribed by public key and account id')
+
+// Nothing has been read from the chain itself yet: the ledger is only fetched when a
+// transaction is actually signed, because its values go stale within a few blocks.
+assert.equal(ledgerReads, 0, 'connecting reads no ledger')
+ok('no ledger read before one is needed')
+
+// BLAKE3-32 of "hello" — the published test vector, so this pins our hashing.
+const helloHash = 'ea8f163db38682925e4491c5e58d4bb3506ef8c14eb78a86e908c5624a67200f'
+await evidenceCard.getByRole('button', { name: 'File', exact: true }).click()
+await evidenceCard
+  .locator('input[type=file]')
+  .setInputFiles({ name: 'hello.txt', mimeType: 'text/plain', buffer: Buffer.from('hello') })
+await evidenceCard.locator('[data-testid=evidence-hash]', { hasText: helloHash }).waitFor({ timeout: 5_000 })
+ok('evidence hash is BLAKE3-32 of the file')
+
+// A pasted hash is used as given; anything that is not 32 bytes of hex is refused.
+await evidenceCard.getByRole('button', { name: 'Paste hash', exact: true }).click()
+const hashInput = evidenceCard.locator('[data-testid=evidence-hash-input]')
+await hashInput.fill(helloHash.slice(2))
+await evidenceCard.locator('[data-testid=evidence-hash-error]').waitFor({ timeout: 5_000 })
+assert.equal(await evidenceCard.locator('[data-testid=evidence-hash]').count(), 0, 'a short hash is not used')
+await hashInput.fill(`0x${helloHash.toUpperCase()}`)
+await evidenceCard.locator('[data-testid=evidence-hash]', { hasText: helloHash }).waitFor({ timeout: 5_000 })
+ok('a pasted evidence hash is used, and a short one refused')
+
+// Each later build pastes a hash of its own, so it never repeats the one before.
+const pasteHash = (label) => hashInput.fill(Buffer.from(blake3(Buffer.from(label))).toString('hex'))
+
+await evidenceCard.locator('#meta').fill('invoice-2026-09, acme-corp')
+await evidenceCard.getByRole('button', { name: 'Build & sign' }).click()
+await evidenceCard.locator('[data-testid=chain-state]').waitFor({ timeout: 20_000 })
+assert.equal(ledgerReads, 1, 'the ledger is read once, while signing')
+ok('the ledger is read at build time')
+
+const cell = async (label) =>
+  (
+    await evidenceCard
+      .locator('[data-testid=chain-state] tr')
+      .filter({ hasText: label })
+      .locator('td')
+      .first()
+      .textContent()
+  ).trim()
+
+assert.equal(await cell('Chain'), '1', 'chain number read from the ledger')
+assert.equal(await cell('Ledger block'), '41', 'ledger block read from the ledger')
+assert.equal(await cell('Target block'), '42', 'target block is ledger block + 1')
+assert.equal(await cell('Node number'), '3', 'node number is nodeNumSelf, not the index')
+assert.equal(await cell('Nonce'), '7', 'nonce read from the coin-asset record')
+ok('chain state derived from the ledger with no user input')
+
+// The limits live in the ledger, so they become visible once one has been read.
+assert.match(
+  await evidenceCard.locator('[data-testid=meta-limits]').textContent(),
+  /4 labels · 64 bytes each/,
+  'metadata limits read from the ledger parameters',
+)
+ok('metadata limits surfaced from the ledger')
+
+await evidenceCard.locator('[data-testid=tx-base64]').waitFor({ timeout: 20_000 })
+ok('built and signed evidence from a keypair and a hash alone')
+
+// Round-tripping through base64 must reproduce the string exactly — Buffer.from
+// silently ignores invalid characters, so decoding alone would prove nothing.
+const readFields = async () => ({
+  tx: (await evidenceCard.locator('[data-testid=tx-base64]').textContent()).trim(),
+  payload: (await evidenceCard.locator('[data-testid=payload-base64]').textContent()).trim(),
+})
+const built = await readFields()
+for (const [label, value] of Object.entries(built)) {
+  assert.ok(value.length > 40, `${label} is base64 of some length`)
+  assert.equal(Buffer.from(value, 'base64').toString('base64'), value, `${label} is valid base64`)
+}
+ok('transaction and payload are well-formed base64')
+
+await evidenceCard.locator('[data-testid=submit]').click()
+await evidenceCard.getByText('Node response', { exact: true }).waitFor({ timeout: 15_000 })
+assert.equal(submitted.length, 1, 'exactly one transaction reached the node')
+assert.equal(submitted[0].type, 'uat')
+assert.equal(submitted[0].data.transaction, built.tx, 'posted transaction matches the built one')
+assert.equal(submitted[0].data.payload, built.payload, 'posted payload matches the built one')
+ok('posted exactly the transaction and payload that were signed')
+
+// Close the loop: the values the fixture published must be the values actually signed
+// into the bytes the node received.
+const posted = new Message(
+  Buffer.from(submitted[0].data.transaction, 'base64'),
+  true,
+).getRoot(UserAppTx).getData()
+assert.equal(posted.getChainNum(), 1, 'signed chain number')
+assert.equal(posted.getBlockNum(), 42, 'signed target block')
+assert.equal(posted.getNodeNum(), 3, 'signed node number')
+assert.equal(posted.getNonce(), 7, 'signed nonce')
+ok('the derived values are the ones carried in the signed transaction')
+
+// Subscribe before submit: the node had been told to push this account's statuses before
+// the transaction reached it.
+const beforePost = nodeSocket().frames.filter(
+  (f) => f.event === 'client' && f.postedBefore === 0 && f.payload.publicKeys.includes(accountIdB64),
+)
+assert.ok(beforePost.length > 0, 'the signer was subscribed before the POST')
+ok('the signer was subscribed before the transaction was posted')
+
+await evidenceCard.locator('[data-testid=tx-status][data-status=pending]').waitFor({ timeout: 5_000 })
+ok('a 200 shows as pending, not as a success')
+
+// The id the page shows is the refHash the node would file this transaction under.
+const evidenceId = nodeRefHash(submitted[0])
+assert.equal(
+  (await evidenceCard.locator('[data-testid=tx-id]').textContent()).trim(),
+  evidenceId,
+  'the SDK hashes evidence the way the node does — signature included',
+)
+ok('the evidence id matches the node refHash for the posted bytes')
+
+uutStatus(evidenceId, 'valid')
+await evidenceCard.locator('[data-testid=tx-status][data-status=confirmed]').waitFor({ timeout: 5_000 })
+ok('a valid status over the socket confirms the evidence')
+assert.match(
+  await chainCard.locator('[data-testid=socket-events]').textContent(),
+  /uut_status/,
+  'the socket panel shows what the node pushed',
+)
+ok('the raw node event is visible in the socket feed')
+
+// Two transactions from one account against one block are BOTH rejected by the chain,
+// so the SDK refuses to build the second rather than destroying the first.
+await pasteHash('hello again')
+await evidenceCard.getByRole('button', { name: 'Build & sign' }).click()
+await evidenceCard.locator('[data-testid=build-error]').waitFor({ timeout: 20_000 })
+assert.match(
+  await evidenceCard.locator('[data-testid=build-error]').textContent(),
+  /One transaction per account per block/,
+  'nonce collision is refused, not silently built',
+)
+ok('refuses a second evidence submission against the same block')
+
+// Once the chain moves on, the same account can submit evidence again.
+ledger.block = 42
+ledger.nonce = 8
+await evidenceCard.getByRole('button', { name: 'Build & sign' }).click()
+await evidenceCard.locator('[data-testid=tx-base64]').waitFor({ timeout: 20_000 })
+const afterAdvance = await readFields()
+assert.notEqual(afterAdvance.tx, built.tx, 'a new block and nonce produce a new transaction')
+ok('builds again once the block advances')
+
+// A node answers a submission it refuses with an error and never sends a status for it,
+// so the page must settle it from the response rather than wait for one.
+submitMode = 'refuse'
+// Chromium logs every 4xx response to the console; this one is the point of the step.
+expectedConsoleErrors.push(/status of 400 \(Bad Request\)/)
+await evidenceCard.locator('[data-testid=submit]').click()
+await evidenceCard
+  .locator('[data-testid=tx-status][data-status=rejected][data-reason=refused]')
+  .waitFor({ timeout: 5_000 })
+assert.match(
+  await evidenceCard.locator('[data-testid=tx-status]').textContent(),
+  /Refused on submission[\s\S]*refused by the browser check/,
+  'a refused submission is rejected at once, with the node words',
+)
+assert.equal(
+  await evidenceCard.locator('[data-testid=tx-events] li').count(),
+  0,
+  'settled from the response alone — no socket event was sent for it',
+)
+ok('a refused submission is rejected without waiting on the socket')
+
+// An unfunded account is the ordinary first experience, and gets its own explanation.
+ledger.mode = 'no-account'
+await pasteHash('unfunded')
+await evidenceCard.getByRole('button', { name: 'Build & sign' }).click()
+await evidenceCard.locator('[data-testid=build-error]').waitFor({ timeout: 20_000 })
+assert.match(
+  await evidenceCard.locator('[data-testid=build-error]').textContent(),
+  /never received coins/,
+  'an unfunded account is explained, not reported as a failure',
+)
+ok('an account missing from the ledger is explained')
+
+// A node that answers but cannot be decoded must not look like a network problem.
+ledger.mode = 'garbage'
+// A fresh chain, so the decode is attempted rather than served from the cache the
+// previous builds filled.
+await chainCard.locator('[data-testid=connect]').click()
+await chainCard.locator('[data-testid=selected-node]').waitFor({ timeout: 20_000 })
+await pasteHash('garbage ledger')
+await evidenceCard.getByRole('button', { name: 'Build & sign' }).click()
+await page.waitForFunction(
+  () => document.querySelector('[data-testid=build-error]')?.textContent?.includes('base64'),
+  null,
+  { timeout: 15_000 },
+)
+ok('an undecodable ledger is reported as such')
+
+ledger.mode = 'ok'
+
+// 8. Sending coin. A different transaction type: validation layer rather than
+// application layer, so one blob to submit rather than two, posted as `uvt`.
+ledger.mode = 'ok'
+ledger.block = 43
+ledger.nonce = 9
+await chainCard.locator('[data-testid=connect]').click()
+await chainCard.locator('[data-testid=selected-node]').waitFor({ timeout: 20_000 })
+
+// A third-party recipient. Built with the SDK itself rather than scraped, because the
+// page's own address would be a transfer to self, which the SDK refuses outright.
+await geeqSdk.initGeeq()
+const recipientId = new Uint8Array(32).fill(0x5a)
+const receiverAddress = await geeqSdk.createWalletAddress({
+  accountId: recipientId,
+  chainNumber: 1,
+})
+
+// Amounts name their unit, and the page shows the pennies a typed figure comes to.
+await transferCard.locator('[data-testid=amount]').fill('1.50')
+assert.equal(
+  (await transferCard.locator('[data-testid=pennies]').textContent()).trim(),
+  String(geeq('1.50')),
+  'the typed figure is shown in pennies',
+)
+ok("an amount is read as pennies, at the app's pennies-per-geeq")
+
+// One decimal place more than the unit has is money the chain cannot represent, so it is
+// refused outright.
+await transferCard.locator('[data-testid=amount]').fill(`0.${'1'.padStart(String(penniesPerGeeq).length, '0')}`)
+await transferCard.locator('[data-testid=amount-problem]').waitFor({ timeout: 5_000 })
+assert.match(
+  await transferCard.locator('[data-testid=amount-problem]').textContent(),
+  /are possible/,
+  'a decimal place past the unit is refused rather than rounded',
+)
+ok('an impossible amount is refused, not rounded')
+
+// Below the chain's minimum: 0.1 geeq is minTxAmt x geeqNorm, one penny short of it.
+await transferCard.locator('[data-testid=amount]').fill('0.1')
+await transferCard.locator('[data-testid=recipient]').fill(receiverAddress)
+await transferCard.locator('[data-testid=build-transfer]').click()
+await transferCard.locator('[data-testid=transfer-error]').waitFor({ timeout: 20_000 })
+assert.match(
+  await transferCard.locator('[data-testid=transfer-error]').textContent(),
+  new RegExp(`below ${shownPattern(MINIMUM)} geeq`),
+  'the chain minimum is read from the ledger and explained',
+)
+ok('an amount below the chain minimum is refused')
+
+// More than the account holds.
+await transferCard.locator('[data-testid=amount]').fill('9999')
+await transferCard.locator('[data-testid=build-transfer]').click()
+await page.waitForFunction(
+  () => document.querySelector('[data-testid=transfer-error]')?.textContent?.includes('holds'),
+  null,
+  { timeout: 15_000 },
+)
+ok('a transfer larger than the balance is refused')
+
+// And one that works.
+await transferCard.locator('[data-testid=amount]').fill('1.50')
+await transferCard.locator('[data-testid=build-transfer]').click()
+await transferCard.locator('[data-testid=transfer-base64]').waitFor({ timeout: 20_000 })
+
+assert.match(
+  await transferCard.locator('[data-testid=balance]').textContent(),
+  new RegExp(`1000 geeq \\(${geeq('1000')} pennies\\)`),
+  'the balance is read from the ledger and shown, in geeq and pennies',
+)
+assert.match(
+  await transferCard.locator('[data-testid=transfer-summary]').textContent(),
+  new RegExp(`^1\\.5 geeq \\(${geeq('1.50')} pennies\\) →`),
+  'the amount is shown back in geeq, with its pennies beside it',
+)
+ok('a coin transfer is built and signed')
+
+const before = submitted.length
+await transferCard.locator('[data-testid=submit-transfer]').click()
+await transferCard.locator('[data-testid=tx-status][data-status=pending]').waitFor({ timeout: 15_000 })
+assert.equal(submitted.length, before + 1, 'the transfer reached the node')
+
+const postedTransfer = submitted[submitted.length - 1]
+assert.equal(postedTransfer.type, 'uvt', 'a transfer posts as uvt, not uat')
+assert.equal(postedTransfer.data.payload, undefined, 'a transfer has no separate payload')
+assert.equal(
+  postedTransfer.data.transaction,
+  (await transferCard.locator('[data-testid=transfer-base64]').textContent()).trim(),
+  'posted exactly what was signed',
+)
+ok('the transfer posts one blob as uvt, unlike evidence')
+
+// The fee the page shows is what the node charges for the bytes it actually received.
+const transferFee = nodeFee(postedTransfer, geeq('1.50'))
+assert.equal(
+  (await transferCard.locator('[data-testid=tx-fee-total]').textContent()).trim(),
+  shown(transferFee),
+  'the fee shown is the node formula over the posted bytes',
+)
+assert.equal(
+  (await transferCard.locator('[data-testid=tx-fee-pennies]').textContent()).trim(),
+  `(${transferFee} pennies)`,
+  'and the same fee in pennies beside it',
+)
+assert.equal(
+  (await transferCard.locator('[data-testid=tx-cost]').textContent()).trim(),
+  shown(geeq('1.50') + transferFee),
+  'and the account pays the amount plus the fee',
+)
+ok('the transfer shows the fee the node will charge, and the total it costs')
+
+// Close the loop: the values the fixture published are the ones in the signed bytes.
+const transferData = new Message(
+  Buffer.from(postedTransfer.data.transaction, 'base64'),
+  true,
+).getRoot(UserValTx).getData()
+assert.equal(transferData.getChainNum(), 1, 'signed chain number')
+assert.equal(transferData.getBlockNum(), 44, 'signed target block')
+assert.equal(transferData.getNodeNum(), 3, 'signed node number')
+const assetTx = transferData.getTx().getCoin().getTxType().getAsset()
+assert.equal(assetTx.getNonce(), 9, 'signed nonce')
+assert.equal(assetTx.getAmtCoin().getSome().toDataView().getBigUint64(0, true), geeq('1.50'), 'signed amount')
+assert.deepEqual(
+  Buffer.from(assetTx.getAcctNumRcv().toArrayBuffer()),
+  Buffer.from(recipientId),
+  'the pasted address resolved to the account id it encodes',
+)
+ok('the transfer carries the amount, recipient and chain state that were derived')
+
+// A transfer is filed under the hash of its UNSIGNED flatten — the opposite of
+// evidence. Hashing the signed form would give an id no status event ever carries.
+const transferId = nodeRefHash(postedTransfer)
+assert.equal(
+  (await transferCard.locator('[data-testid=tx-id]').textContent()).trim(),
+  transferId,
+  'the SDK hashes a transfer the way the node does — signature excluded',
+)
+ok('the transfer id matches the node refHash for the posted bytes')
+
+// A nonsane is not necessarily the last word; a later verdict decides.
+uutStatus(transferId, 'nonsane', { error: 'Choose list sets operation: nonce' })
+await transferCard.locator('[data-testid=tx-events] li').first().waitFor({ timeout: 5_000 })
+assert.equal(
+  await transferCard.locator('[data-testid=tx-status]').getAttribute('data-status'),
+  'pending',
+  'a nonsane alone does not settle it',
+)
+uutStatus(transferId, 'invalid', { error: 'Nonce Check failed' })
+await transferCard
+  .locator('[data-testid=tx-status][data-status=rejected][data-reason=invalid]')
+  .waitFor({ timeout: 5_000 })
+const transferStatus = await transferCard.locator('[data-testid=tx-status]').textContent()
+assert.match(transferStatus, /fee is still charged/, 'an invalid transfer says the fee is still charged')
+assert.match(transferStatus, /Nonce Check failed/, 'with the node reason')
+assert.equal(await transferCard.locator('[data-testid=tx-events] li').count(), 2, 'both events kept')
+assert.match(
+  await transferCard.locator('[data-testid=tx-events] li').first().textContent(),
+  /nonsane · block 42 · outgoing/,
+  'each event shows its verdict, block and direction',
+)
+ok('nonsane then invalid settles the transfer rejected, with both events kept')
+
+// Anything else the node pushes reaches the page through the same class.
+push('coin-account-update', { buffer: 'AA==', block: 44 })
+await page.waitForFunction(
+  () => document.querySelector('[data-testid=socket-events]')?.textContent?.includes('coin-account-update'),
+  null,
+  { timeout: 5_000 },
+)
+ok('an arbitrary node event is delivered to the page')
+
+// A node forgets a connection's subscriptions when it drops, so the page must tell the new
+// one everything again — on its own, before it calls the socket open.
+const dialled = sockets.length
+await nodeSocket().route.close()
+await chainCard.locator('[data-testid=socket][data-state=reconnecting]').waitFor({ timeout: 5_000 })
+await chainCard.locator('[data-testid=socket][data-state=open]').waitFor({ timeout: 10_000 })
+assert.equal(sockets.length, dialled + 1, 'the page dialled once more, by itself')
+await subscribedTo(accountIdB64)
+ok('a dropped socket reconnects and replays its subscriptions')
+
+// A socket that dropped and cannot come back cannot take the subscription. The SDK gives
+// up after its 15 s open timeout, and the page sends the transaction anyway, saying so.
+socketDown = true
+ledger.block = 44
+ledger.nonce = 10
+await nodeSocket().route.close()
+await chainCard.locator('[data-testid=socket][data-state=reconnecting]').waitFor({ timeout: 5_000 })
+await pasteHash('no verdict')
+await evidenceCard.getByRole('button', { name: 'Build & sign' }).click()
+await evidenceCard.locator('[data-testid=tx-base64]').waitFor({ timeout: 20_000 })
+let sent = submitted.length
+await evidenceCard.locator('[data-testid=submit]').click()
+await evidenceCard.locator('[data-testid=tx-untracked]').waitFor({ timeout: 25_000 })
+assert.equal(submitted.length, sent + 1, 'sent anyway')
+assert.match(
+  await evidenceCard.locator('[data-testid=tx-untracked]').textContent(),
+  /no confirmation will follow[\s\S]*Could not subscribe/,
+  'and says why no verdict will be shown',
+)
+ok('a subscription that fails still sends the transaction, with a warning')
+
+// No socket at all — the first handshake fails, as an untrusted certificate makes it. The
+// page warns, submits anyway, and recovers when asked to retry.
+ledger.block = 45
+ledger.nonce = 11
+await chainCard.locator('[data-testid=connect]').click()
+await chainCard.locator('[data-testid=socket][data-state=failed]').waitFor({ timeout: 20_000 })
+assert.match(
+  await chainCard.locator('[data-testid=socket-error]').textContent(),
+  /Could not open the Geeq node socket/,
+  'step 3 says why',
+)
+await pasteHash('no socket')
+await evidenceCard.getByRole('button', { name: 'Build & sign' }).click()
+await evidenceCard.locator('[data-testid=tx-base64]').waitFor({ timeout: 20_000 })
+const warning = evidenceCard.locator('[data-testid=socket-warning]')
+assert.match(
+  await warning.textContent(),
+  /No confirmation will follow[\s\S]*Could not open the Geeq node socket/,
+  'the panel warns before anything is sent, with the socket error',
+)
+sent = submitted.length
+await evidenceCard.locator('[data-testid=submit]').click()
+await evidenceCard.locator('[data-testid=tx-untracked]').waitFor({ timeout: 15_000 })
+assert.equal(submitted.length, sent + 1, 'submitted anyway')
+assert.equal(await evidenceCard.locator('[data-testid=tx-status]').count(), 0, 'no earlier verdict left standing under it')
+socketDown = false
+await warning.locator('[data-testid=socket-retry]').click()
+await chainCard.locator('[data-testid=socket][data-state=open]').waitFor({ timeout: 10_000 })
+assert.equal(await warning.count(), 0, 'the warning clears once the socket is open')
+await subscribedTo(accountIdB64)
+ok('with no socket the page warns, still submits, and Retry recovers')
+
+// 10. Delegating authority. A validation-layer transaction like a transfer, naming this
+// account as the authority account's admin, with an id derived from its key.
+const authorityCard = page.locator('section.card').nth(5)
+ledger.block = 46
+ledger.nonce = 12
+
+// The chain's minimum applies to the funding too.
+await authorityCard.locator('[data-testid=authority-amount]').fill('0.1')
+await authorityCard.locator('[data-testid=build-authority]').click()
+await authorityCard.locator('[data-testid=authority-error]').waitFor({ timeout: 20_000 })
+assert.match(
+  await authorityCard.locator('[data-testid=authority-error]').textContent(),
+  new RegExp(`at least ${shownPattern(MINIMUM)} geeq`),
+  'names the minimum',
+)
+ok('authority account funding below the chain minimum is refused')
+
+await authorityCard.locator('[data-testid=authority-amount]').fill('20')
+await authorityCard.locator('[data-testid=build-authority]').click()
+await authorityCard.locator('[data-testid=authority-base64]').waitFor({ timeout: 20_000 })
+// The id the Geeq apps derive for this key's authority account at an index, computed
+// independently.
+const derivedAuthorityId = (index) =>
+  Buffer.from(
+    wasm.generateIrn(wasm.IrnRecordType.ProxyNftMint, Buffer.from(publicKeyB64, 'base64'), index),
+  ).toString('base64')
+const authorityId = derivedAuthorityId(1)
+assert.equal((await authorityCard.locator('[data-testid=authority-index]').textContent()).trim(), '1')
+assert.equal((await authorityCard.locator('[data-testid=authority-id]').textContent()).trim(), authorityId)
+ok("an account's first authority account takes index 1, with the id the Geeq apps would derive")
+
+sent = submitted.length
+await authorityCard.locator('[data-testid=submit-authority]').click()
+await authorityCard.locator('[data-testid=tx-status][data-status=pending]').waitFor({ timeout: 15_000 })
+assert.equal(submitted.length, sent + 1, 'the delegation reached the node')
+assert.equal(
+  (await authorityCard.locator('[data-testid=admin-nonce]').textContent()).trim(),
+  '12',
+  "the page says which of the account's nonces it spends",
+)
+assert.ok(
+  await authorityCard.locator('[data-testid=submit-authority]').isDisabled(),
+  'a submitted delegation cannot be sent a second time',
+)
+const postedDelegation = submitted[submitted.length - 1]
+assert.equal(postedDelegation.type, 'uvt', 'a delegation posts as uvt, like a transfer')
+const delegationData = new Message(Buffer.from(postedDelegation.data.transaction, 'base64'), true)
+  .getRoot(UserValTx)
+  .getData()
+assert.equal(delegationData.getBlockNum(), 47, 'signed target block')
+const delegation = delegationData.getTx().getProxyCreate()
+assert.equal(delegation.getNonce(), 12, "spends the admin's nonce")
+assert.equal(delegation.getAmtCoin().toDataView().getBigUint64(0, true), geeq('20'), 'funds 20 geeq')
+assert.equal(Buffer.from(delegation.getAcctNumRcv().toUint8Array()).toString('base64'), authorityId)
+assert.equal(
+  Buffer.from(delegation.getTxType().getNftMint().getAcctNumAdminUser().toUint8Array()).toString('base64'),
+  accountIdB64,
+  'this account is the admin',
+)
+ok('the delegation funds the derived id, with this account as admin')
+
+const delegationId = nodeRefHash(postedDelegation)
+assert.equal((await authorityCard.locator('[data-testid=tx-id]').textContent()).trim(), delegationId)
+uutStatus(delegationId, 'valid')
+await authorityCard.locator('[data-testid=tx-status][data-status=confirmed]').waitFor({ timeout: 5_000 })
+ok('the delegation is confirmed over the socket')
+
+// The ledger lists an authority account only once a block has confirmed it, and finds it from the
+// admin's key alone.
+await authorityCard.locator('[data-testid=find-authorities]').click()
+await authorityCard.locator('[data-testid=no-authorities]').waitFor({ timeout: 10_000 })
+assert.equal((await authorityCard.locator('[data-testid=next-index]').textContent()).trim(), '1')
+// The block that adds the authority account also spends the account's nonce.
+ledger.block = 47
+ledger.authorityId = authorityId
+ledger.nonce = 13
+await authorityCard.locator('[data-testid=find-authorities]').click()
+await authorityCard.locator('[data-testid=authority]').waitFor({ timeout: 10_000 })
+assert.equal(
+  (await authorityCard.locator('[data-testid=authority] .v').textContent()).trim(),
+  (await authorityCard.locator('[data-testid=authority-address]').textContent()).trim(),
+  'the one it built',
+)
+assert.match(
+  await authorityCard.locator('[data-testid=authority]').textContent(),
+  new RegExp(`Authority account 1[\\s\\S]*20 geeq \\(${geeq('20')} pennies\\) · own nonce 1`),
+  'with its index, balance and own nonce',
+)
+assert.equal((await authorityCard.locator('[data-testid=next-index]').textContent()).trim(), '2')
+ok('the confirmed authority account is found in the ledger by its admin, and the next index is 2')
+
+// The next authority account takes the next index, found from the ledger rather than
+// remembered.
+await authorityCard.locator('[data-testid=build-authority]').click()
+await authorityCard.locator('[data-testid=authority-index]', { hasText: '2' }).waitFor({ timeout: 20_000 })
+assert.equal((await authorityCard.locator('[data-testid=authority-id]').textContent()).trim(), derivedAuthorityId(2))
+assert.equal(
+  (await authorityCard.locator('[data-testid=admin-nonce]').textContent()).trim(),
+  '13',
+  "the account's next nonce, not the authority account's",
+)
+assert.ok(await authorityCard.locator('[data-testid=submit-authority]').isEnabled(), 'a new build can be sent')
+ok("a second authority account takes index 2 and the account's next nonce")
+
+// 11. Creating a digital asset through the confirmed authority account. An application-layer
+// transaction like evidence, sent by the authority account on its own nonce and signed by
+// this account as its admin.
+const createAssetCard = page.locator('section.card').nth(6)
+assert.ok(await createAssetCard.locator('[data-testid=build-asset]').isDisabled(), 'nothing to create through yet')
+await createAssetCard.locator('[data-testid=find-asset-authorities]').click()
+await createAssetCard.locator('[data-testid=asset-authority] option', { hasText: 'Authority account 1' }).waitFor({ state: 'attached', timeout: 10_000 })
+assert.equal(await createAssetCard.locator('[data-testid=asset-authority]').inputValue(), '1', 'the first authority account is chosen')
+assert.match(
+  await createAssetCard.locator('[data-testid=asset-authority]').textContent(),
+  new RegExp(`Authority account 1 · 20 geeq\\s+\\(${geeq('20')} pennies\\)`),
+  'listed with its balance',
+)
+ok("the account's authority accounts are offered to create through")
+
+const deed = Buffer.from('a deed')
+await createAssetCard.locator('[data-testid=asset-file]').setInputFiles({ name: 'deed.txt', mimeType: 'text/plain', buffer: deed })
+await createAssetCard.locator('[data-testid=asset-metadata]').fill('deed')
+await createAssetCard.locator('[data-testid=build-asset]').click()
+await createAssetCard.locator('[data-testid=asset-base64]').waitFor({ timeout: 20_000 })
+// Changing a label drops that build unsent, so building again in the same block goes through.
+await createAssetCard.locator('[data-testid=asset-metadata]').fill('deed, lot 7')
+await createAssetCard.locator('[data-testid=asset-base64]').waitFor({ state: 'detached', timeout: 5_000 })
+await createAssetCard.locator('[data-testid=build-asset]').click()
+await createAssetCard.locator('[data-testid=asset-base64]').waitFor({ timeout: 20_000 })
+assert.equal(await createAssetCard.locator('[data-testid=asset-error]').count(), 0, 'the rebuild is not refused')
+assert.equal(
+  (await createAssetCard.locator('[data-testid=authority-nonce]').textContent()).trim(),
+  '1',
+  "the authority account's own nonce, not the account's 13",
+)
+assert.match(
+  await createAssetCard.locator('[data-testid=chain-state] tr', { hasText: 'Nonce' }).textContent(),
+  /Nonce\s*1\s*the number authority account 1's next transaction must carry/,
+  'the chain state table shows the same, as the authority account\'s',
+)
+ok('a build that was never sent is rebuilt in the same block, on the same nonce')
+
+sent = submitted.length
+await createAssetCard.locator('[data-testid=submit-asset]').click()
+await createAssetCard.locator('[data-testid=tx-status][data-status=pending]').waitFor({ timeout: 15_000 })
+assert.equal(submitted.length, sent + 1, 'the asset creation reached the node')
+const postedAsset = submitted[submitted.length - 1]
+assert.equal(postedAsset.type, 'uat', 'an asset creation posts as uat, like evidence')
+const assetData = new Message(Buffer.from(postedAsset.data.transaction, 'base64'), true)
+  .getRoot(UserAppTx)
+  .getData()
+assert.equal(assetData.getBlockNum(), 48, 'signed target block')
+assert.equal(assetData.getNonce(), 1, "spends the authority account's nonce")
+assert.equal(Buffer.from(assetData.getPubKey().toUint8Array()).toString('base64'), publicKeyB64, 'signed by the admin')
+const creation = assetData.getTxType().getNftMint()
+assert.equal(Buffer.from(creation.getAcctNumVal().toUint8Array()).toString('base64'), authorityId, 'sent by the authority account')
+assert.equal(Buffer.from(creation.getAcctNumRcv().toUint8Array()).toString('base64'), accountIdB64, 'to this account')
+assert.equal(creation.getAmtCoin().toDataView().getBigUint64(0, true), MINIMUM, "with the chain's minimum")
+const assetId = Buffer.from(creation.getAcctNumApp().toUint8Array()).toString('base64')
+assert.equal((await createAssetCard.locator('[data-testid=asset-id]').textContent()).trim(), assetId)
+const assetPayload = new Message(Buffer.from(postedAsset.data.payload, 'base64'), true)
+  .getRoot(Payload)
+  .getTxType()
+  .getNftMint()
+const payloadData = assetPayload.getAttestationSubgroup().getData()
+assert.equal(Buffer.from(assetPayload.getAcctNumApp().toUint8Array()).toString('base64'), assetId, 'payload and transaction agree')
+assert.deepEqual(Buffer.from(payloadData.getAttestHash().toUint8Array()), Buffer.from(blake3(deed, { dkLen: 32 })), "the file's hash")
+assert.deepEqual(
+  payloadData.getMetadata().toArray().map((entry) => Buffer.from(entry.getItem().toUint8Array()).toString()),
+  ['deed', 'lot 7'],
+)
+assert.equal(Buffer.from(payloadData.getAcctNumVal().toUint8Array()).toString('base64'), authorityId, 'naming the authority account')
+ok("the asset creation is sent by the authority account on its nonce, to this account, carrying the file's hash")
+
+// Creating a digital asset pays for its payload's bytes too, and the authority account pays it.
+assert.equal(
+  (await createAssetCard.locator('[data-testid=tx-fee-total]').textContent()).trim(),
+  shown(nodeFee(postedAsset, MINIMUM)),
+  'the fee shown is the node formula over the posted transaction and payload',
+)
+assert.match(await createAssetCard.locator('[data-testid=tx-fee]').textContent(), /paid by authority account 1/)
+ok('the asset creation shows the fee the authority account will pay')
+
+const assetTxId = nodeRefHash(postedAsset)
+assert.equal((await createAssetCard.locator('[data-testid=tx-id]').textContent()).trim(), assetTxId)
+uutStatus(assetTxId, 'valid')
+await createAssetCard.locator('[data-testid=tx-status][data-status=confirmed]').waitFor({ timeout: 5_000 })
+ok('the asset creation is confirmed over the socket')
+
+// One that was sent keeps its nonce: a second creation through the authority account waits
+// for the block.
+await createAssetCard.locator('[data-testid=build-asset]').click()
+await createAssetCard.locator('[data-testid=asset-error]').waitFor({ timeout: 20_000 })
+assert.match(
+  await createAssetCard.locator('[data-testid=asset-error]').textContent(),
+  /already has a transaction built with nonce 1 against block 47/,
+)
+ok('an asset creation that was sent is not rebuilt on its nonce in the same block')
+
+// 12. The account's digital assets. The block that confirms the creation puts the digital
+// asset on this account's record; what it stands for is in the application layer ledger.
+const assetsCard = page.locator('section.card').nth(7)
+await assetsCard.locator('[data-testid=get-assets]').click()
+await assetsCard.locator('[data-testid=no-assets]').waitFor({ timeout: 10_000 })
+ledger.block = 48
+const ticketId = Buffer.alloc(32, 0x77).toString('base64')
+ledger.assets = [
+  { id: assetId, attestHash: blake3(deed, { dkLen: 32 }), metadata: ['deed', 'lot 7'] },
+  { id: ticketId, attestHash: Buffer.alloc(32, 0x11), metadata: ['ticket'] },
+]
+await assetsCard.locator('[data-testid=get-assets]').click()
+await assetsCard.locator('[data-testid=asset]').nth(1).waitFor({ timeout: 10_000 })
+const deedAsset = await assetsCard.locator('[data-testid=asset]').first().textContent()
+assert.match(deedAsset, /deed, lot 7/, 'with its labels, in order')
+assert.ok(deedAsset.includes(assetId), 'and its id')
+assert.ok(deedAsset.includes(Buffer.from(blake3(deed, { dkLen: 32 })).toString('hex')), "and the file's hash")
+ok("the account's digital assets are listed from the ledger, with what each was created with")
+
+// 13. Sending digital assets: a transfer that names them, with the chain's minimum as its coin.
+await transferCard.locator('[data-testid=send-assets]').check()
+assert.equal(await transferCard.locator('[data-testid=amount]').count(), 0, 'no amount to type')
+await transferCard.locator('[data-testid=transfer-get-assets]').click()
+await transferCard.locator('[data-testid=asset-choice]').nth(1).waitFor({ timeout: 10_000 })
+await transferCard.locator('[data-testid=asset-choice]').first().check()
+await transferCard.locator('[data-testid=build-transfer]').click()
+await transferCard.locator('[data-testid=transfer-base64]').waitFor({ timeout: 20_000 })
+assert.match(await transferCard.locator('[data-testid=transfer-summary]').textContent(), new RegExp(`^\\s*1 digital asset \\+ ${shownPattern(MINIMUM)} geeq \\(${MINIMUM} pennies\\) →`))
+// Ticking another drops that build unsent, so building again in the same block goes through.
+await transferCard.locator('[data-testid=asset-choice]').nth(1).check()
+await transferCard.locator('[data-testid=transfer-base64]').waitFor({ state: 'detached', timeout: 5_000 })
+await transferCard.locator('[data-testid=build-transfer]').click()
+await transferCard.locator('[data-testid=transfer-summary]', { hasText: `2 digital assets + ${shown(MINIMUM)} geeq` }).waitFor({ timeout: 20_000 })
+assert.equal(await transferCard.locator('[data-testid=transfer-error]').count(), 0, 'the rebuild is not refused')
+ok('one digital asset or several are built into a transfer, rebuilt freely until sent')
+
+sent = submitted.length
+await transferCard.locator('[data-testid=submit-transfer]').click()
+await transferCard.locator('[data-testid=tx-status][data-status=pending]').waitFor({ timeout: 15_000 })
+assert.equal(submitted.length, sent + 1, 'the digital asset transfer reached the node')
+const postedAssets = submitted[submitted.length - 1]
+assert.equal(postedAssets.type, 'uvt', 'posted as a transfer')
+const assetsTransfer = new Message(Buffer.from(postedAssets.data.transaction, 'base64'), true)
+  .getRoot(UserValTx)
+  .getData()
+assert.equal(assetsTransfer.getBlockNum(), 49, 'signed target block')
+const transferTx = assetsTransfer.getTx().getCoin().getTxType().getAsset()
+assert.equal(transferTx.getNonce(), 13, "spends the account's nonce")
+assert.equal(transferTx.getAmtCoin().getSome().toDataView().getBigUint64(0, true), MINIMUM, "with the chain's minimum")
+assert.deepEqual(Buffer.from(transferTx.getAcctNumRcv().toArrayBuffer()), Buffer.from(recipientId), 'to the pasted address')
+assert.deepEqual(
+  transferTx.getNftAssetSubgroups().toArray().map((entry) => [
+    entry.getPosition(),
+    Buffer.from(entry.getItem().getAcctNumApp().toUint8Array()).toString('base64'),
+  ]),
+  [[0, assetId], [1, ticketId]],
+  "each digital asset with its place in the account's record",
+)
+const assetsTransferId = nodeRefHash(postedAssets)
+assert.equal((await transferCard.locator('[data-testid=tx-id]').textContent()).trim(), assetsTransferId)
+uutStatus(assetsTransferId, 'valid')
+await transferCard.locator('[data-testid=tx-status][data-status=confirmed]').waitFor({ timeout: 5_000 })
+ok('the digital asset transfer names both, carries the minimum, and is confirmed over the socket')
+
+// A built transfer can wait only so long. Once the chain is past its last block, Submit
+// says so rather than posting something every node would refuse.
+ledger.block = 49
+await transferCard.locator('[data-testid=send-geeq]').check()
+await transferCard.locator('[data-testid=amount]').fill('2')
+await transferCard.locator('[data-testid=build-transfer]').click()
+await transferCard.locator('[data-testid=transfer-base64]').waitFor({ timeout: 20_000 })
+assert.equal(
+  (await transferCard.locator('[data-testid=tx-valid-until]').textContent()).trim(),
+  '58',
+  'its target block, 50, plus 8',
+)
+sent = submitted.length
+ledger.block = 59
+await transferCard.locator('[data-testid=submit-transfer]').click()
+await transferCard.locator('[data-testid=tx-expired]').waitFor({ timeout: 10_000 })
+assert.equal(submitted.length, sent, 'nothing was posted')
+assert.ok(await transferCard.locator('[data-testid=submit-transfer]').isDisabled(), 'and Submit is off')
+ok('a transfer held past its last block is not sent, and says to build again')
+
+// 14. The block explorer. The page takes a base64 refHash and the explorer is asked in hex.
+const explorerCard = page.locator('section.card').nth(8)
+const evidenceHex = Buffer.from(evidenceId, 'base64').toString('hex')
+indexed.set(evidenceHex, {
+  refHash: evidenceHex,
+  type: 'attestation',
+  status: 'valid',
+  block: 42,
+  chainName: 'test',
+  chainNumber: 1,
+  from: 'GEEQ-SENDER-ADDRESS',
+  senderType: 'coin',
+  to: '',
+  receiverType: '',
+  publicKey: '',
+  signature: '',
+  createdAt: '2026-10-01T10:00:00.000Z',
+  fee: '1',
+  values: [],
+})
+await explorerCard.locator('[data-testid=explorer-url]').fill(base)
+await explorerCard.locator('[data-testid=explorer-refhash]').fill(evidenceId)
+await explorerCard.locator('[data-testid=explorer-lookup]').click()
+await explorerCard.locator('[data-testid=explorer-result]').waitFor({ timeout: 10_000 })
+assert.equal(explorerAsked.at(-1), evidenceHex, 'the explorer was asked in hex')
+assert.match(
+  await explorerCard.locator('[data-testid=explorer-result]').textContent(),
+  /valid[\s\S]*attestation[\s\S]*42 · chain 1[\s\S]*GEEQ-SENDER-ADDRESS/,
+  'what the explorer returned is shown',
+)
+ok('a transaction is found in the explorer by its base64 refHash')
+
+// Chromium logs the explorer's 500 for an unknown refHash; that answer is the point here.
+expectedConsoleErrors.push(/status of 500/)
+await explorerCard.locator('[data-testid=explorer-refhash]').fill(transferId)
+await explorerCard.locator('[data-testid=explorer-lookup]').click()
+await explorerCard.locator('[data-testid=explorer-not-found]').waitFor({ timeout: 10_000 })
+assert.equal(await explorerCard.locator('[data-testid=explorer-result]').count(), 0, 'no stale result')
+ok('a refHash the explorer does not have is reported as not found')
+
+const askedSoFar = explorerAsked.length
+await explorerCard.locator('[data-testid=explorer-refhash]').fill(evidenceHex)
+await explorerCard.locator('[data-testid=explorer-lookup]').click()
+await explorerCard.locator('[data-testid=explorer-error]').waitFor({ timeout: 10_000 })
+assert.match(
+  await explorerCard.locator('[data-testid=explorer-error]').textContent(),
+  /32-byte hash/,
+  'a hex refHash is refused, since it is not the base64 of 32 bytes',
+)
+assert.equal(explorerAsked.length, askedSoFar, 'and the explorer was not asked')
+ok('a refHash that is not base64 is refused before the explorer is asked')
+
+// 9. Nothing broke along the way.
+for (const expected of expectedConsoleErrors) {
+  const index = consoleErrors.findIndex((line) => expected.test(line))
+  assert.notEqual(index, -1, `expected a console error matching ${expected}`)
+  consoleErrors.splice(index, 1)
+}
+assert.deepEqual(consoleErrors, [], `console errors: ${consoleErrors.join(' | ')}`)
+ok('no console errors')
+assert.deepEqual(failedRequests, [], `failed requests: ${failedRequests.join(' | ')}`)
+ok('no failed network requests')
+
+await browser.close()
+server.close()
+console.log(`\nAll ${n} browser checks passed.`)