@meddleware/walrus-ui 0.1.42 → 0.1.44

package/README.md

@@ -31,19 +31,18 @@ All `VITE_*` vars are baked into the static bundle at build time.
 
 | Variable | Default | Description |
 | --- | --- | --- |
-| `VITE_NETWORK` | `testnet` | `testnet` or `mainnet` |
+| `VITE_NETWORK` | `testnet` | Network the standalone build selects (`testnet` or `mainnet`); embedded, the host's selector rules |
 | `VITE_WALRUS_RELAY_TESTNET` | Public Mysten relay | Operator relay URL for testnet |
 | `VITE_WALRUS_RELAY_MAINNET` | Public Mysten relay | Operator relay URL for mainnet |
-| `VITE_RPC_TESTNET` | `https://sui-testnet-rpc.publicnode.com` | Sui RPC for testnet |
-| `VITE_RPC_MAINNET` | `https://fullnode.mainnet.sui.io:443` | Sui RPC for mainnet |
 | `VITE_ACCESS_GATE_ID_TESTNET` | — | Gate object ID (testnet; unset = no gate) |
 | `VITE_ACCESS_GATE_SOULBOUND_TESTNET` | `false` | `true` if NFTs are soulbound |
 | `VITE_ACCESS_GATE_PRICE_MIST_TESTNET` | `0` | Purchase price in MIST |
 | `VITE_ACCESS_GATE_ID_MAINNET` | — | Gate object ID (mainnet) |
 | `VITE_UPLOAD_RELAY_MAX_TIP_MIST` | `50000000` | Max relay tip cap in MIST (0.05 SUI) |
 
-`ACCESS_GATE_PACKAGE_ID` and `ACCESS_GATE_PLATFORM_CONFIG_ID` are hardcoded in
-`@meddleware/walrus-relay` — operators only configure the values listed above.
+The `access_gate` package and `PlatformConfig` come from the published deployment
+(`relayGateConfig` in `@meddleware/walrus-relay`) — operators only configure the values listed
+above.
 
 ## Docker build
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meddleware/walrus-ui",
-  "version": "0.1.42",
+  "version": "0.1.44",
   "homepage": "https://docs.meddleware.co.uk/blockchain/sui/walrus-storage/",
   "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>",
@@ -46,18 +46,21 @@
   },
   "dependencies": {
     "@meddleware/design-tokens": "^0.1.7",
-    "@meddleware/nft-gate-client": "^0.0.12",
     "@meddleware/ui": "^0.1.28",
-    "@meddleware/wallet-adapter": "^0.0.10",
-    "@meddleware/walrus-client": "^0.0.18",
-    "@meddleware/walrus-relay": "^0.1.19",
+    "@meddleware/walrus-client": "^0.0.21",
+    "@meddleware/walrus-relay": "^0.1.20",
     "@mysten/sui": "^2.33.1",
     "@mysten/wallet-standard": "^0.21.0",
-    "@mysten/walrus": "~1.2.31",
+    "@mysten/walrus": "~1.2.32",
     "@mysten/walrus-wasm": "~0.3.1",
     "vue": "^3.5.43"
   },
+  "peerDependencies": {
+    "@meddleware/wallet-adapter": ">=0.0.12 <0.2.0"
+  },
   "devDependencies": {
+    "@meddleware/access-gate-client": "^0.0.1",
+    "@meddleware/wallet-adapter": "^0.0.12",
     "@playwright/test": "~1.63.0",
     "@types/node": "~24.12.2",
     "@vitejs/plugin-vue": "^6.0.8",
@@ -75,7 +78,7 @@
     "stylelint-config-standard": "^40.0.0",
     "typescript": "~6.0.0",
     "vite": "^8.3.0",
-    "vitest": "~5.0.1",
+    "vitest": "~5.0.2",
     "vue-eslint-parser": "^10.4.1",
     "vue-tsc": "~3.3.0"
   },

package/src/App.vue

@@ -3,7 +3,7 @@
 // The core UI lives in WalrusView.vue (also exported for inline embedding in the dashboard).
 import { AppHeader, AppFooter, ColorModeControl, useColorMode } from '@meddleware/ui'
 import { TipConfigBadge } from '@meddleware/walrus-relay'
-import { NETWORK, OPERATOR_RELAY_HOSTS } from './config.js'
+import { walrusNetwork, OPERATOR_RELAY_HOSTS } from './config.js'
 import WalrusView from './components/WalrusView.vue'
 
 const { mode, set } = useColorMode('dark')
@@ -18,14 +18,14 @@ const DEV_URL  = import.meta.env.VITE_DEV_URL  || 'https://dev.meddleware.co.uk/
         <h1 class="brand-title">Walrus Assets</h1>
       </template>
       <template #actions>
-        <TipConfigBadge :host="OPERATOR_RELAY_HOSTS[NETWORK]" />
+        <TipConfigBadge v-if="walrusNetwork" :host="OPERATOR_RELAY_HOSTS[walrusNetwork]" />
         <ColorModeControl :model-value="mode" @update:model-value="set" />
       </template>
     </AppHeader>
 
-    <div class="app__content">
+    <main class="app__content">
       <WalrusView />
-    </div>
+    </main>
 
     <AppFooter :docs-url="DOCS_URL" :dev-url="DEV_URL" />
   </div>

package/src/components/MyBlobs.vue

