@meddleware/token-deployer-ui 0.0.1

package/tests/licenses.test.ts

@@ -0,0 +1,78 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import {
+  fetchLicenseList,
+  fetchLicenseText,
+  NO_LICENSE,
+  __resetLicenseCaches,
+} from '../src/lib/licenses.js'
+
+const LIST = {
+  licenses: [
+    { licenseId: 'MIT', name: 'MIT License', isOsiApproved: true, isDeprecatedLicenseId: false },
+    { licenseId: 'CC0-1.0', name: 'Creative Commons Zero v1.0 Universal', isOsiApproved: false, isDeprecatedLicenseId: false },
+    { licenseId: 'GPL-1.0', name: 'GNU GPL v1.0 (deprecated)', isOsiApproved: false, isDeprecatedLicenseId: true },
+  ],
+}
+
+function mockFetch(bodyByUrl: Record<string, { ok?: boolean; json?: unknown; text?: string; status?: number }>) {
+  return vi.fn<(url: string) => Promise<Response>>(async (url: string): Promise<Response> => {
+    const entry = bodyByUrl[url as string] ?? bodyByUrl['*']
+    return {
+      ok: entry?.ok ?? true,
+      status: entry?.status ?? 200,
+      json: async () => entry?.json,
+      text: async () => entry?.text ?? '',
+    } as Response
+  }) as unknown as typeof fetch
+}
+
+const LIST_URL = 'https://raw.githubusercontent.com/spdx/license-list-data/main/json/licenses.json'
+
+beforeEach(() => __resetLicenseCaches())
+
+describe('fetchLicenseList', () => {
+  it('filters deprecated, sorts, includes NONE, and surfaces popular first', async () => {
+    const f = mockFetch({ [LIST_URL]: { json: LIST } })
+    const cat = await fetchLicenseList(f)
+
+    expect(cat.all[0]).toBe(NO_LICENSE)
+    const ids = cat.all.map((l) => l.id)
+    expect(ids).toContain('MIT')
+    expect(ids).toContain('CC0-1.0')
+    expect(ids).not.toContain('GPL-1.0') // deprecated dropped
+
+    // popular ordering: CC0 before MIT
+    const popIds = cat.popular.map((l) => l.id)
+    expect(popIds.indexOf('CC0-1.0')).toBeLessThan(popIds.indexOf('MIT'))
+  })
+
+  it('caches the list (one network call across calls)', async () => {
+    const f = mockFetch({ [LIST_URL]: { json: LIST } })
+    await fetchLicenseList(f)
+    await fetchLicenseList(f)
+    expect((f as unknown as { mock: { calls: unknown[] } }).mock.calls.length).toBe(1)
+  })
+})
+
+describe('fetchLicenseText', () => {
+  it('fetches and caches license text', async () => {
+    const url = 'https://raw.githubusercontent.com/spdx/license-list-data/main/text/MIT.txt'
+    const f = mockFetch({ [url]: { text: 'MIT LICENSE BODY' } })
+    expect(await fetchLicenseText('MIT', f)).toBe('MIT LICENSE BODY')
+    await fetchLicenseText('MIT', f)
+    expect((f as unknown as { mock: { calls: unknown[] } }).mock.calls.length).toBe(1)
+  })
+
+  it('returns null (no fetch) for the proprietary choice', async () => {
+    const f = mockFetch({})
+    expect(await fetchLicenseText('NONE', f)).toBeNull()
+    expect(await fetchLicenseText('', f)).toBeNull()
+    expect((f as unknown as { mock: { calls: unknown[] } }).mock.calls.length).toBe(0)
+  })
+
+  it('throws on a failed fetch', async () => {
+    const url = 'https://raw.githubusercontent.com/spdx/license-list-data/main/text/BOGUS.txt'
+    const f = mockFetch({ [url]: { ok: false, status: 404 } })
+    await expect(fetchLicenseText('BOGUS', f)).rejects.toThrow(/BOGUS/)
+  })
+})

package/tests/template.test.ts

