@meddleware/token-deployer-ui 0.0.1

package/src/lib/accessGate.ts

@@ -0,0 +1,141 @@
+// Client-side helpers for the `access_gate` NFT primitive that gates the operator's
+// upload relay: ownership queries, purchase/consume PTB builders, and the wallet-signed
+// access-proof token.
+//
+// Self-contained (this app is standalone). The wire format mirrors
+// `@meddleware/nft-gate-client` and `@meddleware/sui-walrus`'s access helpers; the
+// `nft-gate` gateway is the authority that verifies these proofs.
+//
+// TODO(unify): consume `@meddleware/nft-gate-client` once published and drop the duplication.
+
+import { Transaction } from '@mysten/sui/transactions'
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+/** Deployed gate + the NFT type that satisfies it. */
+export interface AccessGateConfig {
+  packageId: string
+  gateId: string
+  /** `<pkg>::access_gate::AccessNFT` or `…::SoulboundAccessNFT`. */
+  nftType: string
+  soulbound: boolean
+  /** Purchase price in MIST. */
+  priceMist: bigint
+}
+
+export interface OwnedAccessNft {
+  objectId: string
+  gateId: string
+  /** `null` = unlimited pass; otherwise remaining single-use count. */
+  usesRemaining: number | null
+}
+
+/** Minimal structural subset of the JSON-RPC client used here. */
+export interface OwnedObjectsClient {
+  getOwnedObjects(params: {
+    owner: string
+    filter?: { StructType: string }
+    options?: { showContent?: boolean; showType?: boolean }
+  }): Promise<{ data: unknown[] }>
+}
+
+function parseUsesRemaining(variant: any): number | null {
+  if (variant == null) return null
+  const fields = variant.fields ?? variant
+  const ur = fields?.uses_remaining ?? fields?.SingleUse?.uses_remaining
+  return ur != null ? Number(ur) : null
+}
+
+/** Parse a `getOwnedObjects` entry into an access NFT, or `null` if it isn't one. */
+export function parseOwnedAccessNft(entry: any): OwnedAccessNft | null {
+  const obj = entry?.data ?? entry
+  const objectId: string | undefined = obj?.objectId
+  const inner = obj?.content?.fields?.data?.fields
+  const gateId: string | undefined = inner?.gate_id ?? inner?.gateId
+  if (!objectId || !gateId) return null
+  return { objectId, gateId, usesRemaining: parseUsesRemaining(inner?.variant) }
+}
+
+/** All access NFTs of `nftType` owned by `owner`, optionally restricted to `gateId`. */
+export async function fetchAccessNfts(
+  client: OwnedObjectsClient,
+  owner: string,
+  nftType: string,
+  gateId?: string,
+): Promise<OwnedAccessNft[]> {
+  const { data } = await client.getOwnedObjects({
+    owner,
+    filter: { StructType: nftType },
+    options: { showContent: true, showType: true },
+  })
+  const parsed = (data ?? [])
+    .map(parseOwnedAccessNft)
+    .filter((n): n is OwnedAccessNft => n !== null)
+  return gateId ? parsed.filter((n) => n.gateId === gateId) : parsed
+}
+
+/** Build a PTB that buys access (splits the exact price from gas → `purchase`). */
+export function buildPurchaseTx(cfg: AccessGateConfig): Transaction {
+  const tx = new Transaction()
+  const [payment] = tx.splitCoins(tx.gas, [tx.pure.u64(cfg.priceMist)])
+  tx.moveCall({
+    target: `${cfg.packageId}::access_gate::purchase`,
+    arguments: [tx.object(cfg.gateId), payment],
+  })
+  return tx
+}
+
+/** Build a PTB that consumes one single-use, binding it to `nonce`. */
+export function buildConsumeTx(cfg: AccessGateConfig, nftId: string, nonce: string): Transaction {
+  const tx = new Transaction()
+  const fn = cfg.soulbound ? 'consume_soulbound' : 'consume'
+  const nonceBytes = Array.from(new TextEncoder().encode(nonce))
+  tx.moveCall({
+    target: `${cfg.packageId}::access_gate::${fn}`,
+    arguments: [tx.object(nftId), tx.object(cfg.gateId), tx.pure.vector('u8', nonceBytes)],
+  })
+  return tx
+}
+
+// ── Challenge / proof (mirror of the gateway's wire format) ───────────────────────
+
+export interface RelayChallenge {
+  nonce: string
+  expiresAt: number
+}
+
+export type PersonalMessageSigner = (message: Uint8Array) => Promise<{ signature: string }>
+
+export function personalMessageForNonce(nonce: string): Uint8Array {
+  return new TextEncoder().encode(`nft-gate:access:${nonce}`)
+}
+
+function toBase64(s: string): string {
+  return typeof btoa === 'function' ? btoa(s) : Buffer.from(s, 'utf-8').toString('base64')
+}
+
+export function buildAccessProofToken(proof: {
+  address: string
+  nonce: string
+  signature: string
+  consumeDigest?: string
+}): string {
+  const payload: Record<string, string> = {
+    address: proof.address,
+    nonce: proof.nonce,
+    signature: proof.signature,
+  }
+  if (proof.consumeDigest) payload.consumeDigest = proof.consumeDigest
+  return toBase64(JSON.stringify(payload))
+}
+
+export async function fetchRelayChallenge(
+  relayHost: string,
+  opts: { signal?: AbortSignal } = {},
+): Promise<RelayChallenge> {
+  const res = await fetch(`${relayHost.replace(/\/$/, '')}/v1/challenge`, { signal: opts.signal })
+  if (!res.ok) throw new Error(`challenge request failed: ${res.status}`)
+  const data = (await res.json()) as { nonce?: string; expiresAt?: number; expires_at?: number }
+  if (!data || typeof data.nonce !== 'string') throw new Error('challenge response missing nonce')
+  return { nonce: data.nonce, expiresAt: data.expiresAt ?? data.expires_at ?? 0 }
+}

