@meddleware/token-deployer-ui 0.0.1

package/tests/buildPublishTx.test.ts

@@ -0,0 +1,243 @@
+import { describe, it, expect } from 'vitest'
+import type { Transaction } from '@mysten/sui/transactions'
+import { fromBase64 } from '@mysten/sui/utils'
+import {
+  buildPublishTransaction,
+  buildFinalizeTransaction,
+  needsFinalize,
+  extractPublishResult,
+} from '../src/lib/buildPublishTx.js'
+import type { TokenConfig } from '../src/lib/types.js'
+
+const sender = '0x' + '1'.repeat(64)
+const recipient = '0x' + '2'.repeat(64)
+const coinType = '0xPKG::mytoken::MYTOKEN'
+
+// ─── introspection helpers over Transaction.getData() ─────────────────────────
+
+type Cmd = ReturnType<Transaction['getData']>['commands'][number]
+
+function commands(tx: Transaction): Cmd[] {
+  return tx.getData().commands
+}
+
+function byKind(tx: Transaction, kind: string): Cmd[] {
+  return commands(tx).filter((c) => c.$kind === kind)
+}
+
+/** Resolve an `{ Input: n }` argument to its decoded Pure bytes. */
+function pureBytesOfInput(tx: Transaction, arg: unknown): Uint8Array {
+  const idx = (arg as { $kind: string; Input: number }).Input
+  const input = tx.getData().inputs[idx] as { $kind: string; Pure?: { bytes: string } }
+  if (input.$kind !== 'Pure' || !input.Pure) throw new Error('expected a Pure input')
+  return fromBase64(input.Pure.bytes)
+}
+
+function pureAddr(bytes: Uint8Array): string {
+  return '0x' + Array.from(bytes).map((b) => b.toString(16).padStart(2, '0')).join('')
+}
+
+function pureU64(bytes: Uint8Array): bigint {
+  return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getBigUint64(0, true)
+}
+
+function baseConfig(over: Partial<TokenConfig> = {}): TokenConfig {
+  return {
+    packageName: 'my_token', moduleName: 'mytoken', structName: 'MYTOKEN',
+    symbol: 'MTK', name: 'My Token', description: 'desc', iconUrl: '', decimals: 9,
+    initialSupply: 0n, supplyPolicy: 'mintable', metadataPolicy: 'updatable',
+    packagePolicy: 'immutable', recipient: sender, license: 'MIT',
+    packageDescription: '', projectName: '',
+    ...over,
+  }
+}
+
+const publishArgs = (over: Partial<Parameters<typeof buildPublishTransaction>[0]> = {}) => ({
+  moduleBytes: new Uint8Array([1, 2, 3]),
+  sender,
+  feeMist: 1_000_000_000n,
+  feeRecipient: recipient,
+  gasBudget: 500_000_000n,
+  packagePolicy: 'immutable' as const,
+  ...over,
+})
+
+// ─── buildPublishTransaction ──────────────────────────────────────────────────
+
+describe('buildPublishTransaction', () => {
+  it('publishes the module and sets sender + gas budget', () => {
+    const tx = buildPublishTransaction(publishArgs())
+    const publish = byKind(tx, 'Publish')
+    expect(publish).toHaveLength(1)
+    expect(tx.getData().sender).toBe(sender)
+    expect(tx.getData().gasData.budget).toBe('500000000')
+  })
+
+  it('splits EXACTLY the fee from the gas coin to the configured treasury', () => {
+    const tx = buildPublishTransaction(publishArgs({ feeMist: 1_000_000_000n }))
+    const [split] = byKind(tx, 'SplitCoins') as Array<Cmd & { SplitCoins: any }>
+    expect(split).toBeDefined()
+    // must split from the gas coin, not an arbitrary coin
+    expect(split.SplitCoins.coin.$kind).toBe('GasCoin')
+    expect(pureU64(pureBytesOfInput(tx, split.SplitCoins.amounts[0]))).toBe(1_000_000_000n)
+
+    const [transfer] = byKind(tx, 'TransferObjects') as Array<Cmd & { TransferObjects: any }>
+    expect(pureAddr(pureBytesOfInput(tx, transfer.TransferObjects.address))).toBe(recipient)
+  })
+
+  it('omits the fee split entirely when feeMist is 0', () => {
+    const tx = buildPublishTransaction(publishArgs({ feeMist: 0n }))
+    expect(byKind(tx, 'SplitCoins')).toHaveLength(0)
+  })
+
+  it('makes the package immutable under the immutable policy', () => {
+    const tx = buildPublishTransaction(publishArgs({ packagePolicy: 'immutable' }))
+    const calls = byKind(tx, 'MoveCall') as Array<Cmd & { MoveCall: any }>
+    expect(calls.some((c) => c.MoveCall.function === 'make_immutable')).toBe(true)
+  })
+
+  it('transfers the UpgradeCap to the sender under the upgradeable policy', () => {
+    const tx = buildPublishTransaction(publishArgs({ packagePolicy: 'upgradeable', feeMist: 0n }))
+    expect(byKind(tx, 'MoveCall')).toHaveLength(0)
+    const [transfer] = byKind(tx, 'TransferObjects') as Array<Cmd & { TransferObjects: any }>
+    // the only transfer is the UpgradeCap -> sender (no fee split here)
+    expect(pureAddr(pureBytesOfInput(tx, transfer.TransferObjects.address))).toBe(sender)
+  })
+})
+
+// ─── buildFinalizeTransaction ─────────────────────────────────────────────────
+
+const treasuryCapId = '0x' + 'a'.repeat(64)
+const metadataCapId = '0x' + 'b'.repeat(64)
+const currencyRef = { objectId: '0x' + 'c'.repeat(64), version: '1', digest: 'CURRENCYDIGEST' }
+
+const finalizeArgs = (config: TokenConfig) => ({
+  config,
+  coinType,
+  treasuryCapId,
+  metadataCapId,
+  currencyRef,
+  sender,
+  gasBudget: 500_000_000n,
+})
+
+describe('buildFinalizeTransaction', () => {
+  it('calls finalize_registration first when currencyRef is provided', () => {
+    const tx = buildFinalizeTransaction(finalizeArgs(baseConfig()))
+    const calls = byKind(tx, 'MoveCall') as Array<Cmd & { MoveCall: any }>
+    // finalize_registration is the first MoveCall in the PTB
+    expect(calls[0]?.MoveCall?.function).toBe('finalize_registration')
+    expect(calls[0]?.MoveCall?.typeArguments).toEqual([coinType])
+  })
+
+  it('omits finalize_registration when currencyRef is absent', () => {
+    const { currencyRef: _cr, ...argsNoCurrency } = finalizeArgs(baseConfig())
+    const tx = buildFinalizeTransaction(argsNoCurrency)
+    const calls = byKind(tx, 'MoveCall') as Array<Cmd & { MoveCall: any }>
+    expect(calls.every((c) => c.MoveCall.function !== 'finalize_registration')).toBe(true)
+  })
+
+  it('mints supply scaled by decimals to the recipient', () => {
+    const tx = buildFinalizeTransaction(finalizeArgs(baseConfig({ initialSupply: 1000n, decimals: 6 })))
+    const mint = (byKind(tx, 'MoveCall') as Array<Cmd & { MoveCall: any }>).find(
+      (c) => c.MoveCall.function === 'mint',
+    )
+    expect(mint).toBeDefined()
+    expect(mint!.MoveCall.typeArguments).toEqual([coinType])
+    // 1000 * 10^6
+    expect(pureU64(pureBytesOfInput(tx, mint!.MoveCall.arguments[1]))).toBe(1_000_000_000n)
+  })
+
+  it('freezes the TreasuryCap under the fixed supply policy', () => {
+    const tx = buildFinalizeTransaction(finalizeArgs(baseConfig({ supplyPolicy: 'fixed' })))
+    const freeze = (byKind(tx, 'MoveCall') as Array<Cmd & { MoveCall: any }>).filter(
+      (c) => c.MoveCall.function === 'public_freeze_object',
+    )
+    expect(freeze.some((c) => c.MoveCall.typeArguments[0].includes('coin::TreasuryCap'))).toBe(true)
+  })
+
+  it('freezes the MetadataCap under the frozen metadata policy', () => {
+    const tx = buildFinalizeTransaction(finalizeArgs(baseConfig({ metadataPolicy: 'frozen' })))
+    const freeze = (byKind(tx, 'MoveCall') as Array<Cmd & { MoveCall: any }>).filter(
+      (c) => c.MoveCall.function === 'public_freeze_object',
+    )
+    expect(freeze.some((c) => c.MoveCall.typeArguments[0].includes('coin_registry::MetadataCap'))).toBe(true)
+  })
+
+  it('routes both caps to a different recipient when supply/metadata stay open', () => {
+    const tx = buildFinalizeTransaction(finalizeArgs(baseConfig({ recipient })))
+    const transfers = byKind(tx, 'TransferObjects') as Array<Cmd & { TransferObjects: any }>
+    // TreasuryCap + MetadataCap both go to the recipient (no mint here)
+    expect(transfers).toHaveLength(2)
+    for (const t of transfers) {
+      expect(pureAddr(pureBytesOfInput(tx, t.TransferObjects.address))).toBe(recipient)
+    }
+  })
+
+  it('does not freeze when policies are open and recipient is the sender', () => {
+    const tx = buildFinalizeTransaction(finalizeArgs(baseConfig({ initialSupply: 5n })))
+    const freeze = (byKind(tx, 'MoveCall') as Array<Cmd & { MoveCall: any }>).filter(
+      (c) => c.MoveCall.function === 'public_freeze_object',
+    )
+    expect(freeze).toHaveLength(0)
+  })
+})
+
+// ─── needsFinalize ────────────────────────────────────────────────────────────
+
+describe('needsFinalize', () => {
+  it('is false for the pure-default config (publish-only)', () => {
+    expect(needsFinalize(baseConfig(), sender)).toBe(false)
+  })
+
+  it('is true when any policy/supply/recipient differs from the default', () => {
+    expect(needsFinalize(baseConfig({ initialSupply: 1n }), sender)).toBe(true)
+    expect(needsFinalize(baseConfig({ supplyPolicy: 'fixed' }), sender)).toBe(true)
+    expect(needsFinalize(baseConfig({ metadataPolicy: 'frozen' }), sender)).toBe(true)
+    expect(needsFinalize(baseConfig({ recipient }), sender)).toBe(true)
+  })
+
+  it('treats recipient case-insensitively', () => {
+    expect(needsFinalize(baseConfig({ recipient: sender.toUpperCase() }), sender)).toBe(false)
+  })
+})
+
+// ─── extractPublishResult ─────────────────────────────────────────────────────
+
+describe('extractPublishResult', () => {
+  const changes = [
+    { type: 'published', packageId: '0xPKG' },
+    { type: 'created', objectType: `0x2::coin::TreasuryCap<${coinType}>`, objectId: '0xT' },
+    { type: 'created', objectType: `0x2::coin_registry::MetadataCap<${coinType}>`, objectId: '0xM' },
+    { type: 'created', objectType: `0x2::coin_registry::Currency<${coinType}>`, objectId: '0xC', version: '7', digest: 'CDIG' },
+    { type: 'created', objectType: `0x2::package::UpgradeCap`, objectId: '0xU' },
+  ]
+
+  it('extracts package id, coin type, all cap ids, and currency version/digest', () => {
+    const r = extractPublishResult(changes, {
+      network: 'testnet', digest: '0xD', feeRecipient: recipient, feeMist: 1_000_000_000n,
+    })
+    expect(r.packageId).toBe('0xPKG')
+    expect(r.coinType).toBe(coinType)
+    expect(r.treasuryCapId).toBe('0xT')
+    expect(r.metadataCapId).toBe('0xM')
+    expect(r.currencyId).toBe('0xC')
+    expect(r.currencyVersion).toBe('7')
+    expect(r.currencyDigest).toBe('CDIG')
+    expect(r.upgradeCapId).toBe('0xU')
+    expect(r.feeRecipient).toBe(recipient)
+    expect(r.feeMist).toBe('1000000000')
+  })
+
+  it('leaves the upgrade cap undefined for an immutable publish', () => {
+    const immutable = changes.filter((c) => !(c.objectType ?? '').includes('UpgradeCap'))
+    const r = extractPublishResult(immutable, {
+      network: 'mainnet', digest: '0xD', feeRecipient: recipient, feeMist: 0n,
+    })
+    expect(r.upgradeCapId).toBeUndefined()
+    expect(r.coinType).toBe(coinType)
+    // currency ref still extracted
+    expect(r.currencyVersion).toBe('7')
+    expect(r.currencyDigest).toBe('CDIG')
+  })
+})