@@ -0,0 +1,93 @@
+import { describe, it, expect } from 'vitest'
+import init, { deserialize } from '@mysten/move-bytecode-template'
+import { patchTemplateModule } from '../src/lib/template.js'
+import { TEMPLATE_DEFAULTS } from '../src/move-template/template.js'
+
+const asStr = (data: number[]) => Buffer.from(data.slice(1)).toString('utf8')
+
+interface Decoded {
+  identifiers: string[]
+  constant_pool: { type_: unknown; data: number[] }[]
+}
+
+describe('patchTemplateModule', () => {
+  it('renames identifiers and patches all five constants, producing a valid module', async () => {
+    await (init as unknown as () => Promise<unknown>)()
+
+    const bytes = await patchTemplateModule({
+      moduleName: 'mycoin',
+      structName: 'MYCOIN',
+      symbol: 'MYC',
+      name: 'My Coin',
+      description: 'A great coin',
+      iconUrl: 'https://example.com/icon.svg',
+      decimals: 6,
+    })
+
+    // valid Move module magic
+    expect(Buffer.from(bytes.slice(0, 4)).toString('hex')).toBe('a11ceb0b')
+
+    const back = deserialize(bytes) as unknown as Decoded
+
+    // identifiers renamed; template identifiers gone
+    expect(back.identifiers).toContain('mycoin')
+    expect(back.identifiers).toContain('MYCOIN')
+    expect(back.identifiers).not.toContain('sui_token_template')
+    expect(back.identifiers).not.toContain('SUI_TOKEN_TEMPLATE')
+
+    // constants patched
+    expect(back.constant_pool.some((c) => c.type_ === 'U8' && c.data[0] === 6)).toBe(true)
+    for (const v of ['MYC', 'My Coin', 'A great coin', 'https://example.com/icon.svg']) {
+      expect(back.constant_pool.some((c) => c.type_ !== 'U8' && asStr(c.data) === v)).toBe(true)
+    }
+    // no template defaults remain
+    for (const def of [
+      TEMPLATE_DEFAULTS.symbol,
+      TEMPLATE_DEFAULTS.name,
+      TEMPLATE_DEFAULTS.description,
+      TEMPLATE_DEFAULTS.iconUrl,
+    ]) {
+      expect(back.constant_pool.some((c) => c.type_ !== 'U8' && asStr(c.data) === def)).toBe(false)
+    }
+  })
+
+  it('supports an empty icon URL', async () => {
+    const bytes = await patchTemplateModule({
+      moduleName: 'noicon',
+      structName: 'NOICON',
+      symbol: 'NIC',
+      name: 'No Icon',
+      description: 'desc',
+      iconUrl: '',
+      decimals: 9,
+    })
+    const back = deserialize(bytes) as unknown as Decoded
+    // empty string encodes as a single 0x00 length byte
+    expect(back.constant_pool.some((c) => c.type_ !== 'U8' && c.data.length === 1 && c.data[0] === 0)).toBe(true)
+  })
+
+  it('rejects out-of-range decimals', async () => {
+    await expect(
+      patchTemplateModule({
+        moduleName: 'x', structName: 'X', symbol: 'X', name: 'X', description: 'X', iconUrl: '', decimals: 300,
+      }),
+    ).rejects.toThrow(/decimals/)
+  })
+
+  it('rejects a string constant with control chars or backslashes (defence in depth)', async () => {
+    await expect(
+      patchTemplateModule({
+        moduleName: 'x', structName: 'X', symbol: 'E\nVIL', name: 'X', description: 'X', iconUrl: '', decimals: 9,
+      }),
+    ).rejects.toThrow(/control characters|quotes|backslashes/)
+
+    await expect(
+      patchTemplateModule({
+        moduleName: 'x', structName: 'X', symbol: 'X', name: 'X', description: 'X',
+        iconUrl: 'x'.repeat(600), decimals: 9,
+      }),
+    ).rejects.toThrow(/exceeds/)
+  })
+})
+
+// Temporary test to check Walrus blob URL patching