package/src/lib/buildPublishTx.ts

@@ -0,0 +1,192 @@
+// PTB builders for deploying a coin.
+//
+// Two transactions, because the OTW `init()` creates the TreasuryCap/MetadataCap
+// and sends them to the sender — they are NOT results of `tx.publish`, so they
+// can only be used after the publish executes:
+//
+//   1. buildPublishTransaction — publish the patched module, take the trivial
+//      fee, and apply the UpgradeCap policy (make immutable, or keep). The
+//      TreasuryCap + MetadataCap land with the sender automatically.
+//   2. buildFinalizeTransaction — (optional) mint the initial supply, apply the
+//      supply + metadata policies, promote the currency in the registry, and move
+//      the caps/supply to the recipient. Only needed when any of those differ
+//      from the defaults.
+
+import { Transaction } from '@mysten/sui/transactions'
+import { toBase64 } from '@mysten/sui/utils'
+import type { Network, PublishResult, TokenConfig } from './types.js'
+
+const SUI_FRAMEWORK = '0x2'
+const MOVE_STDLIB = '0x1'
+
+export interface BuildPublishArgs {
+  moduleBytes: Uint8Array
+  sender: string
+  feeMist: bigint
+  feeRecipient: string
+  gasBudget: bigint
+  packagePolicy: TokenConfig['packagePolicy']
+}
+
+/**
+ * Publish PTB: publish -> (make_immutable | transfer UpgradeCap) + fee split.
+ * The user signs this; they pay gas and the fee.
+ */
+export function buildPublishTransaction(args: BuildPublishArgs): Transaction {
+  const tx = new Transaction()
+  tx.setSender(args.sender)
+
+  const [upgradeCap] = tx.publish({
+    modules: [toBase64(args.moduleBytes)],
+    dependencies: [MOVE_STDLIB, SUI_FRAMEWORK],
+  })
+
+  if (args.packagePolicy === 'immutable') {
+    tx.moveCall({ target: `${SUI_FRAMEWORK}::package::make_immutable`, arguments: [upgradeCap] })
+  } else {
+    tx.transferObjects([upgradeCap], args.sender)
+  }
+
+  // Trivial fee: split from the gas coin into the operator treasury.
+  if (args.feeMist > 0n) {
+    const [fee] = tx.splitCoins(tx.gas, [args.feeMist])
+    tx.transferObjects([fee], args.feeRecipient)
+  }
+
+  tx.setGasBudget(args.gasBudget)
+  return tx
+}
+
+export interface BuildFinalizeArgs {
+  config: TokenConfig
+  coinType: string
+  treasuryCapId: string
+  metadataCapId: string
+  /**
+   * Full object reference for the pending Currency<T> object (at address 0xc).
+   * When provided, `finalize_registration` is called first in the PTB, promoting the
+   * pending Currency to a shared, RPC-discoverable object so wallets can read the
+   * coin's decimal metadata via suix_getCoinMetadata.
+   */
+  currencyRef?: { objectId: string; version: string; digest: string }
+  sender: string
+  gasBudget: bigint
+}
+
+/** Whether a finalize transaction is needed at all for this config. */
+export function needsFinalize(config: TokenConfig, sender: string): boolean {
+  return (
+    config.initialSupply > 0n ||
+    config.supplyPolicy === 'fixed' ||
+    config.metadataPolicy === 'frozen' ||
+    config.recipient.toLowerCase() !== sender.toLowerCase()
+  )
+}
+
+/**
+ * Finalize PTB: register the coin in the registry, mint initial supply, apply
+ * supply/metadata policy, and route caps to the recipient.
+ * Built after the publish effects reveal the cap object IDs.
+ */
+export function buildFinalizeTransaction(args: BuildFinalizeArgs): Transaction {
+  const { config, coinType } = args
+  const tx = new Transaction()
+  tx.setSender(args.sender)
+  const recipient = config.recipient || args.sender
+
+  // Always call finalize_registration when we have the full object ref for the pending
+  // Currency<T>. This promotes it from a pending owned object (at @0xc) to a shared,
+  // RPC-discoverable object so wallets can read decimals via suix_getCoinMetadata.
+  // Without this step wallets fall back to 0 decimals and display raw base-unit counts.
+  if (args.currencyRef) {
+    tx.moveCall({
+      target: `${SUI_FRAMEWORK}::coin_registry::finalize_registration`,
+      typeArguments: [coinType],
+      arguments: [
+        tx.object('0xc'),               // &mut CoinRegistry (shared object at well-known address)
+        tx.receivingRef(args.currencyRef), // Receiving<Currency<T>> — pending object at @0xc
+      ],
+    })
+  }
+
+  // Mint the initial supply (scaled by decimals) to the recipient.
+  if (config.initialSupply > 0n) {
+    const amount = config.initialSupply * 10n ** BigInt(config.decimals)
+    const minted = tx.moveCall({
+      target: `${SUI_FRAMEWORK}::coin::mint`,
+      typeArguments: [coinType],
+      arguments: [tx.object(args.treasuryCapId), tx.pure.u64(amount)],
+    })
+    tx.transferObjects([minted], recipient)
+  }
+
+  // Supply policy: fixed => freeze the TreasuryCap (no further minting possible);
+  // mintable => keep it with the recipient.
+  if (config.supplyPolicy === 'fixed') {
+    tx.moveCall({
+      target: `${SUI_FRAMEWORK}::transfer::public_freeze_object`,
+      typeArguments: [`${SUI_FRAMEWORK}::coin::TreasuryCap<${coinType}>`],
+      arguments: [tx.object(args.treasuryCapId)],
+    })
+  } else if (recipient.toLowerCase() !== args.sender.toLowerCase()) {
+    tx.transferObjects([tx.object(args.treasuryCapId)], recipient)
+  }
+
+  // Metadata policy: frozen => freeze the MetadataCap (no further metadata edits);
+  // updatable => keep it with the recipient.
+  if (config.metadataPolicy === 'frozen') {
+    tx.moveCall({
+      target: `${SUI_FRAMEWORK}::transfer::public_freeze_object`,
+      typeArguments: [`${SUI_FRAMEWORK}::coin_registry::MetadataCap<${coinType}>`],
+      arguments: [tx.object(args.metadataCapId)],
+    })
+  } else if (recipient.toLowerCase() !== args.sender.toLowerCase()) {
+    tx.transferObjects([tx.object(args.metadataCapId)], recipient)
+  }
+
+  tx.setGasBudget(args.gasBudget)
+  return tx
+}
+
+interface ObjectChange {
+  type: string
+  objectType?: string
+  objectId?: string
+  packageId?: string
+  /** Version and digest are present for created/mutated objects in the full RPC response. */
+  version?: string
+  digest?: string
+}
+
+/** Pull package id, coin type and cap ids out of publish `objectChanges`. */
+export function extractPublishResult(
+  objectChanges: ObjectChange[],
+  ctx: { network: Network; digest: string; feeRecipient: string; feeMist: bigint },
+): PublishResult {
+  const published = objectChanges.find((c) => c.type === 'published')
+  const packageId = published?.packageId ?? ''
+
+  const createdOfType = (needle: string) =>
+    objectChanges.find((c) => c.type === 'created' && (c.objectType ?? '').includes(needle))
+
+  const treasury = createdOfType('coin::TreasuryCap')
+  const coinTypeMatch = treasury?.objectType?.match(/TreasuryCap<(.+)>/)
+  const coinType = coinTypeMatch?.[1] ?? ''
+
+  const currency = createdOfType('coin_registry::Currency')
+
+  return {
+    network: ctx.network,
+    packageId,
+    coinType,
+    treasuryCapId: treasury?.objectId,
+    metadataCapId: createdOfType('coin_registry::MetadataCap')?.objectId,
+    currencyId: currency?.objectId,
+    currencyVersion: currency?.version,
+    currencyDigest: currency?.digest,
+    upgradeCapId: createdOfType('package::UpgradeCap')?.objectId,
+    digest: ctx.digest,
+    feeRecipient: ctx.feeRecipient,
+    feeMist: ctx.feeMist.toString(),
+  }
+}

