@meddleware/token-deployer-ui 0.0.1

package/src/lib/template.ts

@@ -0,0 +1,131 @@
+// Client-side Move bytecode patching.
+//
+// The current on-chain binary format (v7) cannot be round-tripped by
+// @mysten/move-bytecode-template's `update_identifiers` / `update_constants`
+// helpers (they throw "missing field `version`"). However, `deserialize` and
+// `serialize` DO handle v7 losslessly, so we patch the decoded JSON directly:
+// rename identifiers in place and overwrite constant-pool entries. This is
+// verified end-to-end against a localnet publish (see scripts/publish-localnet.mjs).
+
+import init, { deserialize, serialize } from '@mysten/move-bytecode-template'
+import { bcs } from '@mysten/bcs'
+import { fromBase64 } from '@mysten/sui/utils'
+import { SAFE_TEXT } from './validation.js'
+import {
+  TEMPLATE_MODULE_B64,
+  TEMPLATE_IDENTIFIERS,
+  TEMPLATE_DEFAULTS,
+} from '../move-template/template.js'
+
+let initPromise: Promise<unknown> | null = null
+let wasmInput: unknown = undefined
+
+/**
+ * Register the wasm asset URL without loading it (browser). Call once at app
+ * startup, e.g. `configureWasm(wasmUrl)`. The actual fetch is deferred until the
+ * first patch, so the 343 kB wasm doesn't block initial page load. In Node/tests
+ * this is unnecessary — the nodejs build loads its own wasm.
+ */
+export function configureWasm(input: unknown): void {
+  wasmInput = input
+}
+
+/**
+ * Initialise the wasm module (idempotent + cached). Lazily triggered by the
+ * patch pipeline; uses the URL registered via `configureWasm` in the browser.
+ */
+export function initTemplateWasm(): Promise<unknown> {
+  if (!initPromise) {
+    initPromise = Promise.resolve()
+      .then(() => (init as unknown as (i?: unknown) => unknown)(wasmInput))
+      .catch(() => undefined)
+  }
+  return initPromise
+}
+
+/** BCS bytes for a `vector<u8>` / `String` constant (uleb length + utf8). */
+function vecU8(value: string): number[] {
+  return Array.from(bcs.string().serialize(value).toBytes())
+}
+
+function sameBytes(a: number[], b: number[]): boolean {
+  return a.length === b.length && a.every((x, i) => x === b[i])
+}
+
+export interface PatchParams {
+  moduleName: string
+  structName: string
+  symbol: string
+  name: string
+  description: string
+  iconUrl: string
+  decimals: number
+}
+
+interface DecodedConstant {
+  type_: 'U8' | { Vector: 'U8' } | unknown
+  data: number[]
+}
+
+interface DecodedModule {
+  identifiers: string[]
+  constant_pool: DecodedConstant[]
+}
+
+/**
+ * Patch the template module with the caller's token parameters and return
+ * publishable module bytes. Pure with respect to the shipped artifact — a fresh
+ * copy is decoded each call.
+ */
+export async function patchTemplateModule(params: PatchParams): Promise<Uint8Array> {
+  await initTemplateWasm()
+
+  const original = fromBase64(TEMPLATE_MODULE_B64)
+  const json = deserialize(original) as unknown as DecodedModule
+
+  // 1) Rename the module + struct identifiers in place (index-preserving, so all
+  //    handle references stay valid; the verifier does not require sorted ids).
+  const rename: Record<string, string> = {
+    [TEMPLATE_IDENTIFIERS.module]: params.moduleName,
+    [TEMPLATE_IDENTIFIERS.struct]: params.structName,
+  }
+  json.identifiers = json.identifiers.map((id) => rename[id] ?? id)
+
+  // 2) Overwrite the five constant-pool defaults with the requested values.
+  patchU8Constant(json, TEMPLATE_DEFAULTS.decimals, params.decimals)
+  patchVecConstant(json, TEMPLATE_DEFAULTS.symbol, params.symbol)
+  patchVecConstant(json, TEMPLATE_DEFAULTS.name, params.name)
+  patchVecConstant(json, TEMPLATE_DEFAULTS.description, params.description)
+  patchVecConstant(json, TEMPLATE_DEFAULTS.iconUrl, params.iconUrl)
+
+  return new Uint8Array(serialize(json as unknown as Parameters<typeof serialize>[0]))
+}
+
+function patchU8Constant(json: DecodedModule, current: number, next: number): void {
+  const entry = json.constant_pool.find(
+    (c) => c.type_ === 'U8' && c.data.length === 1 && c.data[0] === current,
+  )
+  if (!entry) throw new Error(`template U8 constant ${current} not found (artifact drift?)`)
+  if (next < 0 || next > 255 || !Number.isInteger(next)) {
+    throw new Error(`decimals must be an integer 0..255, got ${next}`)
+  }
+  entry.data = [next]
+}
+
+/** Upper bound on a patched string constant, matching the form's icon-URL cap. */
+const MAX_VEC_CONSTANT_LEN = 512
+
+function patchVecConstant(json: DecodedModule, current: string, next: string): void {
+  // Defence in depth: the on-chain metadata must match the generated source, so
+  // reject the same characters the form/source guard rejects, and bound the size.
+  if (!SAFE_TEXT.test(next)) {
+    throw new Error('constant contains quotes, backslashes or control characters')
+  }
+  if (next.length > MAX_VEC_CONSTANT_LEN) {
+    throw new Error(`constant exceeds ${MAX_VEC_CONSTANT_LEN} characters`)
+  }
+  const currentBytes = vecU8(current)
+  const entry = json.constant_pool.find((c) => c.type_ !== 'U8' && sameBytes(c.data, currentBytes))
+  if (!entry) throw new Error(`template constant "${current}" not found (artifact drift?)`)
+  entry.data = vecU8(next)
+}