package/tests/templateArtifact.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect, beforeAll } from 'vitest'
+import init, { deserialize } from '@mysten/move-bytecode-template'
+import { fromBase64 } from '@mysten/sui/utils'
+import {
+  TEMPLATE_MODULE_B64,
+  TEMPLATE_IDENTIFIERS,
+  TEMPLATE_DEFAULTS,
+} from '../src/move-template/template.js'
+
+// Provenance guard: the checked-in bytecode (.mv, as base64) and the hand-kept
+// TEMPLATE_IDENTIFIERS / TEMPLATE_DEFAULTS in move-template/template.ts must stay
+// consistent. If regen-template.sh is run but the DEFAULTS aren't updated (or vice
+// versa), the deployer's patch would silently fail to match — this test catches
+// that drift in CI instead of at deploy time.
+
+interface Decoded {
+  identifiers: string[]
+  constant_pool: { type_: unknown; data: number[] }[]
+}
+
+// A BCS-encoded String/vector<u8> is a uleb length prefix + utf8 bytes; for these
+// short defaults the prefix is a single byte, so slice(1) recovers the text.
+const asStr = (data: number[]) => Buffer.from(data.slice(1)).toString('utf8')
+
+describe('template artifact provenance', () => {
+  let decoded: Decoded
+
+  beforeAll(async () => {
+    await (init as unknown as () => Promise<unknown>)()
+    decoded = deserialize(fromBase64(TEMPLATE_MODULE_B64)) as unknown as Decoded
+  })
+
+  it('is a valid v7 Move module (magic a11ceb0b)', () => {
+    expect(Buffer.from(fromBase64(TEMPLATE_MODULE_B64).slice(0, 4)).toString('hex')).toBe('a11ceb0b')
+  })
+
+  it('contains the declared template identifiers', () => {
+    expect(decoded.identifiers).toContain(TEMPLATE_IDENTIFIERS.module)
+    expect(decoded.identifiers).toContain(TEMPLATE_IDENTIFIERS.struct)
+  })
+
+  it('contains the declared decimals default as a U8 constant', () => {
+    expect(
+      decoded.constant_pool.some((c) => c.type_ === 'U8' && c.data[0] === TEMPLATE_DEFAULTS.decimals),
+    ).toBe(true)
+  })
+
+  it('contains each declared string default as a distinct vector constant', () => {
+    for (const def of [
+      TEMPLATE_DEFAULTS.symbol,
+      TEMPLATE_DEFAULTS.name,
+      TEMPLATE_DEFAULTS.description,
+      TEMPLATE_DEFAULTS.iconUrl,
+    ]) {
+      expect(
+        decoded.constant_pool.some((c) => c.type_ !== 'U8' && asStr(c.data) === def),
+        `default "${def}" not found in the shipped bytecode`,
+      ).toBe(true)
+    }
+  })
+})

