@meddleware/walrus-ui 0.1.25 → 0.1.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meddleware/walrus-ui",
-  "version": "0.1.25",
+  "version": "0.1.27",
   "description": "Standalone Vue 3 SPA for uploading blobs to Walrus decentralised storage and managing owned blobs — wallet-connected, NFT-gated relay support.",
   "author": "Meddleware <dev@meddleware.co.uk>",
   "license": "0BSD",
@@ -44,8 +44,8 @@
     "@meddleware/nft-gate-client": "^0.0.6",
     "@meddleware/ui": "^0.1.10",
     "@meddleware/wallet-adapter": "^0.0.5",
-    "@meddleware/walrus-client": "^0.0.9",
-    "@meddleware/walrus-relay": "^0.1.10",
+    "@meddleware/walrus-client": "^0.0.11",
+    "@meddleware/walrus-relay": "^0.1.11",
     "@mysten/sui": "^2.30.0",
     "@mysten/wallet-standard": "^0.20.0",
     "@mysten/walrus": "~1.2.24",

package/src/blob-groups.ts

@@ -0,0 +1,68 @@
+// Group a wallet's owned Walrus blobs by `blobId` for display. Re-uploading the same content creates
+// multiple independent Blob objects (each its own storage reservation); grouping collapses those into
+// one row so My Blobs matches how Walruscan thinks per-blobId, while still exposing each copy.
+import type { OwnedBlob } from '@meddleware/walrus-client'
+
+export interface BlobGroup {
+  /** Shared Walrus blob id. */
+  blobId: string
+  /** Size in bytes (identical across copies of the same content). */
+  size: number
+  /** Furthest storage end epoch across copies — the effective availability of this content. */
+  maxEndEpoch: number
+  /** True if any copy is certified (i.e. the content is currently available on-chain). */
+  anyCertified: boolean
+  /** The copy that defines availability (max end epoch); the default target for Extend. */
+  representative: OwnedBlob
+  /** All underlying Blob objects for this blobId, furthest-expiry first. */
+  copies: OwnedBlob[]
+}
+
+/** Collapse owned blobs into per-blobId groups, each sorted by end epoch (furthest first). */
+export function groupBlobs(blobs: OwnedBlob[]): BlobGroup[] {
+  const byId = new Map<string, OwnedBlob[]>()
+  for (const b of blobs) {
+    const list = byId.get(b.blobId)
+    if (list) list.push(b)
+    else byId.set(b.blobId, [b])
+  }
+  const groups: BlobGroup[] = []
+  for (const [blobId, copies] of byId) {
+    const sorted = [...copies].sort((a, b) => b.endEpoch - a.endEpoch)
+    const representative = sorted[0]
+    groups.push({
+      blobId,
+      size: representative.size,
+      maxEndEpoch: representative.endEpoch,
+      anyCertified: sorted.some((b) => b.certified),
+      representative,
+      copies: sorted,
+    })
+  }
+  // Most-expiring-soonest groups first (matches the pre-grouping sort), so attention lands on them.
+  return groups.sort((a, b) => a.maxEndEpoch - b.maxEndEpoch)
+}
+
+/** Epochs of storage left before expiry (clamped at 0). */
+export function epochsLeft(endEpoch: number, currentEpoch: number): number {
+  return Math.max(0, endEpoch - currentEpoch)
+}
+
+/** Human label for a blob's remaining lifetime, transport-independent (no fabricated day estimate). */
+export function expiryLabel(endEpoch: number, currentEpoch: number): string {
+  const left = epochsLeft(endEpoch, currentEpoch)
+  if (left <= 0) return `epoch ${endEpoch} · expired`
+  return `epoch ${endEpoch} · ${left} epoch${left === 1 ? '' : 's'} left`
+}
+
+/**
+ * Epochs that can still be added to a blob before hitting `max_epochs_ahead` (a blob's end epoch
+ * cannot exceed `currentEpoch + maxReservation`). Zero means it's already at max lifetime.
+ */
+export function maxExtendableEpochs(
+  endEpoch: number,
+  currentEpoch: number,
+  maxReservation: number,
+): number {
+  return Math.max(0, currentEpoch + maxReservation - endEpoch)
+}

package/src/certify-resume.ts

