@meddleware/token-deployer-ui 0.0.8 → 0.0.10

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>

package/src/lib/deployExecutor.ts

@@ -1,23 +1,25 @@
 // Builds a deploy Executor using the wallet-adapter's shared signing capability
-// + SuiClient for execution (returns objectChanges required by extractPublishResult).
+// + the app's gRPC client for execution (returns the object changes required by
+// extractPublishResult).
 //
 // The wallet-adapter's own Executor only returns { digest } which is not sufficient
 // for the token deploy flow; we sign via the shared wallet connection but execute
-// via SuiClient so we can request showEffects + showObjectChanges.
+// via our own client so we can request effects + object types.
 
-import { SuiJsonRpcClient } from '@mysten/sui/jsonRpc'
+import { fromBase64 } from '@mysten/sui/utils'
 import { useWallet } from '@meddleware/wallet-adapter'
 import type { Transaction } from '@mysten/sui/transactions'
+import { toSuiTxResult } from './deploy.js'
 import type { SuiTxResult, Executor } from './deploy.js'
 import type { Network } from './types.js'
-import { RPC_URLS } from '../config.js'
+import { getReadClient } from './readClient.js'
 
 /**
  * Build a deploy Executor bound to the currently connected wallet (via the
- * wallet-adapter singleton) and the given network's RPC URL.
+ * wallet-adapter singleton) and the given network's gRPC client.
  *
  * The returned executor signs via `sui:signTransaction` and executes via
- * `SuiClient.executeTransactionBlock` with `showEffects + showObjectChanges`
+ * `executeTransaction` with `effects + objectTypes`, mapped by {@link toSuiTxResult}
  * so the caller can extract the published package ID, coin type, TreasuryCap, etc.
  */
 export async function buildDeployExecutor(network: Network): Promise<Executor> {
@@ -26,7 +28,7 @@ export async function buildDeployExecutor(network: Network): Promise<Executor> {
   const acct = account.value
   if (!wallet || !acct) throw new Error('Connect a wallet first.')
 
-  const suiClient = new SuiJsonRpcClient({ url: RPC_URLS[network], network })
+  const suiClient = getReadClient(network)
   const chain = `sui:${network}` as const
 
   const signFeature = wallet.features['sui:signTransaction'] as
@@ -47,12 +49,12 @@ export async function buildDeployExecutor(network: Network): Promise<Executor> {
         account: acct,
         chain,
       })
-      const res = await suiClient.executeTransactionBlock({
-        transactionBlock: bytes,
-        signature,
-        options: { showEffects: true, showObjectChanges: true },
+      const res = await suiClient.executeTransaction({
+        transaction: fromBase64(bytes),
+        signatures: [signature],
+        include: { effects: true, objectTypes: true },
       })
-      return res as unknown as SuiTxResult
+      return toSuiTxResult(res)
     },
     async waitForTransaction(digest: string): Promise<void> {
       await suiClient.waitForTransaction({ digest })

package/src/lib/generatePackage.ts

@@ -11,7 +11,12 @@
 import { zipSync, strToU8 } from 'fflate'
 import templateFiles from '../template-src/files.json'
 import type { PublishResult, TokenConfig } from './types.js'
-import { SAFE_TEXT, deriveStructName, validateIdentifier, hasAllowedIconScheme } from './validation.js'
+import {
+  SAFE_TEXT,
+  deriveStructName,
+  validateIdentifier,
+  hasAllowedIconScheme,
+} from './validation.js'
 
 const files = templateFiles as Record<string, string>
 
@@ -117,12 +122,12 @@ function renderMoveToml(cfg: TokenConfig): string {
 function renderSource(cfg: TokenConfig): string {
   let out = files['source.move']
 
-  // license header (lines 1-2)
+  // license header (lines 1-2) — always rewritten, whatever licence the template itself carries
   const lines = out.split('\n')
   if (isProprietary(cfg.license)) {
     lines[0] = '// SPDX-License-Identifier: UNLICENSED'
     lines[1] = '// All rights reserved. Proprietary and not licensed for redistribution.'
-  } else if (spdxId(cfg.license) !== 'CC0-1.0') {
+  } else {
     lines[0] = `// SPDX-License-Identifier: ${spdxId(cfg.license)}`
     lines[1] = `// Licensed under the ${spdxId(cfg.license)} license; see the LICENSE file.`
   }
@@ -152,18 +157,18 @@ function renderPublishScript(cfg: TokenConfig): string {
   return out
 }
 
+/** The template README's licence line, whatever licence the template itself ships with. */
+const TEMPLATE_LICENSE_LINE = /^(?:CC0 1\.0 Universal|BSD Zero Clause License).*$/m
+
 function renderReadme(cfg: TokenConfig): string {
-  let out = applyDocPlaceholders(files['README.md'], cfg)
+  const out = applyDocPlaceholders(files['README.md'], cfg)
   const licenseName = cfg.licenseName || spdxId(cfg.license)
-  if (isProprietary(cfg.license)) {
-    out = out.replace(
-      /^CC0 1\.0 Universal.*$/m,
-      'All rights reserved. This package is proprietary and not licensed for redistribution.',
-    )
-  } else if (spdxId(cfg.license) !== 'CC0-1.0') {
-    out = out.replace(/^CC0 1\.0 Universal.*$/m, `${licenseName} — see the LICENSE file.`)
-  }
-  return out
+  return out.replace(
+    TEMPLATE_LICENSE_LINE,
+    isProprietary(cfg.license)
+      ? 'All rights reserved. This package is proprietary and not licensed for redistribution.'
+      : `${licenseName} — see the LICENSE file.`,
+  )
 }
 
 /**

package/src/lib/licenses.ts

@@ -23,9 +23,9 @@ export const NO_LICENSE: SpdxLicense = {
   deprecated: false,
 }
 
-/** Ids surfaced first in the picker. CC0 is the project default. */
+/** Ids surfaced first in the picker. 0BSD is the project default; CC0 stays available. */
 export const POPULAR_LICENSE_IDS = [
-  'CC0-1.0',
+  '0BSD',
   'MIT',
   'Apache-2.0',
   'BSD-3-Clause',
@@ -37,9 +37,10 @@ export const POPULAR_LICENSE_IDS = [
   'MPL-2.0',
   'ISC',
   'Unlicense',
+  'CC0-1.0',
 ] as const
 
-export const DEFAULT_LICENSE_ID = 'CC0-1.0'
+export const DEFAULT_LICENSE_ID = '0BSD'
 
 type Fetcher = typeof fetch
 

package/src/lib/listMyTokens.ts

@@ -0,0 +1,41 @@
+// Discover coins the connected wallet has deployed, by listing the TreasuryCap<T> objects it
+// owns (the deploy sends the TreasuryCap to the sender). Read-only; mirrors access-gate's
+// AdminCap-based "My Gates" discovery.
+import { getReadClient } from './readClient.js'
+import type { Network } from './types.js'
+
+/** One deployed coin the wallet controls (holds the TreasuryCap for). */
+export interface DeployedToken {
+  /** Full coin type, e.g. `0x<pkg>::mytoken::MYTOKEN`. */
+  coinType: string
+  /** The published package id (first segment of the coin type). */
+  packageId: string
+  /** Object id of the owned `TreasuryCap<T>`. */
+  treasuryCapId: string
+  /** The one-time-witness struct name (last segment) — a compact display label. */
+  label: string
+}
+
+/** List the coins `owner` has deployed on `network` (via owned `TreasuryCap<T>` objects). */
+export async function listMyTokens(owner: string, network: Network): Promise<DeployedToken[]> {
+  const client = getReadClient(network)
+  // A type filter without type params matches every TreasuryCap<T> instantiation.
+  const { objects } = await client.listOwnedObjects({ owner, type: '0x2::coin::TreasuryCap' })
+  const seen = new Set<string>()
+  const out: DeployedToken[] = []
+  for (const obj of objects) {
+    // gRPC may render the framework address in long form (0x000…02).
+    const m = obj.type.match(/^0x0*2::coin::TreasuryCap<(.+)>$/)
+    if (!m) continue
+    const coinType = m[1]
+    if (seen.has(coinType)) continue
+    seen.add(coinType)
+    out.push({
+      coinType,
+      packageId: coinType.split('::')[0] ?? '',
+      treasuryCapId: obj.objectId,
+      label: coinType.split('::').pop() ?? coinType,
+    })
+  }
+  return out
+}

package/src/lib/readClient.ts

@@ -1,17 +1,25 @@
-// Cached SuiClient per network for read-only queries (getOwnedObjects, etc.).
-// Replaces getSuiClient from the deleted useSuiClient.ts composable.
-import { SuiJsonRpcClient } from '@mysten/sui/jsonRpc'
+// Cached gRPC client per network, shared by read-only queries (listOwnedObjects, etc.) and
+// the deploy executor. Public fullnodes have deprecated JSON-RPC, so this is a SuiGrpcClient.
+import { SuiGrpcClient } from '@mysten/sui/grpc'
 import type { Network } from './types.js'
 import { RPC_URLS } from '../config.js'
 
-const clients = new Map<Network, SuiJsonRpcClient>()
+const clients = new Map<Network, SuiGrpcClient>()
 
-/** Return a memoised {@link SuiJsonRpcClient} for the given network. */
-export function getReadClient(network: Network): SuiJsonRpcClient {
+/** Return a memoised {@link SuiGrpcClient} for the given network. */
+export function getReadClient(network: Network): SuiGrpcClient {
   let c = clients.get(network)
   if (!c) {
-    c = new SuiJsonRpcClient({ url: RPC_URLS[network], network })
+    c = new SuiGrpcClient({ network, baseUrl: RPC_URLS[network] })
     clients.set(network, c)
   }
   return c
 }
+
+/**
+ * Replace the client for `network` (E2E builds only — lets `main.ts` inject a stub client in
+ * place of the network, since gRPC-web responses are binary and cannot be faked via `fetch`).
+ */
+export function setReadClient(network: Network, client: SuiGrpcClient): void {
+  clients.set(network, client)
+}

package/src/lib/types.ts

@@ -41,7 +41,7 @@ export interface TokenConfig {
   /** 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. */
+  /** SPDX id (e.g. "0BSD", "MIT") 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

package/src/lib/validation.ts

@@ -123,18 +123,22 @@ export function validateForm(form: ValidatableForm): FormErrors {
 
   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'
+  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'
+  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'
+  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 (!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'
   }
 

package/src/lib/walrus-constants.ts

@@ -1,5 +1,5 @@
 // Lightweight Walrus constants with NO heavy imports, so both the (lazily loaded)
-// `lib/walrus.ts` client and the eagerly rendered `WalrusIconUpload.vue` component
+// `lib/walrus.ts` client and the eagerly rendered `IconPicker.vue` component
 // can share a single source of truth without pulling `@mysten/walrus` into the
 // component's chunk.
 

package/src/lib/walrus.ts

@@ -12,7 +12,7 @@
 
 import { SuiGrpcClient } from '@mysten/sui/grpc'
 import { walrus, blobIdFromInt } from '@mysten/walrus'
-import type { SuiJsonRpcClient } from '@mysten/sui/jsonRpc'
+import type { ClientWithCoreApi } from '@mysten/sui/client'
 import { WALRUS_RELAY_HOSTS, WALRUS_MAX_TIP_MIST, WALRUS_RPC_URLS } from '../config.js'
 
 export { ICON_EPOCHS } from './walrus-constants.js'
@@ -107,33 +107,44 @@ export interface OwnedBlob {
   certified: boolean
 }
 
+/**
+ * Unwrap a Move-struct field bag from a core `json` value. The gRPC/core API returns struct
+ * fields flat; the old JSON-RPC shape nested them under `.fields`. Tolerate both, since the
+ * SDK documents that the `json` shape may vary between API implementations.
+ */
+function structFields(v: unknown): Record<string, unknown> | undefined {
+  if (!v || typeof v !== 'object') return undefined
+  const o = v as Record<string, unknown>
+  const nested = o.fields
+  return nested && typeof nested === 'object' ? (nested as Record<string, unknown>) : o
+}
+
 /**
  * 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,
+  suiClient: ClientWithCoreApi,
   walrusClient: ReturnType<typeof createWalrusClient>,
   owner: string,
 ): Promise<OwnedBlob[]> {
   const blobType = await walrusClient.walrus.getBlobType()
-  const { data } = await suiClient.getOwnedObjects({
+  const { objects } = await suiClient.core.listOwnedObjects({
     owner,
-    filter: { StructType: blobType },
-    options: { showContent: true },
+    type: blobType,
+    include: { json: 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
+  for (const obj of objects) {
+    const fields = structFields(obj.json)
     if (!fields) continue
-    const storage = fields.storage as { fields?: { end_epoch?: unknown } } | undefined
+    const storage = structFields(fields.storage)
     try {
       blobs.push({
-        objectId: item.data.objectId,
+        objectId: obj.objectId,
         blobId: blobIdFromInt(BigInt(fields.blob_id as string)),
         size: Number(fields.size),
-        endEpoch: Number(storage?.fields?.end_epoch ?? 0),
+        endEpoch: Number(storage?.end_epoch ?? 0),
         certified: fields.certified_epoch !== null && fields.certified_epoch !== undefined,
       })
     } catch {

package/src/main.ts

@@ -6,12 +6,19 @@ import App from './App.vue'
 import './styles.css'
 import './component-styles.css'
 import { configureWasm } from './lib/template.js'
-import { useColorMode } from '@meddleware/ui'
+// Static: readClient is already in the main chunk (IconPicker, WalrusBlobBrowser and listMyTokens
+// import it), so a dynamic import in the E2E block below could not split it out anyway.
+import { getReadClient, setReadClient } from './lib/readClient.js'
+import type { SuiGrpcClient } from '@mysten/sui/grpc'
+import { useColorMode, useSeason } from '@meddleware/ui'
 
 // 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')
 
+// Enable seasonal theming (sets data-season on <html>; seasons.css is imported above).
+useSeason()
+
 // 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'
 
@@ -19,73 +26,54 @@ import wasmUrl from '@mysten/move-bytecode-template/web/move_bytecode_template_b
 // doesn't block initial page load.
 configureWasm(wasmUrl)
 
-// E2E-only: register mock wallet and expose getSuiClient for headless tests.
+// E2E-only: stub the Sui client, register a 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)
+    // Stub gRPC client in place of the network (gRPC-web is binary, so it cannot be faked
+    // at the fetch layer). Returns a successful publish whose effects carry the created
+    // TreasuryCap/MetadataCap, and empty owned-object lists.
+    const publishDigest = 'E2E' + 'a'.repeat(41)
     const packageId = '0x' + 'bb'.repeat(32)
-    const treasureCapId = '0x' + 'cc'.repeat(32)
+    const treasuryCapId = '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,
+    const created = (objectId: string) => ({
+      objectId,
+      outputState: 'ObjectWrite',
+      idOperation: 'Created',
+      outputVersion: '1',
+      outputDigest: publishDigest,
+    })
+    const executed = {
+      $kind: 'Transaction',
+      Transaction: {
+        digest: publishDigest,
+        status: { success: true, error: null },
+        effects: {
+          changedObjects: [
+            { objectId: packageId, outputState: 'PackageWrite', idOperation: 'Created' },
+            created(treasuryCapId),
+            created(metadataCapId),
+          ],
         },
-        {
-          type: 'created',
-          objectType: `0x2::coin_registry::MetadataCap<${packageId}::mytoken::MYTOKEN>`,
-          objectId: metadataCapId,
+        objectTypes: {
+          [treasuryCapId]: `0x2::coin::TreasuryCap<${packageId}::mytoken::MYTOKEN>`,
+          [metadataCapId]: `0x2::coin_registry::MetadataCap<${packageId}::mytoken::MYTOKEN>`,
         },
-      ],
-      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 noObjects = async () => ({ objects: [], hasNextPage: false, cursor: null })
+    const stubClient = {
+      executeTransaction: async () => executed,
+      waitForTransaction: async () => executed,
+      listOwnedObjects: noObjects,
+      core: { listOwnedObjects: noObjects },
+    } as unknown as SuiGrpcClient
+    setReadClient('testnet', stubClient)
+    setReadClient('mainnet', stubClient)
 
     const E2E_ADDR = '0x' + 'a'.repeat(64)
     const E2E_PUB_KEY = new Uint8Array(32)
@@ -151,7 +139,7 @@ configureWasm(wasmUrl)
     }
 
     // Expose getSuiClient for tests to build transactions
-    w.__getSuiClient = getSuiClient
+    w.__getSuiClient = getReadClient
   }
 
   createApp(App).mount('#app')

package/src/styles.css

@@ -2,12 +2,18 @@
    Token variables come from @meddleware/design-tokens, imported before this.
    Component utility classes live in component-styles.css. */
 
-.theme-bar {
-  display: flex;
-  justify-content: flex-end;
+/* The colour-mode control is the page header's first grid item, aligned to the inline end. */
+.theme-toggle {
+  justify-self: end;
   margin-bottom: 0.75rem;
 }
 
+.page-footer {
+  margin-top: 3rem;
+  color: var(--muted);
+  font-size: 0.9rem;
+}
+
 body {
   margin: 0;
   background: var(--bg);
@@ -21,12 +27,14 @@ body {
 }
 
 main {
-  max-width: 760px;
+  max-width: var(--mw-tool-content-max);
   margin: 0 auto;
   padding: 1.5rem 1.25rem 4rem;
 }
 
-header {
+/* A single-column grid so the colour-mode control can sit at the inline end without a wrapper. */
+.page-header {
+  display: grid;
   padding-bottom: 1.5rem;
   border-bottom: 1px solid var(--border);
   margin-bottom: 1.5rem;