package/src/lib/types.ts

@@ -0,0 +1,69 @@
+// Shared types for the token deployer.
+
+/** A Sui network the deployer can target. */
+export type Network = 'testnet' | 'mainnet' | 'localnet'
+
+/** Whether the deployer keeps the ability to mint more supply after launch. */
+export type SupplyPolicy = 'fixed' | 'mintable'
+
+/** Whether description/icon stay updatable (MetadataCap retained) or are frozen. */
+export type MetadataPolicy = 'updatable' | 'frozen'
+
+/** Whether the package code can be upgraded, or is made immutable at publish. */
+export type PackagePolicy = 'immutable' | 'upgradeable'
+
+/**
+ * The full set of choices a user makes. `identifiers` are baked into the coin
+ * type and are permanent; `symbol`/`name`/`decimals` are permanent on-chain.
+ */
+export interface TokenConfig {
+  /** Move package name, e.g. "my_token" (snake_case identifier). */
+  packageName: string
+  /** Move module name, e.g. "mytoken" (snake_case identifier). */
+  moduleName: string
+  /** One-time-witness struct name, e.g. "MYTOKEN" (SCREAMING_SNAKE identifier). */
+  structName: string
+
+  symbol: string
+  name: string
+  description: string
+  /** Icon URL (may be a Walrus aggregator URL). Empty string allowed. */
+  iconUrl: string
+  /** 0..255; conventionally 9 on Sui. */
+  decimals: number
+
+  /** Whole-token initial supply minted to the recipient (before decimals scaling). Use 0 for none. */
+  initialSupply: bigint
+  supplyPolicy: SupplyPolicy
+  metadataPolicy: MetadataPolicy
+  packagePolicy: PackagePolicy
+
+  /** Address that receives the caps + initial supply. Defaults to the connected wallet. */
+  recipient: string
+
+  /** SPDX id (e.g. "MIT", "CC0-1.0") or "NONE" for proprietary. Affects the downloadable package only. */
+  license: string
+  /** Human-readable license name for the README (defaults to the SPDX id). */
+  licenseName?: string
+  /** Free-text descriptions used only in generated docs. */
+  packageDescription: string
+  projectName: string
+}
+
+/** Result of a successful on-chain publish. */
+export interface PublishResult {
+  network: Network
+  packageId: string
+  coinType: string
+  treasuryCapId?: string
+  metadataCapId?: string
+  currencyId?: string
+  /** Version and digest of the pending Currency<T> object — needed for finalize_registration. */
+  currencyVersion?: string
+  currencyDigest?: string
+  upgradeCapId?: string
+  digest: string
+  /** Where the trivial fee was sent, and how much (MIST). */
+  feeRecipient: string
+  feeMist: string
+}

