@meddleware/walrus-ui 0.1.24 → 0.1.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meddleware/walrus-ui",
-  "version": "0.1.24",
+  "version": "0.1.25",
   "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",
@@ -45,7 +45,7 @@
     "@meddleware/ui": "^0.1.10",
     "@meddleware/wallet-adapter": "^0.0.5",
     "@meddleware/walrus-client": "^0.0.9",
-    "@meddleware/walrus-relay": "^0.1.9",
+    "@meddleware/walrus-relay": "^0.1.10",
     "@mysten/sui": "^2.30.0",
     "@mysten/wallet-standard": "^0.20.0",
     "@mysten/walrus": "~1.2.24",

package/src/components/WalrusView.vue

@@ -19,6 +19,7 @@ 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 {
   consumeStorageKey,
   isRedeemedConflict,
@@ -101,22 +102,29 @@ async function performUpload(
         })
 
   const runOnce = async (authToken: string | undefined): Promise<UploadResult> => {
-    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 {
+      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
+    } 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 {

package/src/upload-flow.ts

@@ -12,6 +12,7 @@
 // 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'
 
 /** Minimal transaction executor — the structural subset App.vue's wallet executor already provides. */
 export interface UploadExecutor {
@@ -104,13 +105,27 @@ export async function runBlobUpload(deps: RunBlobUploadDeps): Promise<UploadResu
   deps.onStatus({ step: 'upload', detail: 'Uploading to the relay…' })
   await flow.upload({ digest: reg.digest, deletable: false })
 
-  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)
+  // 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()
+    return { blobId: blob.blobId, url: walrusBlobUrl(deps.network, blob.blobId), digest: cert.digest }
+  }
 
-  const blob = await flow.getBlob()
-  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
+  }
 }