@meddleware/walrus-ui 0.1.18 → 0.1.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meddleware/walrus-ui",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "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",
@@ -42,9 +42,9 @@
   "dependencies": {
     "@meddleware/design-tokens": "^0.1.2",
     "@meddleware/nft-gate-client": "^0.0.6",
-    "@meddleware/ui": "^0.1.9",
+    "@meddleware/ui": "^0.1.10",
     "@meddleware/wallet-adapter": "^0.0.5",
-    "@meddleware/walrus-client": "^0.0.7",
+    "@meddleware/walrus-client": "^0.0.8",
     "@meddleware/walrus-relay": "^0.1.8",
     "@mysten/sui": "^2.30.0",
     "@mysten/wallet-standard": "^0.20.0",

package/src/access-resume.ts

@@ -21,6 +21,55 @@ 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)
+}
+
 /**
  * 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

package/src/components/MyBlobs.vue

@@ -1,9 +1,10 @@
 <script setup lang="ts">
 import { onMounted, ref, watch } from 'vue'
+import { CopyableAddress, ExplorerLink } from '@meddleware/ui'
 import type { OwnedBlob } from '@meddleware/walrus-client'
 import walrusWasmUrl from '@mysten/walrus-wasm/web/walrus_wasm_bg.wasm?url'
 import type { Executor } from '../wallet.js'
-import { NETWORK } from '../config.js'
+import { NETWORK, walruscanBlobUrl } from '../config.js'
 import { useOwnedBlobs } from '../composables/useOwnedBlobs.js'
 
 const props = defineProps<{
@@ -92,7 +93,15 @@ watch(() => props.address, (addr) => void load(addr))
           :key="blob.objectId"
           :class="{ warn: blob.endEpoch - currentEpoch < EXPIRY_WARN_EPOCHS }"
         >
-          <td class="mono">{{ blob.blobId.slice(0, 12) }}…</td>
+          <td>
+            <CopyableAddress :address="blob.blobId" label="Copy blob ID">
+              <ExplorerLink
+                :href="walruscanBlobUrl(NETWORK, blob.blobId)"
+                :value="blob.blobId"
+                :chars="[8, 6]"
+              />
+            </CopyableAddress>
+          </td>
           <td>{{ (blob.size / 1024).toFixed(1) }} KB</td>
           <td>
             epoch {{ blob.endEpoch }}

package/src/components/WalrusView.vue

@@ -11,14 +11,24 @@ import {
   MAX_SINGLE_RESERVATION_EPOCHS,
 } from '@meddleware/walrus-relay'
 import type { UploadResult } from '@meddleware/walrus-relay'
+import { CopyableAddress, ExplorerLink, UiNotice, suiExplorerUrl } 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 } from '../config.js'
+import { NETWORK, relayHosts, accessGate, uploadRelayMaxTipMist, walruscanBlobUrl } from '../config.js'
 import { runBlobUpload } from '../upload-flow.js'
-import { consumeStorageKey, isRedeemedConflict, resolveGatedAuthToken } from '../access-resume.js'
+import {
+  consumeStorageKey,
+  isRedeemedConflict,
+  resolveGatedAuthToken,
+  registerStorageKey,
+  contentKey,
+  loadRegisterResume,
+  saveRegisterResume,
+  clearRegisterResume,
+} from '../access-resume.js'
 import { useOwnedBlobs } from '../composables/useOwnedBlobs.js'
 import MyBlobs from './MyBlobs.vue'
 
@@ -52,14 +62,16 @@ 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.
+// 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).
 async function performUpload(
   bytes: Uint8Array,
   opts: { relayHost: string; onStatus: (s: string) => void },
@@ -67,67 +79,74 @@ 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
 
-  // Ungated relay: no consume, straight upload.
-  if (!(gate && gateState.hasAccess.value === true && gateState.nftId.value)) {
-    return runBlobUpload(uploadDeps(bytes, opts, executor, undefined))
-  }
+  const gated = !!(gate && gateState.hasAccess.value === true && gateState.nftId.value)
+  const consumeKey = gate ? consumeStorageKey(NETWORK, gate.gateId, address) : null
+  const regKey = registerStorageKey(NETWORK, address)
 
-  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,
-      forceFresh,
-    })
+  // 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({
+          storage,
+          key: consumeKey as string,
+          relayHost: opts.relayHost,
+          address,
+          nftId: gateState.nftId.value as string,
+          fetchChallenge,
+          buildConsume: (id, nonce) => gateState.buildConsume(id, nonce),
+          signAndExecute: (tx) => executor.signAndExecute(tx),
+          waitForTransaction: (digest) => executor.waitForTransaction(digest),
+          buildAccessProof,
+          sign: signPersonalMessage,
+          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
+  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
+    }
   }
-}
 
-/** 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,
-    address: account.value.address,
-    wasmUrl: walrusWasmUrl,
-    maxTipMist: uploadRelayMaxTipMist(),
-    epochs: MAX_SINGLE_RESERVATION_EPOCHS,
-    executor,
-    suiClient: getSuiClient(),
-    authToken,
-    onStatus: opts.onStatus,
+  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 — resuming the registered blob if one is still saved for this file.
+      storage.removeItem(consumeKey as string)
+      return await runOnce(await token(true))
+    }
+    throw e // keep the saved register digest so a manual retry / reload resumes
   }
 }
 
@@ -173,32 +192,76 @@ function onSettled(): void {
 
     <WalletGuard message="Connect a Sui wallet to upload and manage your blobs.">
       <template v-if="activeTab === 'upload'">
-        <AccessGateCta
-          :gate-configured="gateState.gateConfigured"
-          :has-access="gateState.hasAccess.value"
-          :busy="purchasing"
-          :price-mist="gate?.priceMist ?? null"
-          @purchase="onPurchase"
-        />
+        <!-- Gated + no access: replace the form with the purchase CTA so the user is guided to buy
+             first, rather than facing a disabled form. -->
+        <div v-if="gateState.gateConfigured && gateState.hasAccess.value === false" class="gate-card">
+          <AccessGateCta
+            :gate-configured="gateState.gateConfigured"
+            :has-access="gateState.hasAccess.value"
+            :busy="purchasing"
+            :price-mist="gate?.priceMist ?? null"
+            @purchase="onPurchase"
+          />
+        </div>
+
+        <!-- Ownership check still in flight. -->
+        <p
+          v-else-if="gateState.gateConfigured && gateState.hasAccess.value === null"
+          class="checking"
+        >
+          Checking access…
+        </p>
 
-        <WalrusUpload
-          :hosts="relayHosts(NETWORK)"
-          :connected="!!account"
-          :access="{ gateConfigured: gateState.gateConfigured, hasAccess: gateState.hasAccess }"
-          :perform-upload="performUpload"
-          @uploaded="onUploaded"
-          @settled="onSettled"
-        />
+        <!-- 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
+               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>
 
-        <section v-if="result" class="result">
-          <h2>Uploaded ✓</h2>
-          <p><strong>Blob ID:</strong> <code>{{ result.blobId }}</code></p>
-          <p>
-            <strong>URL:</strong>
-            <a :href="result.url" target="_blank" rel="noopener">{{ result.url }}</a>
-          </p>
-          <p v-if="result.digest"><strong>Certify tx:</strong> <code>{{ result.digest }}</code></p>
-        </section>
+          <WalrusUpload
+            :hosts="relayHosts(NETWORK)"
+            :connected="!!account"
+            :access="{ gateConfigured: gateState.gateConfigured, hasAccess: gateState.hasAccess }"
+            :perform-upload="performUpload"
+            @uploaded="onUploaded"
+            @settled="onSettled"
+          />
+
+          <section v-if="result" class="result">
+            <h2>Uploaded ✓</h2>
+            <p>
+              <strong>Blob ID:</strong>
+              <CopyableAddress :address="result.blobId" label="Copy blob ID">
+                <ExplorerLink
+                  :href="walruscanBlobUrl(NETWORK, result.blobId)"
+                  :value="result.blobId"
+                  :chars="[8, 6]"
+                />
+              </CopyableAddress>
+            </p>
+            <p>
+              <strong>URL:</strong>
+              <a :href="result.url" target="_blank" rel="noopener">{{ result.url }}</a>
+            </p>
+            <p v-if="result.digest">
+              <strong>Certify tx:</strong>
+              <CopyableAddress :address="result.digest" label="Copy transaction digest">
+                <ExplorerLink
+                  :href="suiExplorerUrl('txblock', result.digest, NETWORK)"
+                  :value="result.digest"
+                  :chars="[8, 6]"
+                />
+              </CopyableAddress>
+            </p>
+          </section>
+        </template>
       </template>
 
       <MyBlobs
@@ -235,6 +298,27 @@ function onSettled(): void {
   font-size: 0.85rem;
 }
 
+.gate-card {
+  margin-top: 1rem;
+  padding: 1.5rem;
+  border: 1px solid var(--border);
+  border-radius: 12px;
+  background: var(--surface, transparent);
+  text-align: center;
+}
+
+.checking {
+  margin-top: 1.5rem;
+  color: var(--muted);
+  text-align: center;
+}
+
+.use-notice {
+  margin: 1rem 0;
+  font-size: 0.85rem;
+  line-height: 1.5;
+}
+
 .tabs {
   display: flex;
   gap: 0.25rem;

package/src/composables/useOwnedBlobs.ts

@@ -34,11 +34,14 @@ async function load(address: string | null, opts: { force?: boolean } = {}): Pro
     const { createWalrusClient, fetchOwnedWalrusBlobs } = await import('@meddleware/walrus-client')
     const suiClient = getSuiClient()
     const walrusClient = createWalrusClient({ network: NETWORK, 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").
     const [sys, fetched] = await Promise.all([
-      suiClient.getCurrentSystemState(),
+      walrusClient.walrus.systemState(),
       fetchOwnedWalrusBlobs(suiClient, walrusClient, address),
     ])
-    currentEpoch.value = Number(sys.systemState.epoch)
+    currentEpoch.value = Number(sys.committee.epoch)
     blobs.value = fetched.sort((a: OwnedBlob, b: OwnedBlob) => a.endEpoch - b.endEpoch)
     loadedFor.value = address
   } catch (e) {

package/src/config.ts

@@ -34,6 +34,14 @@ export function relayHosts(network: WalrusNetwork): { operator: string; public:
   return { operator: OPERATOR_RELAY_HOSTS[network], public: PUBLIC_WALRUS_RELAY_HOSTS[network] }
 }
 
+/**
+ * Walruscan explorer URL for a blob. A Walrus blob id is not a Sui object, so it links to the
+ * Walrus-native explorer rather than a Sui explorer (SuiVision handles Sui entities elsewhere).
+ */
+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
 

