@meddleware/walrus-ui 0.1.16 → 0.1.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meddleware/walrus-ui",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "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.9",
     "@meddleware/wallet-adapter": "^0.0.5",
-    "@meddleware/walrus-client": "^0.0.6",
+    "@meddleware/walrus-client": "^0.0.7",
     "@meddleware/walrus-relay": "^0.1.8",
     "@mysten/sui": "^2.30.0",
     "@mysten/wallet-standard": "^0.20.0",

package/src/access-resume.ts

@@ -0,0 +1,108 @@
+// 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}`
+}
+
+/**
+ * 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/components/WalrusView.vue

@@ -18,6 +18,7 @@ import { useWallet, getSuiClient } from '../wallet.js'
 import { fetchChallenge, buildAccessProof } from '@meddleware/nft-gate-client'
 import { NETWORK, relayHosts, accessGate, uploadRelayMaxTipMist } from '../config.js'
 import { runBlobUpload } from '../upload-flow.js'
+import { consumeStorageKey, isRedeemedConflict, resolveGatedAuthToken } from '../access-resume.js'
 import { useOwnedBlobs } from '../composables/useOwnedBlobs.js'
 import MyBlobs from './MyBlobs.vue'
 
@@ -53,34 +54,69 @@ 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 only
 // gathers the wallet-bound inputs (executor, sui client, gated proof token) and delegates.
+//
+// Single-use resume: the relay treats the permanent on-chain `consumeDigest` as the one-time
+// redemption token, so a use is only spent when an upload succeeds. We persist the digest before
+// uploading and reuse it on retry/reload (re-signing a fresh challenge is free) — an interrupted
+// upload never burns a use. On success we clear it; if the relay reports the digest already
+// redeemed (a prior upload actually landed), we clear and consume a fresh use once.
 async function performUpload(
   bytes: Uint8Array,
   opts: { relayHost: string; onStatus: (s: string) => void },
 ): Promise<UploadResult> {
   if (!account.value) throw new Error('Connect your wallet first.')
   const executor = await buildExecutor()
+  const address = account.value.address
 
-  // If the relay is NFT-gated and we hold access, run the SINGLE_USE consume flow:
-  // fetch a challenge nonce, execute the on-chain access_gate::consume tx to record
-  // use of that nonce (produces a consumeDigest), then sign a proof token that
-  // includes both. SINGLE_USE=true gateways reject proofs without a consumeDigest.
-  // TODO: replace this block with `gateState.consumeAndBuildToken(...)` once
-  //       @meddleware/walrus-relay ≥ 0.1.6 is installed.
-  let authToken: string | undefined
-  if (gate && gateState.hasAccess.value === true && gateState.nftId.value) {
-    const challenge = await fetchChallenge(opts.relayHost)
-    const consumeTx = gateState.buildConsume(gateState.nftId.value, challenge.nonce)
-    const consumeResult = await executor.signAndExecute(consumeTx)
-    if (consumeResult.digest) await executor.waitForTransaction(consumeResult.digest).catch(() => {})
-    authToken = await buildAccessProof({
-      address: account.value.address,
-      challenge,
+  // Ungated relay: no consume, straight upload.
+  if (!(gate && gateState.hasAccess.value === true && gateState.nftId.value)) {
+    return runBlobUpload(uploadDeps(bytes, opts, executor, undefined))
+  }
+
+  const nftId = gateState.nftId.value
+  const key = consumeStorageKey(NETWORK, gate.gateId, address)
+  const resolve = (forceFresh: boolean) =>
+    resolveGatedAuthToken({
+      storage: window.localStorage,
+      key,
+      relayHost: opts.relayHost,
+      address,
+      nftId,
+      fetchChallenge,
+      buildConsume: (id, nonce) => gateState.buildConsume(id, nonce),
+      signAndExecute: (tx) => executor.signAndExecute(tx),
+      waitForTransaction: (digest) => executor.waitForTransaction(digest),
+      buildAccessProof,
       sign: signPersonalMessage,
-      consumeDigest: consumeResult.digest,
+      forceFresh,
     })
+
+  try {
+    const authToken = await resolve(false)
+    const result = await runBlobUpload(uploadDeps(bytes, opts, executor, authToken))
+    window.localStorage.removeItem(key) // upload succeeded → the use is now spent
+    return result
+  } catch (e) {
+    if (!isRedeemedConflict(e)) throw e // transient failure → keep the digest so the next try resumes
+    // The stored consume was already redeemed (a prior upload actually landed). Clear it and spend
+    // one fresh use for this new upload.
+    window.localStorage.removeItem(key)
+    const authToken = await resolve(true)
+    const result = await runBlobUpload(uploadDeps(bytes, opts, executor, authToken))
+    window.localStorage.removeItem(key)
+    return result
   }
+}
 
-  return runBlobUpload({
+/** Assemble the register→upload→certify inputs for {@link runBlobUpload}. */
+function uploadDeps(
+  bytes: Uint8Array,
+  opts: { relayHost: string; onStatus: (s: string) => void },
+  executor: Awaited<ReturnType<typeof buildExecutor>>,
+  authToken: string | undefined,
+) {
+  if (!account.value) throw new Error('Connect your wallet first.')
+  return {
     bytes,
     network: NETWORK,
     relayHost: opts.relayHost,
@@ -92,7 +128,7 @@ async function performUpload(
     suiClient: getSuiClient(),
     authToken,
     onStatus: opts.onStatus,
-  })
+  }
 }
 
 const ownedBlobs = useOwnedBlobs()