@meddleware/token-deployer-ui 0.0.16 → 0.0.17

package/src/lib/buildPublishTx.ts

@@ -1,182 +0,0 @@
-// 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
-}
-
-/**
- * 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

@@ -1,210 +0,0 @@
-// 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 type { SuiClientTypes } from '@mysten/sui/client'
-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 } }
-}
-
-/** 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>
-  /** 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
-}
-
-/**
- * Only an explicit `success` effects status counts: a missing status (an executor that did not
- * return effects) is treated as failure, never as success.
- */
-function assertSuccess(res: SuiTxResult, what: string): void {
-  const status = res.effects?.status?.status
-  if (status !== 'success') {
-    throw new Error(
-      `${what} failed: ${res.effects?.status?.error ?? status ?? 'no effects status returned'}`,
-    )
-  }
-}
-
-/**
- * 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.MODE === 'e2e' && 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
-}