From 70399833dc245c53835d534955a2baefd28f8411 Mon Sep 17 00:00:00 2001
From: Adam K Dean <adamkdean@googlemail.com>
Date: Tue, 29 Sep 2026 15:46:24 +0100
Subject: [PATCH 01/12] feat: add claim xe service client and transfer tracking

---
 src/utils/claim.js      | 125 ++++++++++++++++++++++++++++++++++++++++
 src/utils/claim.test.js | 101 ++++++++++++++++++++++++++++++++
 2 files changed, 226 insertions(+)
 create mode 100644 src/utils/claim.js
 create mode 100644 src/utils/claim.test.js

diff --git a/src/utils/claim.js b/src/utils/claim.js
new file mode 100644
index 0000000..462872a
--- /dev/null
+++ b/src/utils/claim.js
@@ -0,0 +1,125 @@
+// Copyright (C) 2026 Edge Network Technologies Limited
+// Use of this source code is governed by a GNU GPL-style license
+// that can be found in the LICENSE.md file. All rights reserved.
+
+// Claim XE: client for the claims service (edge/xe-claim) and the logic that
+// follows a claim transfer on the Edge chain.
+
+const CLAIMS_API_URL = import.meta.env.VITE_CLAIMS_API_URL
+
+export const claimsEnabled = () => !!CLAIMS_API_URL
+
+async function request(path, options = {}) {
+  const res = await fetch(`${CLAIMS_API_URL}${path}`, {
+    ...options,
+    headers: { 'content-type': 'application/json' }
+  })
+  const body = await res.json().catch(() => ({}))
+  if (!res.ok) throw new Error(body.error || `Claims service error (HTTP ${res.status}).`)
+  return body
+}
+
+export const fetchClaimsInfo = () => request('/info')
+
+export const createClaim = (edgeAddress, xeAddress, amount) => request('/claims', {
+  method: 'POST',
+  body: JSON.stringify({ edgeAddress, xeAddress, amount })
+})
+
+export const fetchClaim = ref => request(`/claims/${ref}`)
+
+export const fetchClaims = async address => (await request(`/claims?address=${address}`)).results
+
+// New XE address: 64 hex, no prefix. Not an Edge address (xe_...).
+export const newXeAddressRegexp = /^[0-9a-f]{64}$/
+
+export const normaliseXeAddress = address => address.trim().toLowerCase()
+
+// Stages of a claim transfer, in order.
+export const STAGES = ['posted', 'in_block', 'confirmed', 'received']
+
+// Where a claim transfer is, from one round of checks:
+//   chainTx       GET /transaction/:hash on the chain, or null when not found
+//   pending       the hash is in the sender's pending transactions
+//   walletNonce   the sender's confirmed nonce
+//   txNonce       the nonce the claim transfer was signed with
+//   claim         the claim from the claims service, or null
+//   required      confirmations the claims service waits for
+// The chain can accept a transfer and then drop it. A transfer that is
+// neither pending nor in a block, while its nonce is still unused, is
+// 'missing'; the caller treats repeated misses as a failed claim.
+export function claimProgress({ chainTx, pending, walletNonce, txNonce, claim, required }) {
+  if (claim && claim.status === 'received') return { stage: 'received', confirmations: required, percent: 100 }
+
+  // The chain is the evidence: a transfer in a block is on its way, whatever
+  // the claims service says about the claim's expiry.
+  if (chainTx) {
+    const confirmations = chainTx.confirmations
+    if (confirmations >= required) return { stage: 'confirmed', confirmations, percent: 90 }
+    return { stage: 'in_block', confirmations, percent: 30 + Math.floor(55 * confirmations / required) }
+  }
+
+  if (claim && claim.status === 'expired') return { stage: 'failed', confirmations: 0, percent: 0 }
+
+  if (pending || walletNonce > txNonce) return { stage: 'posted', confirmations: 0, percent: 15 }
+  return { stage: 'missing', confirmations: 0, percent: 15 }
+}
+
+// Misses in a row before a claim counts as failed. One miss can be a transfer
+// moving from the mempool into a block between two requests.
+export const MISSES_TO_FAIL = 3
+
+// The claim in progress is kept in the browser, per Edge address, so the
+// modal can follow it again after the page is closed.
+const storageKey = address => `claim-xe:${address}`
+
+export function saveActiveClaim(address, claim) {
+  try {
+    localStorage.setItem(storageKey(address), JSON.stringify(claim))
+  } catch (err) {
+    console.error('Could not save the claim in progress:', err)
+  }
+}
+
+export function loadActiveClaim(address) {
+  try {
+    return JSON.parse(localStorage.getItem(storageKey(address)))
+  } catch {
+    return null
+  }
+}
+
+export function clearActiveClaim(address) {
+  try {
+    localStorage.removeItem(storageKey(address))
+  } catch {
+    // Storage unavailable: nothing to clear.
+  }
+}
+
+// References whose transfer this browser saw fail. The claims service only
+// calls such a claim expired after its TTL, so the list shows it failed now.
+const failedKey = address => `claim-xe-failed:${address}`
+
+export function loadFailedRefs(address) {
+  try {
+    return JSON.parse(localStorage.getItem(failedKey(address))) || []
+  } catch {
+    return []
+  }
+}
+
+export function markClaimFailed(address, ref) {
+  try {
+    const refs = loadFailedRefs(address).filter(r => r !== ref)
+    localStorage.setItem(failedKey(address), JSON.stringify([ref, ...refs].slice(0, 20)))
+  } catch (err) {
+    console.error('Could not save the failed claim:', err)
+  }
+}
+
+// Status for the claims list: failed when the service says expired, or when
+// the transfer failed here and the service has not seen one.
+export function claimFailed(claim, failedRefs) {
+  return claim.status === 'expired' || (claim.status === 'awaiting_transfer' && failedRefs.includes(claim.ref))
+}
diff --git a/src/utils/claim.test.js b/src/utils/claim.test.js
new file mode 100644
index 0000000..4c4c59a
--- /dev/null
+++ b/src/utils/claim.test.js
@@ -0,0 +1,101 @@
+// Copyright (C) 2026 Edge Network Technologies Limited
+// Use of this source code is governed by a GNU GPL-style license
+// that can be found in the LICENSE.md file. All rights reserved.
+
+import {
+  claimFailed, claimProgress, clearActiveClaim, loadActiveClaim, loadFailedRefs, markClaimFailed,
+  newXeAddressRegexp, normaliseXeAddress, saveActiveClaim
+} from './claim'
+
+const base = { chainTx: null, pending: false, walletNonce: 4, txNonce: 4, claim: null, required: 10 }
+
+describe('claimProgress', () => {
+  it('is posted while the transfer is pending', () => {
+    expect(claimProgress({ ...base, pending: true }).stage).toBe('posted')
+  })
+
+  it('counts confirmations once the transfer is in a block', () => {
+    const at0 = claimProgress({ ...base, chainTx: { confirmations: 0 } })
+    const at5 = claimProgress({ ...base, chainTx: { confirmations: 5 } })
+    expect(at0).toMatchObject({ stage: 'in_block', confirmations: 0 })
+    expect(at5).toMatchObject({ stage: 'in_block', confirmations: 5 })
+    expect(at5.percent).toBeGreaterThan(at0.percent)
+  })
+
+  it('is confirmed at the required confirmations', () => {
+    expect(claimProgress({ ...base, chainTx: { confirmations: 10 } }).stage).toBe('confirmed')
+    expect(claimProgress({ ...base, chainTx: { confirmations: 25 } }).stage).toBe('confirmed')
+  })
+
+  it('is received once the claims service has it, whatever the chain says', () => {
+    const received = claimProgress({ ...base, claim: { status: 'received' } })
+    expect(received).toMatchObject({ stage: 'received', percent: 100 })
+  })
+
+  it('is missing when the transfer is nowhere and its nonce is unused', () => {
+    expect(claimProgress(base).stage).toBe('missing')
+  })
+
+  it('is not missing when the nonce is used: the transfer is on its way into a block', () => {
+    expect(claimProgress({ ...base, walletNonce: 5 }).stage).toBe('posted')
+  })
+
+  it('fails when the claims service reports the claim expired', () => {
+    expect(claimProgress({ ...base, claim: { status: 'expired' } }).stage).toBe('failed')
+  })
+
+  it('trusts the chain over an expired claim', () => {
+    const progress = claimProgress({ ...base, chainTx: { confirmations: 2 }, claim: { status: 'expired' } })
+    expect(progress.stage).toBe('in_block')
+  })
+
+  it('keeps the percentage in order through the stages', () => {
+    const percents = [
+      claimProgress({ ...base, pending: true }),
+      claimProgress({ ...base, chainTx: { confirmations: 0 } }),
+      claimProgress({ ...base, chainTx: { confirmations: 9 } }),
+      claimProgress({ ...base, chainTx: { confirmations: 10 } }),
+      claimProgress({ ...base, claim: { status: 'received' } })
+    ].map(p => p.percent)
+    expect([...percents].sort((a, b) => a - b)).toEqual(percents)
+  })
+})
+
+describe('new XE addresses', () => {
+  it('accepts 64 hex after trimming and lowercasing', () => {
+    expect(newXeAddressRegexp.test(normaliseXeAddress(`  ${'AB'.repeat(32)} `))).toBe(true)
+  })
+
+  it('rejects Edge addresses and short values', () => {
+    expect(newXeAddressRegexp.test(normaliseXeAddress('xe_0cba2b664C9672860Bcbf51d7Ed022Cb9E007563'))).toBe(false)
+    expect(newXeAddressRegexp.test('ab'.repeat(31))).toBe(false)
+  })
+})
+
+describe('failed claims', () => {
+  it('remembers failed references per address', () => {
+    markClaimFailed('xe_one', 'r1')
+    markClaimFailed('xe_one', 'r2')
+    markClaimFailed('xe_one', 'r1')
+    expect(loadFailedRefs('xe_one')).toEqual(['r1', 'r2'])
+    expect(loadFailedRefs('xe_two')).toEqual([])
+  })
+
+  it('shows a claim failed when expired, or awaiting with a transfer that failed here', () => {
+    expect(claimFailed({ status: 'expired', ref: 'x' }, [])).toBe(true)
+    expect(claimFailed({ status: 'awaiting_transfer', ref: 'x' }, ['x'])).toBe(true)
+    expect(claimFailed({ status: 'awaiting_transfer', ref: 'x' }, [])).toBe(false)
+    expect(claimFailed({ status: 'received', ref: 'x' }, ['x'])).toBe(false)
+  })
+})
+
+describe('active claim storage', () => {
+  it('saves, loads and clears the claim in progress per address', () => {
+    const claim = { ref: 'a'.repeat(64), hash: 'b'.repeat(64), nonce: 3 }
+    saveActiveClaim('xe_one', claim)
+    expect(loadActiveClaim('xe_one')).toEqual(claim)
+    expect(loadActiveClaim('xe_two')).toBeNull()
+    clearActiveClaim('xe_one')
+    expect(loadActiveClaim('xe_one')).toBeNull()
+  })
+})

