@meddleware/walrus-ui 0.1.20 → 0.1.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meddleware/walrus-ui",
-  "version": "0.1.20",
+  "version": "0.1.22",
   "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,7 +44,7 @@
     "@meddleware/nft-gate-client": "^0.0.6",
     "@meddleware/ui": "^0.1.10",
     "@meddleware/wallet-adapter": "^0.0.5",
-    "@meddleware/walrus-client": "^0.0.8",
+    "@meddleware/walrus-client": "^0.0.9",
     "@meddleware/walrus-relay": "^0.1.8",
     "@mysten/sui": "^2.30.0",
     "@mysten/wallet-standard": "^0.20.0",

package/src/components/WalrusView.vue

@@ -61,10 +61,26 @@ async function onPurchase(): Promise<void> {
   }
 }
 
+// On-chain resume discovery: given the encoded blobId, find an already-registered, uncertified blob
+// owned by `owner` and return its register digest, so an interrupted upload can resume WITHOUT a
+// local pointer (robust to cache-clear / new device / incognito). Best-effort: any failure falls
+// through to a fresh register. The walrus client is loaded lazily to keep it out of the eager graph.
+async function discoverRegistration(owner: string, blobId: string): Promise<string | undefined> {
+  try {
+    const { createWalrusClient, findUncertifiedRegisteredBlob } = await import('@meddleware/walrus-client')
+    const walrusClient = createWalrusClient({ network: NETWORK, wasmUrl: walrusWasmUrl })
+    const found = await findUncertifiedRegisteredBlob(getSuiClient(), walrusClient, owner, blobId)
+    return found?.registerDigest
+  } catch {
+    return undefined
+  }
+}
+
 // 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 two resume layers so an interrupted upload wastes nothing —
-// both persisted in localStorage, so they survive a page reload once the same file is re-selected:
+// both persisted in localStorage (fast path) and rediscoverable on-chain (fallback), so they
+// survive a page reload — and even a cache-clear — once the same file is re-selected:
 //   1. 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.
@@ -122,6 +138,9 @@ async function performUpload(
         authToken,
         onStatus: opts.onStatus,
         resumeRegisterDigest,
+        // On-chain fallback when the local pointer is missing (cache-clear / new device): find an
+        // already-registered, uncertified blob for this content and resume from it — gas-free.
+        discoverRegisterDigest: (blobId) => discoverRegistration(address, blobId),
         onRegistered: (digest) => saveRegisterResume(storage, regKey, key, digest),
       })
       // Success → clear both resume layers (the use is now genuinely spent for an upload).
@@ -214,15 +233,15 @@ function onSettled(): void {
 
         <!-- Access held (or ungated relay): show the upload form. -->
         <template v-else>
-          <!-- Gated relays spend a use before the file is stored — make the "attempt, not a
+          <!-- Gated relays spend a credit before the file is stored — make the "attempt, not a
                guarantee" nature explicit, while reassuring that attempts resume. -->
-          <UiNotice v-if="gateState.gateConfigured" type="info" class="use-notice">
-            Uploading spends <strong>one use</strong> of your access NFT (an on-chain step) before
-            the file is stored — it pays for an upload <em>attempt</em>, not a guaranteed upload.
-            Your attempt resumes automatically, even after a page reload if you re-select the same
-            file, so a use is normally not lost. A use is spent without a completed upload only if
-            you abandon the upload entirely, cancel a required wallet approval, or wait long enough
-            that the reserved storage lapses.
+          <UiNotice v-if="gateState.gateConfigured" type="info" class="credit-notice">
+            Uploading spends <strong>one credit</strong> from your access NFT (an on-chain step)
+            before the file is stored — it pays for an upload <em>attempt</em>, not a guaranteed
+            upload. Your attempt resumes automatically, even after a page reload if you re-select
+            the same file, so a credit is normally not lost. A credit is spent without a completed
+            upload only if you abandon the upload entirely, cancel a required wallet approval, or
+            wait long enough that the reserved storage lapses.
           </UiNotice>
 
           <WalrusUpload
@@ -313,7 +332,7 @@ function onSettled(): void {
   text-align: center;
 }
 
-.use-notice {
+.credit-notice {
   margin: 1rem 0;
   font-size: 0.85rem;
   line-height: 1.5;

package/src/upload-flow.ts

@@ -25,7 +25,9 @@ interface BuiltTx {
 }
 
 export interface BlobUploadFlow {
-  encode(): Promise<void>
+  // The SDK `encode()` returns a `WriteBlobStepEncoded`; we use its deterministic `blobId` to look
+  // up an existing on-chain registration for the same content (resume discovery).
+  encode(): Promise<{ blobId: string }>
   register(opts: { owner: string; epochs: number; deletable: boolean }): BuiltTx
   // `digest` = the register transaction digest. When resuming without a prior `register()` call on
   // this flow instance, the SDK accepts the digest + `deletable` to upload against the already
@@ -65,6 +67,13 @@ export interface RunBlobUploadDeps {
    * WAL/gas), even across a reload once the same file is re-selected. Omit for a fresh upload.
    */
   resumeRegisterDigest?: string
+  /**
+   * On-chain resume fallback: called with the encoded `blobId` when no `resumeRegisterDigest` was
+   * supplied. Returns the register digest of an already-registered, uncertified on-chain blob for
+   * this content (or `undefined`). This makes resume robust to a lost local pointer (cache-clear /
+   * new device) — the registration is discovered on-chain rather than remembered client-side.
+   */
+  discoverRegisterDigest?: (blobId: string) => Promise<string | undefined>
   /**
    * Called with the register transaction digest immediately after a fresh register succeeds, so the
    * caller can PERSIST it (e.g. to localStorage) and resume the upload after a failure/reload
@@ -97,16 +106,19 @@ export async function runBlobUpload(deps: RunBlobUploadDeps): Promise<UploadResu
   const flow = createBlobUploadFlow(client, deps.bytes)
 
   // Encoding is deterministic from the content and costs no gas, so it always runs — including on a
-  // resume, where it re-derives the slivers for the re-selected file.
+  // resume, where it re-derives the slivers for the re-selected file (and yields the blobId used
+  // for on-chain resume discovery).
   deps.onStatus('Encoding…')
-  await flow.encode()
+  const { blobId } = await flow.encode()
+
+  // Resolve a resume point: a caller-provided digest (localStorage fast path) or, failing that, an
+  // on-chain lookup by blobId (robust to a lost local pointer). Either skips the register tx.
+  let registerDigest = deps.resumeRegisterDigest
+  if (registerDigest === undefined && deps.discoverRegisterDigest) {
+    registerDigest = (await deps.discoverRegisterDigest(blobId)) ?? undefined
+  }
 
-  let registerDigest: string
-  if (deps.resumeRegisterDigest) {
-    // Resume: the blob was registered in a prior attempt. Skip the register transaction (no new
-    // WAL/gas) and upload against the existing on-chain registration.
-    registerDigest = deps.resumeRegisterDigest
-  } else {
+  if (registerDigest === undefined) {
     deps.onStatus('Registering blob (approve in wallet)…')
     const regTx = flow.register({ owner: deps.address, epochs: deps.epochs, deletable: false })
     regTx.setSenderIfNotSet(deps.address)