@meddleware/token-deployer-ui 0.0.16 → 0.0.18

package/src/lib/generatePackage.ts

@@ -1,317 +0,0 @@
-// Client-side generator for the downloadable source package. Mirrors the CLI
-// generator (blockchain/sui/sui-token-template/scripts/03_create_token.sh) so the
-// zip a user downloads matches what the CLI would produce (and the on-chain
-// bytecode). Template text is synced verbatim via scripts/sync-template-src.sh.
-//
-// Published.toml: since Sui v1.63, the CLI writes deployed addresses to Published.toml
-// (not Move.lock). Because the deployer bypasses the CLI, we generate it when a
-// PublishResult is available so the downloaded package is immediately usable as a
-// dependency reference without requiring the user to reconstruct the file manually.
-
-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'
-
-const files = templateFiles as Record<string, string>
-
-/** License identifiers may only contain SPDX-safe characters. */
-const LICENSE_ID = /^[A-Za-z0-9.\-+]*$/
-
-/**
- * Defence in depth: re-assert the invariants the form validator enforces before
- * substituting any user value into Move source or the publish shell script. A
- * value that fails here (e.g. a newline or quote that could break out of a Move
- * `b"..."` literal) throws rather than producing a malformed/injectable package,
- * so the generator is safe even if called with an unvalidated config.
- */
-function assertSafeConfig(cfg: TokenConfig): void {
-  const idFields: Array<[string, string]> = [
-    ['package name', cfg.packageName],
-    ['module name', cfg.moduleName],
-  ]
-  for (const [label, value] of idFields) {
-    const err = validateIdentifier(value)
-    if (err) throw new Error(`Invalid ${label}: ${err}`)
-  }
-  if (cfg.structName !== deriveStructName(cfg.moduleName)) {
-    throw new Error('Invalid struct name: must be the module name uppercased.')
-  }
-  const textFields: Array<[string, string]> = [
-    ['symbol', cfg.symbol],
-    ['name', cfg.name],
-    ['description', cfg.description],
-    ['icon URL', cfg.iconUrl],
-  ]
-  for (const [label, value] of textFields) {
-    if (!SAFE_TEXT.test(value)) {
-      throw new Error(`Invalid ${label}: contains quotes, backslashes or control characters.`)
-    }
-  }
-  // Re-assert the icon-URL scheme allowlist here too (layered defence, independent of the
-  // form): a non-empty icon URL must use https:// or ipfs:// before it is baked into metadata.
-  if (cfg.iconUrl && !hasAllowedIconScheme(cfg.iconUrl)) {
-    throw new Error('Invalid icon URL: only https:// or ipfs:// URLs are allowed.')
-  }
-  if (!Number.isInteger(cfg.decimals) || cfg.decimals < 0 || cfg.decimals > 18) {
-    throw new Error('Invalid decimals: expected a whole number between 0 and 18.')
-  }
-  if (!LICENSE_ID.test(cfg.license)) {
-    throw new Error('Invalid license identifier.')
-  }
-}
-
-/** Escape a string for safe use as a literal RegExp. */
-function esc(s: string): string {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-}
-
-/** Replace every occurrence of a plain-string needle. */
-function replaceAll(input: string, needle: string, value: string): string {
-  return input.replace(new RegExp(esc(needle), 'g'), () => value)
-}
-
-/** Apply the shared X…X documentation placeholders. */
-function applyDocPlaceholders(input: string, cfg: TokenConfig): string {
-  const map: Record<string, string> = {
-    XPACKAGENAMEX: cfg.packageName,
-    XMODULENAMEX: cfg.moduleName,
-    XSTRUCTNAMEX: cfg.structName,
-    XSYMBOLX: cfg.symbol,
-    XNAMEX: cfg.name,
-    XDESCRIPTIONX: cfg.description,
-    XDECIMALSX: String(cfg.decimals),
-    XPROJECTNAMEX: cfg.projectName,
-    XPACKAGEDESCRIPTIONX: cfg.packageDescription,
-  }
-  let out = input
-  for (const [k, v] of Object.entries(map)) out = replaceAll(out, k, v)
-  return out
-}
-
-// Chain IDs for the two production networks (hex short form).
-const CHAIN_IDS: Record<string, string> = {
-  testnet: '4c78adac',
-  mainnet: '35834a8a',
-}
-
-// Sui CLI version that compiled the shipped template bytecode. Keep in sync
-// with TEMPLATE_MODULE_B64 in src/move-template/template.ts; updated by regen-template.sh.
-const TEMPLATE_TOOLCHAIN_VERSION = '1.76.1'
-
-const isProprietary = (license: string) =>
-  ['none', 'unlicensed', 'noassertion', ''].includes(license.trim().toLowerCase())
-
-function spdxId(license: string): string {
-  return isProprietary(license) ? 'UNLICENSED' : license.trim()
-}
-
-/** Move.toml: package name + license field. */
-function renderMoveToml(cfg: TokenConfig): string {
-  let out = replaceAll(files['Move.toml'], 'sui_token_template', cfg.packageName)
-  out = out.replace(/^license = .*$/m, `license = "${spdxId(cfg.license)}"`)
-  return out
-}
-
-/** The Move source: identifiers, named constants, and the license header. */
-function renderSource(cfg: TokenConfig): string {
-  let out = files['source.move']
-
-  // 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 {
-    lines[0] = `// SPDX-License-Identifier: ${spdxId(cfg.license)}`
-    lines[1] = `// Licensed under the ${spdxId(cfg.license)} license; see the LICENSE file.`
-  }
-  out = lines.join('\n')
-
-  out = replaceAll(
-    out,
-    'module sui_token_template::sui_token_template;',
-    `module ${cfg.packageName}::${cfg.moduleName};`,
-  )
-  out = replaceAll(out, 'SUI_TOKEN_TEMPLATE', cfg.structName)
-  out = replaceAll(out, 'XPACKAGEDESCRIPTIONX', cfg.packageDescription)
-  out = replaceAll(out, 'XMODULENAMEX', cfg.moduleName)
-
-  out = replaceAll(out, 'const DECIMALS: u8 = 9;', `const DECIMALS: u8 = ${cfg.decimals};`)
-  out = replaceAll(out, 'b"TEMPLATE_SYMBOL"', `b"${cfg.symbol}"`)
-  out = replaceAll(out, 'b"TEMPLATE_NAME"', `b"${cfg.name}"`)
-  out = replaceAll(out, 'b"TEMPLATE_DESCRIPTION"', `b"${cfg.description}"`)
-  out = replaceAll(out, 'b"TEMPLATE_ICON_URL"', `b"${cfg.iconUrl}"`)
-  return out
-}
-
-function renderPublishScript(cfg: TokenConfig): string {
-  let out = replaceAll(files['scripts/publish.sh'], 'SUI_TOKEN_TEMPLATE', cfg.structName)
-  out = replaceAll(out, 'XMODULENAMEX', cfg.moduleName)
-  out = replaceAll(out, 'XPACKAGENAMEX', cfg.packageName)
-  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 {
-  const out = applyDocPlaceholders(files['README.md'], cfg)
-  const licenseName = cfg.licenseName || spdxId(cfg.license)
-  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.`,
-  )
-}
-
-/**
- * Replace a single table row in a markdown section in-place.
- * Matches: `| <fieldName> | \`FILL_IN_AFTER_DEPLOY\` |`
- */
-function fillRow(section: string, fieldName: string, value: string): string {
-  return section.replace(
-    `| ${fieldName} | \`FILL_IN_AFTER_DEPLOY\` |`,
-    `| ${fieldName} | \`${value}\` |`,
-  )
-}
-
-/**
- * Fill the deployment table rows for the specified network section only.
- * Operates on the substring between the section header and the next `## ` heading.
- */
-function fillNetworkSection(doc: string, network: string, result: PublishResult): string {
-  const header = `## ${network.charAt(0).toUpperCase() + network.slice(1)}\n`
-  const start = doc.indexOf(header)
-  if (start === -1) return doc
-  const afterHeader = start + header.length
-  const nextSection = doc.indexOf('\n## ', afterHeader)
-  const end = nextSection === -1 ? doc.length : nextSection
-
-  let section = doc.slice(start, end)
-
-  section = fillRow(section, 'Package ID', result.packageId)
-  if (result.treasuryCapId) section = fillRow(section, 'TreasuryCap ID', result.treasuryCapId)
-  if (result.metadataCapId) section = fillRow(section, 'MetadataCap ID', result.metadataCapId)
-  if (result.currencyId) section = fillRow(section, 'Currency object ID', result.currencyId)
-
-  if (result.upgradeCapId) {
-    section = fillRow(section, 'UpgradeCap ID (burned)', result.upgradeCapId)
-    section = section.replace(
-      '| Immutability confirmed | Yes (Y/N) |',
-      '| Immutability confirmed | No (pending) |',
-    )
-  } else {
-    section = fillRow(section, 'UpgradeCap ID (burned)', 'burned')
-    section = section.replace(
-      '| Immutability confirmed | Yes (Y/N) |',
-      '| Immutability confirmed | Yes |',
-    )
-  }
-
-  const deployed = new Date().toISOString().replace('T', ' ').split('.')[0] + ' UTC'
-  section = fillRow(section, 'Deployed', deployed)
-
-  return doc.slice(0, start) + section + doc.slice(end)
-}
-
-/** Optionally fill deployments.md with the just-published IDs. */
-function renderDeployments(cfg: TokenConfig, result?: PublishResult): string {
-  let out = applyDocPlaceholders(files['deployments.md'], cfg)
-  if (!result) return out
-
-  // Fill the network-specific table section with known artefact IDs
-  out = fillNetworkSection(out, result.network, result)
-
-  // Fill the <PACKAGE_ID> placeholder in the downstream Move.toml reference block
-  out = out.replace(/<PACKAGE_ID>/g, result.packageId)
-
-  // Append extra data not represented in the table (coin type, digest)
-  const note = [
-    '',
-    `<!-- Auto-filled by the Token Deployer on ${new Date().toISOString()} (${result.network}) -->`,
-    `<!-- Coin type: ${result.coinType} -->`,
-    `<!-- Publish digest: ${result.digest} -->`,
-    '',
-  ].join('\n')
-  return `${out.trimEnd()}\n${note}`
-}
-
-/**
- * Generate a Published.toml for the deployed package.
- * Since v1.63, the Sui CLI writes Published.toml (not Move.lock) to record deployed
- * addresses per environment. The deployer bypasses the CLI, so we produce this file
- * so the downloaded package is immediately usable as a Move dependency reference.
- * Commit Published.toml to source control; add Pub.*.toml (ephemeral) to .gitignore.
- */
-function renderPublishedToml(result: PublishResult): string {
-  const env = result.network === 'mainnet' ? 'mainnet' : 'testnet'
-  const chainId = CHAIN_IDS[env] ?? ''
-  const lines = [
-    `[published.${env}]`,
-    `chain-id = "${chainId}"`,
-    `original-id = "${result.packageId}"`,
-    `published-at = "${result.packageId}"`,
-    `version = 1`,
-    `toolchain-version = "${TEMPLATE_TOOLCHAIN_VERSION}"`,
-    `build-config = { flavor = "sui", edition = "2024" }`,
-  ]
-  if (result.upgradeCapId) {
-    lines.push(`upgrade-capability = "${result.upgradeCapId}"`)
-  } else {
-    lines.push(
-      `# upgrade-capability burned via 0x2::package::make_immutable — package is immutable`,
-    )
-  }
-  return lines.join('\n') + '\n'
-}
-
-export interface GeneratePackageOptions {
-  config: TokenConfig
-  /** Full license text; when omitted for a real license, no LICENSE file is written. */
-  licenseText?: string
-  /** Publish result, to pre-fill deployments.md. */
-  result?: PublishResult
-}
-
-/** Build the in-memory file map for the generated package. */
-export function buildPackageFiles(opts: GeneratePackageOptions): Record<string, string> {
-  const { config, licenseText } = opts
-  assertSafeConfig(config)
-  const out: Record<string, string> = {
-    'Move.toml': renderMoveToml(config),
-    [`sources/${config.moduleName}.move`]: renderSource(config),
-    'scripts/publish.sh': renderPublishScript(config),
-    '.gitignore': files['.gitignore'],
-    'README.md': renderReadme(config),
-    'deployments.md': renderDeployments(config, opts.result),
-    'CLAUDE.md': applyDocPlaceholders(files['CLAUDE.md'], config),
-    'AGENTS.md': applyDocPlaceholders(files['AGENTS.md'], config),
-  }
-  if (opts.result) {
-    // Published.toml records the deployed address per environment (Sui v1.63+ convention).
-    // Commit this file to source control; add Pub.*.toml (ephemeral) to .gitignore.
-    out['Published.toml'] = renderPublishedToml(opts.result)
-  }
-  if (!isProprietary(config.license) && licenseText) {
-    out['LICENSE'] = licenseText
-  }
-  return out
-}
-
-/** Zip the generated package. Returns bytes suitable for a download Blob. */
-export function generatePackageZip(opts: GeneratePackageOptions): Uint8Array {
-  const filesMap = buildPackageFiles(opts)
-  const zipInput: Record<string, Uint8Array> = {}
-  const root = opts.config.packageName
-  for (const [path, content] of Object.entries(filesMap)) {
-    zipInput[`${root}/${path}`] = strToU8(content)
-  }
-  return zipSync(zipInput, { level: 6 })
-}

package/src/lib/listMyTokens.ts

@@ -1,41 +0,0 @@
-// 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,25 +0,0 @@
-// 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, SuiGrpcClient>()
-
-/** Return a memoised {@link SuiGrpcClient} for the given network. */
-export function getReadClient(network: Network): SuiGrpcClient {
-  let c = clients.get(network)
-  if (!c) {
-    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/template.ts

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

package/src/lib/types.ts

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

package/src/move-template/template.ts

@@ -1,31 +0,0 @@
-// AUTO-GENERATED ARTIFACT — do not edit by hand.
-//
-// Base64 of the compiled `sui_token_template` Move module (binary format v7),
-// produced by `sui move build --build-env testnet` from
-// blockchain/sui/sui-token-template. Regenerate with scripts/regen-template.sh
-// whenever the canonical template source changes (see move-template/README.md).
-//
-// The DEFAULT_* values below are the constant-pool defaults compiled into the
-// module. The deployer patches the module by matching these exact defaults and
-// replacing them (see lib/template.ts). They are DISTINCT on purpose: identical
-// Move constants deduplicate into a single unpatchable pool entry.
-
-export const TEMPLATE_MODULE_B64 =
-  'oRzrCwcAAAUKAQAMAgweAyohBEsIBVNaB60B3QEIigNgBuoDVAq+BAUMwwQ6AA8BDgIGAgcCEAIRAAICAAEDBwACBAwBAAEDAAABAAEDAQwBAAEFBQIAAAoAAQABEgMEAAMJCAkBAAMLBgcBAgQMDQEBDAUNCgsAAwUCBQQMBA4CCAAHCAUAAgsEAQgACwIBCAABCgIBCAEBCAAHCQACCAEIAQgBCAEHCAUCCwMBCQALAgEJAAILAwEJAAcIBQELBAEJAAEGCAUBBQELAgEIAAIJAAUBCwQBCAATQ3VycmVuY3lJbml0aWFsaXplcgtNZXRhZGF0YUNhcBJTVUlfVE9LRU5fVEVNUExBVEUGU3RyaW5nC1RyZWFzdXJ5Q2FwCVR4Q29udGV4dARjb2luDWNvaW5fcmVnaXN0cnkLZHVtbXlfZmllbGQIZmluYWxpemUEaW5pdBVuZXdfY3VycmVuY3lfd2l0aF9vdHcPcHVibGljX3RyYW5zZmVyBnNlbmRlcgZzdHJpbmcSc3VpX3Rva2VuX3RlbXBsYXRlCHRyYW5zZmVyCnR4X2NvbnRleHQEdXRmOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIBCQoCEA9URU1QTEFURV9TWU1CT0wKAg4NVEVNUExBVEVfTkFNRQoCFRRURU1QTEFURV9ERVNDUklQVElPTgoCEhFURU1QTEFURV9JQ09OX1VSTAACAQgBAAAAAAIbCwAHAAcBEQEHAhEBBwMRAQcEEQEKATgADAMKATgBDAILAwoBLhEFOAILAgsBLhEFOAMCAAA='
-
-/** Identifiers compiled into the template module (renamed at patch time). */
-export const TEMPLATE_IDENTIFIERS = {
-  /** module identifier (lowercase) */
-  module: 'sui_token_template',
-  /** one-time-witness struct identifier (uppercase) */
-  struct: 'SUI_TOKEN_TEMPLATE',
-} as const
-
-/** Distinct constant-pool defaults the deployer patches away from. */
-export const TEMPLATE_DEFAULTS = {
-  decimals: 9,
-  symbol: 'TEMPLATE_SYMBOL',
-  name: 'TEMPLATE_NAME',
-  description: 'TEMPLATE_DESCRIPTION',
-  iconUrl: 'TEMPLATE_ICON_URL',
-} as const