From a179a92f0f6504545b29ec10de14cbd725672ab8 Mon Sep 17 00:00:00 2001
From: Adam K Dean <adamkdean@googlemail.com>
Date: Tue, 29 Sep 2026 15:46:24 +0100
Subject: [PATCH 02/12] feat: add claim xe modal with progress tracking

---
 src/components/tx/ClaimModal.vue | 636 +++++++++++++++++++++++++++++++
 1 file changed, 636 insertions(+)
 create mode 100644 src/components/tx/ClaimModal.vue

diff --git a/src/components/tx/ClaimModal.vue b/src/components/tx/ClaimModal.vue
new file mode 100644
index 0000000..8396c9b
--- /dev/null
+++ b/src/components/tx/ClaimModal.vue
@@ -0,0 +1,636 @@
+<template>
+  <div>
+    <Modal :close="cancel" :visible="visible && step === 1">
+      <template v-slot:header>
+        <h2 class="mb-8">Claim $XE<span class="testnet-header" v-if="isTestnet">(Testnet)</span></h2>
+        <span class="sub-heading d-block text-gray text-caption">
+          <Amount :value="balance / 1e6" currency="$EDGE"/> available
+        </span>
+      </template>
+      <template v-slot:body>
+        <div class="pb-14 min-h-410">
+          <p class="mb-14 text-gray">Claim $XE on the new XE network, 1 $XE for each $EDGE.</p>
+          <div class="form-group" :class="{'form-group__error': v$.xeAddress.$error}">
+            <label for="claim-xe-address" class="label">XE ADDRESS</label>
+            <input
+              id="claim-xe-address"
+              type="text"
+              autocomplete="off"
+              spellcheck="false"
+              placeholder="Your new XE address (64 characters)"
+              v-model="v$.xeAddress.$model"
+            />
+            <div class="form-group__error input-error" v-for="error of v$.xeAddress.$errors" :key="error.$uid">{{error.$message}}</div>
+          </div>
+          <div class="lg-input-group" :class="{'form-group__error': v$.amount.$error}">
+            <label for="claim-amount">AMOUNT</label>
+            <div class="relative input-wrap">
+              <input
+                type="text"
+                id="claim-amount"
+                placeholder="0.00"
+                v-model="v$.amount.$model"
+                class="placeholder-white placeholder-opacity-100"
+              />
+              <span class="absolute right-0 text-xl currentColor top-23">$EDGE</span>
+              <div class="mt-5 form-group__error input-error" style="color: #CD5F4E" v-for="error of v$.amount.$errors" :key="error.$uid">{{error.$message}}</div>
+            </div>
+          </div>
+          <div class="flex flex-wrap pt-12 radio-list">
+            <Radio name="claim-amount-max" id="claim-max" label="MAX" :selected="isMaxAmountEntered" @click="setMaxAmount" />
+          </div>
+          <label class="claim-check">
+            <input type="checkbox" v-model="v$.checked.$model" />
+            <span>I have checked this XE address, and I have the recovery phrase for it.</span>
+          </label>
+          <div v-if="infoError" class="claim-box claim-box--error">{{ infoError }}</div>
+
+          <div v-if="claims.length" class="claim-history">
+            <label class="label">Your claims</label>
+            <div v-for="c in claims" :key="c.ref" class="claim-history__item">
+              <span><Amount :value="c.amount / 1e6" currency="$EDGE" short/></span>
+              <span class="text-gray">{{ formatDate(c.createdAt) }}</span>
+              <span :class="statusClass(c)">{{ statusText(c) }}</span>
+              <button v-if="isFailed(c)" class="claim-history__retry" @click="retryFrom(c)">Retry</button>
+              <span v-else></span>
+            </div>
+          </div>
+        </div>
+      </template>
+
+      <template v-slot:footer>
+        <div class="px-24 pt-32 pb-40 border-t border-gray-700 border-opacity-30">
+          <div class="grid grid-cols-1 gap-24 md:grid-cols-2">
+            <button class="w-full button button--outline-success" @click="cancel">Cancel</button>
+            <button class="w-full button button--success" :disabled="!canContinue" @click="readyClaim">Continue</button>
+          </div>
+        </div>
+      </template>
+    </Modal>
+
+    <Modal :close="cancel" :visible="visible && step === 2">
+      <template v-slot:header>
+        <h2 class="mb-8">Claim $XE<span class="testnet-header" v-if="isTestnet">(Testnet)</span></h2>
+        <span class="sub-heading d-block text-gray text-caption">
+          <Amount :value="balance / 1e6" currency="$EDGE"/> available
+        </span>
+      </template>
+      <template v-slot:body>
+        <div class="pb-14 min-h-410">
+          <div class="form-group mb-14 text-xl">
+            <label class="label">XE address</label>
+            <span class="break-all">{{ xeAddressNormalised }}</span>
+          </div>
+          <div class="mb-16 form-group">
+            <label>You send</label>
+            <Amount :value="amountParsed" currency="$EDGE" short sub/>
+          </div>
+          <div class="mb-16 form-group">
+            <label>You claim</label>
+            <Amount :value="amountParsed" currency="$XE" short sub/>
+          </div>
+          <div class="form-group mb-14">
+            <label class="label">Claims wallet</label>
+            <HashLink to="explorer" :wallet="info && info.claimsAddress" />
+          </div>
+        </div>
+      </template>
+
+      <template v-slot:footer>
+        <div class="px-24 pt-32 pb-40 border-t border-gray-700 border-opacity-30">
+          <form>
+            <div class="form-group" :class="{'form-group__error': v$.password.$error || (passwordError && !v$.password.$dirty)}">
+              <label for="claim-pass">Enter Password</label>
+              <div class="relative input-wrap">
+                <span class="icon">
+                  <LockOpenIcon/>
+                </span>
+                <input
+                  type="password"
+                  autocomplete="off"
+                  @keypress="claimOnEnter"
+                  placeholder="Your password"
+                  id="claim-pass"
+                  v-model="v$.password.$model"
+                />
+              </div>
+              <div class="form-group__error input-error" v-for="error of v$.password.$errors" :key="error.$uid">{{error.$message}}</div>
+              <div class="form-group__error input-error" v-if="passwordError && !v$.password.$dirty">{{passwordError}}</div>
+            </div>
+          </form>
+          <div class="grid grid-cols-1 gap-24 md:grid-cols-2">
+            <button class="w-full button button--outline-success" @click="() => goto(1)">Back</button>
+            <button :disabled="!canClaim || submitting" @click="claim" class="w-full button button--success">Confirm claim</button>
+          </div>
+          <div v-if="submitError" class="claim-box claim-box--error">{{ submitError }}</div>
+        </div>
+      </template>
+    </Modal>
+
+    <Modal :close="cancel" :visible="visible && step === 3">
+      <template v-slot:header>
+        <h2 class="mb-8">{{ progressTitle }}<span class="testnet-header" v-if="isTestnet">(Testnet)</span></h2>
+      </template>
+      <template v-slot:body>
+        <div class="pb-14 min-h-410" v-if="active">
+          <div class="claim-progress">
+            <div class="claim-progress__bar" :class="{'claim-progress__bar--failed': failed}" :style="{ width: `${failed ? 100 : progress.percent}%` }"></div>
+          </div>
+          <ol class="claim-stages">
+            <li :class="stageClass('posted')">Transfer posted</li>
+            <li :class="stageClass('in_block')">In a block<span v-if="progress.stage === 'in_block'"> ({{ progress.confirmations }} of {{ required }} confirmations)</span></li>
+            <li :class="stageClass('confirmed')">{{ required }}+ confirmations</li>
+            <li :class="stageClass('received')">Received by the claims service</li>
+          </ol>
+
+          <div v-if="failed" class="claim-box claim-box--error">
+            The transfer was not processed, so your $EDGE did not move. You can try again.
+          </div>
+          <div v-else-if="progress.stage === 'received'" class="claim-box">
+            Your claim is received. Your $XE is sent to your XE address after approval.
+          </div>
+          <div v-else class="claim-box">
+            You can leave this page: your claim continues without it. Keep the page open to follow it here.
+          </div>
+
+          <div class="mt-20 form-group mb-14">
+            <label>Amount</label>
+            <Amount :value="active.amount / 1e6" currency="$EDGE" short sub/>
+          </div>
+          <div class="form-group mb-14">
+            <label>Transaction hash</label>
+            <HashLink to="explorer" :transaction="active.hash" truncated />
+          </div>
+        </div>
+      </template>
+
+      <template v-slot:footer>
+        <div class="px-24 pt-40 pb-40 border-t border-gray-700 border-opacity-30">
+          <div v-if="failed" class="grid grid-cols-1 gap-24 md:grid-cols-2">
+            <button class="w-full button button--outline-success" @click="cancel">Close</button>
+            <button class="w-full button button--success" @click="tryAgain">Try again</button>
+          </div>
+          <button v-else @click="cancel" class="block w-full mx-auto text-center button button--success md:w-1/2">Close</button>
+        </div>
+      </template>
+    </Modal>
+  </div>
+</template>
+
+<script>
+import * as storage from '../../utils/storage'
+import * as validation from '../../utils/validation'
+import * as xe from '@edge/xe-utils'
+import Amount from '../Amount.vue'
+import HashLink from '../HashLink.vue'
+import { LockOpenIcon } from '@heroicons/vue/outline'
+import Modal from '../Modal.vue'
+import Radio from '../Radio.vue'
+import { helpers } from '@vuelidate/validators'
+import { mapState } from 'vuex'
+import { parseAmount } from '../../utils/form'
+import useVuelidate from '@vuelidate/core'
+import {
+  MISSES_TO_FAIL, STAGES, claimFailed, claimProgress, clearActiveClaim, createClaim, fetchClaim, fetchClaims,
+  fetchClaimsInfo, loadActiveClaim, loadFailedRefs, markClaimFailed, newXeAddressRegexp, normaliseXeAddress,
+  saveActiveClaim
+} from '../../utils/claim'
+
+const POLL_MS = 5000
+
+export default {
+  name: 'ClaimModal',
+  components: {
+    Amount,
+    HashLink,
+    LockOpenIcon,
+    Modal,
+    Radio
+  },
+  props: {
+    close: Function,
+    visible: Boolean
+  },
+  data() {
+    return {
+      step: 1,
+
+      info: null,
+      infoError: '',
+      claims: [],
+      failedRefs: [],
+
+      xeAddress: '',
+      amount: '',
+      checked: false,
+      password: '',
+      passwordError: '',
+      submitError: '',
+      submitting: false,
+
+      active: null,
+      progress: { stage: 'posted', confirmations: 0, percent: 15 },
+      misses: 0,
+      failed: false,
+      pollTimer: null
+    }
+  },
+  validations() {
+    return {
+      xeAddress: [
+        validation.required,
+        helpers.withMessage(
+          'Enter your new XE address: 64 characters, 0-9 and a-f. An Edge address (xe_...) does not work.',
+          v => newXeAddressRegexp.test(normaliseXeAddress(v))
+        )
+      ],
+      amount: [
+        validation.required,
+        ...validation.amount(this.balance, this.amountParsed),
+        helpers.withParams({ p: this.amountParsed }, helpers.withMessage(
+          () => `The minimum claim is ${this.minAmount / 1e6} $EDGE.`,
+          () => this.amountParsed >= this.minAmount / 1e6
+        ))
+      ],
+      checked: [helpers.withMessage('Confirm that you checked the address.', v => v === true)],
+      password: [validation.passwordRequired]
+    }
+  },
+  computed: {
+    ...mapState(['address', 'balance', 'nextNonce']),
+    amountParsed() {
+      return parseAmount(this.amount)
+    },
+    xeAddressNormalised() {
+      return normaliseXeAddress(this.xeAddress)
+    },
+    minAmount() {
+      return this.info ? this.info.minAmount : 1e6
+    },
+    required() {
+      return this.info ? this.info.confirmations : 10
+    },
+    canContinue() {
+      return !!this.info && ![this.v$.xeAddress, this.v$.amount, this.v$.checked].map(f => f.$invalid).includes(true)
+    },
+    canClaim() {
+      return !this.v$.$invalid
+    },
+    isMaxAmountEntered() {
+      return this.balance > 0 && this.amountParsed === this.balance / 1e6
+    },
+    progressTitle() {
+      if (this.failed) return 'Claim failed'
+      if (this.progress.stage === 'received') return 'Claim received'
+      return 'Claim in progress'
+    }
+  },
+  watch: {
+    visible(v, oldv) {
+      if (v === oldv) return
+      if (v) this.open()
+      else this.stopPolling()
+    }
+  },
+  unmounted() {
+    this.stopPolling()
+  },
+  methods: {
+    async open() {
+      this.$store.dispatch('refresh')
+      this.active = loadActiveClaim(this.address)
+      if (this.active) {
+        this.goto(3)
+        this.startPolling()
+      }
+      try {
+        this.info = await fetchClaimsInfo()
+        this.infoError = this.info.open ? '' : 'Claims are closed.'
+        if (!this.info.open) this.info = null
+      }
+      catch (err) {
+        this.infoError = 'The claims service is not available. Try again later.'
+      }
+      this.loadClaims()
+    },
+    async loadClaims() {
+      this.failedRefs = loadFailedRefs(this.address)
+      try {
+        this.claims = (await fetchClaims(this.address)).slice(0, 5)
+      }
+      catch (err) {
+        this.claims = []
+      }
+    },
+    cancel() {
+      this.stopPolling()
+      if (this.active && (this.failed || this.progress.stage === 'received')) clearActiveClaim(this.active.sender)
+      this.reset()
+      this.close()
+    },
+    goto(step) {
+      this.step = step
+    },
+    reset() {
+      this.goto(1)
+      this.xeAddress = ''
+      this.amount = ''
+      this.checked = false
+      this.password = ''
+      this.passwordError = ''
+      this.submitError = ''
+      this.submitting = false
+      this.active = null
+      this.progress = { stage: 'posted', confirmations: 0, percent: 15 }
+      this.misses = 0
+      this.failed = false
+      this.v$.$reset()
+    },
+    readyClaim() {
+      const fields = [this.v$.xeAddress, this.v$.amount, this.v$.checked]
+      fields.forEach(f => f.$touch())
+      if (fields.map(f => f.$error).includes(true)) return
+      this.goto(2)
+    },
+    async checkPassword() {
+      this.v$.password.$reset()
+      if (await storage.comparePassword(this.password)) {
+        this.passwordError = ''
+        return true
+      }
+      this.passwordError = 'Incorrect password.'
+      return false
+    },
+    async claim() {
+      this.passwordError = ''
+      this.submitError = ''
+      if (!await this.v$.$validate()) return
+      if (!await this.checkPassword()) return
+
+      this.submitting = true
+      try {
+        const privateKey = await storage.getPrivateKey(this.password)
+        const claim = await createClaim(this.address, this.xeAddressNormalised, xe.xe.toMxe(this.amountParsed))
+
+        await this.$store.dispatch('refresh')
+        const nonce = this.nextNonce
+        const tx = xe.tx.sign({
+          timestamp: Date.now(),
+          sender: this.address,
+          recipient: claim.claimsAddress,
+          amount: claim.amount,
+          data: { memo: claim.memo, ref: claim.ref },
+          nonce
+        }, privateKey)
+
+        const { metadata, results } = await xe.tx.createTransactions(import.meta.env.VITE_BLOCKCHAIN_API_URL, [tx])
+        if (!metadata.accepted) {
+          this.submitError = results[0].reason
+          return
+        }
+
+        this.active = {
+          sender: this.address,
+          ref: claim.ref,
+          hash: results[0].hash,
+          nonce,
+          amount: claim.amount,
+          xeAddress: this.xeAddressNormalised,
+          createdAt: Date.now()
+        }
+        saveActiveClaim(this.address, this.active)
+        this.goto(3)
+        this.startPolling()
+      }
+      catch (err) {
+        console.error(err)
+        this.submitError = err.message
+      }
+      finally {
+        this.submitting = false
+      }
+    },
+    claimOnEnter(event) {
+      if (event.charCode !== 13) return
+      event.preventDefault()
+      this.claim()
+    },
+    startPolling() {
+      this.stopPolling()
+      const tick = async () => {
+        await this.pollClaim()
+        if (this.visible && !this.failed && this.progress.stage !== 'received') {
+          this.pollTimer = setTimeout(tick, POLL_MS)
+        }
+      }
+      tick()
+    },
+    stopPolling() {
+      clearTimeout(this.pollTimer)
+      this.pollTimer = null
+    },
+    async pollClaim() {
+      const host = import.meta.env.VITE_BLOCKCHAIN_API_URL
+      const { hash, nonce, ref, sender } = this.active
+      try {
+        const [chainTx, pendingTxs, walletInfo, claim] = await Promise.all([
+          fetch(`${host}/transaction/${hash}`).then(res => res.ok ? res.json() : null),
+          xe.tx.pendingTransactions(host, sender),
+          xe.wallet.info(host, sender),
+          fetchClaim(ref).catch(() => null)
+        ])
+        const progress = claimProgress({
+          chainTx,
+          pending: pendingTxs.some(t => t.hash === hash),
+          walletNonce: walletInfo.nonce,
+          txNonce: nonce,
+          claim,
+          required: this.required
+        })
+
+        if (progress.stage === 'missing') {
+          this.misses++
+          if (this.misses >= MISSES_TO_FAIL) this.setFailed()
+          return
+        }
+        this.misses = 0
+        if (progress.stage === 'failed') {
+          this.setFailed()
+          return
+        }
+        this.progress = progress
+      }
+      catch (err) {
+        // Network trouble: keep the last known state and check again.
+        console.error('Claim check failed:', err)
+      }
+    },
+    setFailed() {
+      this.failed = true
+      markClaimFailed(this.active.sender, this.active.ref)
+    },
+    tryAgain() {
+      const { amount, sender, xeAddress } = this.active
+      clearActiveClaim(sender)
+      this.reset()
+      this.amount = (amount / 1e6).toString()
+      this.xeAddress = xeAddress
+      this.loadClaims()
+    },
+    retryFrom(claim) {
+      this.amount = (claim.amount / 1e6).toString()
+    },
+    setMaxAmount() {
+      this.amount = (this.balance / 1e6).toFixed(6)
+    },
+    stageClass(stage) {
+      const current = STAGES.indexOf(this.progress.stage)
+      const index = STAGES.indexOf(stage)
+      if (this.failed) return index === 0 ? 'claim-stage--failed' : ''
+      if (index < current || this.progress.stage === 'received') return 'claim-stage--done'
+      if (index === current) return 'claim-stage--current'
+      return ''
+    },
+    isFailed(claim) {
+      return claimFailed(claim, this.failedRefs)
+    },
+    statusClass(claim) {
+      if (this.isFailed(claim)) return 'claim-status--failed'
+      return claim.status === 'received' ? 'claim-status--received' : ''
+    },
+    statusText(claim) {
+      if (this.isFailed(claim)) return 'Failed'
+      if (claim.status === 'awaiting_transfer') return 'Waiting for transfer'
+      if (claim.processed) return 'Paid'
+      if (claim.approved) return 'Approved'
+      return claim.review.length ? 'Received, in review' : 'Received'
+    },
+    formatDate(date) {
+      return new Date(date).toLocaleDateString()
+    }
+  },
+  setup() {
+    return {
+      v$: useVuelidate()
+    }
+  }
+}
+</script>
+
+<style scoped>
+.sub-heading :deep(.amount .currency) {
+  @apply ml-5;
+}
+
+.amount.sub {
+  @apply text-white text-3xl;
+}
+
+.amount.sub :deep(.currency) {
+  @apply text-half bottom-0 ml-2;
+}
+
+.testnet-header {
+  color: #0ecc5f;
+  padding-left: 10px;
+}
+
+.claim-check {
+  @apply flex items-start mt-20 cursor-pointer text-gray;
+  gap: 10px;
+  font-size: 14px;
+  letter-spacing: normal;
+  text-transform: none;
+}
+
+.claim-check input {
+  accent-color: #0ecc5f;
+  margin-top: 3px;
+}
+
+.claim-box {
+  @apply px-20 py-16 mt-20 text-white bg-black border border-gray-700 rounded border-opacity-30;
+}
+
+.claim-box--error {
+  color: #CD5F4E;
+}
+
+.claim-history {
+  @apply mt-24;
+}
+
+.claim-history__item {
+  @apply grid items-center py-8 border-b border-gray-700 border-opacity-30;
+  grid-template-columns: 1fr 1fr 1fr 48px;
+  gap: 12px;
+}
+
+.claim-history__item > :nth-child(3),
+.claim-history__item > :nth-child(4) {
+  @apply text-right;
+}
+
+.claim-history__item :deep(.currency) {
+  margin-left: 4px;
+}
+
+.claim-history__retry {
+  @apply text-green underline;
+}
+
+.claim-status--received {
+  color: #0ecc5f;
+}
+
+.claim-status--failed {
+  color: #CD5F4E;
+}
+
+.claim-progress {
+  @apply w-full mb-20 overflow-hidden bg-gray-700 rounded;
+  height: 8px;
+}
+
+.claim-progress__bar {
+  height: 100%;
+  background: #0ecc5f;
+  transition: width 0.5s ease;
+}
+
+.claim-progress__bar--failed {
+  background: #CD5F4E;
+}
+
+.claim-stages li {
+  @apply py-4 text-gray;
+}
+
+.claim-stages li::before {
+  content: '○';
+  @apply mr-8;
+}
+
+.claim-stages li.claim-stage--done {
+  @apply text-white;
+}
+
+.claim-stages li.claim-stage--done::before {
+  content: '●';
+  color: #0ecc5f;
+}
+
+.claim-stages li.claim-stage--current {
+  @apply text-white;
+}
+
+.claim-stages li.claim-stage--current::before {
+  content: '◐';
+  color: #0ecc5f;
+}
+
+.claim-stages li.claim-stage--failed::before {
+  content: '✕';
+  color: #CD5F4E;
+}
+</style>