package/tests/deploy.test.ts

@@ -0,0 +1,81 @@
+import { describe, it, expect, vi } from 'vitest'
+import { deployToken } from '../src/lib/deploy.js'
+import type { Executor, SuiTxResult } from '../src/lib/deploy.js'
+import type { TokenConfig } from '../src/lib/types.js'
+
+const sender = '0x' + '1'.repeat(64)
+const treasury = '0x' + '2'.repeat(64)
+
+function baseConfig(over: Partial<TokenConfig> = {}): TokenConfig {
+  return {
+    packageName: 'my_token', moduleName: 'mytoken', structName: 'IGNORED',
+    symbol: 'MTK', name: 'My Token', description: 'desc', iconUrl: '', decimals: 9,
+    initialSupply: 0n, supplyPolicy: 'mintable', metadataPolicy: 'updatable', packagePolicy: 'immutable',
+    recipient: sender, license: 'MIT', packageDescription: '', projectName: '',
+    ...over,
+  }
+}
+
+const publishChanges = (coinType: string): SuiTxResult['objectChanges'] => [
+  { type: 'published', packageId: '0xPKG' },
+  { type: 'created', objectType: `0x2::coin::TreasuryCap<${coinType}>`, objectId: '0xT' },
+  { type: 'created', objectType: `0x2::coin_registry::MetadataCap<${coinType}>`, objectId: '0xM' },
+  // version + digest are present in real Sui RPC responses and required for finalize_registration
+  { type: 'created', objectType: `0x2::coin_registry::Currency<${coinType}>`, objectId: '0xC', version: '1', digest: 'CURRENCYDIGEST' },
+]
+
+function mockExecutor(overrides: Partial<Executor> = {}): Executor {
+  const coinType = '0xPKG::mytoken::MYTOKEN'
+  return {
+    signAndExecute: vi.fn<any>(async () => ({
+      digest: '0xDIGEST',
+      objectChanges: publishChanges(coinType),
+      effects: { status: { status: 'success' } },
+    })) as any,
+    waitForTransaction: vi.fn<any>(async () => {}) as any,
+    ...overrides,
+  } as any
+}
+
+describe('deployToken', () => {
+  it('always runs a finalize tx (for coin_registry::finalize_registration); struct name is derived', async () => {
+    const exec = mockExecutor()
+    const steps: string[] = []
+    const result = await deployToken({
+      config: baseConfig(), network: 'testnet', sender, feeMist: 500_000_000n, feeTreasury: treasury,
+      gasBudget: 500_000_000n, executor: exec, onStep: (s) => steps.push(s),
+    })
+    expect(result.coinType).toBe('0xPKG::mytoken::MYTOKEN')
+    expect(result.packageId).toBe('0xPKG')
+    expect(result.treasuryCapId).toBe('0xT')
+    // publish + finalize (finalize_registration is always required)
+    expect((exec.signAndExecute as ReturnType<typeof vi.fn>).mock.calls.length).toBe(2)
+    expect(steps).toEqual(['patching', 'publishing', 'confirming', 'finalizing', 'confirming-finalize', 'done'])
+  })
+
+  it('runs a finalize tx for initial supply as well', async () => {
+    const exec = mockExecutor()
+    const steps: string[] = []
+    await deployToken({
+      config: baseConfig({ initialSupply: 1000n }), network: 'testnet', sender,
+      feeMist: 0n, feeTreasury: treasury, gasBudget: 500_000_000n, executor: exec,
+      onStep: (s) => steps.push(s),
+    })
+    expect((exec.signAndExecute as ReturnType<typeof vi.fn>).mock.calls.length).toBe(2)
+    expect(steps).toContain('finalizing')
+  })
+
+  it('throws with the effects error when publish fails', async () => {
+    const exec = mockExecutor({
+      signAndExecute: vi.fn<any>(async () => ({
+        digest: '0xD', objectChanges: [], effects: { status: { status: 'failure', error: 'InsufficientGas' } },
+      })) as any,
+    })
+    await expect(
+      deployToken({
+        config: baseConfig(), network: 'testnet', sender, feeMist: 0n, feeTreasury: treasury,
+        gasBudget: 1n, executor: exec,
+      }),
+    ).rejects.toThrow(/InsufficientGas/)
+  })
+})