package/tests/templateParity.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest'
+import { readFileSync, existsSync } from 'node:fs'
+import { dirname } from 'node:path'
+import { createRequire } from 'node:module'
+import templateFiles from '../src/template-src/files.json'
+
+// Single-source-of-truth guard. `src/template-src/files.json` is generated from
+// the canonical sui-token-template by scripts/sync-template-src.sh. This test
+// fails if the two drift — i.e. the template changed but the sync script was not
+// re-run — so the downloadable package can never silently diverge from the CLI
+// generator (and, via the shared source, the on-chain bytecode).
+
+const files = templateFiles as Record<string, string>
+
+// The canonical template ships as the published @meddleware/sui-token-template
+// package (resolved from node_modules); SUI_TOKEN_TEMPLATE_DIR overrides with a
+// local checkout. When neither resolves (e.g. before the package is published),
+// the per-file parity assertions skip — the app still ships the vendored
+// files.json + .mv, so this is a maintainer-time check only.
+function resolveTemplateDir(): string | null {
+  if (process.env.SUI_TOKEN_TEMPLATE_DIR) return process.env.SUI_TOKEN_TEMPLATE_DIR
+  try {
+    return dirname(createRequire(import.meta.url).resolve('@meddleware/sui-token-template/package.json'))
+  } catch {
+    return null
+  }
+}
+const T = resolveTemplateDir()
+
+// Mirrors the key -> source mapping in scripts/sync-template-src.sh.
+const SOURCE_OF: Record<string, string> = {
+  'Move.toml': 'Move.toml',
+  'source.move': 'sources/sui_token_template.move',
+  'scripts/publish.sh': 'templates/publish.sh',
+  '.gitignore': 'templates/.gitignore',
+  'README.md': 'templates/README.md',
+  'deployments.md': 'templates/deployments.md',
+  'CLAUDE.md': 'templates/CLAUDE.md',
+  'AGENTS.md': 'templates/AGENTS.md',
+}
+
+describe('template-src parity with the canonical sui-token-template', () => {
+  const templatePresent = T !== null && existsSync(`${T}/Move.toml`)
+
+  it('bundles exactly the expected file keys', () => {
+    expect(Object.keys(files).sort()).toEqual(Object.keys(SOURCE_OF).sort())
+  })
+
+  for (const [key, rel] of Object.entries(SOURCE_OF)) {
+    it.skipIf(!templatePresent)(`files.json["${key}"] matches ${rel} verbatim`, () => {
+      const canonical = readFileSync(`${T as string}/${rel}`, 'utf8')
+      expect(files[key]).toBe(canonical)
+    })
+  }
+})

package/tests/useAccessGate.test.ts

@@ -0,0 +1,101 @@
+import { describe, it, expect, vi, afterEach } from 'vitest'
+import { useAccessGate } from '../src/composables/useAccessGate.js'
+import type { AccessGateConfig, OwnedObjectsClient } from '../src/lib/accessGate.js'
+
+afterEach(() => vi.restoreAllMocks())
+
+const GATE = '0x00000000000000000000000000000000000000000000000000000000000000a1'
+const NFT_TYPE = '0xpkg::access_gate::AccessNFT'
+
+const gate: AccessGateConfig = {
+  packageId: '0xpkg',
+  gateId: GATE,
+  nftType: NFT_TYPE,
+  soulbound: true,
+  priceMist: 1000n,
+}
+
+function ownedEntry(uses?: number) {
+  return {
+    data: {
+      objectId: '0xnft',
+      content: {
+        fields: {
+          data: {
+            fields: {
+              gate_id: GATE,
+              variant:
+                uses === undefined
+                  ? { variant: 'UnlimitedPass', fields: {} }
+                  : { variant: 'SingleUse', fields: { uses_remaining: String(uses) } },
+            },
+          },
+        },
+      },
+    },
+  }
+}
+
+function clientReturning(data: unknown[]): OwnedObjectsClient {
+  return { getOwnedObjects: vi.fn(async () => ({ data })) }
+}
+
+describe('useAccessGate', () => {
+  it('treats the relay as open when no gate is configured', async () => {
+    const g = useAccessGate('testnet', { getClient: () => clientReturning([]), gate: null })
+    expect(g.gateConfigured).toBe(false)
+    expect(g.hasAccess.value).toBe(true)
+    await g.checkOwnership('0xowner')
+    expect(g.accessGranted.value).toBe(true)
+  })
+
+  it('grants access when the wallet holds the gate NFT', async () => {
+    const g = useAccessGate('testnet', { getClient: () => clientReturning([ownedEntry(3)]), gate })
+    expect(g.hasAccess.value).toBe(null) // unknown until checked
+    await g.checkOwnership('0xowner')
+    expect(g.hasAccess.value).toBe(true)
+    expect(g.usesRemaining.value).toBe(3)
+    expect(g.accessGranted.value).toBe(true)
+  })
+
+  it('denies access when the wallet holds no matching NFT', async () => {
+    const g = useAccessGate('testnet', { getClient: () => clientReturning([]), gate })
+    await g.checkOwnership('0xowner')
+    expect(g.hasAccess.value).toBe(false)
+    expect(g.accessGranted.value).toBe(false)
+  })
+
+  it('surfaces an error and denies (does not throw) when the query fails', async () => {
+    const g = useAccessGate('testnet', {
+      getClient: () => ({
+        getOwnedObjects: vi.fn(async () => {
+          throw new Error('rpc down')
+        }),
+      }),
+      gate,
+    })
+    await g.checkOwnership('0xowner')
+    expect(g.hasAccess.value).toBe(false)
+    expect(g.error.value).toMatch(/rpc down/)
+  })
+
+  it('builds a relay access token by signing the challenge', async () => {
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(async () => new Response(JSON.stringify({ nonce: 'the-nonce', expiresAt: 1 }), { status: 200 })),
+    )
+    const g = useAccessGate('testnet', { getClient: () => clientReturning([]), gate })
+    const sign = vi.fn(async (message: Uint8Array) => {
+      expect(new TextDecoder().decode(message)).toBe('nft-gate:access:the-nonce')
+      return { signature: 'SIG' }
+    })
+    const token = await g.buildRelayAccessToken({
+      relayHost: 'https://relay.example',
+      address: '0xowner',
+      sign,
+      consumeDigest: 'dig',
+    })
+    const decoded = JSON.parse(Buffer.from(token, 'base64').toString('utf-8'))
+    expect(decoded).toEqual({ address: '0xowner', nonce: 'the-nonce', signature: 'SIG', consumeDigest: 'dig' })
+  })
+})