package/src/lib/validation.ts

@@ -0,0 +1,172 @@
+// Pure form validation. Kept separate from Vue so it is unit-testable and can be
+// reused by the review step. Rules protect both the on-chain publish and the
+// validity of the generated Move source.
+
+import type { TokenConfig } from './types.js'
+
+/** Max supply Sui `coin::mint` accepts (u64). */
+export const MAX_U64 = 18_446_744_073_709_551_615n
+
+/** Sui OTW rule: the witness struct is the module name, uppercased. */
+export function deriveStructName(moduleName: string): string {
+  return moduleName.toUpperCase()
+}
+
+/** Move identifier shape: lowercase start, then lowercase/digits/underscores. */
+export const MOVE_IDENT = /^[a-z][a-z0-9_]*$/
+/**
+ * Printable ASCII excluding the double-quote and backslash, so values embed
+ * safely inside a Move `b"..."` byte-string literal in the downloadable source.
+ */
+export const SAFE_TEXT = /^[\x20-\x21\x23-\x5b\x5d-\x7e]*$/
+const SUI_ADDRESS = /^0x[0-9a-fA-F]{64}$/
+
+/** Upper bound on package/module identifiers — bounds bytecode/const-pool size. */
+export const MAX_IDENT_LEN = 64
+
+/**
+ * Schemes permitted for the on-chain `icon_url` metadata. `https:` covers a Walrus
+ * aggregator URL and any hosted image; `ipfs:` covers decentralised pins. This is a
+ * defence-in-depth **content** guard layered *on top of* downstream wallet/explorer URL
+ * sanitisation (not a replacement for it): it stops `javascript:`, `data:`, and insecure
+ * `http:` from ever being baked into the generated coin metadata, while renderers remain
+ * responsible for their own sanitisation. Empty (no icon) is allowed by the caller.
+ */
+export const ICON_URL_ALLOWED_SCHEMES = ['https://', 'ipfs://'] as const
+
+/** True if `url` begins with an allowed icon scheme (case-insensitive). */
+export function hasAllowedIconScheme(url: string): boolean {
+  const u = url.trim().toLowerCase()
+  return ICON_URL_ALLOWED_SCHEMES.some((s) => u.startsWith(s))
+}
+
+/**
+ * Move reserved words. A package or module named after one of these compiles
+ * incorrectly or fails, so they are rejected up front. Lowercase-compared, which
+ * also covers the derived (uppercased) OTW struct name.
+ */
+export const MOVE_RESERVED_WORDS: ReadonlySet<string> = new Set([
+  'abort',
+  'acquires',
+  'as',
+  'break',
+  'const',
+  'continue',
+  'copy',
+  'else',
+  'entry',
+  'enum',
+  'false',
+  'for',
+  'friend',
+  'fun',
+  'has',
+  'if',
+  'in',
+  'invariant',
+  'let',
+  'loop',
+  'macro',
+  'match',
+  'module',
+  'move',
+  'mut',
+  'native',
+  'package',
+  'phantom',
+  'public',
+  'return',
+  'script',
+  'spec',
+  'struct',
+  'true',
+  'type',
+  'use',
+  'while',
+  'key',
+  'store',
+  'drop',
+])
+
+/** Validate one Move identifier field; returns an error message or null. */
+export function validateIdentifier(value: string): string | null {
+  if (!value) return 'Required'
+  if (value.length > MAX_IDENT_LEN) return `${MAX_IDENT_LEN} characters maximum`
+  if (!/^[a-z]/.test(value)) return 'Must start with a lowercase letter'
+  if (!MOVE_IDENT.test(value)) return 'Lowercase letters, digits and underscores only'
+  if (MOVE_RESERVED_WORDS.has(value)) return `"${value}" is a reserved keyword`
+  return null
+}
+
+export type FormErrors = Partial<Record<keyof TokenConfig, string>>
+
+export interface ValidatableForm {
+  packageName: string
+  moduleName: string
+  symbol: string
+  name: string
+  description: string
+  iconUrl: string
+  decimals: number | string
+  initialSupply: string
+  recipient: string
+}
+
+/** Validate the user-entered fields. Returns a map of field -> message. */
+export function validateForm(form: ValidatableForm): FormErrors {
+  const errors: FormErrors = {}
+
+  const packageNameError = validateIdentifier(form.packageName)
+  if (packageNameError) errors.packageName = packageNameError
+  const moduleNameError = validateIdentifier(form.moduleName)
+  if (moduleNameError) errors.moduleName = moduleNameError
+
+  if (!form.symbol.trim()) errors.symbol = 'Required'
+  else if (form.symbol.length > 32) errors.symbol = 'Maximum 32 characters'
+  else if (!SAFE_TEXT.test(form.symbol)) errors.symbol = 'Double quotes and backslashes are not supported'
+
+  if (!form.name.trim()) errors.name = 'Required'
+  else if (form.name.length > 64) errors.name = 'Maximum 64 characters'
+  else if (!SAFE_TEXT.test(form.name)) errors.name = 'Double quotes and backslashes are not supported'
+
+  if (form.description.length > 256) errors.description = 'Maximum 256 characters'
+  else if (!SAFE_TEXT.test(form.description)) errors.description = 'Double quotes and backslashes are not supported'
+
+  if (form.iconUrl) {
+    if (form.iconUrl.length > 512) errors.iconUrl = 'Maximum 512 characters'
+    else if (!SAFE_TEXT.test(form.iconUrl)) errors.iconUrl = 'Double quotes and backslashes are not supported'
+    else if (!hasAllowedIconScheme(form.iconUrl)) errors.iconUrl = 'Use an https:// or ipfs:// URL'
+  }
+
+  const decimals = Number(form.decimals)
+  if (!Number.isInteger(decimals)) errors.decimals = 'Enter a whole number'
+  else if (decimals < 0) errors.decimals = 'Must be 0 or greater'
+  else if (decimals > 18) errors.decimals = 'Maximum is 18 (9 is typical on Sui)'
+
+  const supply = parseSupply(form.initialSupply)
+  if (supply === null) {
+    errors.initialSupply = 'Enter a whole number, or leave blank for none'
+  } else if (Number.isInteger(decimals) && decimals >= 0 && decimals <= 18) {
+    if (supply * 10n ** BigInt(decimals) > MAX_U64) {
+      errors.initialSupply = 'Supply exceeds the maximum for this decimal precision'
+    }
+  }
+
+  if (form.recipient && !SUI_ADDRESS.test(form.recipient)) {
+    errors.recipient = 'Enter a full Sui address (0x followed by 64 hex digits)'
+  }
+
+  return errors
+}
+
+/** Parse the supply text into a non-negative bigint, or null if invalid. */
+export function parseSupply(input: string): bigint | null {
+  const s = input.trim()
+  if (s === '') return 0n
+  if (!/^\d+$/.test(s)) return null
+  return BigInt(s)
+}
+
+export function isValid(errors: FormErrors): boolean {
+  return Object.keys(errors).length === 0
+}

