@meddleware/walrus-ui 0.1.20 → 0.1.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meddleware/walrus-ui",
-  "version": "0.1.20",
+  "version": "0.1.23",
   "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/access-resume.ts

@@ -21,54 +21,11 @@ export function consumeStorageKey(network: string, gateId: string, address: stri
   return `mw:walrus:consume:${network}:${gateId}:${address}`
 }
 
-// ── Register-resume (Walrus flow) ───────────────────────────────────────────────────────────
-// A blob registered on-chain but not yet uploaded/certified can be resumed WITHOUT re-registering
-// (no new WAL/gas): persist its register transaction digest, keyed by a hash of the file content,
-// and reuse it when the same file is uploaded again — even after a page reload, since the user
-// re-selects the file (only the tiny digest is persisted, never the bytes).
-
-/** Stable per-(network, address) key under which a pending register digest + content hash is stored. */
-export function registerStorageKey(network: string, address: string): string {
-  return `mw:walrus:register:${network}:${address}`
-}
-
-/** Cheap content fingerprint (length + head/tail bytes) to match a retry to the same file. */
-export function contentKey(bytes: Uint8Array): string {
-  const head = Array.from(bytes.slice(0, 16)).join(',')
-  const tail = Array.from(bytes.slice(-16)).join(',')
-  return `${bytes.length}:${head}:${tail}`
-}
-
-/** Return the stored register digest iff it was saved for this exact file content. */
-export function loadRegisterResume(
-  storage: StorageLike,
-  key: string,
-  content: string,
-): string | null {
-  const raw = storage.getItem(key)
-  if (!raw) return null
-  try {
-    const v = JSON.parse(raw) as { contentKey?: string; registerDigest?: string }
-    return v.contentKey === content && v.registerDigest ? v.registerDigest : null
-  } catch {
-    return null
-  }
-}
-
-/** Persist a register digest against a file content key so the upload can resume later. */
-export function saveRegisterResume(
-  storage: StorageLike,
-  key: string,
-  content: string,
-  registerDigest: string,
-): void {
-  storage.setItem(key, JSON.stringify({ contentKey: content, registerDigest }))
-}
-
-/** Clear any stored register-resume entry (on success, or to fall back to a fresh register). */
-export function clearRegisterResume(storage: StorageLike, key: string): void {
-  storage.removeItem(key)
-}
+// 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

package/src/components/WalrusView.vue

@@ -23,11 +23,6 @@ import {
   consumeStorageKey,
   isRedeemedConflict,
   resolveGatedAuthToken,
-  registerStorageKey,
-  contentKey,
-  loadRegisterResume,
-  saveRegisterResume,
-  clearRegisterResume,
 } from '../access-resume.js'
 import { useOwnedBlobs } from '../composables/useOwnedBlobs.js'
 import MyBlobs from './MyBlobs.vue'