package/tests/useWallet.test.ts

@@ -0,0 +1,74 @@
+import { describe, it, expect, vi } from 'vitest'
+import { readonly, isReadonly } from 'vue'
+
+// Reproduces a real Sui wallet extension: `name`/`icon` are getters backed by an
+// ES private field, so they throw ("attempted to get private field on
+// non-instance") if invoked with a Vue reactive/readonly Proxy as `this`. Plain
+// object literals (like our e2e mock) do NOT have this property, which is why the
+// bug only surfaced with actual installed wallets.
+class PrivateFieldWallet {
+  #name = 'Slush'
+  #icon = 'data:image/svg+xml;base64,AAAA'
+  get name() {
+    return this.#name
+  }
+  get icon() {
+    return this.#icon
+  }
+  version = '1.0.0'
+  chains = ['sui:testnet']
+  accounts = [
+    {
+      address: '0x' + '1'.repeat(64),
+      publicKey: new Uint8Array(),
+      chains: ['sui:testnet'],
+      features: ['sui:signTransaction'],
+      label: 'Account 1',
+    },
+  ]
+  features = {
+    'standard:connect': { version: '1.0.0', connect: async () => ({ accounts: this.accounts }) },
+    'standard:events': { version: '1.0.0', on: () => () => {} },
+    'sui:signTransaction': { version: '2.0.0', signTransaction: async () => ({ bytes: '', signature: '' }) },
+    'sui:signPersonalMessage': {
+      version: '1.0.0',
+      signPersonalMessage: async () => ({ bytes: '', signature: 'PMSIG' }),
+    },
+  }
+}
+
+const wallet = new PrivateFieldWallet()
+
+vi.mock('@mysten/wallet-standard', () => ({
+  getWallets: () => ({ get: () => [wallet], on: () => {} }),
+  isWalletWithRequiredFeatureSet: () => true,
+}))
+
+describe('useWallet with real extension wallets (private-field getters)', () => {
+  it('sanity: a private-field getter DOES throw through a Vue readonly Proxy', () => {
+    // This is the exact failure the composable must avoid; if this ever stops
+    // throwing the guard below is testing nothing.
+    const proxied = readonly(new PrivateFieldWallet()) as PrivateFieldWallet
+    expect(() => proxied.name).toThrow('Cannot read private member')
+  })
+
+  it('exposes discovered wallets un-proxied so name/icon read safely', async () => {
+    const { useWallet } = await import('@meddleware/wallet-adapter')
+    const { wallets } = useWallet()
+    const list = wallets.value
+    expect(list.length).toBe(1)
+    // markRaw means Vue never wraps the wallet, so the getters use the real `this`
+    expect(isReadonly(list[0])).toBe(false)
+    expect(() => list[0].name).not.toThrow()
+    expect(list[0].name).toBe('Slush')
+    expect(list[0].icon).toContain('data:image')
+  })
+
+  it('signs a personal message via the wallet feature (for the NFT-gate challenge)', async () => {
+    const { useWallet } = await import('@meddleware/wallet-adapter')
+    const { connect, signPersonalMessage, wallets } = useWallet()
+    await connect(wallets.value[0])
+    const res = await signPersonalMessage(new TextEncoder().encode('nft-gate:access:abc'))
+    expect(res.signature).toBe('PMSIG')
+  })
+})

