@meddleware/token-deployer-ui 0.0.10 → 0.0.12

package/tests/github.test.ts

@@ -1,61 +0,0 @@
-import { describe, it, expect, vi } from 'vitest'
-import { createRepoAndPush, toBase64Utf8 } from '../src/lib/github.js'
-
-function jsonRes(body: unknown, ok = true, status = 200): Response {
-  return { ok, status, json: async () => body } as Response
-}
-
-describe('toBase64Utf8', () => {
-  it('encodes UTF-8 correctly', () => {
-    expect(toBase64Utf8('hello')).toBe('aGVsbG8=')
-    // round-trips multibyte
-    expect(Buffer.from(toBase64Utf8('héllo—'), 'base64').toString('utf8')).toBe('héllo—')
-  })
-})
-
-describe('createRepoAndPush', () => {
-  it('creates the repo then PUTs each file, reporting progress', async () => {
-    const fetcher = vi.fn<(url: string, _init?: RequestInit) => Promise<Response>>(async (url: string, _init?: RequestInit): Promise<Response> => {
-      if (url.endsWith('/user/repos')) {
-        return jsonRes({ full_name: 'alice/my_token', html_url: 'https://github.com/alice/my_token', owner: { login: 'alice' }, name: 'my_token' })
-      }
-      return jsonRes({ content: {} }, true, 201)
-    }) as unknown as typeof fetch
-
-    const progress: number[] = []
-    const res = await createRepoAndPush({
-      token: 'ghp_x',
-      repoName: 'my_token',
-      files: { 'Move.toml': 'a', 'sources/mytoken.move': 'b' },
-      fetcher,
-      onProgress: (d) => progress.push(d),
-    })
-
-    expect(res.htmlUrl).toBe('https://github.com/alice/my_token')
-    expect(res.owner).toBe('alice')
-    // 1 create + 2 file PUTs
-    const calls = (fetcher as unknown as { mock: { calls: [string, RequestInit][] } }).mock.calls
-    expect(calls.length).toBe(3)
-    expect(calls[0][1]?.method).toBe('POST')
-    expect(calls[1][1]?.method).toBe('PUT')
-    expect(progress).toEqual([1, 2])
-  })
-
-  it('surfaces the GitHub error message on repo-create failure', async () => {
-    const fetcher = vi.fn<() => Promise<Response>>(async (): Promise<Response> => jsonRes({ message: 'name already exists on this account' }, false, 422)) as unknown as typeof fetch
-    await expect(
-      createRepoAndPush({ token: 't', repoName: 'dupe', files: { a: 'x' }, fetcher }),
-    ).rejects.toThrow(/already exists/)
-  })
-
-  it('sends the token as a Bearer header', async () => {
-    const fetcher = vi.fn<(url: string) => Promise<Response>>(async (url: string): Promise<Response> =>
-      url.endsWith('/user/repos')
-        ? jsonRes({ html_url: 'h', owner: { login: 'bob' }, name: 'r', full_name: 'bob/r' })
-        : jsonRes({}, true, 201),
-    ) as unknown as typeof fetch
-    await createRepoAndPush({ token: 'secret', repoName: 'r', files: { a: 'x' }, fetcher })
-    const headers = (fetcher as unknown as { mock: { calls: [string, RequestInit][] } }).mock.calls[0][1]?.headers as Record<string, string>
-    expect(headers.Authorization).toBe('Bearer secret')
-  })
-})

package/tests/licenses.test.ts

@@ -1,81 +0,0 @@
-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: '0BSD', name: 'BSD Zero Clause 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') // still selectable
-    expect(ids).not.toContain('GPL-1.0') // deprecated dropped
-
-    // popular ordering: the 0BSD default first, CC0 still offered
-    const popIds = cat.popular.map((l) => l.id)
-    expect(popIds[0]).toBe('0BSD')
-    expect(popIds.indexOf('0BSD')).toBeLessThan(popIds.indexOf('MIT'))
-    expect(popIds).toContain('CC0-1.0')
-  })
-
-  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/listMyTokens.test.ts

@@ -1,30 +0,0 @@
-import { describe, it, expect, vi } from 'vitest'
-
-const listOwnedObjects = vi.hoisted(() => vi.fn())
-vi.mock('../src/lib/readClient.js', () => ({
-  getReadClient: () => ({ listOwnedObjects }),
-}))
-
-import { listMyTokens } from '../src/lib/listMyTokens.js'
-
-const PKG = '0x' + 'ab'.repeat(32)
-
-describe('listMyTokens', () => {
-  it('queries owned TreasuryCaps and parses short- and long-form framework types', async () => {
-    listOwnedObjects.mockResolvedValue({
-      objects: [
-        { objectId: '0x1', type: `0x2::coin::TreasuryCap<${PKG}::a::A>` },
-        { objectId: '0x2', type: `0x${'0'.repeat(63)}2::coin::TreasuryCap<${PKG}::b::B>` },
-        // duplicate coin type and an unrelated type are skipped
-        { objectId: '0x3', type: `0x2::coin::TreasuryCap<${PKG}::a::A>` },
-        { objectId: '0x4', type: '0x2::coin::Coin<0x2::sui::SUI>' },
-      ],
-    })
-    const tokens = await listMyTokens('0xowner', 'testnet')
-    expect(listOwnedObjects).toHaveBeenCalledWith({ owner: '0xowner', type: '0x2::coin::TreasuryCap' })
-    expect(tokens).toEqual([
-      { coinType: `${PKG}::a::A`, packageId: PKG, treasuryCapId: '0x1', label: 'A' },
-      { coinType: `${PKG}::b::B`, packageId: PKG, treasuryCapId: '0x2', label: 'B' },
-    ])
-  })
-})

package/tests/template.test.ts

@@ -1,93 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,97 +0,0 @@
-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 {
-    objectId: '0xnft',
-    json: {
-      data: {
-        gate_id: GATE,
-        variant:
-          uses === undefined
-            ? { variant: 'UnlimitedPass', fields: {} }
-            : { variant: 'SingleUse', fields: { uses_remaining: String(uses) } },
-      },
-    },
-  }
-}
-
-function clientReturning(objects: unknown[]): OwnedObjectsClient {
-  return { core: { listOwnedObjects: vi.fn(async () => ({ objects })) } }
-}
-
-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: () => ({
-        core: {
-          listOwnedObjects: 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

@@ -1,74 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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)
-  })
-})