@@ -63,15 +58,13 @@ async function onPurchase(): Promise<void> {
 
 // 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:
-//   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.
-//   2. Walrus register: a registered-but-not-uploaded blob is resumed by its persisted register
-//      digest (matched to the re-selected file by content hash), skipping the register transaction
-//      (no new WAL/gas). Cleared on success, or when a resumed attempt itself fails (fall back to a
-//      fresh register).
+// 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".
 async function performUpload(
   bytes: Uint8Array,
   opts: { relayHost: string; onStatus: (s: string) => void },
@@ -79,12 +72,10 @@ async function performUpload(
   if (!account.value) throw new Error('Connect your wallet first.')
   const executor = await buildExecutor()
   const address = account.value.address
-  const key = contentKey(bytes)
   const storage = window.localStorage
 
   const gated = !!(gate && gateState.hasAccess.value === true && gateState.nftId.value)
   const consumeKey = gate ? consumeStorageKey(NETWORK, gate.gateId, address) : null
-  const regKey = registerStorageKey(NETWORK, address)
 
   // Resolve this attempt's relay token (gated only); reuses a stored consume, fresh challenge each time.
   const token = (forceFresh: boolean): Promise<string | undefined> =>
@@ -106,35 +97,22 @@ async function performUpload(
         })
 
   const runOnce = async (authToken: string | undefined): Promise<UploadResult> => {
-    // Resume the register step iff a digest was saved for THIS exact file (survives reload).
-    const resumeRegisterDigest = loadRegisterResume(storage, regKey, key) ?? undefined
-    try {
-      const r = await runBlobUpload({
-        bytes,
-        network: NETWORK,
-        relayHost: opts.relayHost,
-        address,
-        wasmUrl: walrusWasmUrl,
-        maxTipMist: uploadRelayMaxTipMist(),
-        epochs: MAX_SINGLE_RESERVATION_EPOCHS,
-        executor,
-        suiClient: getSuiClient(),
-        authToken,
-        onStatus: opts.onStatus,
-        resumeRegisterDigest,
-        onRegistered: (digest) => saveRegisterResume(storage, regKey, key, digest),
-      })
-      // Success → clear both resume layers (the use is now genuinely spent for an upload).
-      clearRegisterResume(storage, regKey)
-      if (consumeKey) storage.removeItem(consumeKey)
-      return r
-    } catch (e) {
-      // A resumed attempt that fails drops the saved register digest so the next try does a full
-      // fresh register (never worse than today). A non-resumed failure keeps the digest that
-      // onRegistered saved, so the next try (or a reload + re-select) resumes without re-registering.
-      if (resumeRegisterDigest !== undefined) clearRegisterResume(storage, regKey)
-      throw e
-    }
+    const r = await runBlobUpload({
+      bytes,
+      network: NETWORK,
+      relayHost: opts.relayHost,
+      address,
+      wasmUrl: walrusWasmUrl,
+      maxTipMist: uploadRelayMaxTipMist(),
+      epochs: MAX_SINGLE_RESERVATION_EPOCHS,
+      executor,
+      suiClient: getSuiClient(),
+      authToken,
+      onStatus: opts.onStatus,
+    })
+    // Success → clear the consume layer (the use is now genuinely spent for an upload).
+    if (consumeKey) storage.removeItem(consumeKey)
+    return r
   }
 
   try {
@@ -142,11 +120,11 @@ async function performUpload(
   } catch (e) {
     if (gated && isRedeemedConflict(e)) {
       // Stored consume already redeemed (a prior upload actually landed): clear it, spend a fresh
-      // use, and retry — resuming the registered blob if one is still saved for this file.
+      // use, and retry.
       storage.removeItem(consumeKey as string)
       return await runOnce(await token(true))
     }
-    throw e // keep the saved register digest so a manual retry / reload resumes
+    throw e
   }
 }
 
@@ -214,15 +192,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 +291,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

@@ -4,6 +4,13 @@
 // 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 } from '@meddleware/walrus-relay'
 
 /** Minimal transaction executor — the structural subset App.vue's wallet executor already provides. */
@@ -25,11 +32,11 @@ 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>
   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
-  // registered blob (see `@mysten/walrus` WriteBlobFlowUploadOptions).
+  // `digest` = the register transaction digest produced by the register tx executed this attempt.
   upload(opts: { digest: string; deletable?: boolean }): Promise<void>
   certify(): BuiltTx
   getBlob(): Promise<{ blobId: string }>
@@ -51,33 +58,20 @@ export interface RunBlobUploadDeps {
   /** 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 resumed
+   * 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)
   onStatus: (s: string) => void
   /** Lazy loader for the Walrus client module (keeps wasm out of the eager bundle). */
   loadWalrusClient?: () => Promise<WalrusClientModule>
-  /**
-   * Resume from a blob registered in a PRIOR attempt (this session or a previous page load) by
-   * passing its register transaction digest. The file is re-encoded (client-side, no gas) but the
-   * on-chain `register` transaction is skipped — so an interrupted upload never re-registers (no new
-   * WAL/gas), even across a reload once the same file is re-selected. Omit for a fresh upload.
-   */
-  resumeRegisterDigest?: string
-  /**
-   * 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
-   * without re-registering.
-   */
-  onRegistered?: (registerDigest: string) => void
 }
 
 /**
- * Register → upload → certify a blob and resolve its id + public URL. Encoding is always performed
- * (client-side, no gas); when `resumeRegisterDigest` is supplied the on-chain register transaction
- * is skipped and the upload proceeds against the already-registered blob. Up to two wallet approvals
- * (register — skipped on resume — and certify) are requested via `executor`; `onStatus` narrates.
+ * 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
@@ -96,30 +90,18 @@ 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.
   deps.onStatus('Encoding…')
   await flow.encode()
 
-  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 {
-    deps.onStatus('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)
-    registerDigest = reg.digest
-    // Persist point: hand back the digest so the upload can be resumed after a failure/reload.
-    deps.onRegistered?.(registerDigest)
-  }
+  deps.onStatus('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('Uploading to the relay…')
-  await flow.upload({ digest: registerDigest, deletable: false })
+  await flow.upload({ digest: reg.digest, deletable: false })
 
   deps.onStatus('Certifying (approve in wallet)…')
   const certTx = flow.certify()