From 1bfec38ef4e4663535b9582f45fb0e8db49228d2 Mon Sep 17 00:00:00 2001
From: Adam K Dean <adamkdean@googlemail.com>
Date: Tue, 29 Sep 2026 15:46:24 +0100
Subject: [PATCH 03/12] feat: add claim xe button to account panel

---
 src/components/AccountPanel.vue | 33 +++++++++++++++++++++++++++++++--
 1 file changed, 31 insertions(+), 2 deletions(-)

diff --git a/src/components/AccountPanel.vue b/src/components/AccountPanel.vue
index 65b27a0..5498bf3 100644
--- a/src/components/AccountPanel.vue
+++ b/src/components/AccountPanel.vue
@@ -24,7 +24,7 @@
             Create Stake
           </button>
         </div>
-        <div v-else class="account-panel__buttons">
+        <div v-else class="account-panel__buttons" :class="{'account-panel__buttons--four': claimsOpen}">
           <button class="w-full button button--success" @click="openSend">
             <span class="w-12 button__icon">
               <ArrowUpIcon/>
@@ -45,11 +45,19 @@
             </span>
             Swap
           </button>
+
+          <button v-if="claimsOpen" class="w-full button button--outline-success" @click="openClaim">
+            <span class="button__icon w-15">
+              <SparklesIcon/>
+            </span>
+            Claim XE
+          </button>
         </div>
       </div>
     </div>
 
     <div class="account-panel__modals">
