@meddleware/walrus-ui 0.1.56 → 0.1.58

package/CHANGELOG.md

@@ -0,0 +1,47 @@
+# Changelog
+
+All notable changes to `@meddleware/walrus-ui` are documented here.
+Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versioning follows
+[Semantic Versioning](https://semver.org/). Before 0.2.0, breaking changes ship as patch releases.
+
+## [0.1.58] - 2026-10-18
+
+### Changed (breaking, pre-v0.2)
+
+- **Adopts `@meddleware/walrus-relay` 0.1.31.** `useAccessGate` is given the network and a client getter
+  that serves the active network only; the access gate is still built by `relayGateConfig`, so it names the
+  published `access_gate` deployment. The purchase prompt (`AccessGateCta`) now shows the price, payees,
+  network and pass kind read from the chain, with a "Read the price again" button when they cannot be read.
+- **`VITE_ACCESS_GATE_PRICE_MIST_TESTNET` is removed** (code, `.env.example`, Dockerfile build argument,
+  release workflow and README). The price is read from the gate on the chain; a build that still sets the
+  variable ignores it.
+- `WalrusUpload` gets `sessionKey` (`<network>:<address>`), so a change of account or network discards the
+  chosen file and any held retry; the upload approvals hint follows the held pass (`singleUse`).
+- Dependencies: `@meddleware/walrus-client` ^0.0.28, `@meddleware/walrus-relay` ^0.1.31,
+  `@meddleware/design-tokens` ^0.1.10, `@meddleware/access-gate-client` ^0.0.9. The unused
+  `@mysten/wallet-standard` dependency is dropped.
+- Image base: `static-server` 0.1.8 (`sha256:e32cf42b…4000`).
+
+### Fixed
+
+- **A slower owned-blob load no longer overwrites a newer one** after a wallet-account or network switch,
+  a disconnect, or a switch back to a list that is already held (a stale result, error or `loading` flag is
+  dropped); a cleared list no longer reads as loaded for the previous account.
+- **Extend shows its cost before the wallet opens.** The seeded +10 epochs is priced on the first press
+  (the button reads "Show cost"), the amount and `≈ WAL` cost are shown, and the wallet opens on the next
+  press (`Extend`). An amount that cannot be priced says "price unavailable".
+- **My Blobs text meets AA contrast in both themes.** It read `--mw-color-*` custom properties that
+  design-tokens does not define, so literal fallbacks (`#888`, `#c00`, `#ddd`, `#f90`) ignored theme and
+  season; it now uses `--muted`, `--danger`, `--border`, `--warning` (tint only) and `--accent`.
+  A test fails if a component reads a custom property design-tokens does not define.
+
+### Security
+
+- `.env*` is git-ignored (except `.env.example`).
+- `SECURITY.md` invariant 1 names the real wiring of the tip ceiling (`maxTipMist` to `runBlobUpload`).
+
+### Added
+
+- `CHANGELOG.md` (it was listed in the package `files` without existing).
+- Tests: stale-load guard (`useOwnedBlobs.stale`), extend quotes, the custom-property check, and the
+  gate-config/`useAccessGate` pairing.

package/README.md

@@ -36,7 +36,6 @@ All `VITE_*` vars are baked into the static bundle at build time.
 | `VITE_WALRUS_RELAY_MAINNET` | Public Mysten relay | Operator relay URL for mainnet |
 | `VITE_ACCESS_GATE_ID_TESTNET` | — | Gate object ID (testnet; unset = no gate) |
 | `VITE_ACCESS_GATE_SOULBOUND_TESTNET` | `false` | `true` if NFTs are soulbound |
-| `VITE_ACCESS_GATE_PRICE_MIST_TESTNET` | `0` | Purchase price in MIST |
 | `VITE_ACCESS_GATE_ID_MAINNET` | — | Gate object ID (mainnet) |
 | `VITE_UPLOAD_RELAY_MAX_TIP_MIST` | `50000000` | Max relay tip cap in MIST (0.05 SUI) |
 
@@ -54,7 +53,6 @@ docker build \
   --build-arg VITE_NETWORK=testnet \
   --build-arg VITE_WALRUS_RELAY_TESTNET=https://sui-walrus-relay.example.com \
   --build-arg VITE_ACCESS_GATE_ID_TESTNET=0x... \
-  --build-arg VITE_ACCESS_GATE_PRICE_MIST_TESTNET=100000000 \
   -t walrus-ui:latest .
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meddleware/walrus-ui",
-  "version": "0.1.56",
+  "version": "0.1.58",
   "homepage": "https://docs.meddleware.co.uk/blockchain/sui/walrus-storage/",
   "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>",
@@ -39,18 +39,19 @@
     "lint:css": "stylelint \"src/**/*.{css,vue}\"",
     "lint:js": "eslint .",
     "lint": "npm run lint:css && npm run lint:js && npm run lint:html",
-    "lint:html": "html-validate \"src/**/*.vue\""
+    "lint:html": "html-validate \"src/**/*.vue\"",
+    "licenses": "node scripts/third-party-licenses.mjs",
+    "check:licenses": "node scripts/third-party-licenses.mjs --check"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@meddleware/design-tokens": "^0.1.9",
+    "@meddleware/design-tokens": "^0.1.10",
     "@meddleware/ui": "^0.1.31",
-    "@meddleware/walrus-client": "^0.0.27",
-    "@meddleware/walrus-relay": "^0.1.30",
+    "@meddleware/walrus-client": "^0.0.28",
+    "@meddleware/walrus-relay": "^0.1.31",
     "@mysten/sui": "^2.33.2",
-    "@mysten/wallet-standard": "^0.21.0",
     "@mysten/walrus": "~1.2.32",
     "@mysten/walrus-wasm": "~0.3.1",
     "vue": "^3.5.43"
@@ -59,7 +60,7 @@
     "@meddleware/wallet-adapter": ">=0.0.12 <0.2.0"
   },
   "devDependencies": {
-    "@meddleware/access-gate-client": "^0.0.8",
+    "@meddleware/access-gate-client": "^0.0.9",
     "@meddleware/eslint-config": "^0.0.2",
     "@meddleware/wallet-adapter": "^0.0.17",
     "@playwright/test": "~1.63.0",

package/src/components/MyBlobs.vue

@@ -7,6 +7,7 @@ import walrusWasmUrl from '@mysten/walrus-wasm/web/walrus_wasm_bg.wasm?url'
 import type { Executor } from '../wallet.js'
 import { walrusNetwork, walruscanBlobUrl } from '../config.js'
 import { useOwnedBlobs } from '../composables/useOwnedBlobs.js'
+import { useExtendQuotes } from '../composables/useExtendQuotes.js'
 import { groupBlobs, expiryLabel, maxExtendableEpochs, type BlobGroup } from '../blob-groups.js'
 import {
   pendingCertifyKey,
@@ -49,7 +50,6 @@ const pending = ref<Record<string, PendingCertify>>({})
 const busy = ref<string | null>(null)
 const actionStatus = ref<Record<string, string>>({})
 const extendAmount = ref<Record<string, number>>({})
-const extendCostFrost = ref<Record<string, bigint | null>>({})
 
 const MAX = MAX_SINGLE_RESERVATION_EPOCHS
 
@@ -104,35 +104,39 @@ function refreshPending(): void {
 }
 
 // ── Extend ──────────────────────────────────────────────────────────────────
-const extendReq: Record<string, number> = {}
+// Extend adds storage only (no one-time write cost), so the quote prices the `storageCost` component.
+async function estimateExtendCost(size: number, epochs: number): Promise<bigint | null> {
+  const { createWalrusClient, estimateStorageCost } = await import('@meddleware/walrus-client')
+  const walrusClient = createWalrusClient({ network: currentNetwork(), wasmUrl: walrusWasmUrl })
+  return (await estimateStorageCost(walrusClient, size, epochs)).storageCost
+}
+const extendQuotes = useExtendQuotes(estimateExtendCost)
 
-// User picked an amount → clamp and (re)price it. We estimate only on interaction, not for every row
-// on load, to avoid spinning up a Walrus client per blob.
+// User picked an amount → clamp and (re)price it. Only the picked amount is priced here, not every
+// row on load, to avoid spinning up a Walrus client per blob; a row that was never touched is priced
+// when Extend is first pressed (see `extendBlob`), before the wallet opens.
 function setExtendAmount(blob: OwnedBlob, value: number | string): void {
   const max = maxAddable(blob.endEpoch)
   const v = Math.min(max, Math.max(1, Math.floor(Number(value) || 1)))
   extendAmount.value = { ...extendAmount.value, [blob.objectId]: v }
-  void estimateExtend(blob, v)
+  void extendQuotes.price(blob.objectId, blob.size, v)
 }
-async function estimateExtend(blob: OwnedBlob, epochs: number): Promise<void> {
-  const id = blob.objectId
-  const token = (extendReq[id] = (extendReq[id] ?? 0) + 1)
-  try {
-    const { createWalrusClient, estimateStorageCost } = await import('@meddleware/walrus-client')
-    const walrusClient = createWalrusClient({ network: currentNetwork(), wasmUrl: walrusWasmUrl })
-    // Extend adds storage only (no one-time write cost), so price the `storageCost` component.
-    const cost = await estimateStorageCost(walrusClient, blob.size, epochs)
-    if (extendReq[id] === token) {
-      extendCostFrost.value = { ...extendCostFrost.value, [id]: cost.storageCost }
-    }
-  } catch {
-    if (extendReq[id] === token) extendCostFrost.value = { ...extendCostFrost.value, [id]: null }
-  }
+
+/** What the row shows beside the Extend button for its current amount. */
+function extendQuoteLabel(blob: OwnedBlob): string {
+  const epochs = extendAmount.value[blob.objectId]
+  const q = extendQuotes.quoteFor(blob.objectId, epochs)
+  if (q?.state === 'ready') return `≈${formatCoinAmount(q.costFrost, 'WAL')} for +${q.epochs} epochs`
+  if (q?.state === 'unavailable') return 'price unavailable'
+  return extendQuotes.pricing.value[blob.objectId] === epochs ? 'pricing…' : ''
 }
 
 async function extendBlob(blob: OwnedBlob): Promise<void> {
   const epochs = extendAmount.value[blob.objectId]
   if (!epochs || busy.value) return
+  // The wallet opens only for an amount whose cost the user has been shown. The seeded default has
+  // no quote yet: price it now, show it, and let the user press Extend again to confirm.
+  if (!(await extendQuotes.shownBeforeSigning(blob.objectId, blob.size, epochs))) return
   busy.value = blob.objectId
   actionStatus.value = { ...actionStatus.value, [blob.objectId]: 'Building transaction…' }
   try {
@@ -143,6 +147,7 @@ async function extendBlob(blob: OwnedBlob): Promise<void> {
     actionStatus.value = { ...actionStatus.value, [blob.objectId]: 'Approve in wallet…' }
     const { digest } = await executor.signAndExecute(tx)
     await executor.waitForTransaction(digest)
+    extendQuotes.clear(blob.objectId)
     actionStatus.value = { ...actionStatus.value, [blob.objectId]: `Extended ✓ (${digest.slice(0, 8)}…)` }
     await refresh()
   } catch (e) {
@@ -298,10 +303,10 @@ watch(
                   >
                     Max
                   </button>
-                  <button type="button" :disabled="!!busy" @click="extendBlob(g.representative)">Extend</button>
-                  <span v-if="extendCostFrost[g.representative.objectId] != null" class="est">
-                    ≈{{ formatCoinAmount(extendCostFrost[g.representative.objectId]!, 'WAL') }}
-                  </span>
+                  <button type="button" :disabled="!!busy" @click="extendBlob(g.representative)">
+                    {{ extendQuotes.quoteFor(g.representative.objectId, extendAmount[g.representative.objectId]) ? 'Extend' : 'Show cost' }}
+                  </button>
+                  <span class="est" aria-live="polite">{{ extendQuoteLabel(g.representative) }}</span>
                 </span>
               </template>
             </td>
@@ -355,11 +360,11 @@ watch(
   font-size: 1.2rem;
 }
 .hint {
-  color: var(--mw-color-text-muted, #888);
+  color: var(--muted);
   font-size: 0.9rem;
 }
 .err {
-  color: var(--mw-color-danger, #c00);
+  color: var(--danger);
   font-size: 0.9rem;
 }
 .blob-table {
@@ -371,21 +376,21 @@ watch(
 .blob-table td {
   text-align: left;
   padding: 0.4rem 0.6rem;
-  border-bottom: 1px solid var(--mw-color-border, #ddd);
+  border-bottom: 1px solid var(--border);
   vertical-align: top;
 }
 .blob-table th {
   font-weight: 600;
-  color: var(--mw-color-text-muted, #888);
+  color: var(--muted);
 }
 .blob-table tr.warn td {
-  background: color-mix(in srgb, var(--mw-color-warning, #f90) 8%, transparent);
+  background: color-mix(in srgb, var(--warning) 8%, transparent);
 }
 .blob-table tr.highlight td {
-  background: color-mix(in srgb, var(--accent, #6366f1) 14%, transparent);
+  background: color-mix(in srgb, var(--accent) 14%, transparent);
 }
 .copy-row td {
-  background: color-mix(in srgb, var(--mw-color-text-muted, #888) 6%, transparent);
+  background: color-mix(in srgb, var(--muted) 6%, transparent);
   font-size: 0.82rem;
 }
 .copies-toggle {
@@ -415,23 +420,23 @@ watch(
 }
 .est {
   font-size: 0.78rem;
-  color: var(--mw-color-text-muted, #888);
+  color: var(--muted);
 }
 .at-max {
   font-size: 0.8rem;
-  color: var(--mw-color-text-muted, #888);
+  color: var(--muted);
 }
 .act-status {
   font-size: 0.85rem;
-  color: var(--mw-color-text-muted, #888);
+  color: var(--muted);
 }
 .certify-btn {
-  border-color: var(--accent, #6366f1);
-  color: var(--accent, #6366f1);
+  border-color: var(--accent);
+  color: var(--accent);
 }
 .pending-badge {
   font-size: 0.78rem;
-  color: var(--accent, #6366f1);
+  color: var(--accent);
   font-weight: 600;
 }
 </style>

package/src/components/WalrusView.vue

@@ -9,6 +9,7 @@ import {
   WalrusUpload,
   AccessGateCta,
   useAccessGate,
+  type WalrusNetwork,
 } from '@meddleware/walrus-relay'
 import { AppTabNav, CopyableAddress, ExplorerLink, UiNotice, UiTabPanel, UiToolIntro, suiExplorerUrl, safeHref, type AppTab } from '@meddleware/ui'
 // Lightweight URL import — just the wasm asset URL (does not pull the walrus client).
@@ -45,9 +46,16 @@ const { account, signPersonalMessage, buildExecutor } = useWallet()
 
 // One access-gate state per Walrus network (the gate is a per-network setting); the active
 // network's is used. Each is inert until an ownership check runs.
+// `useAccessGate` throws for a gate that is not the published deployment on its network;
+// `accessGate()` only returns such configs (or null, ungated). The shared client serves the active
+// network only, so a state for another network refuses to read rather than reading the wrong chain.
+function gateClient(net: WalrusNetwork) {
+  if (net !== network.value) throw new Error(`No Sui client for ${net} while ${network.value} is active.`)
+  return getSuiClient()
+}
 const gateStates = {
-  testnet: useAccessGate({ gate: accessGate('testnet'), getClient: () => getSuiClient() }),
-  mainnet: useAccessGate({ gate: accessGate('mainnet'), getClient: () => getSuiClient() }),
+  testnet: useAccessGate({ network: 'testnet', gate: accessGate('testnet'), getClient: gateClient }),
+  mainnet: useAccessGate({ network: 'mainnet', gate: accessGate('mainnet'), getClient: gateClient }),
 }
 /** The active network's gate state (testnet's while the view is hidden on a non-Walrus network). */
 const gateState = computed(() => gateStates[walrusNetwork.value ?? 'testnet'])
@@ -75,6 +83,8 @@ async function onPurchase(): Promise<void> {
   try {
     const executor = await buildExecutor()
     await gateState.value.purchase(executor, account.value.address)
+  } catch {
+    // The reason is published in `purchaseError` and shown by the prompt.
   } finally {
     purchasing.value = false
   }
@@ -237,9 +247,19 @@ function onSettled(): void {
               :gate-configured="gateState.gateConfigured"
               :has-access="gateState.hasAccess.value"
               :busy="purchasing"
-              :price-mist="gateState.gate?.priceMist ?? null"
+              :terms="gateState.terms.value"
+              :terms-error="gateState.termsError.value"
+              :purchase-error="gateState.purchaseError.value"
               @purchase="onPurchase"
             />
+            <button
+              v-if="gateState.termsError.value && !gateState.termsLoading.value"
+              type="button"
+              class="retry-terms"
+              @click="gateState.loadTerms()"
+            >
+              Read the price again
+            </button>
           </div>
 
           <!-- Ownership check still in flight. -->
@@ -266,7 +286,8 @@ function onSettled(): void {
             <WalrusUpload
               :hosts="relayHosts(walrusNetwork)"
               :connected="!!account"
-              :access="{ gateConfigured: gateState.gateConfigured, hasAccess: gateState.hasAccess }"
+              :access="{ gateConfigured: gateState.gateConfigured, hasAccess: gateState.hasAccess, singleUse: gateState.singleUse }"
+              :session-key="`${walrusNetwork}:${account?.address ?? ''}`"
               :perform-upload="performUpload"
               :estimate-storage-cost="estimateUploadStorageCost"
               @uploaded="onUploaded"

package/src/composables/useExtendQuotes.ts

@@ -0,0 +1,69 @@
+// Prices an Extend before the wallet opens (audit F12). A row's quote is the WAL cost of adding
+// `epochs`; Extend opens the wallet only for an amount whose quote the user has been shown. A quote is
+// an estimate (labelled `≈`): the wallet and the chain still decide the amount actually paid.
+import { ref } from 'vue'
+
+export type ExtendQuote =
+  | { epochs: number; state: 'ready'; costFrost: bigint }
+  | { epochs: number; state: 'unavailable'; costFrost: null }
+
+/** Cost in FROST of storing `size` bytes for `epochs`, or `null` when it cannot be priced. */
+export type EstimateExtendCost = (size: number, epochs: number) => Promise<bigint | null>
+
+export function useExtendQuotes(estimate: EstimateExtendCost) {
+  /** Latest quote per Blob object id (one per row). */
+  const quotes = ref<Record<string, ExtendQuote>>({})
+  const pricing = ref<Record<string, number>>({})
+  /** Per-row request counter: an older answer never replaces a newer amount's quote. */
+  const tokens: Record<string, number> = {}
+
+  /** Price `epochs` for the row; resolves to its quote, or `null` if a newer request replaced this one. */
+  async function price(id: string, size: number, epochs: number): Promise<ExtendQuote | null> {
+    const token = (tokens[id] = (tokens[id] ?? 0) + 1)
+    pricing.value = { ...pricing.value, [id]: epochs }
+    let cost: bigint | null
+    try {
+      cost = await estimate(size, epochs)
+    } catch {
+      cost = null
+    }
+    if (tokens[id] !== token) return null
+    const rest = { ...pricing.value }
+    delete rest[id]
+    pricing.value = rest
+    const quote: ExtendQuote =
+      cost === null ? { epochs, state: 'unavailable', costFrost: null } : { epochs, state: 'ready', costFrost: cost }
+    quotes.value = { ...quotes.value, [id]: quote }
+    return quote
+  }
+
+  /** The row's quote, only if it is for exactly `epochs` (an older amount's quote is not shown). */
+  function quoteFor(id: string, epochs: number | undefined): ExtendQuote | null {
+    const q = quotes.value[id]
+    return q && q.epochs === epochs ? q : null
+  }
+
+  /**
+   * Whether Extend may open the wallet now: only when the quote for `epochs` has been shown. If it has
+   * not (the seeded default, or a price still loading), it is fetched now, so the user sees the cost
+   * and presses Extend again — never a wallet prompt for an unpriced amount.
+   */
+  async function shownBeforeSigning(id: string, size: number, epochs: number): Promise<boolean> {
+    if (quoteFor(id, epochs)) return true
+    await price(id, size, epochs)
+    return false
+  }
+
+  /** Forget the row's quote (after its blob was extended, the next Extend is priced afresh). */
+  function clear(id: string): void {
+    tokens[id] = (tokens[id] ?? 0) + 1
+    const q = { ...quotes.value }
+    delete q[id]
+    quotes.value = q
+    const p = { ...pricing.value }
+    delete p[id]
+    pricing.value = p
+  }
+
+  return { quotes, pricing, price, quoteFor, shownBeforeSigning, clear }
+}

package/src/composables/useOwnedBlobs.ts

@@ -20,18 +20,41 @@ const error = ref<string | null>(null)
 /** `<network>|<address>` the current `blobs` were fetched for; `null` until a successful load. */
 const loadedFor = ref<string | null>(null)
 
+/** Counts calls that decide what the list shows; a result is applied only if it is still the latest. */
+let latest = 0
+/** Key of the load in flight (the latest one), or `null` when none is. */
+let inflightKey: string | null = null
+
+/** Drop whatever load is in flight: its result will be discarded and it no longer owns `loading`. */
+function supersede(): void {
+  latest++
+  inflightKey = null
+  loading.value = false
+}
+
 async function load(address: string | null, opts: { force?: boolean } = {}): Promise<void> {
   const net = walrusNetwork.value
   if (!address || !net) {
+    supersede()
     blobs.value = []
     loadedFor.value = null
     return
   }
   // Skip refetch when we already have this address's list and the last load succeeded.
   const key = `${net}|${address}`
-  if (!opts.force && loadedFor.value === key && error.value === null) return
-  if (loadedFor.value !== key) blobs.value = [] // never show another network's or wallet's list
+  if (!opts.force && loadedFor.value === key && error.value === null) {
+    // Switching back to a list we hold: a slower load for another account or network must not land.
+    if (inflightKey !== null && inflightKey !== key) supersede()
+    return
+  }
+  if (loadedFor.value !== key) {
+    // Never show another network's or wallet's list; and a cleared list must not read as loaded.
+    blobs.value = []
+    loadedFor.value = null
+  }
 
+  const mine = ++latest
+  inflightKey = key
   loading.value = true
   error.value = null
   try {
@@ -45,13 +68,20 @@ async function load(address: string | null, opts: { force?: boolean } = {}): Pro
       walrusClient.walrus.systemState(),
       fetchOwnedWalrusBlobs(suiClient, walrusClient, address),
     ])
+    // A newer load (or a switch) took over while this one was in flight: its answer is for another
+    // account or network, so drop it without touching the list, the error or `loading`.
+    if (mine !== latest) return
     currentEpoch.value = Number(sys.committee.epoch)
     blobs.value = fetched.sort((a: OwnedBlob, b: OwnedBlob) => a.endEpoch - b.endEpoch)
     loadedFor.value = key
   } catch (e) {
+    if (mine !== latest) return
     error.value = e instanceof Error ? e.message : String(e)
   } finally {
-    loading.value = false
+    if (mine === latest) {
+      loading.value = false
+      inflightKey = null
+    }
   }
 }
 

package/src/config.ts

@@ -2,7 +2,8 @@
 // selects VITE_NETWORK in main.ts; embedded, the host's selector rules). Operator settings are
 // build-time VITE_* per network: relay hostnames default to the public Mysten relay (set
 // VITE_WALRUS_RELAY_* to your operator relay to collect the tip); the access gate is optional
-// (unset ⇒ ungated), and its package + PlatformConfig come from the published deployment.
+// (unset ⇒ ungated), and its package + PlatformConfig come from the published deployment; the
+// purchase price and payees are read from the chain, never configured.
 import { computed } from 'vue'
 import type { WalrusNetwork, RelayGateConfig } from '@meddleware/walrus-relay'
 import { relayGateConfig } from '@meddleware/walrus-relay'
@@ -64,9 +65,10 @@ export function uploadRelayMaxTipMist(envSource: EnvSource = env): number {
 }
 
 /**
- * The optional NFT access gate for a network: the operator supplies only the Gate id, soulbound
- * flag and purchase price (`VITE_ACCESS_GATE_*_{NET}`); `relayGateConfig` fixes the package and
- * `PlatformConfig` to the published deployment (commission enforcement). `null` — an ungated
+ * The optional NFT access gate for a network: the operator supplies only the Gate id and soulbound
+ * flag (`VITE_ACCESS_GATE_*_{NET}`); `relayGateConfig` fixes the package and `PlatformConfig` to the
+ * published deployment (commission enforcement), and the price is read from the gate on the chain.
+ * `null` — an ungated
  * relay — when no gate id is set, or when no access_gate deployment is recorded for the network.
  */
 export function accessGate(network: WalrusNetwork, envSource: EnvSource = env): RelayGateConfig | null {
@@ -77,7 +79,6 @@ export function accessGate(network: WalrusNetwork, envSource: EnvSource = env):
     return relayGateConfig(network, {
       gateId,
       soulbound: envSource[`VITE_ACCESS_GATE_SOULBOUND_${NET}`] === 'true',
-      priceMist: BigInt(envSource[`VITE_ACCESS_GATE_PRICE_MIST_${NET}`] || '0'),
     })
   } catch (e) {
     console.warn(`[walrus-ui] access gate for ${network} disabled: ${e instanceof Error ? e.message : String(e)}`)