@meddleware/token-deployer-ui 0.0.9 → 0.0.11

package/src/components/IconPicker.vue

@@ -4,15 +4,12 @@ import { useWallet } from '@meddleware/wallet-adapter'
 import { buildDeployExecutor } from '../lib/deployExecutor.js'
 import { getReadClient } from '../lib/readClient.js'
 import { useWalrusRelay } from '../composables/useWalrusRelay.js'
-import { useAccessGate } from '../composables/useAccessGate.js'
+import { useAccessGate } from '@meddleware/walrus-relay'
+// The flow subpath carries no wasm; it loads the Walrus client lazily when an upload starts.
+import { consumeStorageKey, createGatedAccess, runBlobUpload } from '@meddleware/walrus-client/flow'
 import { ICON_EPOCHS } from '../lib/walrus-constants.js'
-import { ICON_MAX_BYTES, validateIconFile } from '../config.js'
-import {
-  fetchRelayChallenge,
-  personalMessageForNonce,
-  buildAccessProofToken,
-} from '../lib/accessGate.js'
-import type { WalrusNetwork } from '../lib/walrus.js'
+import { ACCESS_GATE, ICON_MAX_BYTES, WALRUS_MAX_TIP_MIST, WALRUS_RPC_URLS, validateIconFile } from '../config.js'
+import type { WalrusNetwork } from '../config.js'
 import type { Network } from '../lib/types.js'
 import { UiNotice, UiFieldHint, UiSegmentedControl } from '@meddleware/ui'
 import WalrusBlobBrowser from './WalrusBlobBrowser.vue'
@@ -36,7 +33,7 @@ const isWalrusNetwork = computed(() => props.network !== 'localnet')
 const walrusNet: WalrusNetwork = props.network === 'mainnet' ? 'mainnet' : 'testnet'
 
 // NFT-gated relay access (inert when no gate is configured for this network).