package/src/lib/deploy.ts

@@ -0,0 +1,168 @@
+// Deployment orchestration: patch -> publish -> wait -> (finalize) -> result.
+// Decoupled from the wallet via an `Executor` so it is unit-testable.
+
+import type { Transaction } from '@mysten/sui/transactions'
+import { patchTemplateModule } from './template.js'
+import {
+  buildPublishTransaction,
+  buildFinalizeTransaction,
+  extractPublishResult,
+} from './buildPublishTx.js'
+import { deriveStructName } from './validation.js'
+import type { Network, PublishResult, TokenConfig } from './types.js'
+
+export interface SuiTxResult {
+  digest: string
+  objectChanges?: {
+    type: string
+    objectType?: string
+    objectId?: string
+    packageId?: string
+    /** Present for created/mutated objects in the full Sui RPC response. */
+    version?: string
+    digest?: string
+  }[]
+  effects?: { status?: { status?: string; error?: string } }
+}
+
+export interface Executor {
+  /** Sign with the wallet and execute; must request object changes + effects. */
+  signAndExecute(tx: Transaction): Promise<SuiTxResult>
+  /** Block until the digest is indexed (so new objects resolve). */
+  waitForTransaction(digest: string): Promise<void>
+}
+
+export type DeployStep =
+  | 'patching'
+  | 'publishing'
+  | 'confirming'
+  | 'finalizing'
+  | 'confirming-finalize'
+  | 'done'
+
+export interface DeployArgs {
+  config: TokenConfig
+  network: Network
+  sender: string
+  feeMist: bigint
+  feeTreasury: string
+  gasBudget: bigint
+  executor: Executor
+  onStep?: (step: DeployStep) => void
+}
+
+function assertSuccess(res: SuiTxResult, what: string): void {
+  const status = res.effects?.status?.status
+  if (status && status !== 'success') {
+    throw new Error(`${what} failed: ${res.effects?.status?.error ?? status}`)
+  }
+}
+
+/**
+ * Deploy a token end-to-end. Returns the publish result once any required
+ * finalize transaction has also confirmed.
+ */
+export async function deployToken(args: DeployArgs): Promise<PublishResult> {
+  const { config, executor, onStep } = args
+  const structName = deriveStructName(config.moduleName)
+  const normalizedConfig: TokenConfig = { ...config, structName }
+  const recipient = normalizedConfig.recipient || args.sender
+  const isE2e = import.meta.env.VITE_E2E === '1'
+
+  onStep?.('patching')
+  const moduleBytes = await patchTemplateModule({
+    moduleName: normalizedConfig.moduleName,
+    structName,
+    symbol: normalizedConfig.symbol,
+    name: normalizedConfig.name,
+    description: normalizedConfig.description,
+    iconUrl: normalizedConfig.iconUrl,
+    decimals: normalizedConfig.decimals,
+  })
+
+  onStep?.('publishing')
+  const publishTx = buildPublishTransaction({
+    moduleBytes,
+    sender: args.sender,
+    feeMist: args.feeMist,
+    feeRecipient: args.feeTreasury,
+    gasBudget: args.gasBudget,
+    packagePolicy: normalizedConfig.packagePolicy,
+  })
+  const pub = await (async () => {
+    try {
+      const result = await executor.signAndExecute(publishTx)
+      if (isE2e) console.log('[E2E Deploy]', 'Publish TX result:', result)
+      assertSuccess(result, 'Publish')
+
+      onStep?.('confirming')
+      try {
+        if (isE2e) console.log('[E2E Deploy]', 'Waiting for transaction digest:', result.digest)
+        await executor.waitForTransaction(result.digest)
+        if (isE2e) console.log('[E2E Deploy]', 'Transaction confirmed')
+      } catch (e) {
+        if (isE2e) console.error('[E2E Deploy]', 'waitForTransaction error:', e)
+        throw e
+      }
+
+      return result
+    } catch (e) {
+      if (isE2e) console.error('[E2E Deploy]', 'Publish TX error:', e)
+      throw e
+    }
+  })()
+
+  const result = extractPublishResult(pub.objectChanges ?? [], {
+    network: args.network,
+    digest: pub.digest,
+    feeRecipient: args.feeTreasury,
+    feeMist: args.feeMist,
+  })
+
+  // A successful publish must surface the package id + coin type in its object
+  // changes; if not, fail loudly rather than returning an empty result panel.
+  if (!result.packageId || !result.coinType) {
+    throw new Error(
+      'Publish succeeded but the package id / coin type could not be read from the transaction effects.',
+    )
+  }
+
+  // Build the currency receiving ref for finalize_registration (requires version + digest
+  // from the publish objectChanges, present in production Sui RPC responses).
+  const currencyChange = (pub.objectChanges ?? []).find(
+    (c) => c.type === 'created' && (c.objectType ?? '').includes('coin_registry::Currency'),
+  )
+  const currencyRef =
+    currencyChange?.objectId && currencyChange?.version && currencyChange?.digest
+      ? {
+          objectId: currencyChange.objectId,
+          version: currencyChange.version,
+          digest: currencyChange.digest,
+        }
+      : undefined
+
+  // Always finalize: the finalize PTB calls coin_registry::finalize_registration,
+  // which is required to promote the pending Currency<T> to a shared, wallet-discoverable
+  // object. Without it, suix_getCoinMetadata returns null and wallets fall back to
+  // 0 decimals, displaying raw base-unit counts instead of whole-token amounts.
+  if (!result.treasuryCapId || !result.metadataCapId) {
+    throw new Error('Published, but could not locate the TreasuryCap/MetadataCap to finalize.')
+  }
+  onStep?.('finalizing')
+  const finalizeTx = buildFinalizeTransaction({
+    config: { ...normalizedConfig, recipient },
+    coinType: result.coinType,
+    treasuryCapId: result.treasuryCapId,
+    metadataCapId: result.metadataCapId,
+    currencyRef,
+    sender: args.sender,
+    gasBudget: args.gasBudget,
+  })
+  const fin = await executor.signAndExecute(finalizeTx)
+  assertSuccess(fin, 'Finalize')
+  onStep?.('confirming-finalize')
+  await executor.waitForTransaction(fin.digest)
+
+  onStep?.('done')
+  return result
+}