+      <ClaimModal v-if="claimsOpen" :close="reset" :visible="modal === 'claim'"/>
       <CreateStakeModal :close="reset" :visible="modal === 'createStake'"/>
       <DepositModal :close="reset" :visible="modal === 'deposit'"/>
       <ReceiveModal :close="reset" :visible="modal === 'receive'"/>
@@ -69,6 +77,7 @@
 
 <script>
 import Amount from './Amount.vue'
+import ClaimModal from './tx/ClaimModal.vue'
 import CreateStakeModal from './stakes/CreateStakeModal.vue'
 import DepositModal from './tx/DepositModal.vue'
 import ReceiveModal from './tx/ReceiveModal.vue'
@@ -77,7 +86,8 @@ import SendModal from './tx/SendModal.vue'
 import SwapModal from './tx/SwapModal.vue'
 import WithdrawModal from './tx/WithdrawModal.vue'
 import { mapState } from 'vuex'
-import { ArrowDownIcon, ArrowUpIcon, PlusIcon, SwitchHorizontalIcon } from '@heroicons/vue/outline'
+import { ArrowDownIcon, ArrowUpIcon, PlusIcon, SparklesIcon, SwitchHorizontalIcon } from '@heroicons/vue/outline'
+import { claimsEnabled, fetchClaimsInfo } from '../utils/claim'
 
 export default {
   name: 'AccountPanel',
@@ -86,12 +96,14 @@ export default {
     Amount,
     ArrowDownIcon,
     ArrowUpIcon,
+    ClaimModal,
     CreateStakeModal,
     DepositModal,
     PlusIcon,
     ReceiveModal,
     SellModal,
     SendModal,
+    SparklesIcon,
     SwapModal,
     SwitchHorizontalIcon,
     WithdrawModal
@@ -99,10 +111,23 @@ export default {
   computed: mapState(['address', 'balance', 'usdBalance']),
   data() {
     return {
+      claimsOpen: false,
       modal: ''
     }
   },
+  async mounted() {
+    if (!claimsEnabled()) return
+    try {
+      this.claimsOpen = (await fetchClaimsInfo()).open
+    }
+    catch (err) {
+      console.error('Claims service not available:', err)
+    }
+  },
   methods: {
+    openClaim() {
+      this.modal = 'claim'
+    },
     openCreateStake() {
       this.modal = 'createStake'
     },
@@ -204,6 +229,10 @@ export default {
     @apply grid grid-cols-3 mt-0;
   }
 
+  .account-panel__buttons--four {
+    @apply grid-cols-4;
+  }
+
   .account-panel__buttons.staking-buttons {
     @apply grid-cols-1;
   }

From 5f00a7673e49bd7ec3193f9fbb873e28754a25b2 Mon Sep 17 00:00:00 2001
From: Adam K Dean <adamkdean@googlemail.com>
Date: Mon, 5 Oct 2026 13:19:16 +0100
Subject: [PATCH 04/12] build: add bip39 and noble crypto packages for xe
 addresses

---
 package-lock.json | 63 +++++++++++++++++++++++++++++++++++++++++++++++
 package.json      |  3 +++
 2 files changed, 66 insertions(+)

diff --git a/package-lock.json b/package-lock.json
index 1fc5e33..2c2b1ac 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -16,6 +16,9 @@
         "@heroicons/vue": "^1.0.1",
         "@metamask/detect-provider": "^1.2.0",
         "@metamask/onboarding": "^1.0.0",
+        "@noble/curves": "^2.4.0",
+        "@noble/hashes": "^2.4.0",
+        "@scure/bip39": "^2.4.0",
         "@vuelidate/core": "^2.0.0-alpha.16",
         "@vuelidate/validators": "^2.0.0-alpha.13",
         "chart.js": "^3.7.1",
@@ -1600,6 +1603,33 @@
         "bowser": "^2.9.0"
       }
     },
+    "node_modules/@noble/curves": {
+      "version": "2.4.0",
+      "resolved": "https://registry.npmjs.org/@noble/curves/-/curves-2.4.0.tgz",
+      "integrity": "sha512-P4/62zrgfH33CneE3Dn4WhJVA22YUU0eR51wKIan4NVRvwsA0YnPTwWGpNbpuacSujmSFLvyzpyuR30+fbq2Ew==",
+      "license": "MIT",
+      "dependencies": {
+        "@noble/hashes": "2.4.0"
+      },
+      "engines": {
+        "node": ">= 20.19.0"
+      },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      }
+    },
+    "node_modules/@noble/hashes": {
+      "version": "2.4.0",
+      "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-2.4.0.tgz",
+      "integrity": "sha512-X5XaVWZIBCT7HHZGm5I7ZQXDwLG+bGXuSrMQAW+7Zvl87h1kmc1ZB1VSRJcpUfoUrGQp4Fkoxm5kZ+Ms+aW+eA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 20.19.0"
+      },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      }
+    },
     "node_modules/@nodelib/fs.scandir": {
       "version": "2.1.5",
       "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
@@ -1967,6 +1997,18 @@
         "win32"
       ]
     },
+    "node_modules/@scure/bip39": {
+      "version": "2.4.0",
+      "resolved": "https://registry.npmjs.org/@scure/bip39/-/bip39-2.4.0.tgz",
+      "integrity": "sha512-82dxFbZUYboyOf0AXiydsQrFQ5Q4h9mX+O2UkE91ROYmsc0BKMGZLwDmy96Jpa2+vrtoxomjUhy1RPIgH/r2nA==",
+      "license": "MIT",
+      "dependencies": {
+        "@noble/hashes": "2.4.0"
+      },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      }
+    },
     "node_modules/@standard-schema/spec": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
@@ -7744,6 +7786,19 @@
         "bowser": "^2.9.0"
       }
     },
+    "@noble/curves": {
+      "version": "2.4.0",
+      "resolved": "https://registry.npmjs.org/@noble/curves/-/curves-2.4.0.tgz",
+      "integrity": "sha512-P4/62zrgfH33CneE3Dn4WhJVA22YUU0eR51wKIan4NVRvwsA0YnPTwWGpNbpuacSujmSFLvyzpyuR30+fbq2Ew==",
+      "requires": {
+        "@noble/hashes": "2.4.0"
+      }
+    },
+    "@noble/hashes": {
+      "version": "2.4.0",
+      "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-2.4.0.tgz",
+      "integrity": "sha512-X5XaVWZIBCT7HHZGm5I7ZQXDwLG+bGXuSrMQAW+7Zvl87h1kmc1ZB1VSRJcpUfoUrGQp4Fkoxm5kZ+Ms+aW+eA=="
+    },
     "@nodelib/fs.scandir": {
       "version": "2.1.5",
       "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
@@ -7923,6 +7978,14 @@
       "integrity": "sha512-mxRFDdHIWRxg3UfIIAwCm6NzvxG0jDX/wBN6KsQFTvKFqqg9vTrWUE68qEjHt19A5wwx5X5aUi2zuZT7YR0jrA==",
       "optional": true
     },
+    "@scure/bip39": {
+      "version": "2.4.0",
+      "resolved": "https://registry.npmjs.org/@scure/bip39/-/bip39-2.4.0.tgz",
+      "integrity": "sha512-82dxFbZUYboyOf0AXiydsQrFQ5Q4h9mX+O2UkE91ROYmsc0BKMGZLwDmy96Jpa2+vrtoxomjUhy1RPIgH/r2nA==",
+      "requires": {
+        "@noble/hashes": "2.4.0"
+      }
+    },
     "@standard-schema/spec": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