@@ -0,0 +1,66 @@
+// Persistence for "uploaded but not yet certified" blobs, so certification can be completed later —
+// after a tab switch OR a full page reload — from the My Blobs page, without re-uploading.
+//
+// A Walrus upload is register → upload → certify. Register + upload are paid and, with the tip relay,
+// cannot be replayed (the register tx ages out — see upload-flow.ts). If certify doesn't happen (the
+// user dismisses the prompt), the blob is registered + stored + paid but uncertified. The storage-node
+// availability certificate returned by the upload step is all that's needed to certify, and it is not
+// a secret, so we persist it keyed by (network, address). `@meddleware/walrus-client`'s
+// `certifyBlobTransaction` accepts that base64 certificate directly — certify is a plain owner tx.
+
+import type { StorageLike } from './access-resume.js'
+
+/** A stored pending certification, keyed in the map by `blobObjectId`. */
+export interface PendingCertify {
+  /** The Walrus blob id (for display / matching). */
+  blobId: string
+  /** The on-chain Blob object id — the map key and the object being certified. */
+  blobObjectId: string
+  /** Base64 availability certificate from the upload step (accepted directly by the SDK). */
+  certificate: string
+  /** How the blob was registered (our uploads are non-deletable). */
+  deletable: boolean
+  /** Epoch ms the entry was saved, for display / housekeeping. */
+  savedAt: number
+}
+
+/** Stable per-(network, address) key under which pending certifications are stored. */
+export function pendingCertifyKey(network: string, address: string): string {
+  return `mw:walrus:pendingCertify:${network}:${address}`
+}
+
+/** Read the pending-certify map (keyed by blobObjectId); empty object if none/corrupt. */
+export function loadPendingCertifies(
+  storage: StorageLike,
+  key: string,
+): Record<string, PendingCertify> {
+  const raw = storage.getItem(key)
+  if (!raw) return {}
+  try {
+    const v = JSON.parse(raw) as Record<string, PendingCertify>
+    return v && typeof v === 'object' ? v : {}
+  } catch {
+    return {}
+  }
+}
+
+/** Persist one pending certification (merged into the map by blobObjectId). */
+export function savePendingCertify(
+  storage: StorageLike,
+  key: string,
+  entry: Omit<PendingCertify, 'savedAt'>,
+): void {
+  const map = loadPendingCertifies(storage, key)
+  map[entry.blobObjectId] = { ...entry, savedAt: Date.now() }
+  storage.setItem(key, JSON.stringify(map))
+}
+
+/** Remove a pending certification once the blob is certified (or found already certified). */
+export function clearPendingCertify(storage: StorageLike, key: string, blobObjectId: string): void {
+  const map = loadPendingCertifies(storage, key)
+  if (blobObjectId in map) {
+    delete map[blobObjectId]
+    if (Object.keys(map).length === 0) storage.removeItem(key)
+    else storage.setItem(key, JSON.stringify(map))
+  }
+}

package/src/components/MyBlobs.vue

@@ -1,67 +1,212 @@
 <script setup lang="ts">
-import { onMounted, ref, watch } from 'vue'
+import { computed, nextTick, onMounted, ref, watch } from 'vue'
 import { CopyableAddress, ExplorerLink } from '@meddleware/ui'
 import type { OwnedBlob } from '@meddleware/walrus-client'
+import { MAX_SINGLE_RESERVATION_EPOCHS } from '@meddleware/walrus-relay'
 import walrusWasmUrl from '@mysten/walrus-wasm/web/walrus_wasm_bg.wasm?url'
 import type { Executor } from '../wallet.js'
 import { NETWORK, walruscanBlobUrl } from '../config.js'
 import { useOwnedBlobs } from '../composables/useOwnedBlobs.js'
+import { groupBlobs, expiryLabel, maxExtendableEpochs, type BlobGroup } from '../blob-groups.js'
+import {
+  pendingCertifyKey,
+  loadPendingCertifies,
+  clearPendingCertify,
+  type PendingCertify,
+} from '../certify-resume.js'
 
 const props = defineProps<{
   /** Connected wallet address whose owned blobs to list; `null` when no wallet is connected. */
   address: string | null
-  /** Factory that builds a transaction {@link Executor} bound to the connected wallet (for extend). */
+  /** Factory that builds a transaction {@link Executor} bound to the connected wallet. */
   buildExecutor: () => Promise<Executor>
+  /** When set, the matching group is expanded + scrolled into view (from the duplicate-upload flow). */
+  highlightBlobId?: string | null
 }>()
 
 // Shared, session-persistent cache (survives tab switches and inline re-mounts).
 const { blobs, currentEpoch, loading, error, load } = useOwnedBlobs()
-const extending = ref<string | null>(null)
-const extendStatus = ref<Record<string, string>>({})
 
-const EXPIRY_WARN_EPOCHS = 10
-const EPOCHS_PER_DAY = 1 / 0.038 // ~1 Walrus epoch ≈ 38 minutes on testnet
+// One row per blobId; re-uploads of the same content are collapsed into a group's `copies`.
+const groups = computed(() => groupBlobs(blobs.value))
+const expanded = ref<Set<string>>(new Set())
 