package/src/lib/deployExecutor.ts

@@ -0,0 +1,61 @@
+// Builds a deploy Executor using the wallet-adapter's shared signing capability
+// + SuiClient for execution (returns objectChanges 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.
+
+import { SuiJsonRpcClient } from '@mysten/sui/jsonRpc'
+import { useWallet } from '@meddleware/wallet-adapter'
+import type { Transaction } from '@mysten/sui/transactions'
+import type { SuiTxResult, Executor } from './deploy.js'
+import type { Network } from './types.js'
+import { RPC_URLS } from '../config.js'
+
+/**
+ * Build a deploy Executor bound to the currently connected wallet (via the
+ * wallet-adapter singleton) and the given network's RPC URL.
+ *
+ * The returned executor signs via `sui:signTransaction` and executes via
+ * `SuiClient.executeTransactionBlock` with `showEffects + showObjectChanges`
+ * so the caller can extract the published package ID, coin type, TreasuryCap, etc.
+ */
+export async function buildDeployExecutor(network: Network): Promise<Executor> {
+  const { currentWallet, account } = useWallet()
+  const wallet = currentWallet.value
+  const acct = account.value
+  if (!wallet || !acct) throw new Error('Connect a wallet first.')
+
+  const suiClient = new SuiJsonRpcClient({ url: RPC_URLS[network], network })
+  const chain = `sui:${network}` as const
+
+  const signFeature = wallet.features['sui:signTransaction'] as
+    | {
+        signTransaction: (input: {
+          transaction: Transaction
+          account: typeof acct
+          chain: `sui:${string}`
+        }) => Promise<{ bytes: string; signature: string }>
+      }
+    | undefined
+  if (!signFeature) throw new Error('This wallet cannot sign transactions.')
+
+  return {
+    async signAndExecute(tx: Transaction): Promise<SuiTxResult> {
+      const { bytes, signature } = await signFeature.signTransaction({
+        transaction: tx,
+        account: acct,
+        chain,
+      })
+      const res = await suiClient.executeTransactionBlock({
+        transactionBlock: bytes,
+        signature,
+        options: { showEffects: true, showObjectChanges: true },
+      })
+      return res as unknown as SuiTxResult
+    },
+    async waitForTransaction(digest: string): Promise<void> {
+      await suiClient.waitForTransaction({ digest })
+    },
+  }
+}