package/tests/useWalrusRelayGating.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest'
+import { ref } from 'vue'
+import { useWalrusRelay } from '../src/composables/useWalrusRelay.js'
+
+// These tests cover the NFT-gate logic layered onto relay selection. The operator-relay
+// visibility also depends on operator-relay env config (not set in unit tests), so we assert
+// on `accessSatisfied`, which is a pure function of gate config + ownership.
+
+describe('useWalrusRelay gating', () => {
+  it('is unrestricted when no gate is configured (unchanged behaviour)', () => {
+    const relay = useWalrusRelay('testnet')
+    expect(relay.accessSatisfied.value).toBe(true)
+    // The public relay is always present as a fallback.
+    expect(relay.availableRelays.value.some((r) => r.isPublic)).toBe(true)
+  })
+
+  it('reflects ownership when a gate is configured', () => {
+    const hasAccess = ref<boolean | null>(null)
+    const relay = useWalrusRelay('testnet', { gateConfigured: true, hasAccess })
+    expect(relay.accessSatisfied.value).toBe(false) // unknown ⇒ not satisfied
+
+    hasAccess.value = true
+    expect(relay.accessSatisfied.value).toBe(true)
+
+    hasAccess.value = false
+    expect(relay.accessSatisfied.value).toBe(false)
+    // Public relay still available regardless of gate access.
+    expect(relay.availableRelays.value.some((r) => r.isPublic)).toBe(true)
+  })
+})

package/tests/validation.test.ts