-const accessGate = useAccessGate(walrusNet, { getClient: (n) => getReadClient(n) })
+const accessGate = useAccessGate({ gate: ACCESS_GATE[walrusNet], getClient: () => getReadClient(walrusNet) })
 
 const {
   selectedRelayHost,
@@ -142,82 +139,53 @@ async function upload(): Promise<void> {
     uploadError.value = 'Connect your wallet first.'
     return
   }
+  const address = account.value.address
   uploading.value = true
   uploadError.value = null
   try {
-    const { createWalrusClient, createBlobUploadFlow, walrusBlobUrl } =
-      await import('../lib/walrus.js')
     const executor = await buildDeployExecutor(props.network as Network)
-    const suiClient = getReadClient(props.network as Network)
 
-    // If the gated operator relay is selected, prove NFT access: (single-use only) consume
-    // one use on-chain bound to the challenge nonce, then sign the challenge. The token rides
-    // the relay Authorization header; the nft-gate gateway verifies it before proxying.
-    let uploadRelayAuthToken: string | undefined
+    // The gated operator relay needs proof of an access pass. For a single-use pass the on-chain
+    // consume is persisted before the upload and reused on a retry (the gateway redeems a consume
+    // digest once, on a successful upload), so an interrupted upload never burns a use; a fresh use
+    // is spent only after the gateway reports the stored one redeemed.
     const publicHost = availableRelays.value.find((r) => r.isPublic)?.host
-    const usingOperatorRelay = selectedRelayHost.value !== publicHost
-    if (accessGate.gateConfigured && usingOperatorRelay && account.value) {
-      const challenge = await fetchRelayChallenge(selectedRelayHost.value)
-      let consumeDigest: string | undefined
-      if (accessGate.usesRemaining.value != null && accessGate.nftId.value) {
-        status.value = 'Consuming one access use (approve in wallet)…'
-        const consumeTx = accessGate.buildConsume(accessGate.nftId.value, challenge.nonce)
-        const cres = await executor.signAndExecute(consumeTx)
-        await executor.waitForTransaction(cres.digest)
-        consumeDigest = cres.digest
-      }
-      status.value = 'Signing relay access proof…'
-      const { signature } = await signPersonalMessage(personalMessageForNonce(challenge.nonce))
-      uploadRelayAuthToken = buildAccessProofToken({
-        address: account.value.address,
-        nonce: challenge.nonce,
-        signature,
-        consumeDigest,
-      })
-    }
-
-    const client = createWalrusClient(walrusNet, {
+    const gate = accessGate.gate
+    const nftId = accessGate.nftId.value
+    const gated = !!gate && accessGate.hasAccess.value === true && !!nftId && selectedRelayHost.value !== publicHost
+    const access =
+      gated && gate && nftId
+        ? createGatedAccess({
+            storage: window.localStorage,
+            key: consumeStorageKey(walrusNet, gate.gateId, address),
+            relayHost: selectedRelayHost.value,
+            address,
+            nftId,
+            singleUse: accessGate.usesRemaining.value !== null,
+            buildConsume: (id, nonce) => accessGate.buildConsume(id, nonce),
+            signAndExecute: (tx) => executor.signAndExecute(tx),
+            waitForTransaction: (digest) => executor.waitForTransaction(digest),
+            sign: signPersonalMessage,
+            onStatus: (p) => (status.value = p.detail ?? ''),
+          })
+        : undefined
+
+    const result = await runBlobUpload({
+      bytes,
+      network: walrusNet,
+      relayHost: selectedRelayHost.value,
+      address,
+      rpcUrl: WALRUS_RPC_URLS[walrusNet],
       wasmUrl: walrusWasmUrl,
-      uploadRelayHost: selectedRelayHost.value,
-      uploadRelayAuthToken,
-    })
-    const flow = createBlobUploadFlow(client, bytes)
-
-    status.value = 'Encoding…'
-    await flow.encode()
-
-    let feeNote = ''
-    try {
-      const tipMist = await client.walrus.calculateUploadRelayTip({ size: bytes.length })
-      const tipSui = Number(tipMist) / 1e9
-      feeNote = tipMist > 0n ? ` Relay fee ≈ ${tipSui.toFixed(4)} SUI + storage (WAL).` : ''
-    } catch {
-      // Non-fatal — the register step surfaces any real tip error.
-    }
-
-    status.value = `Registering blob (approve in wallet)…${feeNote}`
-    const regTx = flow.register({
-      owner: account.value.address,
+      maxTipMist: Number(WALRUS_MAX_TIP_MIST),
       epochs: ICON_EPOCHS,
       deletable: !permanent.value,
+      executor,
+      suiClient: getReadClient(props.network as Network),
+      access,
+      onStatus: (p) => (status.value = p.detail ?? ''),
     })
-    regTx.setSenderIfNotSet(account.value.address)
-    await regTx.build({ client: suiClient })
-    const reg = await executor.signAndExecute(regTx)
-    await executor.waitForTransaction(reg.digest)
-
-    status.value = 'Uploading to the relay…'
-    await flow.upload({ digest: reg.digest })
-
-    status.value = 'Certifying (approve in wallet)…'
-    const certTx = flow.certify()
-    certTx.setSenderIfNotSet(account.value.address)
-    await certTx.build({ client: suiClient })
-    const cert = await executor.signAndExecute(certTx)
-    await executor.waitForTransaction(cert.digest)
-
-    const blob = await flow.getBlob()
-    emit('update:modelValue', walrusBlobUrl(walrusNet, blob.blobId))
+    emit('update:modelValue', result.url)
     tab.value = 'url'
     status.value = 'Uploaded ✓ — URL filled in above.'
   } catch (e) {
@@ -225,6 +193,7 @@ async function upload(): Promise<void> {
     status.value = ''
   } finally {
     uploading.value = false
+    if (account.value) void refreshAccess() // uses remaining may have changed
   }
 }
 

package/src/components/LicensePicker.vue

@@ -2,7 +2,7 @@
 import { computed, onMounted, ref } from 'vue'
 import { fetchLicenseList, fetchLicenseText, NO_LICENSE } from '../lib/licenses.js'
 import type { SpdxLicense } from '../lib/licenses.js'
-import { UiDialog, UiFieldHint, UiFormField, UiNotice, UiSelect } from '@meddleware/ui'
+import { UiDialog, UiFieldHint, UiFormField, UiNotice, UiSelect, safeHref } from '@meddleware/ui'
 
 const props = defineProps<{ modelValue: string }>()
 const emit = defineEmits<{
@@ -73,7 +73,8 @@ async function openLicenseModal(): Promise<void> {
       <UiFieldHint field-id="license-select">
         Applies only to the downloadable Move source package — embedded in the LICENSE file and
         source headers. Has <b>no effect on the on-chain token</b> or its transferability. Choose
-        <b>CC0-1.0</b> (default) for public domain. Choose <b>None</b> to retain all rights.
+        <b>0BSD</b> (default) for a minimal permissive licence, or <b>CC0-1.0</b> for public domain.
+        Choose <b>None</b> to retain all rights.
       </UiFieldHint>
     </template>
     <template #default="{ attrs }">
@@ -130,7 +131,7 @@ async function openLicenseModal(): Promise<void> {
     <template v-else>
       <p class="license-spdx">
         <a
-          :href="`https://spdx.org/licenses/${modelValue}.html`"
+          :href="safeHref(`https://spdx.org/licenses/${encodeURIComponent(modelValue)}.html`)"
           target="_blank"
           rel="noopener noreferrer"
           >View on SPDX ↗</a

package/src/components/ResultPanel.vue

@@ -5,7 +5,7 @@ import { explorerObjectUrl } from '../config.js'
 import { generatePackageZip } from '../lib/generatePackage.js'
 import { fetchLicenseText } from '../lib/licenses.js'
 import GithubPush from './GithubPush.vue'
-import { UiNotice } from '@meddleware/ui'
+import { UiNotice, safeHref } from '@meddleware/ui'
 
 const props = defineProps<{ result: PublishResult; config: TokenConfig }>()
 defineEmits<{ (e: 'restart'): void }>()
@@ -51,7 +51,7 @@ async function downloadPackage(): Promise<void> {
       <dd class="mono">{{ result.coinType }}</dd>
       <dt>Package</dt>
       <dd class="mono">
-        <a :href="packageUrl" target="_blank" rel="noopener noreferrer">
+        <a :href="safeHref(packageUrl)" target="_blank" rel="noopener noreferrer">
           {{ result.packageId }}
         </a>
       </dd>

package/src/components/ReviewPanel.vue

@@ -1,12 +1,15 @@
 <script setup lang="ts">
 import type { TokenConfig, Network } from '../lib/types.js'
-import { FEE_MIST } from '../config.js'
+import { FEE_MIST, FEE_TREASURY, isFeeConfigured } from '../config.js'
 import { UiNotice } from '@meddleware/ui'
 
 const props = defineProps<{ config: TokenConfig; network: Network }>()
 defineEmits<{ (e: 'back'): void; (e: 'confirm'): void }>()
 
+// Mirrors TokenDeployerView: the fee is only charged when a real treasury is configured.
+const feeCharged = isFeeConfigured(props.network)
 const feeSui = Number(FEE_MIST) / 1e9
+const treasury = FEE_TREASURY[props.network]
 </script>
 
 <template>
@@ -51,8 +54,13 @@ const feeSui = Number(FEE_MIST) / 1e9
     </dl>
 
     <p v-once class="hint">
-      Your wallet signs and pays gas. A one-off fee of <strong>{{ feeSui }} SUI</strong> is included
-      in the publish transaction. Nothing is compiled or signed on a server.
+      Your wallet signs and pays gas.
+      <template v-if="feeCharged">
+        A one-off fee of <strong>{{ feeSui }} SUI</strong> is included in the publish transaction,
+        paid to the operator treasury <span class="mono">{{ treasury }}</span>.
+      </template>
+      <template v-else>No operator fee is charged on this network.</template>
+      Nothing is compiled or signed on a server.
     </p>
 
     <p v-once class="hint">

package/src/components/TokenDeployerView.vue

@@ -191,57 +191,61 @@ function restart(): void {
 </script>
 
 <template>
-  <UiToolIntro
-    >Deploy your own Sui coin — your wallet signs and pays; no intermediaries ({{
-      network
-    }}).</UiToolIntro
-  >
-
-  <AppTabNav
-    v-model="activeTab"
-    :tabs="TABS"
-    id-prefix="token-deployer"
-    aria-label="Sections"
-    class="deployer-tabs"
-  />
-
-  <WalletGuard message="Connect a Sui wallet to deploy your token.">
+  <div class="mw-token-deployer">
+    <UiToolIntro
+      >Deploy your own Sui coin — your wallet signs and pays; no intermediaries ({{
+        network
+      }}).</UiToolIntro
+    >
+
+    <AppTabNav
+      v-model="activeTab"
+      :tabs="TABS"
+      id-prefix="token-deployer"
+      aria-label="Sections"
+      class="deployer-tabs"
+    />
+
+    <!-- The tab list and its panel always render (the selected tab controls a live panel); the wallet
+         prompt replaces only the panel's content until a wallet is connected. -->
     <UiTabPanel id-prefix="token-deployer" :tab="activeTab">
-      <template v-if="activeTab === 'deploy'">
-        <UiStepper :steps="STEPS" :model-value="stepIndex" @update:model-value="onStepperBack" />
-        <ConfigForm
-          v-if="step === 'identity' || step === 'token' || step === 'settings'"
-          :form="form"
-          :errors="errors"
-          :can-proceed="canProceed"
-          :network="network"
-          :connected="connected"
-          :form-step="formStep"
-          @next="goNext"
-          @back="goBack"
-        />
-        <ReviewPanel
-          v-if="step === 'review'"
-          :config="config"
-          :network="network"
-          @back="goBack"
-          @confirm="confirmDeploy"
-        />
-        <DeployProgress v-if="step === 'deploying'" :step="deployStep" />
-        <ResultPanel
-          v-if="step === 'done' && result"
-          :result="result"
-          :config="config"
-          @restart="restart"
-        />
-        <UiNotice v-if="deployError" type="error">{{ deployError }}</UiNotice>
-      </template>
-
-      <MyTokens v-else :owner="account?.address ?? null" :network="network" />
+      <WalletGuard message="Connect a Sui wallet to deploy your token.">
+        <template v-if="activeTab === 'deploy'">
+          <UiStepper :steps="STEPS" :model-value="stepIndex" @update:model-value="onStepperBack" />
+          <ConfigForm
+            v-if="step === 'identity' || step === 'token' || step === 'settings'"
+            :form="form"
+            :errors="errors"
+            :can-proceed="canProceed"
+            :network="network"
+            :connected="connected"
+            :form-step="formStep"
+            @next="goNext"
+            @back="goBack"
+          />
+          <ReviewPanel
+            v-if="step === 'review'"
+            :config="config"
+            :network="network"
+            @back="goBack"
+            @confirm="confirmDeploy"
+          />
+          <DeployProgress v-if="step === 'deploying'" :step="deployStep" />
+          <ResultPanel
+            v-if="step === 'done' && result"
+            :result="result"
+            :config="config"
+            @restart="restart"
+          />
+          <UiNotice v-if="deployError" type="error">{{ deployError }}</UiNotice>
+        </template>
+
+        <MyTokens v-else :owner="account?.address ?? null" :network="network" />
+      </WalletGuard>
     </UiTabPanel>
-  </WalletGuard>
 
-  <TermsDialog :open="showTerms" @accept="onTermsAccept" @cancel="onTermsCancel" />
+    <TermsDialog :open="showTerms" @accept="onTermsAccept" @cancel="onTermsCancel" />
+  </div>
 </template>
 
 <style scoped>

package/src/components/WalletBar.vue

@@ -3,6 +3,17 @@ import { computed, ref, watch } from 'vue'
 import { useWallet, useNetwork } from '@meddleware/wallet-adapter'
 import { SELECTABLE_NETWORKS } from '../config.js'
 import type { Network } from '../lib/types.js'
+
+/** Wallet-supplied icons are untrusted: render only inline images or https URLs. */
+function safeIcon(icon: string | undefined): string | undefined {
+  if (!icon) return undefined
+  if (/^data:image\/(png|svg\+xml|jpeg|webp|gif);/i.test(icon)) return icon
+  try {
+    return new URL(icon).protocol === 'https:' ? icon : undefined
+  } catch {
+    return undefined
+  }
+}
 import { UiDialog, UiFormField, UiNotice, UiSelect } from '@meddleware/ui'
 
 const { wallets, currentWallet, account, connecting, error, connect, disconnect } = useWallet()
@@ -66,7 +77,7 @@ watch(
     <menu class="wallet-list">
       <li v-for="w in wallets" :key="w.name">
         <button type="button" class="primary" :disabled="connecting" @click="connect(w)">
-          <img v-if="w.icon" :src="w.icon" alt="" width="20" height="20" />
+          <img v-if="safeIcon(w.icon)" :src="safeIcon(w.icon)" alt="" width="20" height="20" />
           {{ w.name }}
         </button>
       </li>

package/src/components/WalrusBlobBrowser.vue

@@ -2,7 +2,8 @@
 import { ref, watch } from 'vue'
 import { useWallet } from '@meddleware/wallet-adapter'
 import { getReadClient } from '../lib/readClient.js'
-import type { OwnedBlob, WalrusNetwork } from '../lib/walrus.js'
+import type { OwnedBlob } from '@meddleware/walrus-client'
+import { WALRUS_RPC_URLS, type WalrusNetwork } from '../config.js'
 import type { Network } from '../lib/types.js'
 import { UiNotice } from '@meddleware/ui'
 
@@ -46,10 +47,9 @@ async function load(): Promise<void> {
   blobs.value = []
   hasLoaded.value = false
   try {
-    const { createWalrusClient, walrusBlobUrl, fetchOwnedWalrusBlobs } =
-      await import('../lib/walrus.js')
+    const { createWalrusClient, walrusBlobUrl, fetchOwnedWalrusBlobs } = await import('@meddleware/walrus-client')
     const suiClient = getReadClient(props.network as Network)
-    const client = createWalrusClient(props.network)
+    const client = createWalrusClient({ network: props.network, rpcUrl: WALRUS_RPC_URLS[props.network] })
     const raw = await fetchOwnedWalrusBlobs(suiClient, client, addr)
     blobs.value = raw.map((b) => ({ ...b, url: walrusBlobUrl(props.network, b.blobId) }))
     hasLoaded.value = true

package/src/composables/useWalrusRelay.ts

@@ -4,8 +4,7 @@
 // (`IconPicker.vue`) and tests are unaffected.
 import { useWalrusRelay as useSharedWalrusRelay } from '@meddleware/walrus-relay'
 import type { RelayAccessOptions, RelayOption } from '@meddleware/walrus-relay'
-import { WALRUS_RELAY_HOSTS, PUBLIC_WALRUS_RELAY_HOSTS } from '../config.js'
-import type { WalrusNetwork } from '../lib/walrus.js'
+import { WALRUS_RELAY_HOSTS, PUBLIC_WALRUS_RELAY_HOSTS, type WalrusNetwork } from '../config.js'
 
 export type { RelayAccessOptions, RelayOption }
 

package/src/config.ts

@@ -2,21 +2,21 @@
 // Vite env vars so they can be set at build/deploy time without code changes.
 // See .env.example.
 import type { Network } from './lib/types.js'
-import type { AccessGateConfig } from './lib/accessGate.js'
+import { relayGateConfig, type RelayGateConfig } from '@meddleware/walrus-relay'
 
 const env = (import.meta as unknown as { env?: Record<string, string | undefined> }).env ?? {}
 
 /**
- * Public JSON-RPC fullnode URLs per network (overridable via `VITE_RPC_*`).
+ * Public gRPC fullnode URLs per network (overridable via `VITE_RPC_*`).
  *
- * NOTE: the official testnet fullnode (`fullnode.testnet.sui.io`) now serves gRPC
- * only and returns 404 for JSON-RPC, so a JSON-RPC-capable endpoint is used for
- * testnet. Operators should set `VITE_RPC_*` to their preferred (often paid) RPC
- * for production to avoid public rate limits.
+ * These are **gRPC(-web)** endpoints for `SuiGrpcClient` — public fullnodes have
+ * deprecated JSON-RPC, so a JSON-RPC-only URL will not work here. Operators should
+ * set `VITE_RPC_*` to their preferred (often paid) gRPC endpoint for production to
+ * avoid public rate limits.
  */
 export const RPC_URLS: Record<Network, string> = {
   mainnet: env.VITE_RPC_MAINNET || 'https://fullnode.mainnet.sui.io:443',
-  testnet: env.VITE_RPC_TESTNET || 'https://sui-testnet-rpc.publicnode.com',
+  testnet: env.VITE_RPC_TESTNET || 'https://fullnode.testnet.sui.io:443',
   localnet: env.VITE_RPC_LOCALNET || 'http://127.0.0.1:9000',
 }
 
@@ -56,7 +56,7 @@ export const SELECTABLE_NETWORKS: Network[] = ['testnet', 'mainnet']
 // ---------------------------------------------------------------------------
 // Walrus is a separate protocol from Sui; only testnet/mainnet exist (no
 // localnet). Icon uploads go through an upload relay (direct-to-storage-node
-// writes fail from browsers). See `src/lib/walrus.ts` and the relay runbook in
+// writes fail from browsers). The upload is `@meddleware/walrus-client/flow`; see the relay runbook in
 // README.md / CLAUDE.md for the operator side.
 
 /** A Walrus network — a strict subset of {@link Network} (no localnet). */
@@ -89,15 +89,12 @@ export function isOperatorRelayConfigured(network: WalrusNetwork): boolean {
 /**
  * gRPC fullnode URL for the Walrus icon-upload client (a `SuiGrpcClient`).
  *
- * IMPORTANT: this is a **gRPC** endpoint and is intentionally *separate* from
- * {@link RPC_URLS} (the JSON-RPC endpoints used by the deploy path). The two protocols
- * are not interchangeable — pointing the Walrus gRPC client at a JSON-RPC URL breaks it —
- * so this has its own `VITE_WALRUS_RPC_*` override rather than reusing `VITE_RPC_*`.
- * Defaults to the public gRPC fullnodes (rate-limited); set your own for production.
+ * Defaults to {@link RPC_URLS} (also gRPC); `VITE_WALRUS_RPC_*` overrides it only when
+ * Walrus traffic should use a different fullnode from the deploy path.
  */
 export const WALRUS_RPC_URLS: Record<WalrusNetwork, string> = {
-  testnet: env.VITE_WALRUS_RPC_TESTNET || 'https://fullnode.testnet.sui.io:443',
-  mainnet: env.VITE_WALRUS_RPC_MAINNET || 'https://fullnode.mainnet.sui.io:443',
+  testnet: env.VITE_WALRUS_RPC_TESTNET || RPC_URLS.testnet,
+  mainnet: env.VITE_WALRUS_RPC_MAINNET || RPC_URLS.mainnet,
 }
 
 /**
@@ -116,27 +113,29 @@ export const WALRUS_MAX_TIP_MIST: bigint = BigInt(env.VITE_WALRUS_MAX_TIP_MIST |
 // NFT-gated relay access (optional)
 // ---------------------------------------------------------------------------
 // When the operator relay runs behind an `nft-gate` gateway, using it requires
-// holding the gate's access NFT. Configure the gate per network via env; when a
-// gate is NOT configured the relay behaves exactly as before (no gating). See
-// `src/lib/accessGate.ts` and `useAccessGate`.
+// holding the gate's access NFT. The operator sets the gate id, soulbound flag (default true) and
+// price per network via env; `relayGateConfig` (walrus-relay) fixes the package and PlatformConfig
+// to the published access_gate deployment. When no gate id is set the relay is ungated.
 
-function parseAccessGate(network: WalrusNetwork): AccessGateConfig | null {
+/** The gate config for a network, or `null` (ungated) without a gate id or a recorded deployment. */
+export function parseAccessGate(network: WalrusNetwork, envSource: Record<string, string | undefined> = env): RelayGateConfig | null {
   const NET = network.toUpperCase()
-  const packageId = env[`VITE_ACCESS_GATE_PACKAGE_${NET}`]
-  const gateId = env[`VITE_ACCESS_GATE_ID_${NET}`]
-  const nftType = env[`VITE_ACCESS_GATE_NFT_TYPE_${NET}`]
-  if (!packageId || !gateId || !nftType) return null
-  return {
-    packageId,
-    gateId,
-    nftType,
-    soulbound: (env[`VITE_ACCESS_GATE_SOULBOUND_${NET}`] ?? 'true') !== 'false',
-    priceMist: BigInt(env[`VITE_ACCESS_GATE_PRICE_MIST_${NET}`] || '0'),
+  const gateId = envSource[`VITE_ACCESS_GATE_ID_${NET}`]
+  if (!gateId) return null
+  try {
+    return relayGateConfig(network, {
+      gateId,
+      soulbound: (envSource[`VITE_ACCESS_GATE_SOULBOUND_${NET}`] ?? 'true') !== 'false',
+      priceMist: BigInt(envSource[`VITE_ACCESS_GATE_PRICE_MIST_${NET}`] || '0'),
+    })
+  } catch (e) {
+    console.warn(`[token-deployer-ui] access gate for ${network} disabled: ${e instanceof Error ? e.message : String(e)}`)
+    return null
   }
 }
 
 /** The access gate per Walrus network, or `null` when gating is not configured. */
-export const ACCESS_GATE: Record<WalrusNetwork, AccessGateConfig | null> = {
+export const ACCESS_GATE: Record<WalrusNetwork, RelayGateConfig | null> = {
   testnet: parseAccessGate('testnet'),
   mainnet: parseAccessGate('mainnet'),
 }

package/src/lib/buildPublishTx.ts

@@ -73,16 +73,6 @@ export interface BuildFinalizeArgs {
   gasBudget: bigint
 }
 
-/** Whether a finalize transaction is needed at all for this config. */
-export function needsFinalize(config: TokenConfig, sender: string): boolean {
-  return (
-    config.initialSupply > 0n ||
-    config.supplyPolicy === 'fixed' ||
-    config.metadataPolicy === 'frozen' ||
-    config.recipient.toLowerCase() !== sender.toLowerCase()
-  )
-}
-
 /**
  * Finalize PTB: register the coin in the registry, mint initial supply, apply
  * supply/metadata policy, and route caps to the recipient.

package/src/lib/deploy.ts

@@ -2,6 +2,7 @@
 // Decoupled from the wallet via an `Executor` so it is unit-testable.
 
 import type { Transaction } from '@mysten/sui/transactions'
+import type { SuiClientTypes } from '@mysten/sui/client'
 import { patchTemplateModule } from './template.js'
 import {
   buildPublishTransaction,
@@ -25,6 +26,41 @@ export interface SuiTxResult {
   effects?: { status?: { status?: string; error?: string } }
 }
 
+/** The core-API execution result {@link toSuiTxResult} consumes (effects + object types). */
+export type CoreExecutionResult = SuiClientTypes.TransactionResult<{
+  effects: true
+  objectTypes: true
+}>
+
+/**
+ * Map a core-API (gRPC) execution result onto {@link SuiTxResult}: created/mutated objects
+ * come from `effects.changedObjects` (types from the `objectTypes` map), and a newly written
+ * package becomes the `published` entry. Failed transactions are returned with a failure
+ * status (not thrown) so {@link deployToken}'s `assertSuccess` reports them uniformly.
+ */
+export function toSuiTxResult(res: CoreExecutionResult): SuiTxResult {
+  const tx = res.Transaction ?? res.FailedTransaction
+  const types = tx.objectTypes ?? {}
+  const objectChanges: NonNullable<SuiTxResult['objectChanges']> = []
+  for (const c of tx.effects?.changedObjects ?? []) {
+    if (c.outputState === 'PackageWrite') {
+      if (c.idOperation === 'Created') objectChanges.push({ type: 'published', packageId: c.objectId })
+    } else if (c.outputState === 'ObjectWrite') {
+      objectChanges.push({
+        type: c.idOperation === 'Created' ? 'created' : 'mutated',
+        objectId: c.objectId,
+        objectType: types[c.objectId],
+        version: c.outputVersion ?? undefined,
+        digest: c.outputDigest ?? undefined,
+      })
+    }
+  }
+  const status = tx.status.success
+    ? { status: 'success' }
+    : { status: 'failure', error: tx.status.error.message }
+  return { digest: tx.digest, objectChanges, effects: { status } }
+}
+
 export interface Executor {
   /** Sign with the wallet and execute; must request object changes + effects. */
   signAndExecute(tx: Transaction): Promise<SuiTxResult>
@@ -51,10 +87,16 @@ export interface DeployArgs {
   onStep?: (step: DeployStep) => void
 }
 
+/**
+ * Only an explicit `success` effects status counts: a missing status (an executor that did not
+ * return effects) is treated as failure, never as success.
+ */
 function assertSuccess(res: SuiTxResult, what: string): void {
   const status = res.effects?.status?.status
-  if (status && status !== 'success') {
-    throw new Error(`${what} failed: ${res.effects?.status?.error ?? status}`)
+  if (status !== 'success') {
+    throw new Error(
+      `${what} failed: ${res.effects?.status?.error ?? status ?? 'no effects status returned'}`,
+    )
   }
 }
 
@@ -67,7 +109,7 @@ export async function deployToken(args: DeployArgs): Promise<PublishResult> {
   const structName = deriveStructName(config.moduleName)
   const normalizedConfig: TokenConfig = { ...config, structName }
   const recipient = normalizedConfig.recipient || args.sender
-  const isE2e = import.meta.env.VITE_E2E === '1'
+  const isE2e = import.meta.env.MODE === 'e2e' && import.meta.env.VITE_E2E === '1'
 
   onStep?.('patching')
   const moduleBytes = await patchTemplateModule({