package/src/upload-flow.ts

@@ -24,10 +24,13 @@ interface BuiltTx {
   build(opts: { client: unknown }): Promise<unknown>
 }
 
-interface BlobUploadFlow {
+export interface BlobUploadFlow {
   encode(): Promise<void>
   register(opts: { owner: string; epochs: number; deletable: boolean }): BuiltTx
-  upload(opts: { digest: string }): Promise<void>
+  // `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).
+  upload(opts: { digest: string; deletable?: boolean }): Promise<void>
   certify(): BuiltTx
   getBlob(): Promise<{ blobId: string }>
 }
@@ -47,16 +50,34 @@ export interface RunBlobUploadDeps {
   executor: UploadExecutor
   /** A Sui client used to `build()` the register/certify transactions. */
   suiClient: unknown
-  /** Optional Bearer proof token for an NFT-gated relay. */
-  authToken?: string
+  /**
+   * Bearer proof token for an NFT-gated relay. May be a provider resolved per request so a resumed
+   * 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. Two wallet approvals
- * (register, certify) are requested via `executor`; `onStatus` narrates each step.
+ * 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.
  */
 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
@@ -75,18 +96,30 @@ 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()
 
-  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)
+  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('Uploading to the relay…')
-  await flow.upload({ digest: reg.digest })
+  await flow.upload({ digest: registerDigest, deletable: false })
 
   deps.onStatus('Certifying (approve in wallet)…')
   const certTx = flow.certify()