package/src/lib/walrus-constants.ts

@@ -0,0 +1,15 @@
+// Lightweight Walrus constants with NO heavy imports, so both the (lazily loaded)
+// `lib/walrus.ts` client and the eagerly rendered `WalrusIconUpload.vue` component
+// can share a single source of truth without pulling `@mysten/walrus` into the
+// component's chunk.
+
+/**
+ * Storage duration (in Walrus epochs) reserved for an uploaded icon.
+ *
+ * Capped at Walrus's `max_epochs_ahead` (53 on testnet/mainnet — the maximum a
+ * single `reserve_space` reservation accepts; a larger value aborts on-chain with
+ * MoveAbort code 2). 53 epochs ≈ ~2 years at the ~2-week epoch cadence. Longer
+ * retention requires periodically extending the blob before expiry (there is no
+ * keeper — this is a manual/operator step).
+ */
+export const ICON_EPOCHS = 53

package/src/lib/walrus.ts

@@ -0,0 +1,144 @@
+// Minimal Walrus client for icon uploads. Mirrors the canonical helpers in the
+// `@meddleware/sui-walrus` package (createWalrusClient / createBlobUploadFlow /
+// walrusBlobUrl / fetchOwnedWalrusBlobs) but is kept self-contained here so it
+// resolves cleanly in the app's Vite build and preserves the lazy-load boundary
+// around `@mysten/walrus`. Once `@meddleware/sui-walrus` is published this file
+// should be replaced by imports from it (injecting the app's relay host + max tip).
+//
+// Icons are stored as RAW blobs (not quilts) so `GET /v1/blobs/<blobId>` returns
+// the exact image bytes — directly renderable by wallets/explorers. An upload
+// relay is REQUIRED (direct-to-storage-node writes fail from browsers). Verified
+// end-to-end on testnet (scripts/walrus-upload verification).
+
+import { SuiGrpcClient } from '@mysten/sui/grpc'
+import { walrus, blobIdFromInt } from '@mysten/walrus'
+import type { SuiJsonRpcClient } from '@mysten/sui/jsonRpc'
+import { WALRUS_RELAY_HOSTS, WALRUS_MAX_TIP_MIST, WALRUS_RPC_URLS } from '../config.js'
+
+export { ICON_EPOCHS } from './walrus-constants.js'
+
+export type WalrusNetwork = 'testnet' | 'mainnet'
+
+const AGGREGATOR_HOSTS: Record<WalrusNetwork, string> = {
+  testnet: 'https://aggregator.walrus-testnet.walrus.space',
+  mainnet: 'https://aggregator.walrus-mainnet.walrus.space',
+}
+
+/** Public URL that serves the raw blob bytes. */
+export function walrusBlobUrl(network: WalrusNetwork, blobId: string): string {
+  return `${AGGREGATOR_HOSTS[network]}/v1/blobs/${blobId}`
+}
+
+/** Options for {@link createWalrusClient}. */
+export interface CreateWalrusClientOptions {
+  /** Browser WASM URL (Vite `?url` import). */
+  wasmUrl?: string
+  /**
+   * Upload relay host. Defaults to the configured operator/public relay for the
+   * network ({@link WALRUS_RELAY_HOSTS}); pass a value to honour a user-supplied URL.
+   */
+  uploadRelayHost?: string
+  /**
+   * Maximum tip (MIST) the client will pay. Defaults to {@link WALRUS_MAX_TIP_MIST}.
+   * The SDK throws if the relay's tip exceeds this, so keep it above the relay tip.
+   */
+  uploadRelayMaxTipMist?: bigint
+  /**
+   * Access-proof token for an NFT-gated operator relay (base64 JSON from the access gate).
+   * Sent as the relay `Authorization: Bearer` header; the `nft-gate` gateway verifies it
+   * before proxying to the relay. Omit for the public relay or an ungated operator relay.
+   */
+  uploadRelayAuthToken?: string
+  /**
+   * gRPC fullnode URL for the underlying `SuiGrpcClient`. Defaults to
+   * {@link WALRUS_RPC_URLS} for the network (operator-overridable via `VITE_WALRUS_RPC_*`).
+   * NOTE: must be a **gRPC** endpoint — not a JSON-RPC URL (see `WALRUS_RPC_URLS`).
+   */
+  rpcUrl?: string
+}
+
+/**
+ * A Walrus-extended gRPC client configured with an upload relay + tip guard.
+ *
+ * The relay's tip address/amount is fetched by the SDK from the relay's
+ * `/v1/tip-config`; only the `max` (client-side ceiling) is set here. The
+ * default relay is the operator relay when `VITE_WALRUS_RELAY_*` is set,
+ * otherwise the public Mysten relay (which earns the operator nothing).
+ */
+export function createWalrusClient(
+  network: WalrusNetwork,
+  wasmUrlOrOptions?: string | CreateWalrusClientOptions,
+) {
+  // Back-compat: a bare string is treated as the WASM URL.
+  const opts: CreateWalrusClientOptions =
+    typeof wasmUrlOrOptions === 'string' ? { wasmUrl: wasmUrlOrOptions } : (wasmUrlOrOptions ?? {})
+  const host = opts.uploadRelayHost ?? WALRUS_RELAY_HOSTS[network]
+  const maxTip = opts.uploadRelayMaxTipMist ?? WALRUS_MAX_TIP_MIST
+  const baseUrl = opts.rpcUrl ?? WALRUS_RPC_URLS[network]
+  return new SuiGrpcClient({ network, baseUrl }).$extend(
+    walrus({
+      ...(opts.wasmUrl ? { wasmUrl: opts.wasmUrl } : {}),
+      uploadRelay: {
+        host,
+        sendTip: { max: Number(maxTip) },
+        ...(opts.uploadRelayAuthToken
+          ? { headers: { Authorization: `Bearer ${opts.uploadRelayAuthToken}` } }
+          : {}),
+      },
+    }),
+  )
+}
+
+/** Raw-blob write flow: encode -> register(tx) -> upload -> certify(tx) -> getBlob. */
+export function createBlobUploadFlow(
+  client: ReturnType<typeof createWalrusClient>,
+  bytes: Uint8Array,
+) {
+  return client.walrus.writeBlobFlow({ blob: bytes })
+}
+
+/** A Walrus blob object owned by a Sui address. */
+export interface OwnedBlob {
+  objectId: string
+  /** Aggregator-URL-compatible blob ID string. */
+  blobId: string
+  size: number
+  endEpoch: number
+  certified: boolean
+}
+
+/**
+ * Return all Walrus blobs owned by `owner`. Uses `getBlobType()` for dynamic
+ * package resolution so no hardcoded addresses are needed.
+ */
+export async function fetchOwnedWalrusBlobs(
+  suiClient: SuiJsonRpcClient,
+  walrusClient: ReturnType<typeof createWalrusClient>,
+  owner: string,
+): Promise<OwnedBlob[]> {
+  const blobType = await walrusClient.walrus.getBlobType()
+  const { data } = await suiClient.getOwnedObjects({
+    owner,
+    filter: { StructType: blobType },
+    options: { showContent: true },
+  })
+  const blobs: OwnedBlob[] = []
+  for (const item of data) {
+    if (!item.data) continue
+    const fields = (item.data.content as { fields?: Record<string, unknown> } | undefined)?.fields
+    if (!fields) continue
+    const storage = fields.storage as { fields?: { end_epoch?: unknown } } | undefined
+    try {
+      blobs.push({
+        objectId: item.data.objectId,
+        blobId: blobIdFromInt(BigInt(fields.blob_id as string)),
+        size: Number(fields.size),
+        endEpoch: Number(storage?.fields?.end_epoch ?? 0),
+        certified: fields.certified_epoch !== null && fields.certified_epoch !== undefined,
+      })
+    } catch {
+      // Skip blobs whose fields cannot be parsed.
+    }
+  }
+  return blobs
+}