diff --git a/package.json b/package.json
index b29c804..6070ee0 100644
--- a/package.json
+++ b/package.json
@@ -29,6 +29,9 @@
     "@heroicons/vue": "^1.0.1",
     "@metamask/detect-provider": "^1.2.0",
     "@metamask/onboarding": "^1.0.0",
+    "@noble/curves": "^2.4.0",
+    "@noble/hashes": "^2.4.0",
+    "@scure/bip39": "^2.4.0",
     "@vuelidate/core": "^2.0.0-alpha.16",
     "@vuelidate/validators": "^2.0.0-alpha.13",
     "chart.js": "^3.7.1",

From ba4a59c1ec82209a2fb853dd34ac5656fd7efecc Mon Sep 17 00:00:00 2001
From: Adam K Dean <adamkdean@googlemail.com>
Date: Mon, 5 Oct 2026 13:19:16 +0100
Subject: [PATCH 05/12] feat: add xe account generation with recovery phrase
 vectors

---
 src/utils/xe-account.js                   | 44 ++++++++++++++
 src/utils/xe-account.test.js              | 61 ++++++++++++++++++++
 src/utils/xe-recovery-phrase-vectors.json | 70 +++++++++++++++++++++++
 3 files changed, 175 insertions(+)
 create mode 100644 src/utils/xe-account.js
 create mode 100644 src/utils/xe-account.test.js
 create mode 100644 src/utils/xe-recovery-phrase-vectors.json

diff --git a/src/utils/xe-account.js b/src/utils/xe-account.js
new file mode 100644
index 0000000..d8518b5
--- /dev/null
+++ b/src/utils/xe-account.js
@@ -0,0 +1,44 @@
+// Copyright (C) 2026 Edge Network Technologies Limited
+// Use of this source code is governed by a GNU GPL-style license
+// that can be found in the LICENSE.md file. All rights reserved.
+
+// New XE address for Claim XE. XE is the new chain (xeprotocol/core), not the
+// Edge chain: its addresses are 64 lowercase hex with no prefix.
+//
+// The XE recovery phrase (core #1005) is the 32-byte ed25519 seed written as
+// 24 BIP39 English words: BIP39's entropy-to-mnemonic encoding applied to the
+// seed itself. No PBKDF2, passphrase or derivation path: the words are the
+// seed. The address is sha256("xe/account/v1" || ed25519 public key).
+// xe-recovery-phrase-vectors.json is a copy of the core vectors.
+
+import { ed25519 } from '@noble/curves/ed25519.js'
+import { entropyToMnemonic } from '@scure/bip39'
+import { sha256 } from '@noble/hashes/sha2.js'
+import { wordlist } from '@scure/bip39/wordlists/english.js'
+import { bytesToHex, concatBytes, randomBytes, utf8ToBytes } from '@noble/hashes/utils.js'
+
+const ACCOUNT_DOMAIN = utf8ToBytes('xe/account/v1')
+
+export const phraseFromSeed = seed => entropyToMnemonic(seed, wordlist)
+
+export const publicKeyFromSeed = seed => ed25519.getPublicKey(seed)
+
+export const addressFromPublicKey = publicKey => bytesToHex(sha256(concatBytes(ACCOUNT_DOMAIN, publicKey)))
+
+// A new XE account from a random seed. The seed is not kept: the words are the
+// only copy.
+export function newXeAccount() {
+  const seed = randomBytes(32)
+  return {
+    words: phraseFromSeed(seed).split(' '),
+    address: addressFromPublicKey(publicKeyFromSeed(seed))
+  }
+}
+
+// Distinct word positions (0-based, in order) to ask back after the user has
+// written the phrase down.
+export function pickCheckPositions(count, total) {
+  const positions = new Set()
+  while (positions.size < count) positions.add(Math.floor(Math.random() * total))
+  return [...positions].sort((a, b) => a - b)
+}
diff --git a/src/utils/xe-account.test.js b/src/utils/xe-account.test.js
new file mode 100644
index 0000000..1ee7ca9
--- /dev/null
+++ b/src/utils/xe-account.test.js
@@ -0,0 +1,61 @@
+// Copyright (C) 2026 Edge Network Technologies Limited
+// Use of this source code is governed by a GNU GPL-style license
+// that can be found in the LICENSE.md file. All rights reserved.
+
+import { mnemonicToEntropy } from '@scure/bip39'
+import { sha256 } from '@noble/hashes/sha2.js'
+import vectors from './xe-recovery-phrase-vectors.json'
+import { wordlist } from '@scure/bip39/wordlists/english.js'
+import {
+  addressFromPublicKey, newXeAccount, phraseFromSeed, pickCheckPositions, publicKeyFromSeed
+} from './xe-account'
+import { bytesToHex, hexToBytes, utf8ToBytes } from '@noble/hashes/utils.js'
+
+// The vectors file is a copy of xeprotocol/core core/testdata/recovery-phrase-vectors.json.
+describe('XE recovery phrase vectors', () => {
+  it('uses the BIP39 English wordlist that core pins', () => {
+    expect(bytesToHex(sha256(utf8ToBytes(`${wordlist.join('\n')}\n`)))).toBe(vectors.wordlist_sha256)
+  })
+
+  it('encodes each BIP39 32-byte entropy vector', () => {
+    for (const v of vectors.bip39) {
+      expect(phraseFromSeed(hexToBytes(v.entropy))).toBe(v.mnemonic)
+    }
+  })
+
+  it('derives the phrase, public key and address of each XE vector', () => {
+    for (const v of vectors.xe) {
+      const seed = hexToBytes(v.seed)
+      const publicKey = publicKeyFromSeed(seed)
+      expect(phraseFromSeed(seed)).toBe(v.phrase)
+      expect(bytesToHex(publicKey)).toBe(v.public_key)
+      expect(addressFromPublicKey(publicKey)).toBe(v.address)
+    }
+  })
+})
+
+describe('newXeAccount', () => {
+  it('returns 24 words whose seed derives the returned address', () => {
+    const { address, words } = newXeAccount()
+    expect(words).toHaveLength(24)
+    expect(address).toMatch(/^[0-9a-f]{64}$/)
+    const seed = mnemonicToEntropy(words.join(' '), wordlist)
+    expect(addressFromPublicKey(publicKeyFromSeed(seed))).toBe(address)
+  })
+
+  it('returns a new account each time', () => {
+    expect(newXeAccount().address).not.toBe(newXeAccount().address)
+  })
+})
+
+describe('pickCheckPositions', () => {
+  it('picks distinct positions in order, inside the phrase', () => {
+    for (let i = 0; i < 50; i++) {
+      const positions = pickCheckPositions(3, 24)
+      expect(positions).toHaveLength(3)
+      expect(new Set(positions).size).toBe(3)
+      expect([...positions].sort((a, b) => a - b)).toEqual(positions)
+      positions.forEach(p => expect(p >= 0 && p < 24).toBe(true))
+    }
+  })
+})
diff --git a/src/utils/xe-recovery-phrase-vectors.json b/src/utils/xe-recovery-phrase-vectors.json
new file mode 100644
index 0000000..c5fa223
--- /dev/null
+++ b/src/utils/xe-recovery-phrase-vectors.json
@@ -0,0 +1,70 @@
+{
+  "description": "XE recovery phrase test vectors (xeprotocol/core#1005). An XE recovery phrase is the BIP39 entropy-to-mnemonic encoding of the 32-byte ed25519 seed with the BIP39 English wordlist: seed || first 8 bits of SHA-256(seed) gives 264 bits, read most significant bit first as 24 word indexes of 11 bits. Exactly 24 words. No PBKDF2, no passphrase, no derivation path: the words are the seed. bip39: the official BIP39 English vectors with 32-byte entropy, from trezor/python-mnemonic vectors.json, entropy and mnemonic only (the PBKDF2 seed and xprv columns do not apply). xe: seed (hex), phrase, public_key (hex ed25519 public key from the seed, RFC 8032) and address (hex SHA-256 of the UTF-8 bytes 'xe/account/v1' followed by the 32-byte public key).",
+  "wordlist_sha256": "2f5eed53a4727b4bf8880d8f3f199efc90e58503646d9ff8eff3a2ed3b24dbda",
+  "bip39": [
+    {
+      "entropy": "0000000000000000000000000000000000000000000000000000000000000000",
+      "mnemonic": "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon art"
+    },
+    {
+      "entropy": "7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f",
+      "mnemonic": "legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth title"
+    },
+    {
+      "entropy": "8080808080808080808080808080808080808080808080808080808080808080",
+      "mnemonic": "letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic bless"
+    },
+    {
+      "entropy": "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+      "mnemonic": "zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo vote"
+    },
+    {
+      "entropy": "68a79eaca2324873eacc50cb9c6eca8cc68ea5d936f98787c60c7ebc74e6ce7c",
+      "mnemonic": "hamster diagram private dutch cause delay private meat slide toddler razor book happy fancy gospel tennis maple dilemma loan word shrug inflict delay length"
+    },
+    {
+      "entropy": "9f6a2878b2520799a44ef18bc7df394e7061a224d2c33cd015b157d746869863",
+      "mnemonic": "panda eyebrow bullet gorilla call smoke muffin taste mesh discover soft ostrich alcohol speed nation flash devote level hobby quick inner drive ghost inside"
+    },
+    {
+      "entropy": "066dca1a2bb7e8a1db2832148ce9933eea0f3ac9548d793112d9a95c9407efad",
+      "mnemonic": "all hour make first leader extend hole alien behind guard gospel lava path output census museum junior mass reopen famous sing advance salt reform"
+    },
+    {
+      "entropy": "f585c11aec520db57dd353c69554b21a89b20fb0650966fa0a9d6f74fd989d8f",
+      "mnemonic": "void come effort suffer camp survey warrior heavy shoot primary clutch crush open amazing screen patrol group space point ten exist slush involve unfold"
+    }
+  ],
+  "xe": [
+    {
+      "seed": "0000000000000000000000000000000000000000000000000000000000000000",
+      "phrase": "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon art",
+      "public_key": "3b6a27bcceb6a42d62a3a8d02a6f0d73653215771de243a63ac048a18b59da29",
+      "address": "4ac0d6d4f0bd50354b93324c950096f6e0de5f91e42dac66583756afd50852de"
+    },
+    {
+      "seed": "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+      "phrase": "zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo vote",
+      "public_key": "76a1592044a6e4f511265bca73a604d90b0529d1df602be30a19a9257660d1f5",
+      "address": "b25fe45d4afa568e72559a9e0bcf727c44dbdde8ab591df1f53fdd908cd73dbb"
+    },
+    {
+      "seed": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
+      "phrase": "abandon amount liar amount expire adjust cage candy arch gather drum bullet absurd math era live bid rhythm alien crouch range attend journey unaware",
+      "public_key": "03a107bff3ce10be1d70dd18e74bc09967e4d6309ba50d5f1ddc8664125531b8",
+      "address": "338c76e03f0a8dd21192808ba1a11879b2202591bf53f4338070119f4f54a0e1"
+    },
+    {
+      "seed": "7a11413e0111030869fb5d1e434ef96110be6dbb0fb160064b3fa7a36a5f35bf",
+      "phrase": "key meat exhibit acquire awake loud pony hill bundle bounce salad season armor cycle umbrella wage gas crane soup exercise cute convince street trophy",
+      "public_key": "42aa7e1f7b83cf10b730a4ac7e11c8c4dda9321b60207ee8a9649932cada7319",
+      "address": "1cc821b6fedffceeac924054c97a3185ab835c498da225cbbd7bc89f1945a769"
+    },
+    {
+      "seed": "1c9813e44d6cfe05cd8d55a442897c56091e03aa6744c82cc16e33383d3a054e",
+      "phrase": "broken scene weekend onion soup actual curtain primary picture begin gallery project music achieve praise trigger sight gravity fortune grid long other benefit special",
+      "public_key": "a0ccc1be08b3b369c3b5b2bc8e47a61a1cb2cc6fa5662a5882ba09065cf1558c",
+      "address": "cadb731c0c153a76bd503702f7c2f51026623d2e3b31b51981cbe6873f0bb26b"
+    }
+  ]
+}