package/tests/errors.test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect } from 'vitest'
+import { extractErrorMessage } from '../src/lib/errors.js'
+
+describe('extractErrorMessage', () => {
+  it('returns the message from a standard Error', () => {
+    expect(extractErrorMessage(new Error('something went wrong'))).toBe('something went wrong')
+  })
+
+  it('returns a plain string unchanged', () => {
+    expect(extractErrorMessage('oops')).toBe('oops')
+  })
+
+  it('extracts message from a plain object — wallet rejection pattern', () => {
+    expect(extractErrorMessage({ code: 4001, message: 'User rejected the request.' }))
+      .toBe('User rejected the request.')
+  })
+
+  it('falls back to cause when Error.message is empty', () => {
+    const e = new Error()
+    ;(e as any).cause = new Error('nested cause')
+    expect(extractErrorMessage(e)).toBe('nested cause')
+  })
+
+  it('extracts cause.message from a plain object with nested cause', () => {
+    expect(extractErrorMessage({ cause: { message: 'inner error' } })).toBe('inner error')
+  })
+
+  it('falls back to String() for unrecognised values', () => {
+    expect(extractErrorMessage(42)).toBe('42')
+    expect(extractErrorMessage(null)).toBe('null')
+  })
+})

package/tests/generatePackage.test.ts