package/src/main.ts

@@ -0,0 +1,154 @@
+import { createApp } from 'vue'
+import App from './App.vue'
+import './styles.css'
+import { configureWasm } from './lib/template.js'
+import { useColorMode } from './composables/useColorMode.js'
+
+// Apply the colour mode before mount so there is no theme flash. Defaults to
+// `system` (follows the OS) while enabling the in-app light/dark/system control.
+useColorMode('system')
+
+// Vite serves the wasm as an asset URL; wasm-bindgen's init loads it on demand.
+import wasmUrl from '@mysten/move-bytecode-template/web/move_bytecode_template_bg.wasm?url'
+
+// Register the URL only; the 343 kB wasm is fetched lazily at first deploy so it
+// doesn't block initial page load.
+configureWasm(wasmUrl)
+
+// E2E-only: register mock wallet and expose getSuiClient for headless tests.
+// Wrapped in async IIFE to ensure wallet is registered BEFORE app mounts (timing critical).
+// Tree-shaking removes this entire block from production when VITE_E2E !== '1'.
+;(async () => {
+  if (import.meta.env.VITE_E2E === '1') {
+    const { getWallets } = await import('@mysten/wallet-standard')
+    const { getReadClient: getSuiClient } = await import('./lib/readClient.js')
+
+    // Mock fetch globally for RPC requests so Cypress intercepts are bypassed entirely
+    const originalFetch = globalThis.fetch
+    const publishDigest = '0x' + 'aa'.repeat(32)
+    const packageId = '0x' + 'bb'.repeat(32)
+    const treasureCapId = '0x' + 'cc'.repeat(32)
+    const metadataCapId = '0x' + 'dd'.repeat(32)
+
+    const mockRpcResponse = {
+      digest: publishDigest,
+      effects: {
+        status: { status: 'success' },
+        gasUsed: { computationCost: '1000', storageCost: '2000', storageRebate: '0' },
+      },
+      objectChanges: [
+        { type: 'published', packageId },
+        {
+          type: 'created',
+          objectType: `0x2::coin::TreasuryCap<${packageId}::mytoken::MYTOKEN>`,
+          objectId: treasureCapId,
+        },
+        {
+          type: 'created',
+          objectType: `0x2::coin_registry::MetadataCap<${packageId}::mytoken::MYTOKEN>`,
+          objectId: metadataCapId,
+        },
+      ],
+      events: [],
+      transaction: null,
+      balanceChanges: null,
+    }
+
+    globalThis.fetch = async (input: RequestInfo | URL, init?: RequestInit) => {
+      const url = typeof input === 'string' ? input : input.toString()
+      const method = init?.method || 'GET'
+      const isRpcCall = (url.includes('fullnode') || url.includes('rpc')) && method === 'POST'
+
+      if (isRpcCall) {
+        const body = init?.body ? JSON.parse(String(init.body)) : {}
+        const rpcMethod = body.method
+
+        if (import.meta.env.VITE_E2E === '1') {
+          console.log('[E2E Fetch Mock]', rpcMethod, 'URL:', url)
+        }
+
+        const result =
+          rpcMethod === 'sui_executeTransactionBlock' || rpcMethod === 'sui_getTransactionBlock'
+            ? mockRpcResponse
+            : rpcMethod === 'suix_getCoins' || rpcMethod === 'suix_getBalance'
+              ? { data: [], nextCursor: null, hasNextPage: false }
+              : null
+
+        return new Response(JSON.stringify({ jsonrpc: '2.0', id: body.id || 1, result }), {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+        })
+      }
+
+      return originalFetch(input, init)
+    }
+
+    const E2E_ADDR = '0x' + 'a'.repeat(64)
+    const E2E_PUB_KEY = new Uint8Array(32)
+
+    const mockWallet = {
+      name: 'Test Wallet',
+      version: '1.0.0',
+      icon: 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==',
+      chains: ['sui:testnet', 'sui:mainnet'],
+      accounts: [],
+      features: {
+        'standard:connect': {
+          version: '1.0.0',
+          connect: async () => ({
+            accounts: [
+              {
+                address: E2E_ADDR,
+                publicKey: E2E_PUB_KEY,
+                chains: ['sui:testnet'],
+                features: [],
+                label: 'Test',
+                icon: undefined,
+              },
+            ],
+          }),
+        },
+        'standard:events': {
+          version: '1.0.0',
+          // The app subscribes to the global registry's register/unregister events,
+          // not to per-wallet events, so a no-op listener returning a no-op
+          // unsubscribe satisfies the wallet-standard required-feature filter.
+          on: () => () => {},
+        },
+        'standard:disconnect': {
+          version: '1.0.0',
+          disconnect: async () => undefined,
+        },
+        'sui:signTransaction': {
+          version: '2.0.0',
+          signTransaction: async () => ({
+            bytes: 'bW9jaw==',
+            signature: 'bW9jaw==',
+          }),
+        },
+      },
+    }
+
+    const api = getWallets()
+    let unregister: (() => void) | undefined
+    const w = window as unknown as Record<string, unknown>
+
+    // Register mock wallet synchronously before app mounts so it's available immediately
+    unregister = api.register(mockWallet as never)
+    w.__e2eAddress = E2E_ADDR
+
+    // Expose register/unregister for test control (e.g., disconnect test)
+    w.__registerMockWallet = () => {
+      if (!unregister) unregister = api.register(mockWallet as never)
+    }
+    w.__unregisterMockWallet = () => {
+      unregister?.()
+      unregister = undefined
+    }
+
+    // Expose getSuiClient for tests to build transactions
+    w.__getSuiClient = getSuiClient
+  }
+
+  createApp(App).mount('#app')
+})()