@@ -0,0 +1,117 @@
+import { describe, it, expect } from 'vitest'
+import {
+  validateForm,
+  deriveStructName,
+  parseSupply,
+  isValid,
+  validateIdentifier,
+  hasAllowedIconScheme,
+  MAX_IDENT_LEN,
+} from '../src/lib/validation.js'
+
+const good = {
+  packageName: 'my_token',
+  moduleName: 'mytoken',
+  symbol: 'MTK',
+  name: 'My Token',
+  description: 'A friendly token',
+  iconUrl: 'https://example.com/i.png',
+  decimals: 9,
+  initialSupply: '1000000',
+  recipient: '',
+}
+
+describe('deriveStructName', () => {
+  it('uppercases the module name (Sui OTW rule)', () => {
+    expect(deriveStructName('mwsui')).toBe('MWSUI')
+    expect(deriveStructName('sui_token_template')).toBe('SUI_TOKEN_TEMPLATE')
+  })
+})
+
+describe('validateForm', () => {
+  it('accepts a well-formed config', () => {
+    expect(isValid(validateForm(good))).toBe(true)
+  })
+
+  it('rejects invalid identifiers', () => {
+    expect(validateForm({ ...good, packageName: 'My-Token' }).packageName).toBeTruthy()
+    expect(validateForm({ ...good, moduleName: '1coin' }).moduleName).toBeTruthy()
+  })
+
+  it('rejects unsafe characters that would break the Move byte-string', () => {
+    expect(validateForm({ ...good, symbol: 'A"B' }).symbol).toBeTruthy()
+    expect(validateForm({ ...good, name: 'back\\slash' }).name).toBeTruthy()
+  })
+
+  it('requires symbol and name', () => {
+    expect(validateForm({ ...good, symbol: '' }).symbol).toBeTruthy()
+    expect(validateForm({ ...good, name: '   ' }).name).toBeTruthy()
+  })
+
+  it('bounds decimals to 0..18', () => {
+    expect(validateForm({ ...good, decimals: 19 }).decimals).toBeTruthy()
+    expect(validateForm({ ...good, decimals: -1 }).decimals).toBeTruthy()
+    expect(validateForm({ ...good, decimals: 6 }).decimals).toBeUndefined()
+  })
+
+  it('rejects supply that overflows u64 for the decimals', () => {
+    expect(validateForm({ ...good, initialSupply: '99999999999999', decimals: 18 }).initialSupply).toBeTruthy()
+    expect(validateForm({ ...good, initialSupply: 'abc' }).initialSupply).toBeTruthy()
+    expect(validateForm({ ...good, initialSupply: '' }).initialSupply).toBeUndefined()
+  })
+
+  it('validates an optional recipient address', () => {
+    expect(validateForm({ ...good, recipient: '0x123' }).recipient).toBeTruthy()
+    expect(validateForm({ ...good, recipient: '0x' + 'a'.repeat(64) }).recipient).toBeUndefined()
+  })
+
+  it('rejects Move reserved words as package/module names', () => {
+    expect(validateForm({ ...good, packageName: 'module' }).packageName).toBeTruthy()
+    expect(validateForm({ ...good, moduleName: 'struct' }).moduleName).toBeTruthy()
+    expect(validateForm({ ...good, moduleName: 'public' }).moduleName).toBeTruthy()
+  })
+
+  it('rejects over-length identifiers', () => {
+    const tooLong = 'a'.repeat(MAX_IDENT_LEN + 1)
+    expect(validateForm({ ...good, packageName: tooLong }).packageName).toBeTruthy()
+    expect(validateForm({ ...good, moduleName: 'a'.repeat(MAX_IDENT_LEN) }).moduleName).toBeUndefined()
+  })
+
+  it('rejects a whitespace-only symbol even though it contains "safe" chars', () => {
+    expect(validateForm({ ...good, symbol: '   ' }).symbol).toBeTruthy()
+  })
+})
+
+describe('iconUrl scheme allowlist', () => {
+  it('accepts https:// and ipfs:// (and empty = no icon)', () => {
+    expect(isValid(validateForm({ ...good, iconUrl: 'https://x.io/a.png' }))).toBe(true)
+    expect(isValid(validateForm({ ...good, iconUrl: 'ipfs://bafy.../a.png' }))).toBe(true)
+    expect(isValid(validateForm({ ...good, iconUrl: '' }))).toBe(true)
+    expect(hasAllowedIconScheme('HTTPS://X.IO/a.png')).toBe(true) // case-insensitive
+  })
+
+  it('rejects javascript:, data:, and insecure http:', () => {
+    expect(validateForm({ ...good, iconUrl: 'javascript:alert(1)' }).iconUrl).toBeTruthy()
+    expect(validateForm({ ...good, iconUrl: 'data:image/png;base64,AAAA' }).iconUrl).toBeTruthy()
+    expect(validateForm({ ...good, iconUrl: 'http://x.io/a.png' }).iconUrl).toBeTruthy()
+    expect(hasAllowedIconScheme('javascript:alert(1)')).toBe(false)
+  })
+})
+
+describe('validateIdentifier', () => {
+  it('accepts a valid identifier and rejects shape/keyword/length violations', () => {
+    expect(validateIdentifier('my_token')).toBeNull()
+    expect(validateIdentifier('My-Token')).toBeTruthy()
+    expect(validateIdentifier('const')).toBeTruthy()
+    expect(validateIdentifier('a'.repeat(MAX_IDENT_LEN + 1))).toBeTruthy()
+  })
+})
+
+describe('parseSupply', () => {
+  it('parses whole numbers and blank', () => {
+    expect(parseSupply('')).toBe(0n)
+    expect(parseSupply('  42 ')).toBe(42n)
+    expect(parseSupply('1.5')).toBeNull()
+    expect(parseSupply('-1')).toBeNull()
+  })
+})