package/src/lib/errors.ts

@@ -0,0 +1,21 @@
+/**
+ * Extract a human-readable message from an unknown thrown value.
+ *
+ * Wallet SDKs sometimes throw plain objects (e.g. `{ code: 4001, message: "…" }`)
+ * rather than Error instances. This handles those alongside real Error objects,
+ * nested `cause` fields, and arbitrary fallback via String().
+ */
+export function extractErrorMessage(e: unknown): string {
+  if (typeof e === 'string') return e
+  if (e instanceof Error) {
+    // Some wallet errors wrap the real message in a cause
+    if (!e.message && e.cause != null) return extractErrorMessage(e.cause)
+    return e.message || e.toString()
+  }
+  if (typeof e === 'object' && e !== null) {
+    const obj = e as Record<string, unknown>
+    if (typeof obj.message === 'string' && obj.message) return obj.message
+    if (obj.cause != null) return extractErrorMessage(obj.cause)
+  }
+  return String(e)
+}

package/src/lib/form.ts

@@ -0,0 +1,75 @@
+// The reactive form model (all text inputs are strings) and its conversion into
+// the strongly-typed TokenConfig used by the deploy + generate pipelines.
+
+import type { MetadataPolicy, PackagePolicy, SupplyPolicy, TokenConfig } from './types.js'
+import { deriveStructName, parseSupply } from './validation.js'
+import { DEFAULT_LICENSE_ID } from './licenses.js'
+
+/**
+ * The reactive form state. Every field is a string (as bound to inputs); it is
+ * converted to the strongly-typed {@link TokenConfig} by {@link toTokenConfig}.
+ */
+export interface FormModel {
+  packageName: string
+  moduleName: string
+  symbol: string
+  name: string
+  description: string
+  iconUrl: string
+  decimals: string
+  initialSupply: string
+  supplyPolicy: SupplyPolicy
+  metadataPolicy: MetadataPolicy
+  packagePolicy: PackagePolicy
+  recipient: string
+  license: string
+  licenseName: string
+  packageDescription: string
+  projectName: string
+}
+
+/** A blank form with the recommended safe defaults pre-selected. */
+export function emptyForm(): FormModel {
+  return {
+    packageName: '',
+    moduleName: '',
+    symbol: '',
+    name: '',
+    description: '',
+    iconUrl: '',
+    decimals: '9',
+    initialSupply: '',
+    supplyPolicy: 'mintable',
+    metadataPolicy: 'updatable',
+    packagePolicy: 'immutable',
+    recipient: '',
+    license: DEFAULT_LICENSE_ID,
+    licenseName: '',
+    packageDescription: '',
+    projectName: '',
+  }
+}
+
+/** Convert the form into a TokenConfig. `recipient` empty means the connected wallet. */
+export function toTokenConfig(form: FormModel): TokenConfig {
+  const structName = deriveStructName(form.moduleName)
+  return {
+    packageName: form.packageName.trim(),
+    moduleName: form.moduleName.trim(),
+    structName,
+    symbol: form.symbol.trim(),
+    name: form.name.trim(),
+    description: form.description.trim(),
+    iconUrl: form.iconUrl.trim(),
+    decimals: Number(form.decimals),
+    initialSupply: parseSupply(form.initialSupply) ?? 0n,
+    supplyPolicy: form.supplyPolicy,
+    metadataPolicy: form.metadataPolicy,
+    packagePolicy: form.packagePolicy,
+    recipient: form.recipient.trim(),
+    license: form.license,
+    licenseName: form.licenseName || form.license,
+    packageDescription: form.packageDescription.trim() || `Official ${form.symbol} token.`,
+    projectName: form.projectName.trim() || form.name,
+  }
+}