From c6324f3c01fe780d1f7b1d9e689cea4c43d35d3e Mon Sep 17 00:00:00 2001
From: Adam K Dean <adamkdean@googlemail.com>
Date: Mon, 5 Oct 2026 13:19:16 +0100
Subject: [PATCH 06/12] feat: add create xe address modal to claim flow

---
 src/components/tx/ClaimModal.vue     |  25 ++-
 src/components/tx/XeAddressModal.vue | 224 +++++++++++++++++++++++++++
 2 files changed, 246 insertions(+), 3 deletions(-)
 create mode 100644 src/components/tx/XeAddressModal.vue

diff --git a/src/components/tx/ClaimModal.vue b/src/components/tx/ClaimModal.vue
index 8396c9b..3543ae9 100644
--- a/src/components/tx/ClaimModal.vue
+++ b/src/components/tx/ClaimModal.vue
@@ -1,6 +1,6 @@
 <template>
   <div>
-    <Modal :close="cancel" :visible="visible && step === 1">
+    <Modal :close="cancel" :visible="visible && step === 1 && !creatingAddress">
       <template v-slot:header>
         <h2 class="mb-8">Claim $XE<span class="testnet-header" v-if="isTestnet">(Testnet)</span></h2>
         <span class="sub-heading d-block text-gray text-caption">
@@ -21,6 +21,7 @@
               v-model="v$.xeAddress.$model"
             />
             <div class="form-group__error input-error" v-for="error of v$.xeAddress.$errors" :key="error.$uid">{{error.$message}}</div>
+            <p class="mt-10 text-gray">Don't have an XE address yet? <button class="claim-link" @click="creatingAddress = true">Create one</button></p>
           </div>
           <div class="lg-input-group" :class="{'form-group__error': v$.amount.$error}">
             <label for="claim-amount">AMOUNT</label>
@@ -174,6 +175,8 @@
         </div>
       </template>
     </Modal>
+
+    <XeAddressModal :close="closeCreateAddress" :visible="visible && creatingAddress" @created="useCreatedAddress" />
   </div>
 </template>
 
@@ -186,6 +189,7 @@ import HashLink from '../HashLink.vue'
 import { LockOpenIcon } from '@heroicons/vue/outline'
 import Modal from '../Modal.vue'
 import Radio from '../Radio.vue'
+import XeAddressModal from './XeAddressModal.vue'
 import { helpers } from '@vuelidate/validators'
 import { mapState } from 'vuex'
 import { parseAmount } from '../../utils/form'