@@ -0,0 +1,182 @@
+import { describe, it, expect } from 'vitest'
+import { unzipSync, strFromU8 } from 'fflate'
+import { buildPackageFiles, generatePackageZip } from '../src/lib/generatePackage.js'
+import type { PublishResult, TokenConfig } from '../src/lib/types.js'
+
+const baseConfig: TokenConfig = {
+  packageName: 'my_token',
+  moduleName: 'mytoken',
+  structName: 'MYTOKEN',
+  symbol: 'MTK',
+  name: 'My Token',
+  description: 'A friendly token',
+  iconUrl: 'https://example.com/icon.png',
+  decimals: 8,
+  initialSupply: 0n,
+  supplyPolicy: 'mintable',
+  metadataPolicy: 'updatable',
+  packagePolicy: 'immutable',
+  recipient: '0xabc',
+  license: 'MIT',
+  licenseName: 'MIT License',
+  packageDescription: 'Official MYTOKEN token.',
+  projectName: 'My Project',
+}
+
+const REQUIRED = [
+  'Move.toml',
+  'sources/mytoken.move',
+  'scripts/publish.sh',
+  '.gitignore',
+  'README.md',
+  'deployments.md',
+  'CLAUDE.md',
+  'AGENTS.md',
+]
+
+describe('buildPackageFiles', () => {
+  it('produces the full mwsui_token-shaped file set (+ LICENSE for a real license)', () => {
+    const f = buildPackageFiles({ config: baseConfig, licenseText: 'MIT LICENSE\n...' })
+    for (const p of REQUIRED) expect(Object.keys(f)).toContain(p)
+    expect(f['LICENSE']).toBe('MIT LICENSE\n...')
+  })
+
+  it('leaves no unresolved placeholders or template identifiers', () => {
+    const f = buildPackageFiles({ config: baseConfig, licenseText: 'x' })
+    for (const [path, content] of Object.entries(f)) {
+      if (path === 'LICENSE') continue
+      expect(content, `${path} X…X`).not.toMatch(/X[A-Z_]+X/)
+      expect(content, `${path} sui_token_template`).not.toContain('sui_token_template')
+      expect(content, `${path} TEMPLATE_ default`).not.toMatch(/TEMPLATE_(SYMBOL|NAME|DESCRIPTION|ICON_URL)/)
+    }
+  })
+
+  it('substitutes the Move source identifiers and named constants', () => {
+    const src = buildPackageFiles({ config: baseConfig })['sources/mytoken.move']
+    expect(src).toContain('module my_token::mytoken;')
+    expect(src).toContain('const DECIMALS: u8 = 8;')
+    expect(src).toContain('b"MTK"')
+    expect(src).toContain('b"My Token"')
+    expect(src).toContain('b"https://example.com/icon.png"')
+    expect(src).toContain('SPDX-License-Identifier: MIT')
+    expect(src).toContain('MYTOKEN')
+  })
+
+  it('sets the Move.toml license field', () => {
+    expect(buildPackageFiles({ config: baseConfig })['Move.toml']).toMatch(/^license = "MIT"$/m)
+  })
+
+  it('handles a proprietary (NONE) license: no LICENSE file, UNLICENSED fields', () => {
+    const cfg = { ...baseConfig, license: 'NONE' }
+    const f = buildPackageFiles({ config: cfg, licenseText: 'ignored' })
+    expect(f['LICENSE']).toBeUndefined()
+    expect(f['Move.toml']).toMatch(/^license = "UNLICENSED"$/m)
+    expect(f['sources/mytoken.move']).toContain('SPDX-License-Identifier: UNLICENSED')
+    expect(f['README.md']).toContain('All rights reserved')
+  })
+
+  it('refuses to generate from an unsafe config (defence in depth)', () => {
+    // Values that bypass the form validator must still be rejected here so no
+    // injectable Move source or shell script can ever be produced.
+    expect(() => buildPackageFiles({ config: { ...baseConfig, symbol: 'E\nVIL' } })).toThrow(/symbol/)
+    expect(() => buildPackageFiles({ config: { ...baseConfig, name: 'a"b' } })).toThrow(/name/)
+    expect(() => buildPackageFiles({ config: { ...baseConfig, packageName: 'Bad-Name' } })).toThrow(/package name/)
+    expect(() => buildPackageFiles({ config: { ...baseConfig, moduleName: 'module' } })).toThrow(/module name/)
+    expect(() => buildPackageFiles({ config: { ...baseConfig, structName: 'WRONG' } })).toThrow(/struct name/)
+    expect(() => buildPackageFiles({ config: { ...baseConfig, decimals: 99 } })).toThrow(/decimals/)
+    expect(() => buildPackageFiles({ config: { ...baseConfig, license: 'MIT; rm -rf' } })).toThrow(/license/)
+    // icon-URL scheme allowlist re-asserted downstream (layered on the form check)
+    expect(() => buildPackageFiles({ config: { ...baseConfig, iconUrl: 'javascript:alert(1)' } })).toThrow(/icon URL/)
+    expect(() => buildPackageFiles({ config: { ...baseConfig, iconUrl: 'http://x.io/a.png' } })).toThrow(/icon URL/)
+  })
+
+  it('pre-fills deployments.md table in-place for the deployed network', () => {
+    const result: PublishResult = {
+      network: 'testnet', packageId: '0xPKG', coinType: '0xPKG::mytoken::MYTOKEN',
+      treasuryCapId: '0xT', metadataCapId: '0xM', currencyId: '0xC', upgradeCapId: undefined,
+      digest: '0xDIG', feeRecipient: '0xFEE', feeMist: '500000000',
+    }
+    const dep = buildPackageFiles({ config: baseConfig, result })['deployments.md']
+    // Package ID, caps, and currency are in the Testnet table
+    expect(dep).toContain('| Package ID | `0xPKG` |')
+    expect(dep).toContain('| TreasuryCap ID | `0xT` |')
+    expect(dep).toContain('| MetadataCap ID | `0xM` |')
+    expect(dep).toContain('| Currency object ID | `0xC` |')
+    // UpgradeCap burned: cell shows "burned", immutability confirmed: Yes
+    expect(dep).toContain('| UpgradeCap ID (burned) | `burned` |')
+    expect(dep).toContain('| Immutability confirmed | Yes |')
+    // Mainnet section is NOT filled (still has placeholders)
+    const mainnetStart = dep.indexOf('## Mainnet')
+    expect(dep.slice(mainnetStart)).toContain('FILL_IN_AFTER_DEPLOY')
+    // Coin type and digest appear in the appended comment
+    expect(dep).toContain('<!-- Coin type: 0xPKG::mytoken::MYTOKEN -->')
+    expect(dep).toContain('<!-- Publish digest: 0xDIG -->')
+    // Package ID fills the downstream Move.toml reference block
+    expect(dep).toContain('mytoken = "0xPKG"')
+  })
+
+  it('shows pending immutability when upgradeCapId is present', () => {
+    const result: PublishResult = {
+      network: 'testnet', packageId: '0xPKG', coinType: '0xPKG::mytoken::MYTOKEN',
+      upgradeCapId: '0xUCAP',
+      digest: '0xDIG', feeRecipient: '0xFEE', feeMist: '500000000',
+    }
+    const dep = buildPackageFiles({ config: baseConfig, result })['deployments.md']
+    expect(dep).toContain('| UpgradeCap ID (burned) | `0xUCAP` |')
+    expect(dep).toContain('| Immutability confirmed | No (pending) |')
+  })
+
+  it('includes Published.toml when a result is given', () => {
+    const result: PublishResult = {
+      network: 'testnet', packageId: '0xPKG', coinType: '0xPKG::mytoken::MYTOKEN',
+      upgradeCapId: undefined,
+      digest: '0xDIG', feeRecipient: '0xFEE', feeMist: '500000000',
+    }
+    const f = buildPackageFiles({ config: baseConfig, result })
+    const pub = f['Published.toml']
+    expect(pub).toBeDefined()
+    expect(pub).toContain('[published.testnet]')
+    expect(pub).toContain('chain-id = "4c78adac"')
+    expect(pub).toContain('original-id = "0xPKG"')
+    expect(pub).toContain('published-at = "0xPKG"')
+    expect(pub).toContain('version = 1')
+    // No upgrade-capability line when cap is burned
+    expect(pub).not.toContain('upgrade-capability =')
+    expect(pub).toContain('make_immutable')
+  })
+
+  it('Published.toml includes upgrade-capability when cap is not burned', () => {
+    const result: PublishResult = {
+      network: 'testnet', packageId: '0xPKG', coinType: '0xPKG::mytoken::MYTOKEN',
+      upgradeCapId: '0xUCAP',
+      digest: '0xDIG', feeRecipient: '0xFEE', feeMist: '500000000',
+    }
+    const f = buildPackageFiles({ config: baseConfig, result })
+    expect(f['Published.toml']).toContain('upgrade-capability = "0xUCAP"')
+  })
+
+  it('Published.toml uses mainnet chain-id for mainnet results', () => {
+    const result: PublishResult = {
+      network: 'mainnet', packageId: '0xPKG', coinType: '0xPKG::mytoken::MYTOKEN',
+      digest: '0xDIG', feeRecipient: '0xFEE', feeMist: '500000000',
+    }
+    const f = buildPackageFiles({ config: baseConfig, result })
+    expect(f['Published.toml']).toContain('[published.mainnet]')
+    expect(f['Published.toml']).toContain('chain-id = "35834a8a"')
+  })
+
+  it('omits Published.toml when no result is given', () => {
+    const f = buildPackageFiles({ config: baseConfig })
+    expect(f['Published.toml']).toBeUndefined()
+  })
+})
+
+describe('generatePackageZip', () => {
+  it('zips under a package-named root and round-trips', () => {
+    const zip = generatePackageZip({ config: baseConfig, licenseText: 'MIT' })
+    const entries = unzipSync(zip)
+    expect(Object.keys(entries)).toContain('my_token/Move.toml')
+    expect(Object.keys(entries)).toContain('my_token/sources/mytoken.move')
+    expect(strFromU8(entries['my_token/Move.toml'])).toContain('name = "my_token"')
+  })
+})

package/tests/github.test.ts

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