-function epochsToApproxDays(epochs: number): string {
-  const days = Math.round(epochs * EPOCHS_PER_DAY)
-  if (days <= 0) return 'expired'
-  if (days < 2) return `${days} day`
-  return `${days} days`
+// Pending certifications (uploaded-but-not-certified copies we still hold a certificate for).
+const pending = ref<Record<string, PendingCertify>>({})
+
+// Per-object action state (keyed by Blob objectId), shared by Extend and Certify.
+const busy = ref<string | null>(null)
+const actionStatus = ref<Record<string, string>>({})
+const extendAmount = ref<Record<string, number>>({})
+const extendCostFrost = ref<Record<string, bigint | null>>({})
+
+const MAX = MAX_SINGLE_RESERVATION_EPOCHS
+
+function msg(e: unknown): string {
+  return e instanceof Error ? e.message : String(e)
+}
+/** FROST (1e-9 WAL) → short WAL string. */
+function toWal(frost: bigint): string {
+  return (Number(frost) / 1e9).toFixed(4)
+}
+
+function maxAddable(endEpoch: number): number {
+  return maxExtendableEpochs(endEpoch, currentEpoch.value, MAX)
+}
+
+/** The stored certificate for an uncertified copy, if we can certify it here. */
+function pendingFor(objectId: string): PendingCertify | null {
+  return pending.value[objectId] ?? null
+}
+/** The first pending (certifiable) copy in a group, if any. */
+function groupPendingCopy(g: BlobGroup): OwnedBlob | null {
+  return g.copies.find((c) => !c.certified && pending.value[c.objectId]) ?? null
+}
+/** Status shown in the Certified column for a group. */
+function groupCertStatus(g: BlobGroup): 'certified' | 'pending' | 'none' {
+  if (g.anyCertified) return 'certified'
+  return groupPendingCopy(g) ? 'pending' : 'none'
+}
+
+function toggleExpand(blobId: string): void {
+  const next = new Set(expanded.value)
+  if (next.has(blobId)) next.delete(blobId)
+  else next.add(blobId)
+  expanded.value = next
 }
 
-/** Force a fresh fetch (Refresh button + after an on-chain-affecting action). */
 function refresh(): Promise<void> {
   return load(props.address, { force: true })
 }
 
+/** Reload the pending map from storage, dropping entries whose blob is already certified. */
+function refreshPending(): void {
+  if (!props.address) {
+    pending.value = {}
+    return
+  }
+  const key = pendingCertifyKey(NETWORK, props.address)
+  const map = loadPendingCertifies(window.localStorage, key)
+  for (const blob of blobs.value) {
+    if (blob.certified && blob.objectId in map) {
+      clearPendingCertify(window.localStorage, key, blob.objectId)
+      delete map[blob.objectId]
+    }
+  }
+  pending.value = map
+}
+
+// ── Extend ──────────────────────────────────────────────────────────────────
+let extendReq: Record<string, number> = {}
+
+// User picked an amount → clamp and (re)price it. We estimate only on interaction, not for every row
+// on load, to avoid spinning up a Walrus client per blob.
+function setExtendAmount(blob: OwnedBlob, value: number | string): void {
+  const max = maxAddable(blob.endEpoch)
+  const v = Math.min(max, Math.max(1, Math.floor(Number(value) || 1)))
+  extendAmount.value = { ...extendAmount.value, [blob.objectId]: v }
+  void estimateExtend(blob, v)
+}
+async function estimateExtend(blob: OwnedBlob, epochs: number): Promise<void> {
+  const id = blob.objectId
+  const token = (extendReq[id] = (extendReq[id] ?? 0) + 1)
+  try {
+    const { createWalrusClient, estimateStorageCost } = await import('@meddleware/walrus-client')
+    const walrusClient = createWalrusClient({ network: NETWORK, wasmUrl: walrusWasmUrl })
+    // Extend adds storage only (no one-time write cost), so price the `storageCost` component.
+    const cost = await estimateStorageCost(walrusClient, blob.size, epochs)
+    if (extendReq[id] === token) {
+      extendCostFrost.value = { ...extendCostFrost.value, [id]: cost.storageCost }
+    }
+  } catch {
+    if (extendReq[id] === token) extendCostFrost.value = { ...extendCostFrost.value, [id]: null }
+  }
+}
+
 async function extendBlob(blob: OwnedBlob): Promise<void> {
-  extending.value = blob.objectId
-  extendStatus.value = { ...extendStatus.value, [blob.objectId]: 'Building transaction…' }
+  const epochs = extendAmount.value[blob.objectId]
+  if (!epochs || busy.value) return
+  busy.value = blob.objectId
+  actionStatus.value = { ...actionStatus.value, [blob.objectId]: 'Building transaction…' }
   try {
     const { createWalrusClient, extendBlobLifetimeTransaction } = await import('@meddleware/walrus-client')
     const walrusClient = createWalrusClient({ network: NETWORK, wasmUrl: walrusWasmUrl })
-    const tx = await extendBlobLifetimeTransaction(walrusClient, blob.objectId, { epochs: 10 })
+    const tx = await extendBlobLifetimeTransaction(walrusClient, blob.objectId, { epochs })
     const executor = await props.buildExecutor()
-    extendStatus.value = { ...extendStatus.value, [blob.objectId]: 'Approve in wallet…' }
+    actionStatus.value = { ...actionStatus.value, [blob.objectId]: 'Approve in wallet…' }
     const { digest } = await executor.signAndExecute(tx)
     await executor.waitForTransaction(digest)
-    extendStatus.value = { ...extendStatus.value, [blob.objectId]: `Extended ✓ (${digest.slice(0, 8)}…)` }
-    // Refresh the list so the new endEpoch is visible.
+    actionStatus.value = { ...actionStatus.value, [blob.objectId]: `Extended ✓ (${digest.slice(0, 8)}…)` }
     await refresh()
   } catch (e) {
-    extendStatus.value = {
-      ...extendStatus.value,
-      [blob.objectId]: `Failed: ${e instanceof Error ? e.message : String(e)}`,
-    }
+    actionStatus.value = { ...actionStatus.value, [blob.objectId]: `Failed: ${msg(e)}` }
   } finally {
-    extending.value = null
+    busy.value = null
   }
 }
 
-// Load on first open (fixes "nothing shows until Refresh") and whenever the address changes.
-// The composable no-ops when the list is already cached for this address, so re-mounting is cheap.
+// ── Certify (resume a pending upload from its stored certificate) ─────────────
+async function certifyBlob(blob: OwnedBlob): Promise<void> {
+  const entry = pendingFor(blob.objectId)
+  if (!entry || !props.address || busy.value) return
+  busy.value = blob.objectId
+  actionStatus.value = { ...actionStatus.value, [blob.objectId]: 'Building transaction…' }
+  try {
+    const { createWalrusClient, certifyBlobTransaction } = await import('@meddleware/walrus-client')
+    const walrusClient = createWalrusClient({ network: NETWORK, wasmUrl: walrusWasmUrl })
+    const tx = certifyBlobTransaction(walrusClient, {
+      blobId: entry.blobId,
+      blobObjectId: entry.blobObjectId,
+      certificate: entry.certificate,
+      deletable: entry.deletable,
+    })
+    const executor = await props.buildExecutor()
+    actionStatus.value = { ...actionStatus.value, [blob.objectId]: 'Approve in wallet…' }
+    const { digest } = await executor.signAndExecute(tx)
+    await executor.waitForTransaction(digest)
+    clearPendingCertify(window.localStorage, pendingCertifyKey(NETWORK, props.address), blob.objectId)
+    actionStatus.value = { ...actionStatus.value, [blob.objectId]: `Certified ✓ (${digest.slice(0, 8)}…)` }
+    await refresh()
+  } catch (e) {
+    actionStatus.value = { ...actionStatus.value, [blob.objectId]: `Failed: ${msg(e)}` }
+  } finally {
+    busy.value = null
+  }
+}
+
+// Load on first open and whenever the address changes; re-derive pending on list/address changes.
 onMounted(() => void load(props.address))
 watch(() => props.address, (addr) => void load(addr))
+watch(blobs, () => refreshPending())
+watch(() => props.address, () => refreshPending())
+
+// Seed each group's extend amount with a sensible default (+10, clamped) without pricing it — the
+// estimate is fetched on the first user interaction.
+watch(
+  [groups, currentEpoch],
+  () => {
+    for (const g of groups.value) {
+      const b = g.representative
+      const max = maxAddable(b.endEpoch)
+      if (max > 0 && extendAmount.value[b.objectId] === undefined) {
+        extendAmount.value = { ...extendAmount.value, [b.objectId]: Math.min(10, max) }
+      }
+    }
+  },
+  { immediate: true },
+)
+
+// Highlight + expand the group routed from the duplicate-upload dialog.
+watch(
+  () => props.highlightBlobId,
+  async (blobId) => {
+    if (!blobId) return
+    expanded.value = new Set(expanded.value).add(blobId)
+    await nextTick()
+    document.getElementById(`blob-row-${blobId}`)?.scrollIntoView({ block: 'center', behavior: 'smooth' })
+  },
+  { immediate: true },
+)
 </script>
 
 <template>
@@ -75,9 +220,9 @@ watch(() => props.address, (addr) => void load(addr))
 
     <p v-if="!address" class="hint">Connect your wallet to list your Walrus blobs.</p>
     <p v-else-if="error" class="err">{{ error }}</p>
-    <p v-else-if="!loading && blobs.length === 0" class="hint">No Walrus blobs found for this address.</p>
+    <p v-else-if="!loading && groups.length === 0" class="hint">No Walrus blobs found for this address.</p>
 
-    <table v-if="blobs.length" class="blob-table">
+    <table v-if="groups.length" class="blob-table">
       <thead>
         <tr>
           <th>Blob ID</th>
@@ -88,40 +233,101 @@ watch(() => props.address, (addr) => void load(addr))
         </tr>
       </thead>
       <tbody>
-        <tr
-          v-for="blob in blobs"
-          :key="blob.objectId"
-          :class="{ warn: blob.endEpoch - currentEpoch < EXPIRY_WARN_EPOCHS }"
-        >
-          <td>
-            <CopyableAddress :address="blob.blobId" label="Copy blob ID">
-              <ExplorerLink
-                :href="walruscanBlobUrl(NETWORK, blob.blobId)"
-                :value="blob.blobId"
-                :chars="[8, 6]"
-              />
-            </CopyableAddress>
-          </td>
-          <td>{{ (blob.size / 1024).toFixed(1) }} KB</td>
-          <td>
-            epoch {{ blob.endEpoch }}
-            <span class="approx">(≈{{ epochsToApproxDays(blob.endEpoch - currentEpoch) }})</span>
-          </td>
-          <td>{{ blob.certified ? '✓' : '—' }}</td>
-          <td>
-            <span v-if="extendStatus[blob.objectId]" class="ext-status">
-              {{ extendStatus[blob.objectId] }}
-            </span>
-            <button
-              v-else
-              type="button"
-              :disabled="extending === blob.objectId"
-              @click="extendBlob(blob)"
-            >
-              +10 epochs
-            </button>
-          </td>
-        </tr>
+        <template v-for="g in groups" :key="g.blobId">
+          <tr
+            :id="`blob-row-${g.blobId}`"
+            :class="{ warn: g.maxEndEpoch - currentEpoch < 10, highlight: g.blobId === highlightBlobId }"
+          >
+            <td>
+              <CopyableAddress :address="g.blobId" label="Copy blob ID">
+                <ExplorerLink :href="walruscanBlobUrl(NETWORK, g.blobId)" :value="g.blobId" :chars="[8, 6]" />
+              </CopyableAddress>
+              <button
+                v-if="g.copies.length > 1"
+                type="button"
+                class="copies-toggle"
+                @click="toggleExpand(g.blobId)"
+              >
+                {{ expanded.has(g.blobId) ? '▾' : '▸' }} {{ g.copies.length }} copies
+              </button>
+            </td>
+            <td>{{ (g.size / 1024).toFixed(1) }} KB</td>
+            <td>{{ expiryLabel(g.maxEndEpoch, currentEpoch) }}</td>
+            <td>
+              <span v-if="groupCertStatus(g) === 'certified'">✓</span>
+              <span v-else-if="groupCertStatus(g) === 'pending'" class="pending-badge" title="Uploaded but not certified">pending</span>
+              <span v-else>—</span>
+            </td>
+            <td class="actions">
+              <span v-if="actionStatus[g.representative.objectId]" class="act-status">
+                {{ actionStatus[g.representative.objectId] }}
+              </span>
+              <template v-else>
+                <button
+                  v-if="groupPendingCopy(g)"
+                  type="button"
+                  class="certify-btn"
+                  :disabled="!!busy"
+                  @click="certifyBlob(groupPendingCopy(g)!)"
+                >
+                  Certify
+                </button>
+                <span v-if="maxAddable(g.representative.endEpoch) === 0" class="at-max">at max lifetime</span>
+                <span v-else class="extend">
+                  <input
+                    type="number"
+                    min="1"
+                    :max="maxAddable(g.representative.endEpoch)"
+                    :value="extendAmount[g.representative.objectId]"
+                    aria-label="Epochs to add"
+                    @input="setExtendAmount(g.representative, ($event.target as HTMLInputElement).value)"
+                  />
+                  <button type="button" class="preset" @click="setExtendAmount(g.representative, 10)">+10</button>
+                  <button type="button" class="preset" @click="setExtendAmount(g.representative, 25)">+25</button>
+                  <button
+                    type="button"
+                    class="preset"
+                    @click="setExtendAmount(g.representative, maxAddable(g.representative.endEpoch))"
+                  >
+                    Max
+                  </button>
+                  <button type="button" :disabled="!!busy" @click="extendBlob(g.representative)">Extend</button>
+                  <span v-if="extendCostFrost[g.representative.objectId] != null" class="est">
+                    ≈{{ toWal(extendCostFrost[g.representative.objectId]!) }} WAL
+                  </span>
+                </span>
+              </template>
+            </td>
+          </tr>
+
+          <!-- Per-copy detail for grouped duplicates: certify a specific pending copy. -->
+          <tr v-for="c in (expanded.has(g.blobId) ? g.copies : [])" :key="c.objectId" class="copy-row">
+            <td class="copy-obj">
+              <CopyableAddress :address="c.objectId" label="Copy object ID">
+                <span class="mono">{{ c.objectId.slice(0, 10) }}…</span>
+              </CopyableAddress>
+            </td>
+            <td></td>
+            <td>{{ expiryLabel(c.endEpoch, currentEpoch) }}</td>
+            <td>
+              <span v-if="c.certified">✓</span>
+              <span v-else-if="pendingFor(c.objectId)" class="pending-badge">pending</span>
+              <span v-else>—</span>
+            </td>
+            <td class="actions">
+              <span v-if="actionStatus[c.objectId]" class="act-status">{{ actionStatus[c.objectId] }}</span>
+              <button
+                v-else-if="pendingFor(c.objectId)"
+                type="button"
+                class="certify-btn"
+                :disabled="!!busy"
+                @click="certifyBlob(c)"
+              >
+                Certify
+              </button>
+            </td>
+          </tr>
+        </template>
       </tbody>
     </table>
   </section>
@@ -159,6 +365,7 @@ watch(() => props.address, (addr) => void load(addr))
   text-align: left;
   padding: 0.4rem 0.6rem;
   border-bottom: 1px solid var(--mw-color-border, #ddd);
+  vertical-align: top;
 }
 .blob-table th {
   font-weight: 600;
@@ -167,15 +374,57 @@ watch(() => props.address, (addr) => void load(addr))
 .blob-table tr.warn td {
   background: color-mix(in srgb, var(--mw-color-warning, #f90) 8%, transparent);
 }
+.blob-table tr.highlight td {
+  background: color-mix(in srgb, var(--accent, #6366f1) 14%, transparent);
+}
+.copy-row td {
+  background: color-mix(in srgb, var(--mw-color-text-muted, #888) 6%, transparent);
+  font-size: 0.82rem;
+}
+.copies-toggle {
+  display: inline-block;
+  margin-top: 0.25rem;
+  font-size: 0.78rem;
+  padding: 0.05rem 0.4rem;
+}
 .mono {
   font-family: monospace;
 }
-.approx {
-  font-size: 0.8em;
+.actions {
+  white-space: nowrap;
+}
+.extend {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.3rem;
+  flex-wrap: wrap;
+}
+.extend input {
+  width: 4rem;
+}
+.preset {
+  font-size: 0.75rem;
+  padding: 0.1rem 0.4rem;
+}
+.est {
+  font-size: 0.78rem;
+  color: var(--mw-color-text-muted, #888);
+}
+.at-max {
+  font-size: 0.8rem;
   color: var(--mw-color-text-muted, #888);
 }
-.ext-status {
+.act-status {
   font-size: 0.85rem;
   color: var(--mw-color-text-muted, #888);
 }
+.certify-btn {
+  border-color: var(--accent, #6366f1);
+  color: var(--accent, #6366f1);
+}
+.pending-badge {
+  font-size: 0.78rem;
+  color: var(--accent, #6366f1);
+  font-weight: 600;
+}
 </style>

package/src/components/WalrusView.vue

@@ -8,9 +8,8 @@ import {
   WalrusUpload,
   AccessGateCta,
   useAccessGate,
-  MAX_SINGLE_RESERVATION_EPOCHS,
 } from '@meddleware/walrus-relay'
-import type { UploadResult, UploadProgress } from '@meddleware/walrus-relay'
+import type { UploadResult, UploadProgress, ExistingCopy } from '@meddleware/walrus-relay'
 import { CopyableAddress, ExplorerLink, UiNotice, suiExplorerUrl } from '@meddleware/ui'
 // Lightweight URL import — just the wasm asset URL (does not pull the walrus client).
 import walrusWasmUrl from '@mysten/walrus-wasm/web/walrus_wasm_bg.wasm?url'
@@ -25,6 +24,12 @@ import {
   isRedeemedConflict,
   resolveGatedAuthToken,
 } from '../access-resume.js'
+import {
+  pendingCertifyKey,
+  savePendingCertify,
+  clearPendingCertify,
+  loadPendingCertifies,
+} from '../certify-resume.js'
 import { useOwnedBlobs } from '../composables/useOwnedBlobs.js'
 import MyBlobs from './MyBlobs.vue'
 
@@ -68,7 +73,12 @@ async function onPurchase(): Promise<void> {
 // upload-flow.ts). Reusing a prior registration is what produced "the received transaction is too old".
 async function performUpload(
   bytes: Uint8Array,
-  opts: { relayHost: string; onStatus: (s: string | UploadProgress) => void },
+  opts: {
+    relayHost: string
+    epochs: number
+    force?: boolean
+    onStatus: (s: string | UploadProgress) => void
+  },
 ): Promise<UploadResult> {
   if (!account.value) throw new Error('Connect your wallet first.')
   const executor = await buildExecutor()
@@ -110,11 +120,19 @@ async function performUpload(
         address,
         wasmUrl: walrusWasmUrl,
         maxTipMist: uploadRelayMaxTipMist(),
-        epochs: MAX_SINGLE_RESERVATION_EPOCHS,
+        epochs: opts.epochs,
+        force: opts.force,
+        findExistingCopy,
         executor,
         suiClient: getSuiClient(),
         authToken,
         onStatus: opts.onStatus,
+        // Persist the certificate the moment the upload lands, and drop it once certified — so a
+        // dismissed certify can be finished from My Blobs after a tab switch or reload.
+        onUploaded: (info) =>
+          savePendingCertify(storage, pendingCertifyKey(NETWORK, address), info),
+        onCertified: (blobObjectId) =>
+          clearPendingCertify(storage, pendingCertifyKey(NETWORK, address), blobObjectId),
       })
       // Success → clear the consume layer (the use is now genuinely spent for an upload).
       if (consumeKey) storage.removeItem(consumeKey)
@@ -140,6 +158,57 @@ async function performUpload(
   }
 }
 
+// Precheck (before paying to register): does the wallet already own this exact blob? Returns a
+// `certified` match (offer Extend) or a `pending` one — uncertified but with a saved certificate
+// (offer Certify). Best-effort: any failure returns null so the upload simply proceeds.
+async function findExistingCopy(blobId: string): Promise<ExistingCopy | null> {
+  const address = account.value?.address
+  if (!address) return null
+  try {
+    const { createWalrusClient, fetchOwnedWalrusBlobs } = await import('@meddleware/walrus-client')
+    const walrusClient = createWalrusClient({ network: NETWORK, wasmUrl: walrusWasmUrl })
+    const [sys, owned] = await Promise.all([
+      walrusClient.walrus.systemState(),
+      fetchOwnedWalrusBlobs(getSuiClient(), walrusClient, address),
+    ])
+    const currentEpoch = Number(sys.committee.epoch)
+    const copies = owned.filter((b) => b.blobId === blobId && b.endEpoch > currentEpoch)
+    const certified = copies.find((b) => b.certified)
+    if (certified) {
+      return { kind: 'certified', blobId, objectId: certified.objectId, endEpoch: certified.endEpoch }
+    }
+    const store = loadPendingCertifies(window.localStorage, pendingCertifyKey(NETWORK, address))
+    const pending = copies.find((b) => !b.certified && b.objectId in store)
+    if (pending) {
+      return { kind: 'pending', blobId, objectId: pending.objectId, endEpoch: pending.endEpoch }
+    }
+    return null
+  } catch {
+    return null
+  }
+}
+
+// Injected into the upload widget so it can price a chosen reservation duration (storage is WAL,
+// billed per size × epochs). Returns total cost in FROST, or null on error.
+async function estimateUploadStorageCost(sizeBytes: number, epochs: number): Promise<bigint | null> {
+  try {
+    const { createWalrusClient, estimateStorageCost } = await import('@meddleware/walrus-client')
+    const walrusClient = createWalrusClient({ network: NETWORK, wasmUrl: walrusWasmUrl })
+    const cost = await estimateStorageCost(walrusClient, sizeBytes, epochs)
+    return cost.totalCost
+  } catch {
+    return null
+  }
+}
+
+// The user declined a duplicate upload and chose to manage the existing copy: jump to My Blobs and
+// highlight it (the grouped row exposes Extend for certified, Certify for pending).
+const highlightBlobId = ref<string | null>(null)
+function onManageExisting(existing: ExistingCopy): void {
+  highlightBlobId.value = existing.blobId
+  activeTab.value = 'blobs'
+}
+
 const ownedBlobs = useOwnedBlobs()
 
 function onUploaded(r: UploadResult): void {
@@ -220,8 +289,10 @@ function onSettled(): void {
             :connected="!!account"
             :access="{ gateConfigured: gateState.gateConfigured, hasAccess: gateState.hasAccess }"
             :perform-upload="performUpload"
+            :estimate-storage-cost="estimateUploadStorageCost"
             @uploaded="onUploaded"
             @settled="onSettled"
+            @manage-existing="onManageExisting"
           />
 
           <section v-if="result" class="result">
@@ -258,6 +329,7 @@ function onSettled(): void {
         v-if="activeTab === 'blobs'"
         :address="account?.address ?? null"
         :build-executor="() => buildExecutor()"
+        :highlight-blob-id="highlightBlobId"
       />
     </WalletGuard>
   </div>

package/src/upload-flow.ts

@@ -11,8 +11,8 @@
 // can't be reused across attempts — reusing a prior/discovered registration (localStorage or on-chain
 // discovery) hands the relay an old tx with a non-matching nonce. Each attempt re-encodes (free) and
 // registers fresh so the tip+nonce the relay verifies is always recent.
-import type { UploadResult, UploadProgress } from '@meddleware/walrus-relay'
-import { attachCertifyRetry } from '@meddleware/walrus-relay'
+import type { UploadResult, UploadProgress, ExistingCopy } from '@meddleware/walrus-relay'
+import { attachCertifyRetry, attachDuplicateExisting } from '@meddleware/walrus-relay'
 
 /** Minimal transaction executor — the structural subset App.vue's wallet executor already provides. */
 export interface UploadExecutor {
@@ -35,10 +35,17 @@ interface BuiltTx {
 export interface BlobUploadFlow {
   // Encoding is deterministic from the content and costs no gas; it also mints the per-attempt relay
   // `nonce` committed by the register tip, so it must precede register/upload on this flow instance.
-  encode(): Promise<void>
+  // Returns the content-derived `blobId`, used to check for an existing owned copy before registering.
+  encode(): Promise<{ blobId: string }>
   register(opts: { owner: string; epochs: number; deletable: boolean }): BuiltTx
   // `digest` = the register transaction digest produced by the register tx executed this attempt.
-  upload(opts: { digest: string; deletable?: boolean }): Promise<void>
+  // Returns the SDK "uploaded" step, including the on-chain `blobObjectId` and the base64
+  // availability `certificate` needed to certify later (persisted so certify can resume).
+  upload(opts: { digest: string; deletable?: boolean }): Promise<{
+    blobId: string
+    blobObjectId: string
+    certificate: string
+  }>
   certify(): BuiltTx
   getBlob(): Promise<{ blobId: string }>
 }
@@ -55,6 +62,17 @@ export interface RunBlobUploadDeps {
   maxTipMist: number
   /** Blob storage reservation length in epochs. */
   epochs: number
+  /**
+   * When true, skip the existing-copy precheck and register a fresh copy unconditionally (the user
+   * chose "Upload a new copy" after being warned).
+   */
+  force?: boolean
+  /**
+   * Precheck for an existing owned copy of this content (by `blobId`, computed from `encode()`).
+   * When it returns a match and `force` is not set, the upload aborts BEFORE registering (no
+   * reservation, no tip) and throws an error carrying the match so the UI can offer Extend/Certify.
+   */
+  findExistingCopy?: (blobId: string) => Promise<ExistingCopy | null>
   executor: UploadExecutor
   /** A Sui client used to `build()` the register/certify transactions. */
   suiClient: unknown
@@ -67,6 +85,14 @@ export interface RunBlobUploadDeps {
   onStatus: (p: UploadProgress) => void
   /** Lazy loader for the Walrus client module (keeps wasm out of the eager bundle). */
   loadWalrusClient?: () => Promise<WalrusClientModule>
+  /**
+   * Called once the upload has landed (blob registered + stored + paid) but BEFORE certify, with the
+   * data needed to certify later without re-uploading. Persist it so a dismissed certify can be
+   * resumed from My Blobs after a tab switch or reload. Cleared via {@link RunBlobUploadDeps.onCertified}.
+   */
+  onUploaded?: (info: { blobId: string; blobObjectId: string; certificate: string; deletable: boolean }) => void
+  /** Called with the `blobObjectId` once certify succeeds, so the caller can drop the persisted entry. */
+  onCertified?: (blobObjectId: string) => void
 }
 
 /**
@@ -93,7 +119,19 @@ export async function runBlobUpload(deps: RunBlobUploadDeps): Promise<UploadResu
   const flow = createBlobUploadFlow(client, deps.bytes)
 
   deps.onStatus({ step: 'encode', detail: 'Encoding…' })
-  await flow.encode()
+  const { blobId } = await flow.encode()
+
+  // Before paying to register, check whether the wallet already owns this exact blob. If so, abort
+  // and surface the match so the UI can offer Extend (certified) / Certify (pending) instead of
+  // creating a wasteful duplicate. `force` (chosen "Upload a new copy") bypasses this.
+  if (!deps.force && deps.findExistingCopy) {
+    const existing = await deps.findExistingCopy(blobId)
+    if (existing) {
+      const err = new Error('Blob already stored on-chain')
+      attachDuplicateExisting(err, existing)
+      throw err
+    }
+  }
 
   deps.onStatus({ step: 'register', detail: 'Registering blob (approve in wallet)…' })
   const regTx = flow.register({ owner: deps.address, epochs: deps.epochs, deletable: false })
@@ -103,7 +141,16 @@ export async function runBlobUpload(deps: RunBlobUploadDeps): Promise<UploadResu
   await deps.executor.waitForTransaction(reg.digest)
 
   deps.onStatus({ step: 'upload', detail: 'Uploading to the relay…' })
-  await flow.upload({ digest: reg.digest, deletable: false })
+  const uploaded = await flow.upload({ digest: reg.digest, deletable: false })
+
+  // Upload landed (registered + stored + paid). Persist the certificate NOW so certify can be
+  // completed later from My Blobs (after a tab switch / reload) if the user dismisses the prompt.
+  deps.onUploaded?.({
+    blobId: uploaded.blobId,
+    blobObjectId: uploaded.blobObjectId,
+    certificate: uploaded.certificate,
+    deletable: false,
+  })
 
   // Certify is a plain owner tx built from the storage-node certificate the live `flow` now holds
   // (no relay, no tip). If it fails (e.g. the user rejects the prompt) the blob is already registered
@@ -117,6 +164,7 @@ export async function runBlobUpload(deps: RunBlobUploadDeps): Promise<UploadResu
     const cert = await deps.executor.signAndExecute(certTx)
     await deps.executor.waitForTransaction(cert.digest)
     const blob = await flow.getBlob()
+    deps.onCertified?.(uploaded.blobObjectId) // certified → drop the persisted pending entry
     return { blobId: blob.blobId, url: walrusBlobUrl(deps.network, blob.blobId), digest: cert.digest }
   }