@@ -5,7 +5,7 @@ import type { OwnedBlob } from '@meddleware/walrus-client'
 import { MAX_SINGLE_RESERVATION_EPOCHS, formatCoinAmount } 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 { walrusNetwork, walruscanBlobUrl } from '../config.js'
 import { useOwnedBlobs } from '../composables/useOwnedBlobs.js'
 import { groupBlobs, expiryLabel, maxExtendableEpochs, type BlobGroup } from '../blob-groups.js'
 import {
@@ -13,7 +13,7 @@ import {
   loadPendingCertifies,
   clearPendingCertify,
   type PendingCertify,
-} from '../certify-resume.js'
+} from '@meddleware/walrus-client/flow'
 
 const props = defineProps<{
   /** Connected wallet address whose owned blobs to list; `null` when no wallet is connected. */
@@ -24,6 +24,13 @@ const props = defineProps<{
   highlightBlobId?: string | null
 }>()
 
+/** The active Walrus network; the view is only rendered on one (WalrusView gates it). */
+function currentNetwork(): 'testnet' | 'mainnet' {
+  const net = walrusNetwork.value
+  if (!net) throw new Error('Walrus storage is not available on this network.')
+  return net
+}
+
 // Shared, session-persistent cache (survives tab switches and inline re-mounts).
 const { blobs, currentEpoch, loading, error, load } = useOwnedBlobs()
 
@@ -77,11 +84,11 @@ function refresh(): Promise<void> {
 
 /** Reload the pending map from storage, dropping entries whose blob is already certified. */
 function refreshPending(): void {
-  if (!props.address) {
+  if (!props.address || !walrusNetwork.value) {
     pending.value = {}
     return
   }
-  const key = pendingCertifyKey(NETWORK, props.address)
+  const key = pendingCertifyKey(walrusNetwork.value, props.address)
   const map = loadPendingCertifies(window.localStorage, key)
   for (const blob of blobs.value) {
     if (blob.certified && blob.objectId in map) {
@@ -108,7 +115,7 @@ async function estimateExtend(blob: OwnedBlob, epochs: number): Promise<void> {
   const token = (extendReq[id] = (extendReq[id] ?? 0) + 1)
   try {
     const { createWalrusClient, estimateStorageCost } = await import('@meddleware/walrus-client')
-    const walrusClient = createWalrusClient({ network: NETWORK, wasmUrl: walrusWasmUrl })
+    const walrusClient = createWalrusClient({ network: currentNetwork(), 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) {
@@ -126,7 +133,7 @@ async function extendBlob(blob: OwnedBlob): Promise<void> {
   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 walrusClient = createWalrusClient({ network: currentNetwork(), wasmUrl: walrusWasmUrl })
     const tx = await extendBlobLifetimeTransaction(walrusClient, blob.objectId, { epochs })
     const executor = await props.buildExecutor()
     actionStatus.value = { ...actionStatus.value, [blob.objectId]: 'Approve in wallet…' }
@@ -149,7 +156,7 @@ async function certifyBlob(blob: OwnedBlob): Promise<void> {
   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 walrusClient = createWalrusClient({ network: currentNetwork(), wasmUrl: walrusWasmUrl })
     const tx = certifyBlobTransaction(walrusClient, {
       blobId: entry.blobId,
       blobObjectId: entry.blobObjectId,
@@ -160,7 +167,7 @@ async function certifyBlob(blob: OwnedBlob): Promise<void> {
     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)
+    clearPendingCertify(window.localStorage, pendingCertifyKey(currentNetwork(), props.address), blob.objectId)
     actionStatus.value = { ...actionStatus.value, [blob.objectId]: `Certified ✓ (${digest.slice(0, 8)}…)` }
     await refresh()
   } catch (e) {
@@ -172,9 +179,9 @@ async function certifyBlob(blob: OwnedBlob): Promise<void> {
 
 // 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([() => props.address, walrusNetwork], ([addr]) => void load(addr))
 watch(blobs, () => refreshPending())
-watch(() => props.address, () => refreshPending())
+watch([() => props.address, walrusNetwork], () => 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.
@@ -236,7 +243,7 @@ watch(
           >
             <td>
               <CopyableAddress :address="g.blobId" label="Copy blob ID">
-                <ExplorerLink :href="walruscanBlobUrl(NETWORK, g.blobId)" :value="g.blobId" :chars="[8, 6]" />
+                <ExplorerLink :href="walruscanBlobUrl(walrusNetwork ?? 'testnet', g.blobId)" :value="g.blobId" :chars="[8, 6]" />
               </CopyableAddress>
               <button
                 v-if="g.copies.length > 1"

package/src/components/WalrusView.vue

@@ -3,33 +3,30 @@
 // Rendered standalone by walrus-ui's App.vue and inline by the dashboard. Wallet state comes
 // from the shared @meddleware/wallet-adapter singleton (via ./wallet.js), so connecting here or
 // in any other inline tool view reflects everywhere.
-import { ref, watch } from 'vue'
+import { computed, ref, watch } from 'vue'
 import {
   WalrusUpload,
   AccessGateCta,
   useAccessGate,
 } from '@meddleware/walrus-relay'
-import type { UploadResult, UploadProgress, ExistingCopy } from '@meddleware/walrus-relay'
 import { AppTabNav, CopyableAddress, ExplorerLink, UiNotice, UiTabPanel, UiToolIntro, suiExplorerUrl, safeHref, type AppTab } 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'
 import { WalletGuard } from '@meddleware/wallet-adapter'
 import { useWallet, getSuiClient } from '../wallet.js'
-import { fetchChallenge, buildAccessProof } from '@meddleware/nft-gate-client'
-import { NETWORK, relayHosts, accessGate, uploadRelayMaxTipMist, walruscanBlobUrl } from '../config.js'
-import { runBlobUpload } from '../upload-flow.js'
-import { getCertifyRetry } from '@meddleware/walrus-relay'
+import { network, walrusNetwork, relayHosts, accessGate, uploadRelayMaxTipMist, walruscanBlobUrl } from '../config.js'
 import {
+  runBlobUpload,
+  createGatedAccess,
   consumeStorageKey,
-  isRedeemedConflict,
-  resolveGatedAuthToken,
-} from '../access-resume.js'
-import {
   pendingCertifyKey,
   savePendingCertify,
   clearPendingCertify,
   loadPendingCertifies,
-} from '../certify-resume.js'
+  type BlobUploadResult as UploadResult,
+  type ExistingCopy,
+  type UploadProgress,
+} from '@meddleware/walrus-client/flow'
 import { useOwnedBlobs } from '../composables/useOwnedBlobs.js'
 import MyBlobs from './MyBlobs.vue'
 
@@ -41,16 +38,29 @@ const activeTab = ref<string>('upload')
 
 const { account, signPersonalMessage, buildExecutor } = useWallet()
 
-const gate = accessGate(NETWORK)
-const gateState = useAccessGate({ gate, getClient: () => getSuiClient() })
+// One access-gate state per Walrus network (the gate is a per-network setting); the active
+// network's is used. Each is inert until an ownership check runs.
+const gateStates = {
+  testnet: useAccessGate({ gate: accessGate('testnet'), getClient: () => getSuiClient() }),
+  mainnet: useAccessGate({ gate: accessGate('mainnet'), getClient: () => getSuiClient() }),
+}
+/** The active network's gate state (testnet's while the view is hidden on a non-Walrus network). */
+const gateState = computed(() => gateStates[walrusNetwork.value ?? 'testnet'])
 const purchasing = ref(false)
 const result = ref<UploadResult | null>(null)
 
-// Check gate ownership whenever the connected account changes (handles connect, reconnect,
-// and disconnect without needing a manual trigger from the connect button).
+// Check gate ownership whenever the connected account or the network changes. A switched or
+// disconnected wallet never inherits the previous wallet's access state: `reset()` also discards
+// any in-flight check.
 watch(
-  () => account.value?.address ?? null,
-  (addr) => { if (addr && gate) void gateState.checkOwnership(addr) },
+  [() => account.value?.address ?? null, walrusNetwork],
+  ([addr], previous) => {
+    const prevAddr = previous?.[0] ?? null
+    if (addr !== prevAddr) for (const s of Object.values(gateStates)) s.reset()
+    else gateState.value.reset()
+    result.value = null
+    if (addr && walrusNetwork.value && gateState.value.gate) void gateState.value.checkOwnership(addr)
+  },
   { immediate: true },
 )
 
@@ -59,106 +69,74 @@ async function onPurchase(): Promise<void> {
   purchasing.value = true
   try {
     const executor = await buildExecutor()
-    await gateState.purchase(executor, account.value.address)
+    await gateState.value.purchase(executor, account.value.address)
   } finally {
     purchasing.value = false
   }
 }
 
-// Wire the shared WalrusUpload widget to the extracted upload orchestration + the wallet. The
-// register/upload/certify sequence lives in src/upload-flow.ts (unit-tested); this closure gathers
-// the wallet-bound inputs and manages the single-use consume resume layer:
-//   Single-use consume: the relay treats the permanent on-chain `consumeDigest` as the one-time
-//   redemption token, so a use is only spent when an upload succeeds. The digest is persisted and
-//   reused across retries/reload (re-signing a fresh challenge is free); cleared on success.
-// The Walrus registration is NOT resumed — with an upload relay the tip + nonce live in the register
-// transaction and the relay requires it to be recent, so every attempt registers fresh (see
-// upload-flow.ts). Reusing a prior registration is what produced "the received transaction is too old".
+// Wire the shared WalrusUpload widget to walrus-client's upload orchestrator and the wallet. The
+// orchestrator registers fresh on every attempt (the relay rejects an old register transaction),
+// and, for a gated relay, `createGatedAccess` keeps the single-use consume resumable: its digest is
+// persisted before the upload, reused after an interruption, cleared once the upload lands, and
+// replaced only after the gateway reports it redeemed.
 async function performUpload(
   bytes: Uint8Array,
   opts: {
     relayHost: string
     epochs: number
     force?: boolean
+    deletable?: boolean
     onStatus: (s: string | UploadProgress) => void
   },
 ): Promise<UploadResult> {
   if (!account.value) throw new Error('Connect your wallet first.')
+  const net = walrusNetwork.value
+  if (!net) throw new Error(`Walrus storage is not available on ${network.value}.`)
   const executor = await buildExecutor()
   const address = account.value.address
   const storage = window.localStorage
+  const state = gateState.value
+  const gate = state.gate
+  const nftId = state.nftId.value
 
-  const gated = !!(gate && gateState.hasAccess.value === true && gateState.nftId.value)
-  const consumeKey = gate ? consumeStorageKey(NETWORK, gate.gateId, address) : null
-
-  // Gated uploads spend one NFT use on-chain before the core flow — surface it as the leading
-  // "Access" step so the stepper reflects the extra wallet approval (a reused consume is instant).
-  if (gated) opts.onStatus({ step: 'access', detail: 'Confirming access…' })
-
-  // Resolve this attempt's relay token (gated only); reuses a stored consume, fresh challenge each time.
-  const token = (forceFresh: boolean): Promise<string | undefined> =>
-    !gated
-      ? Promise.resolve(undefined)
-      : resolveGatedAuthToken({
+  const access =
+    gate && state.hasAccess.value === true && nftId
+      ? createGatedAccess({
           storage,
-          key: consumeKey as string,
+          key: consumeStorageKey(net, gate.gateId, address),
           relayHost: opts.relayHost,
           address,
-          nftId: gateState.nftId.value as string,
-          fetchChallenge,
-          buildConsume: (id, nonce) => gateState.buildConsume(id, nonce),
+          nftId,
+          singleUse: state.usesRemaining.value !== null,
+          buildConsume: (id, nonce) => state.buildConsume(id, nonce),
           signAndExecute: (tx) => executor.signAndExecute(tx),
           waitForTransaction: (digest) => executor.waitForTransaction(digest),
-          buildAccessProof,
           sign: signPersonalMessage,
-          forceFresh,
+          onStatus: opts.onStatus,
         })
+      : undefined
 
-  const runOnce = async (authToken: string | undefined): Promise<UploadResult> => {
-    try {
-      const r = await runBlobUpload({
-        bytes,
-        network: NETWORK,
-        relayHost: opts.relayHost,
-        address,
-        wasmUrl: walrusWasmUrl,
-        maxTipMist: uploadRelayMaxTipMist(),
-        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)
-      return r
-    } catch (e) {
-      // A certify-only failure means the upload already landed (relay access was used), so clear the
-      // consume too — the certify retry is a plain Sui tx and must not trigger a fresh NFT consume.
-      if (getCertifyRetry(e) && consumeKey) storage.removeItem(consumeKey)
-      throw e
-    }
-  }
-
-  try {
-    return await runOnce(await token(false))
-  } catch (e) {
-    if (gated && isRedeemedConflict(e)) {
-      // Stored consume already redeemed (a prior upload actually landed): clear it, spend a fresh
-      // use, and retry.
-      storage.removeItem(consumeKey as string)
-      return await runOnce(await token(true))
-    }
-    throw e
-  }
+  return runBlobUpload({
+    bytes,
+    network: net,
+    relayHost: opts.relayHost,
+    address,
+    wasmUrl: walrusWasmUrl,
+    maxTipMist: uploadRelayMaxTipMist(),
+    epochs: opts.epochs,
+    deletable: opts.deletable,
+    force: opts.force,
+    findExistingCopy,
+    executor,
+    suiClient: getSuiClient(),
+    access,
+    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(net, address), info),
+    onCertified: (blobObjectId) => clearPendingCertify(storage, pendingCertifyKey(net, address), blobObjectId),
+  })
 }
 
 // Precheck (before paying to register): does the wallet already own this exact blob? Returns a
@@ -166,10 +144,11 @@ async function performUpload(
 // (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
+  const net = walrusNetwork.value
+  if (!address || !net) return null
   try {
     const { createWalrusClient, fetchOwnedWalrusBlobs } = await import('@meddleware/walrus-client')
-    const walrusClient = createWalrusClient({ network: NETWORK, wasmUrl: walrusWasmUrl })
+    const walrusClient = createWalrusClient({ network: net, wasmUrl: walrusWasmUrl })
     const [sys, owned] = await Promise.all([
       walrusClient.walrus.systemState(),
       fetchOwnedWalrusBlobs(getSuiClient(), walrusClient, address),
@@ -180,7 +159,7 @@ async function findExistingCopy(blobId: string): Promise<ExistingCopy | null> {
     if (certified) {
       return { kind: 'certified', blobId, objectId: certified.objectId, endEpoch: certified.endEpoch }
     }
-    const store = loadPendingCertifies(window.localStorage, pendingCertifyKey(NETWORK, address))
+    const store = loadPendingCertifies(window.localStorage, pendingCertifyKey(net, address))
     const pending = copies.find((b) => !b.certified && b.objectId in store)
     if (pending) {
       return { kind: 'pending', blobId, objectId: pending.objectId, endEpoch: pending.endEpoch }
@@ -194,9 +173,11 @@ async function findExistingCopy(blobId: string): Promise<ExistingCopy | 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> {
+  const net = walrusNetwork.value
+  if (!net) return null
   try {
     const { createWalrusClient, estimateStorageCost } = await import('@meddleware/walrus-client')
-    const walrusClient = createWalrusClient({ network: NETWORK, wasmUrl: walrusWasmUrl })
+    const walrusClient = createWalrusClient({ network: net, wasmUrl: walrusWasmUrl })
     const cost = await estimateStorageCost(walrusClient, sizeBytes, epochs)
     return cost.totalCost
   } catch {
@@ -224,18 +205,23 @@ function onUploaded(r: UploadResult): void {
 function onSettled(): void {
   if (account.value) {
     void ownedBlobs.load(account.value.address, { force: true })
-    void gateState.checkOwnership(account.value.address)
+    if (gateState.value.gate) void gateState.value.checkOwnership(account.value.address)
   }
 }
 </script>
 
 <template>
-    <UiToolIntro>Upload and manage blobs on Walrus decentralised storage ({{ NETWORK }}).</UiToolIntro>
+    <UiToolIntro>Upload and manage blobs on Walrus decentralised storage ({{ network }}).</UiToolIntro>
+
+    <UiNotice v-if="!walrusNetwork" type="info">Walrus storage is not available on {{ network }}. Switch to testnet or mainnet.</UiNotice>
+    <template v-else>
 
     <AppTabNav v-model="activeTab" :tabs="TABS" id-prefix="walrus" aria-label="Feature tabs" class="walrus-tabs" />
 
-    <WalletGuard message="Connect a Sui wallet to upload and manage your blobs.">
-      <UiTabPanel id-prefix="walrus" :tab="activeTab">
+    <!-- The tab list and its panel always render (the selected tab controls a live panel); the wallet
+         prompt replaces only the panel's content until a wallet is connected. -->
+    <UiTabPanel id-prefix="walrus" :tab="activeTab">
+      <WalletGuard message="Connect a Sui wallet to upload and manage your blobs.">
         <template v-if="activeTab === 'upload'">
           <!-- Gated + no access: replace the form with the purchase CTA so the user is guided to buy
                first, rather than facing a disabled form. -->
@@ -244,7 +230,7 @@ function onSettled(): void {
               :gate-configured="gateState.gateConfigured"
               :has-access="gateState.hasAccess.value"
               :busy="purchasing"
-              :price-mist="gate?.priceMist ?? null"
+              :price-mist="gateState.gate?.priceMist ?? null"
               @purchase="onPurchase"
             />
           </div>
@@ -271,7 +257,7 @@ function onSettled(): void {
             </UiNotice>
 
             <WalrusUpload
-              :hosts="relayHosts(NETWORK)"
+              :hosts="relayHosts(walrusNetwork)"
               :connected="!!account"
               :access="{ gateConfigured: gateState.gateConfigured, hasAccess: gateState.hasAccess }"
               :perform-upload="performUpload"
@@ -287,7 +273,7 @@ function onSettled(): void {
                 <strong>Blob ID:</strong>
                 <CopyableAddress :address="result.blobId" label="Copy blob ID">
                   <ExplorerLink
-                    :href="walruscanBlobUrl(NETWORK, result.blobId)"
+                    :href="walruscanBlobUrl(walrusNetwork, result.blobId)"
                     :value="result.blobId"
                     :chars="[8, 6]"
                   />
@@ -301,7 +287,7 @@ function onSettled(): void {
                 <strong>Certify tx:</strong>
                 <CopyableAddress :address="result.digest" label="Copy transaction digest">
                   <ExplorerLink
-                    :href="suiExplorerUrl('txblock', result.digest, NETWORK)"
+                    :href="suiExplorerUrl('txblock', result.digest, walrusNetwork)"
                     :value="result.digest"
                     :chars="[8, 6]"
                   />
@@ -317,8 +303,9 @@ function onSettled(): void {
           :build-executor="() => buildExecutor()"
           :highlight-blob-id="highlightBlobId"
         />
-      </UiTabPanel>
-    </WalletGuard>
+      </WalletGuard>
+    </UiTabPanel>
+    </template>
 </template>
 
 <style scoped>

package/src/composables/useOwnedBlobs.ts

@@ -3,37 +3,41 @@
 // State lives at module scope (not inside the composable factory) so it is shared across every
 // `MyBlobs` mount in the session: switching the Upload/My-Blobs tabs — or navigating the whole
 // tool view in and out inline in the dashboard — no longer loses the list or forces a refetch.
-// `load()` is a no-op when the list is already loaded for the given address, unless `force` is set
+// `load()` is a no-op when the list is already loaded for the given address on the active network,
+// unless `force` is set
 // (used after an upload/extend, which can create or mutate on-chain blobs).
 import { ref } from 'vue'
 import type { OwnedBlob } from '@meddleware/walrus-client'
 // Lightweight URL import — just the wasm asset URL (does not pull the walrus client eagerly).
 import walrusWasmUrl from '@mysten/walrus-wasm/web/walrus_wasm_bg.wasm?url'
 import { getSuiClient } from '../wallet.js'
-import { NETWORK } from '../config.js'
+import { walrusNetwork } from '../config.js'
 
 const blobs = ref<OwnedBlob[]>([])
 const currentEpoch = ref(0)
 const loading = ref(false)
 const error = ref<string | null>(null)
-/** Address the current `blobs` were fetched for; `null` until a successful load. */
+/** `<network>|<address>` the current `blobs` were fetched for; `null` until a successful load. */
 const loadedFor = ref<string | null>(null)
 
 async function load(address: string | null, opts: { force?: boolean } = {}): Promise<void> {
-  if (!address) {
+  const net = walrusNetwork.value
+  if (!address || !net) {
     blobs.value = []
     loadedFor.value = null
     return
   }
   // Skip refetch when we already have this address's list and the last load succeeded.
-  if (!opts.force && loadedFor.value === address && error.value === null) return
+  const key = `${net}|${address}`
+  if (!opts.force && loadedFor.value === key && error.value === null) return
+  if (loadedFor.value !== key) blobs.value = [] // never show another network's or wallet's list
 
   loading.value = true
   error.value = null
   try {
     const { createWalrusClient, fetchOwnedWalrusBlobs } = await import('@meddleware/walrus-client')
     const suiClient = getSuiClient()
-    const walrusClient = createWalrusClient({ network: NETWORK, wasmUrl: walrusWasmUrl })
+    const walrusClient = createWalrusClient({ network: net, wasmUrl: walrusWasmUrl })
     // Blob `endEpoch` is a WALRUS epoch, so compare against the Walrus committee epoch — NOT the
     // Sui system-state epoch (they are different clocks; the Sui epoch, ~1218 vs ~570, made every
     // blob read as "expired").
@@ -43,7 +47,7 @@ async function load(address: string | null, opts: { force?: boolean } = {}): Pro
     ])
     currentEpoch.value = Number(sys.committee.epoch)
     blobs.value = fetched.sort((a: OwnedBlob, b: OwnedBlob) => a.endEpoch - b.endEpoch)
-    loadedFor.value = address
+    loadedFor.value = key
   } catch (e) {
     error.value = e instanceof Error ? e.message : String(e)
   } finally {

package/src/config.ts

@@ -1,12 +1,12 @@
-// Build-time configuration (Vite inlines VITE_*). The relay hostnames default to
-// the public Mysten relay; set VITE_WALRUS_RELAY_* to your operator relay to collect
-// the tip. Access-gate config is optional (unset ⇒ ungated).
+// Configuration. The network is wallet-adapter's shared runtime selector (the standalone build
+// selects VITE_NETWORK in main.ts; embedded, the host's selector rules). Operator settings are
+// build-time VITE_* per network: relay hostnames default to the public Mysten relay (set
+// VITE_WALRUS_RELAY_* to your operator relay to collect the tip); the access gate is optional
+// (unset ⇒ ungated), and its package + PlatformConfig come from the published deployment.
+import { computed } from 'vue'
 import type { WalrusNetwork, RelayGateConfig } from '@meddleware/walrus-relay'
-import {
-  ACCESS_GATE_PACKAGE_ID,
-  ACCESS_GATE_PLATFORM_CONFIG_ID,
-  accessGateNftType,
-} from '@meddleware/walrus-relay'
+import { relayGateConfig } from '@meddleware/walrus-relay'
+import { useNetwork } from '@meddleware/wallet-adapter'
 
 /** Build-time env bag. Injectable on the env-reading helpers below purely so unit tests can exercise
  *  each branch without depending on Vite's (frozen) `import.meta.env` inlining. */
@@ -14,8 +14,13 @@ export type EnvSource = Record<string, string | undefined>
 
 const env: EnvSource = (import.meta as unknown as { env?: EnvSource }).env ?? {}
 
-/** Active Walrus network, from `VITE_NETWORK` (default `testnet`). */
-export const NETWORK: WalrusNetwork = (env.VITE_NETWORK as WalrusNetwork) || 'testnet'
+/** The active network (read-only ref). */
+export const network = useNetwork().network
+
+/** The active network as a Walrus network, or null where Walrus has none (e.g. localnet). */
+export const walrusNetwork = computed<WalrusNetwork | null>(() =>
+  network.value === 'testnet' || network.value === 'mainnet' ? network.value : null,
+)
 
 /** Public Mysten relays — the fallback when no operator relay is configured. */
 export const PUBLIC_WALRUS_RELAY_HOSTS: Record<WalrusNetwork, string> = {
@@ -42,8 +47,11 @@ export function walruscanBlobUrl(network: WalrusNetwork, blobId: string): string
   return `https://walruscan.com/${network}/blob/${blobId}`
 }
 
-/** Default relay tip ceiling (MIST) when `VITE_UPLOAD_RELAY_MAX_TIP_MIST` is unset (0.5 SUI). */
-export const DEFAULT_UPLOAD_RELAY_MAX_TIP_MIST = 500_000_000
+/**
+ * Default relay tip ceiling (MIST) when `VITE_UPLOAD_RELAY_MAX_TIP_MIST` is unset: 0.05 SUI, the
+ * workspace-wide ceiling (~8× the operator relay's worst-case tip at the 100 MiB edge cap).
+ */
+export const DEFAULT_UPLOAD_RELAY_MAX_TIP_MIST = 50_000_000
 
 /**
  * Cap on the relay tip payment in MIST, from `VITE_UPLOAD_RELAY_MAX_TIP_MIST`. This is a ceiling to
@@ -56,33 +64,23 @@ export function uploadRelayMaxTipMist(envSource: EnvSource = env): number {
 }
 
 /**
- * gRPC-web endpoint used to build + execute the register/certify transactions and read owned
- * blobs. The Sui SDK's JSON-RPC client is deprecated, so this must be a gRPC-web-capable endpoint
- * (the Mysten public fullnodes serve gRPC-web at :443 via the browser Fetch transport).
- */
-export const RPC_URLS: Record<WalrusNetwork, string> = {
-  testnet: env.VITE_RPC_TESTNET || 'https://fullnode.testnet.sui.io:443',
-  mainnet: env.VITE_RPC_MAINNET || 'https://fullnode.mainnet.sui.io:443',
-}
-
-/**
- * Parse the optional NFT access-gate config for a network from env.
- * packageId and platformConfigId are hardcoded in the library — operators only
- * need to supply their Gate object ID, soulbound flag, and purchase price.
+ * The optional NFT access gate for a network: the operator supplies only the Gate id, soulbound
+ * flag and purchase price (`VITE_ACCESS_GATE_*_{NET}`); `relayGateConfig` fixes the package and
+ * `PlatformConfig` to the published deployment (commission enforcement). `null` — an ungated
+ * relay — when no gate id is set, or when no access_gate deployment is recorded for the network.
  */
 export function accessGate(network: WalrusNetwork, envSource: EnvSource = env): RelayGateConfig | null {
   const NET = network.toUpperCase()
-  const packageId = ACCESS_GATE_PACKAGE_ID[network]
-  const platformConfigId = ACCESS_GATE_PLATFORM_CONFIG_ID[network]
   const gateId = envSource[`VITE_ACCESS_GATE_ID_${NET}`]
-  if (!packageId || !platformConfigId || !gateId) return null
-  const soulbound = envSource[`VITE_ACCESS_GATE_SOULBOUND_${NET}`] === 'true'
-  return {
-    packageId,
-    gateId,
-    platformConfigId,
-    nftType: accessGateNftType(network, soulbound),
-    soulbound,
-    priceMist: BigInt(envSource[`VITE_ACCESS_GATE_PRICE_MIST_${NET}`] || '0'),
+  if (!gateId) return null
+  try {
+    return relayGateConfig(network, {
+      gateId,
+      soulbound: envSource[`VITE_ACCESS_GATE_SOULBOUND_${NET}`] === 'true',
+      priceMist: BigInt(envSource[`VITE_ACCESS_GATE_PRICE_MIST_${NET}`] || '0'),
+    })
+  } catch (e) {
+    console.warn(`[walrus-ui] access gate for ${network} disabled: ${e instanceof Error ? e.message : String(e)}`)
+    return null
   }
 }

package/src/main.ts

@@ -3,7 +3,14 @@ import '@meddleware/design-tokens/seasons.css'
 import '@meddleware/ui/base.css'
 import { createApp } from 'vue'
 import { useSeason } from '@meddleware/ui'
+import { useNetwork } from '@meddleware/wallet-adapter'
 import App from './App.vue'
 
+// The standalone build targets one network; select it in the shared selector so the client, the
+// relay, the gate and the stored resume keys all agree. (Embedded, the host's selector rules.)
+const env = (import.meta as unknown as { env?: Record<string, string | undefined> }).env ?? {}
+const built = env.VITE_NETWORK || 'testnet'
+if (built === 'testnet' || built === 'mainnet') useNetwork().setNetwork(built)
+
 useSeason()
 createApp(App).mount('#app')

package/src/access-resume.ts

@@ -1,114 +0,0 @@
-// Consume-persistence + resume for the single-use NFT relay paywall.
-//
-// The relay consumes one NFT use BEFORE the upload (the gateway requires an on-chain
-// AccessConsumedEvent before it will proxy). To ensure an interrupted upload never burns a use,
-// the gateway treats the permanent on-chain `consumeDigest` as the one-time redemption token: a
-// use is only spent when an upload succeeds. This module is the client half — it persists the
-// consumeDigest so a reload/retry reuses the SAME consume (re-signing a fresh challenge is free)
-// instead of consuming another use, and clears it once an upload succeeds.
-//
-// Extracted from WalrusView.vue so the resume decision is unit-testable with a fake storage.
-
-/** The subset of the Web Storage API this module needs (injectable for tests). */
-export interface StorageLike {
-  getItem(key: string): string | null
-  setItem(key: string, value: string): void
-  removeItem(key: string): void
-}
-
-/** Stable per-(network, gate, address) key under which the pending consumeDigest is stored. */
-export function consumeStorageKey(network: string, gateId: string, address: string): string {
-  return `mw:walrus:consume:${network}:${gateId}:${address}`
-}
-
-// NOTE: there is deliberately no register-resume layer. With an upload relay (required for browser
-// uploads) the SDK embeds the relay tip + a per-encode nonce INSIDE the register transaction, and
-// the relay rejects a stale `tx_id` as "the received transaction is too old". A registration thus
-// can't be reused across attempts, so every upload registers fresh (see upload-flow.ts). Only the
-// single-use consume digest below is resumable — it's a permanent on-chain token, not a tx that ages.
-
-/**
- * True if `err` is the gateway's "this consume was already redeemed" rejection (HTTP 409 with
- * `code: 'redeemed'`). Distinguished from transient failures so we only re-consume (spend a new
- * use) when the stored digest is genuinely spent — never on a network blip.
- */
-export function isRedeemedConflict(err: unknown): boolean {
-  const e = err as { status?: number; error?: { code?: string } } | null
-  return !!e && e.status === 409 && e.error?.code === 'redeemed'
-}
-
-/** A challenge carrying at least a `nonce` (structural; the full object is passed through). */
-export interface ChallengeLike {
-  nonce: string
-}
-
-/**
- * Injected dependencies for {@link resolveGatedAuthToken} (all wallet/relay/chain calls).
- * Generic over the challenge (`C`), transaction (`Tx`), and signer (`S`) types so the wallet's
- * concrete `PersonalMessageSigner` flows through to `buildAccessProof` without widening.
- */
-export interface ResolveTokenDeps<C extends ChallengeLike, Tx, S> {
-  storage: StorageLike
-  key: string
-  relayHost: string
-  address: string
-  nftId: string
-  /** Fetch a fresh challenge nonce from the gateway. */
-  fetchChallenge: (relayHost: string) => Promise<C>
-  /** Build the on-chain `access_gate::consume` PTB for `nftId` + `nonce`. */
-  buildConsume: (nftId: string, nonce: string) => Tx
-  /** Sign + execute a PTB; resolves with the transaction digest. */
-  signAndExecute: (tx: Tx) => Promise<{ digest?: string }>
-  /** Wait for a transaction to finalise (best-effort; errors are swallowed by the caller). */
-  waitForTransaction: (digest: string) => Promise<unknown>
-  /** Build the base64 relay access-proof token. */
-  buildAccessProof: (args: {
-    address: string
-    challenge: C
-    sign: S
-    consumeDigest?: string
-  }) => Promise<string>
-  /** Personal-message signer (free — no gas, no use). */
-  sign: S
-  /** Ignore any stored digest and consume a fresh use (used after a `redeemed` conflict). */
-  forceFresh?: boolean
-}
-
-/**
- * Resolve the relay auth token for a gated upload, reusing a persisted consume when present.
- *
- * - A stored (unspent) digest ⇒ reuse it: fetch a fresh challenge, sign (free), no new consume.
- * - Otherwise ⇒ consume one use on-chain and persist the digest BEFORE the upload, so an
- *   interruption after this point resumes rather than re-consuming.
- *
- * The caller must clear the stored key on a successful upload and may retry with `forceFresh`
- * after {@link isRedeemedConflict}.
- */
-export async function resolveGatedAuthToken<C extends ChallengeLike, Tx, S>(
-  deps: ResolveTokenDeps<C, Tx, S>,
-): Promise<string> {
-  const stored = deps.forceFresh ? null : deps.storage.getItem(deps.key)
-  const challenge = await deps.fetchChallenge(deps.relayHost)
-
-  let consumeDigest: string | undefined
-  if (stored) {
-    // Resume: reuse the already-consumed use; the fresh challenge is only for signature freshness.
-    consumeDigest = stored
-  } else {
-    const consumeTx = deps.buildConsume(deps.nftId, challenge.nonce)
-    const res = await deps.signAndExecute(consumeTx)
-    consumeDigest = res.digest
-    // Persist BEFORE the upload so a crash/reload between consume and upload success can resume.
-    if (consumeDigest) {
-      deps.storage.setItem(deps.key, consumeDigest)
-      await deps.waitForTransaction(consumeDigest).catch(() => {})
-    }
-  }
-
-  return deps.buildAccessProof({
-    address: deps.address,
-    challenge,
-    sign: deps.sign,
-    consumeDigest,
-  })
-}

package/src/certify-resume.ts

@@ -1,66 +0,0 @@
-// 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/upload-flow.ts

@@ -1,179 +0,0 @@
-// The multi-step Walrus blob upload orchestration (encode → register → upload → certify → resolve),
-// extracted from App.vue so it can be unit-tested and reused by the e2e harness.
-//
-// The `@mysten/walrus` wasm client must NOT be pulled into the eager module graph (see CLAUDE.md),
-// so this module never imports @meddleware/walrus-client at top level — it loads it lazily through
-// the injectable `loadWalrusClient` (default: a dynamic import). Tests inject a fake loader.
-//
-// Register is ALWAYS performed, never resumed/skipped. With an upload relay (required for browser
-// uploads) the SDK embeds the relay tip + a per-encode `nonce` INSIDE the register transaction, and
-// the relay rejects a stale `tx_id` as "the received transaction is too old". A register tx therefore
-// 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, 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 {
-  signAndExecute(tx: unknown): Promise<{ digest: string }>
-  waitForTransaction(digest: string): Promise<unknown>
-}
-
-/** The slice of `@meddleware/walrus-client` this flow needs. */
-export interface WalrusClientModule {
-  createWalrusClient: (opts: Record<string, unknown>) => unknown
-  createBlobUploadFlow: (client: unknown, bytes: Uint8Array) => BlobUploadFlow
-  walrusBlobUrl: (network: string, blobId: string) => string
-}
-
-interface BuiltTx {
-  setSenderIfNotSet(address: string): void
-  build(opts: { client: unknown }): Promise<unknown>
-}
-
-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.
-  // 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.
-  // 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 }>
-}
-
-export interface RunBlobUploadDeps {
-  bytes: Uint8Array
-  network: string
-  relayHost: string
-  /** Owner/sender address (already-connected wallet account). */
-  address: string
-  /** Wasm bundle URL for the Walrus client. */
-  wasmUrl: string
-  /** Cap on the relay tip payment in MIST. */
-  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
-  /**
-   * Bearer proof token for an NFT-gated relay. May be a provider resolved per request so a retried
-   * upload presents a fresh challenge signature (see `@meddleware/walrus-client`).
-   */
-  authToken?: string | (() => string | undefined)
-  /** Structured step progress; drives the stepped indicator in the WalrusUpload widget. */
-  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
-}
-
-/**
- * Register → upload → certify a blob and resolve its id + public URL. Every attempt encodes
- * (client-side, no gas) and registers fresh: the relay tip + nonce the relay verifies live in the
- * register transaction and must be recent, so a registration is never reused across attempts. Two
- * wallet approvals (register and certify) are requested via `executor`; `onStatus` narrates.
- */
-export async function runBlobUpload(deps: RunBlobUploadDeps): Promise<UploadResult> {
-  // The real module's flow types are richer than the narrow structural subset we use here, so the
-  // default loader casts through `unknown`. Tests inject an exact-shape fake instead.
-  const load =
-    deps.loadWalrusClient ??
-    (async () => (await import('@meddleware/walrus-client')) as unknown as WalrusClientModule)
-  const { createWalrusClient, createBlobUploadFlow, walrusBlobUrl } = await load()
-
-  const client = createWalrusClient({
-    network: deps.network,
-    wasmUrl: deps.wasmUrl,
-    uploadRelayHost: deps.relayHost,
-    uploadRelayAuthToken: deps.authToken,
-    uploadRelayMaxTipMist: deps.maxTipMist,
-  })
-  const flow = createBlobUploadFlow(client, deps.bytes)
-
-  deps.onStatus({ step: 'encode', detail: 'Encoding…' })
-  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 })
-  regTx.setSenderIfNotSet(deps.address)
-  await regTx.build({ client: deps.suiClient })
-  const reg = await deps.executor.signAndExecute(regTx)
-  await deps.executor.waitForTransaction(reg.digest)
-
-  deps.onStatus({ step: 'upload', detail: 'Uploading to the relay…' })
-  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
-  // + stored + paid, so we never want to redo the upload — we expose this closure to retry certify
-  // alone. Re-calling `flow.certify()` just rebuilds the same tx from the in-memory certificate.
-  const runCertify = async (): Promise<UploadResult> => {
-    deps.onStatus({ step: 'certify', detail: 'Certifying (approve in wallet)…' })
-    const certTx = flow.certify()
-    certTx.setSenderIfNotSet(deps.address)
-    await certTx.build({ client: deps.suiClient })
-    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 }
-  }
-
-  try {
-    return await runCertify()
-  } catch (e) {
-    // Upload landed but certify did not: attach a retry so the UI can offer a "Certify" button
-    // rather than discarding the paid upload. The closure keeps the live flow (and its certificate).
-    attachCertifyRetry<UploadResult>(e, runCertify)
-    throw e
-  }
-}