@@ -205,7 +209,8 @@ export default {
     HashLink,
     LockOpenIcon,
     Modal,
-    Radio
+    Radio,
+    XeAddressModal
   },
   props: {
     close: Function,
@@ -214,6 +219,7 @@ export default {
   data() {
     return {
       step: 1,
+      creatingAddress: false,
 
       info: null,
       infoError: '',
@@ -333,6 +339,7 @@ export default {
     },
     reset() {
       this.goto(1)
+      this.creatingAddress = false
       this.xeAddress = ''
       this.amount = ''
       this.checked = false
@@ -477,6 +484,17 @@ export default {
       this.xeAddress = xeAddress
       this.loadClaims()
     },
+    closeCreateAddress() {
+      this.creatingAddress = false
+    },
+    // The generator made the user back up the recovery phrase, so the
+    // address is checked and the box is ticked for them.
+    useCreatedAddress(address) {
+      this.xeAddress = address
+      this.checked = true
+      this.v$.xeAddress.$touch()
+      this.creatingAddress = false
+    },
     retryFrom(claim) {
       this.amount = (claim.amount / 1e6).toString()
     },
@@ -575,7 +593,8 @@ export default {
   margin-left: 4px;
 }
 
-.claim-history__retry {
+.claim-history__retry,
+.claim-link {
   @apply text-green underline;
 }
 
diff --git a/src/components/tx/XeAddressModal.vue b/src/components/tx/XeAddressModal.vue
new file mode 100644
index 0000000..b1eabb5
--- /dev/null
+++ b/src/components/tx/XeAddressModal.vue
@@ -0,0 +1,224 @@
+<template>
+  <div>
+    <Modal :close="close" :visible="visible && step === 1">
+      <template v-slot:header>
+        <h2 class="flex items-center mb-8"><XeLogo/>Create an XE address</h2>
+        <span class="sub-heading d-block text-gray text-caption">Step 1 of 2: write down your recovery phrase</span>
+      </template>
+      <template v-slot:body>
+        <div class="pb-14">
+          <p class="mb-14 text-gray">
+            This is a new address on the XE network. Its recovery phrase is these 24 words.
+            Write them down in order and keep them safe.
+          </p>
+          <ol class="xe-words">
+            <li v-for="(word, i) in words" :key="i"><span class="xe-words__n">{{ i + 1 }}</span>{{ word }}</li>
+          </ol>
+          <div class="flex items-start xe-box">
+            <span class="flex-shrink-0 inline-block mr-12 text-white icon w-27"><ShieldExclamationIcon/></span>
+            <p class="mb-0">
+              Anyone with these words controls your $XE. If you lose them, nobody can recover your $XE.
+              This wallet does not keep them.
+            </p>
+          </div>
+          <div class="mt-20 form-group mb-14">
+            <label>XE address</label>
+            <span class="font-mono break-all text-sm2">{{ address }}</span>
+          </div>
+        </div>
+      </template>
+      <template v-slot:footer>
+        <div class="px-24 pt-32 pb-40 border-t border-gray-700 border-opacity-30">
+          <div class="grid grid-cols-1 gap-24 md:grid-cols-2">
+            <button class="w-full button button--outline-success xe-button-outline" @click="close">Cancel</button>
+            <button class="w-full button button--success xe-button" @click="step = 2">I have written them down</button>
+          </div>
+        </div>
+      </template>
+    </Modal>
+
+    <Modal :close="close" :visible="visible && step === 2">
+      <template v-slot:header>
+        <h2 class="flex items-center mb-8"><XeLogo/>Create an XE address</h2>
+        <span class="sub-heading d-block text-gray text-caption">Step 2 of 2: check your recovery phrase</span>
+      </template>
+      <template v-slot:body>
+        <div class="pb-14">
+          <p class="mb-24 text-gray">Enter these words from your written copy.</p>
+          <div
+            v-for="(position, i) in positions"
+            :key="position"
+            class="form-group"
+            :class="{'form-group__error': showError(i)}"
+          >
+            <label :for="`xe-word-${position + 1}`" class="label">Word {{ position + 1 }}</label>
+            <input
+              :id="`xe-word-${position + 1}`"
+              type="text"
+              autocomplete="off"
+              autocapitalize="off"
+              spellcheck="false"
+              v-model="answers[i]"
+              @blur="touched[i] = true"
+            />
+            <div v-if="showError(i)" class="form-group__error input-error">
+              This is not word {{ position + 1 }}. Check your written copy.
+            </div>
+          </div>
+        </div>
+      </template>
+      <template v-slot:footer>
+        <div class="px-24 pt-32 pb-40 border-t border-gray-700 border-opacity-30">
+          <div class="grid grid-cols-1 gap-24 md:grid-cols-2">
+            <button class="w-full button button--outline-success xe-button-outline" @click="step = 1">Back</button>
+            <button class="w-full button button--success xe-button" :disabled="!canUse" @click="use">Use this address</button>
+          </div>
+        </div>
+      </template>
+    </Modal>
+  </div>
+</template>
+
+<script>
+import Modal from '../Modal.vue'
+import { ShieldExclamationIcon } from '@heroicons/vue/outline'
+import { h } from 'vue'
+import { newXeAccount, pickCheckPositions } from '../../utils/xe-account'
+
+const CHECK_WORDS = 3
+
+// The XE mark, from xe.network.
+const XeLogo = () => h('svg', { viewBox: '0 0 30.001 32', fill: 'currentColor', class: 'xe-logo', 'aria-label': 'XE' }, [
+  h('path', { d: 'M14.3896 10.3809C16.3506 12.3011 18.9859 13.3769 21.7305 13.377H30V18.623H21.7305C18.9859 18.6231 16.3506 19.6989 14.3896 21.6191L3.78809 32H0V28.29L8.72266 19.748C10.8236 17.6907 10.8236 14.3093 8.72266 12.252L0 3.70996V0H3.78809L14.3896 10.3809ZM30.001 31.9961H16.3398V30.2471C16.3401 28.3157 17.9064 26.75 19.8379 26.75H30.001V31.9961ZM30.001 0V5.24609H19.8379C17.9064 5.24609 16.34 3.68051 16.3398 1.74902V0H30.001Z' })
+])
+
+// Generates a new XE address in the browser and makes the user back up its
+// recovery phrase before the claim form can use it. Nothing is stored: the
+// words are dropped when the modal closes.
+export default {
+  name: 'XeAddressModal',
+  components: {
+    Modal,
+    ShieldExclamationIcon,
+    XeLogo
+  },
+  props: {
+    close: Function,
+    visible: Boolean
+  },
+  emits: ['created'],
+  data() {
+    return {
+      step: 1,
+      words: [],
+      address: '',
+      positions: [],
+      answers: [],
+      touched: []
+    }
+  },
+  computed: {
+    matches() {
+      return this.positions.map((position, i) => this.answers[i].trim().toLowerCase() === this.words[position])
+    },
+    canUse() {
+      return this.matches.length > 0 && this.matches.every(Boolean)
+    }
+  },
+  watch: {
+    visible(v) {
+      if (v) this.generate()
+      else this.reset()
+    }
+  },
+  methods: {
+    generate() {
+      const { address, words } = newXeAccount()
+      this.words = words
+      this.address = address
+      this.positions = pickCheckPositions(CHECK_WORDS, words.length)
+      this.answers = this.positions.map(() => '')
+      this.touched = this.positions.map(() => false)
+      this.step = 1
+    },
+    reset() {
+      this.step = 1
+      this.words = []
+      this.address = ''
+      this.positions = []
+      this.answers = []
+      this.touched = []
+    },
+    showError(i) {
+      return this.touched[i] && this.answers[i] !== '' && !this.matches[i]
+    },
+    use() {
+      if (this.canUse) this.$emit('created', this.address)
+    }
+  }
+}
+</script>
+
+<style scoped>
+:deep(.xe-logo) {
+  color: #ff6900;
+  width: 26px;
+  height: 28px;
+  margin-right: 12px;
+  flex-shrink: 0;
+}
+
+.xe-words {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 8px;
+}
+
+@media (min-width: 640px) {
+  .xe-words {
+    grid-template-columns: repeat(4, minmax(0, 1fr));
+  }
+}
+
+.xe-words li {
+  @apply px-10 py-6 font-mono bg-black rounded;
+  white-space: nowrap;
+}
+
+.xe-words__n {
+  display: inline-block;
+  min-width: 1.6em;
+  margin-right: 6px;
+  color: #ff6900;
+  text-align: right;
+}
+
+.xe-box {
+  @apply px-20 py-16 mt-20 bg-black border rounded;
+  border-color: #ff6900;
+}
+
+.xe-button {
+  background-color: #ff6900;
+  border-color: #ff6900;
+}
+
+.xe-button:hover {
+  background-color: #e55e00;
+  border-color: #e55e00;
+}
+
+.xe-button:disabled {
+  background-color: #999999;
+  border-color: #999999;
+}
+
+.xe-button-outline {
+  border-color: #ff6900;
+}
+
+.xe-button-outline:hover {
+  background-color: #ff6900;
+  border-color: #ff6900;
+}
+</style>

From b31c73e51dc1aa8cfbb28d5ba1f15588c6797a02 Mon Sep 17 00:00:00 2001
From: Adam K Dean <adamkdean@googlemail.com>
Date: Mon, 5 Oct 2026 13:21:32 +0100
Subject: [PATCH 07/12] feat: add new address button to the xe address
 generator

---
 src/components/tx/XeAddressModal.vue | 34 ++++++++++++++++++++++------
 1 file changed, 27 insertions(+), 7 deletions(-)

diff --git a/src/components/tx/XeAddressModal.vue b/src/components/tx/XeAddressModal.vue
index b1eabb5..377953f 100644
--- a/src/components/tx/XeAddressModal.vue
+++ b/src/components/tx/XeAddressModal.vue
@@ -8,8 +8,17 @@
       <template v-slot:body>
         <div class="pb-14">
           <p class="mb-14 text-gray">
-            This is a new address on the XE network. Its recovery phrase is these 24 words.
-            Write them down in order and keep them safe.
+            This is a new address on the XE network. Choose New address until you have one you like.
+          </p>
+          <div class="form-group mb-14">
+            <div class="flex items-center justify-between">
+              <label>XE address</label>
+              <button class="xe-new" @click="generate"><RefreshIcon/>New address</button>
+            </div>
+            <span class="font-mono break-all text-sm2">{{ address }}</span>
+          </div>
+          <p class="mb-14 text-gray">
+            Its recovery phrase is these 24 words. Write them down in order and keep them safe.
           </p>
           <ol class="xe-words">
             <li v-for="(word, i) in words" :key="i"><span class="xe-words__n">{{ i + 1 }}</span>{{ word }}</li>
@@ -21,10 +30,6 @@
               This wallet does not keep them.
             </p>
           </div>
-          <div class="mt-20 form-group mb-14">
-            <label>XE address</label>
-            <span class="font-mono break-all text-sm2">{{ address }}</span>
-          </div>
         </div>
       </template>
       <template v-slot:footer>
@@ -81,8 +86,8 @@
 
 <script>
 import Modal from '../Modal.vue'
-import { ShieldExclamationIcon } from '@heroicons/vue/outline'
 import { h } from 'vue'
+import { RefreshIcon, ShieldExclamationIcon } from '@heroicons/vue/outline'
 import { newXeAccount, pickCheckPositions } from '../../utils/xe-account'
 
 const CHECK_WORDS = 3
@@ -99,6 +104,7 @@ export default {
   name: 'XeAddressModal',
   components: {
     Modal,
+    RefreshIcon,
     ShieldExclamationIcon,
     XeLogo
   },
@@ -193,6 +199,20 @@ export default {
   text-align: right;
 }
 
+.xe-new {
+  @apply inline-flex items-center mb-10 text-sm;
+  gap: 6px;
+  color: #ff6900;
+}
+
+.xe-new:hover {
+  @apply underline;
+}
+
+.xe-new svg {
+  width: 18px;
+}
+
 .xe-box {
   @apply px-20 py-16 mt-20 bg-black border rounded;
   border-color: #ff6900;

From 24a4a424e10c3e43c4086e60b415d3981b725986 Mon Sep 17 00:00:00 2001
From: Adam K Dean <adamkdean@googlemail.com>
Date: Mon, 5 Oct 2026 13:24:17 +0100
Subject: [PATCH 08/12] fix: remove the intro line from the xe address
 generator

---
 src/components/tx/XeAddressModal.vue | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/components/tx/XeAddressModal.vue b/src/components/tx/XeAddressModal.vue
index 377953f..0209d76 100644
--- a/src/components/tx/XeAddressModal.vue
+++ b/src/components/tx/XeAddressModal.vue
@@ -7,9 +7,6 @@
       </template>
       <template v-slot:body>
         <div class="pb-14">
-          <p class="mb-14 text-gray">
-            This is a new address on the XE network. Choose New address until you have one you like.
-          </p>
           <div class="form-group mb-14">
             <div class="flex items-center justify-between">
               <label>XE address</label>

From 91240a28bebaab24ee738bdf5ff4f4771cbd1e7e Mon Sep 17 00:00:00 2001
From: Adam K Dean <adamkdean@googlemail.com>
Date: Mon, 5 Oct 2026 13:39:42 +0100
Subject: [PATCH 09/12] feat: add helper that keeps the last two words of a
 message together

---
 src/utils/claim.js      |  4 ++++
 src/utils/claim.test.js | 19 +++++++++++++++++--
 2 files changed, 21 insertions(+), 2 deletions(-)

diff --git a/src/utils/claim.js b/src/utils/claim.js
index 462872a..d1b0b8e 100644
--- a/src/utils/claim.js
+++ b/src/utils/claim.js
@@ -35,6 +35,10 @@ export const newXeAddressRegexp = /^[0-9a-f]{64}$/
 
 export const normaliseXeAddress = address => address.trim().toLowerCase()
 
+// Joins the last two words with a non-breaking space, so a message that wraps
+// never leaves one word alone on its last line.
+export const keepLastWordsTogether = text => text.trim().replace(/\s+(\S+)$/, '\u00a0$1')
+
 // Stages of a claim transfer, in order.
 export const STAGES = ['posted', 'in_block', 'confirmed', 'received']
 
diff --git a/src/utils/claim.test.js b/src/utils/claim.test.js
index 4c4c59a..c2cdfcb 100644
--- a/src/utils/claim.test.js
+++ b/src/utils/claim.test.js
@@ -3,8 +3,8 @@
 // that can be found in the LICENSE.md file. All rights reserved.
 
 import {
-  claimFailed, claimProgress, clearActiveClaim, loadActiveClaim, loadFailedRefs, markClaimFailed,
-  newXeAddressRegexp, normaliseXeAddress, saveActiveClaim
+  claimFailed, claimProgress, clearActiveClaim, keepLastWordsTogether, loadActiveClaim, loadFailedRefs,
+  markClaimFailed, newXeAddressRegexp, normaliseXeAddress, saveActiveClaim
 } from './claim'
 
 const base = { chainTx: null, pending: false, walletNonce: 4, txNonce: 4, claim: null, required: 10 }
@@ -99,3 +99,18 @@ describe('active claim storage', () => {
     expect(loadActiveClaim('xe_one')).toBeNull()
   })
 })
+
+describe('keepLastWordsTogether', () => {
+  it('joins the last two words with a non-breaking space', () => {
+    expect(keepLastWordsTogether('too many open claims for this address')).toBe('too many open claims for this\u00a0address')
+  })
+
+  it('ignores trailing space', () => {
+    expect(keepLastWordsTogether('try again later ')).toBe('try again\u00a0later')
+  })
+
+  it('leaves a single word as it is', () => {
+    expect(keepLastWordsTogether('Failed')).toBe('Failed')
+    expect(keepLastWordsTogether('')).toBe('')
+  })
+})

From b9582f82e8c07f52d536eb0f4207256bb1dea262 Mon Sep 17 00:00:00 2001
From: Adam K Dean <adamkdean@googlemail.com>
Date: Mon, 5 Oct 2026 13:39:42 +0100
Subject: [PATCH 10/12] fix: prevent single-word last lines in the claim and xe
 address modals

---
 src/components/tx/ClaimModal.vue     | 27 +++++++++++++++------------
 src/components/tx/XeAddressModal.vue |  8 ++++----
 2 files changed, 19 insertions(+), 16 deletions(-)

diff --git a/src/components/tx/ClaimModal.vue b/src/components/tx/ClaimModal.vue
index 3543ae9..45ae9ff 100644
--- a/src/components/tx/ClaimModal.vue
+++ b/src/components/tx/ClaimModal.vue
@@ -9,7 +9,7 @@
       </template>
       <template v-slot:body>
         <div class="pb-14 min-h-410">
-          <p class="mb-14 text-gray">Claim $XE on the new XE network, 1 $XE for each $EDGE.</p>
+          <p class="mb-14 text-gray">Claim $XE on the new XE network, 1 $XE for each&nbsp;$EDGE.</p>
           <div class="form-group" :class="{'form-group__error': v$.xeAddress.$error}">
             <label for="claim-xe-address" class="label">XE ADDRESS</label>
             <input
@@ -42,7 +42,7 @@
           </div>
           <label class="claim-check">
             <input type="checkbox" v-model="v$.checked.$model" />
-            <span>I have checked this XE address, and I have the recovery phrase for it.</span>
+            <span>I have checked this XE address, and I have the recovery phrase for&nbsp;it.</span>
           </label>
           <div v-if="infoError" class="claim-box claim-box--error">{{ infoError }}</div>
 
@@ -123,7 +123,7 @@
             <button class="w-full button button--outline-success" @click="() => goto(1)">Back</button>
             <button :disabled="!canClaim || submitting" @click="claim" class="w-full button button--success">Confirm claim</button>
           </div>
-          <div v-if="submitError" class="claim-box claim-box--error">{{ submitError }}</div>
+          <div v-if="submitError" class="claim-box claim-box--error">{{ submitErrorText }}</div>
         </div>
       </template>
     </Modal>
@@ -145,13 +145,13 @@
           </ol>
 
           <div v-if="failed" class="claim-box claim-box--error">
-            The transfer was not processed, so your $EDGE did not move. You can try again.
+            The transfer was not processed, so your $EDGE did not move. You can try&nbsp;again.
           </div>
           <div v-else-if="progress.stage === 'received'" class="claim-box">
-            Your claim is received. Your $XE is sent to your XE address after approval.
+            Your claim is received. Your $XE is sent to your XE address after&nbsp;approval.
           </div>
           <div v-else class="claim-box">
-            You can leave this page: your claim continues without it. Keep the page open to follow it here.
+            You can leave this page: your claim continues without it. Keep the page open to follow it&nbsp;here.
           </div>
 
           <div class="mt-20 form-group mb-14">
@@ -196,8 +196,8 @@ import { parseAmount } from '../../utils/form'
 import useVuelidate from '@vuelidate/core'
 import {
   MISSES_TO_FAIL, STAGES, claimFailed, claimProgress, clearActiveClaim, createClaim, fetchClaim, fetchClaims,
-  fetchClaimsInfo, loadActiveClaim, loadFailedRefs, markClaimFailed, newXeAddressRegexp, normaliseXeAddress,
-  saveActiveClaim
+  fetchClaimsInfo, keepLastWordsTogether, loadActiveClaim, loadFailedRefs, markClaimFailed, newXeAddressRegexp,
+  normaliseXeAddress, saveActiveClaim
 } from '../../utils/claim'
 
 const POLL_MS = 5000
@@ -246,7 +246,7 @@ export default {
       xeAddress: [
         validation.required,
         helpers.withMessage(
-          'Enter your new XE address: 64 characters, 0-9 and a-f. An Edge address (xe_...) does not work.',
+          'Enter your new XE address: 64 characters, 0-9 and a-f. An Edge address (xe_...) does not\u00a0work.',
           v => newXeAddressRegexp.test(normaliseXeAddress(v))
         )
       ],
@@ -285,6 +285,9 @@ export default {
     isMaxAmountEntered() {
       return this.balance > 0 && this.amountParsed === this.balance / 1e6
     },
+    submitErrorText() {
+      return keepLastWordsTogether(this.submitError)
+    },
     progressTitle() {
       if (this.failed) return 'Claim failed'
       if (this.progress.stage === 'received') return 'Claim received'
@@ -315,7 +318,7 @@ export default {
         if (!this.info.open) this.info = null
       }
       catch (err) {
-        this.infoError = 'The claims service is not available. Try again later.'
+        this.infoError = 'The claims service is not available. Try again\u00a0later.'
       }
       this.loadClaims()
     },
@@ -518,10 +521,10 @@ export default {
     },
     statusText(claim) {
       if (this.isFailed(claim)) return 'Failed'
-      if (claim.status === 'awaiting_transfer') return 'Waiting for transfer'
+      if (claim.status === 'awaiting_transfer') return 'Waiting for\u00a0transfer'
       if (claim.processed) return 'Paid'
       if (claim.approved) return 'Approved'
-      return claim.review.length ? 'Received, in review' : 'Received'
+      return claim.review.length ? 'Received, in\u00a0review' : 'Received'
     },
     formatDate(date) {
       return new Date(date).toLocaleDateString()
diff --git a/src/components/tx/XeAddressModal.vue b/src/components/tx/XeAddressModal.vue
index 0209d76..59ac9b7 100644
--- a/src/components/tx/XeAddressModal.vue
+++ b/src/components/tx/XeAddressModal.vue
@@ -3,7 +3,7 @@
     <Modal :close="close" :visible="visible && step === 1">
       <template v-slot:header>
         <h2 class="flex items-center mb-8"><XeLogo/>Create an XE address</h2>
-        <span class="sub-heading d-block text-gray text-caption">Step 1 of 2: write down your recovery phrase</span>
+        <span class="sub-heading d-block text-gray text-caption">Step 1 of 2: write down your recovery&nbsp;phrase</span>
       </template>
       <template v-slot:body>
         <div class="pb-14">
@@ -15,7 +15,7 @@
             <span class="font-mono break-all text-sm2">{{ address }}</span>
           </div>
           <p class="mb-14 text-gray">
-            Its recovery phrase is these 24 words. Write them down in order and keep them safe.
+            Its recovery phrase is these 24 words. Write them down in order and keep them&nbsp;safe.
           </p>
           <ol class="xe-words">
             <li v-for="(word, i) in words" :key="i"><span class="xe-words__n">{{ i + 1 }}</span>{{ word }}</li>
@@ -24,7 +24,7 @@
             <span class="flex-shrink-0 inline-block mr-12 text-white icon w-27"><ShieldExclamationIcon/></span>
             <p class="mb-0">
               Anyone with these words controls your $XE. If you lose them, nobody can recover your $XE.
-              This wallet does not keep them.
+              This wallet does not keep&nbsp;them.
             </p>
           </div>
         </div>
@@ -42,7 +42,7 @@
     <Modal :close="close" :visible="visible && step === 2">
       <template v-slot:header>
         <h2 class="flex items-center mb-8"><XeLogo/>Create an XE address</h2>
-        <span class="sub-heading d-block text-gray text-caption">Step 2 of 2: check your recovery phrase</span>
+        <span class="sub-heading d-block text-gray text-caption">Step 2 of 2: check your recovery&nbsp;phrase</span>
       </template>
       <template v-slot:body>
         <div class="pb-14">

From b0896a8d7b248ca0be5430e721a0234e3d849796 Mon Sep 17 00:00:00 2001
From: Adam K Dean <adamkdean@googlemail.com>
Date: Mon, 5 Oct 2026 13:40:09 +0100
Subject: [PATCH 11/12] style: fix brace style in claim utils

---
 src/utils/claim.js | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/src/utils/claim.js b/src/utils/claim.js
index d1b0b8e..90f6214 100644
--- a/src/utils/claim.js
+++ b/src/utils/claim.js
@@ -80,7 +80,8 @@ const storageKey = address => `claim-xe:${address}`
 export function saveActiveClaim(address, claim) {
   try {
     localStorage.setItem(storageKey(address), JSON.stringify(claim))
-  } catch (err) {
+  }
+  catch (err) {
     console.error('Could not save the claim in progress:', err)
   }
 }
@@ -88,7 +89,8 @@ export function saveActiveClaim(address, claim) {
 export function loadActiveClaim(address) {
   try {
     return JSON.parse(localStorage.getItem(storageKey(address)))
-  } catch {
+  }
+  catch {
     return null
   }
 }
@@ -96,7 +98,8 @@ export function loadActiveClaim(address) {
 export function clearActiveClaim(address) {
   try {
     localStorage.removeItem(storageKey(address))
-  } catch {
+  }
+  catch {
     // Storage unavailable: nothing to clear.
   }
 }
@@ -108,7 +111,8 @@ const failedKey = address => `claim-xe-failed:${address}`
 export function loadFailedRefs(address) {
   try {
     return JSON.parse(localStorage.getItem(failedKey(address))) || []
-  } catch {
+  }
+  catch {
     return []
   }
 }
@@ -117,7 +121,8 @@ export function markClaimFailed(address, ref) {
   try {
     const refs = loadFailedRefs(address).filter(r => r !== ref)
     localStorage.setItem(failedKey(address), JSON.stringify([ref, ...refs].slice(0, 20)))
-  } catch (err) {
+  }
+  catch (err) {
     console.error('Could not save the failed claim:', err)
   }
 }

From 6d1e74a7044ebdb0812e2d67884037f4b68a188f Mon Sep 17 00:00:00 2001
From: Adam K Dean <adamkdean@googlemail.com>
Date: Mon, 5 Oct 2026 13:40:50 +0100
Subject: [PATCH 12/12] test: import vitest functions in the claim and xe
 account tests

---
 src/utils/claim.test.js      | 1 +
 src/utils/xe-account.test.js | 1 +
 2 files changed, 2 insertions(+)

diff --git a/src/utils/claim.test.js b/src/utils/claim.test.js
index c2cdfcb..92cfc23 100644
--- a/src/utils/claim.test.js
+++ b/src/utils/claim.test.js
@@ -6,6 +6,7 @@ import {
   claimFailed, claimProgress, clearActiveClaim, keepLastWordsTogether, loadActiveClaim, loadFailedRefs,
   markClaimFailed, newXeAddressRegexp, normaliseXeAddress, saveActiveClaim
 } from './claim'
+import { describe, expect, it } from 'vitest'
 
 const base = { chainTx: null, pending: false, walletNonce: 4, txNonce: 4, claim: null, required: 10 }
 
diff --git a/src/utils/xe-account.test.js b/src/utils/xe-account.test.js
index 1ee7ca9..a05ceee 100644
--- a/src/utils/xe-account.test.js
+++ b/src/utils/xe-account.test.js
@@ -10,6 +10,7 @@ import {
   addressFromPublicKey, newXeAccount, phraseFromSeed, pickCheckPositions, publicKeyFromSeed
 } from './xe-account'
 import { bytesToHex, hexToBytes, utf8ToBytes } from '@noble/hashes/utils.js'
+import { describe, expect, it } from 'vitest'
 
 // The vectors file is a copy of xeprotocol/core core/testdata/recovery-phrase-vectors.json.
 describe('XE recovery phrase vectors', () => {