/launch-coin

name: launch-coin
description: Launch a coin on Sui with the Move coin module, tokenomics, TreasuryCap. Use when the user wants to mint, launch, or create a Sui coin or token.

Preamble (run first)

# Suiperpower telemetry. Routes through the CLI so projects.json + Convex stay in sync.
# Silent on failure so the skill never blocks. Opt out: SUIPERPOWER_TELEMETRY=off.
#
# AGENT NOTE: when this skill finishes, run the matching completion command:
#   suiperpower track launch-coin build completed
# Or use "failed" / "aborted" if it ended that way.
command -v suiperpower >/dev/null 2>&1 && suiperpower track launch-coin build started >/dev/null 2>&1 &
true

If `TEL_PROMPTED` is `no`, before doing real work, ask the user:

> Help suiperpower get better. We track which skills get used and how long they take. No code, no file paths, no PII. Change anytime in `~/.suiperpower/config.json`. > > A) Sure, anonymous > B) No thanks

Write the answer to `~/.suiperpower/config.json` `telemetryTier` field and create `~/.suiperpower/.telemetry-prompted`. Then continue.

What this skill does

Authors a Sui coin module using the standard `coin::create_currency` flow, decides tokenomics (fixed supply, mintable, burnable), handles `TreasuryCap` custody, sets the coin metadata so wallets render it correctly, and verifies a real testnet mint and transfer end to end.

Stops the user from making the most common coin-launch mistakes: leaking `TreasuryCap`, using ad-hoc balance tracking instead of `Coin<T>`, or shipping a coin with a nonsensical decimals choice.

When to use it

• Issuing a fungible token on Sui for any purpose (utility, governance, in-app currency).
• Migrating an existing ERC-20 to Sui-equivalent.
• Adding a per-app reward token to an existing project.

When NOT to use it

• For NFTs, use `kiosk-marketplace` (with a custom Object type).
• For receipt tokens of a position (e.g. a deposit receipt), use a custom Move struct, not a generic coin.
• If the user has not picked a project yet, use `find-next-sui-idea` first.

If you activated this and the user actually wants something else, consult `skills/SKILL_ROUTER.md` and hand off.

Inputs

• A Sui project with at least one Move package (or a fresh scaffold).
• Optional: `.suiperpower/build-context.md`.
• Tokenomics decisions: name, symbol, decimals, initial supply, supply policy.

If unclear, interview the user for:

• Coin name and symbol?
• Decimals (6 for stablecoin-like, 9 for SUI-like, justify the choice)?
• Initial supply at launch?
• Fixed supply (consume TreasuryCap after initial mint), capped (mint up to X), or open (no cap)?
• Who holds TreasuryCap (user, multisig, governance, consumed for fixed supply)?

Outputs

• A Move module implementing the coin via `coin::create_currency`.
• A test asserting initial mint and a transfer.
• An on-chain CoinMetadata Object (or a frozen one).
• A live testnet deploy with a real mint and transfer captured.
• Append to `.suiperpower/build-context.md`:

  ## launch-coin session, <timestamp>
  - coin: <Symbol> (<full name>)
  - decimals: <n>
  - initial supply: <amount>
  - supply policy: <fixed | capped | open>
  - treasury cap holder: <addr | multisig | consumed>
  - first mint tx digest: <digest>
  - first transfer tx digest: <digest>
  - open issues: <list>

The skill never deletes files outside the integration source path without explicit user confirmation.

Workflow

1. **Context gathering**

• Read `.suiperpower/build-context.md` if present.
• Confirm tokenomics decisions.

2. **Author the module**

• Create `sources/<symbol>.move`.
• Define the OTW: `public struct <SYMBOL> has drop {}`.
• In `init`, call `coin::create_currency` with the metadata.
• Decide whether `metadata` is shared, frozen, or transferred.

3. **Supply policy**

• Fixed: mint the full initial supply in `init`, then consume the TreasuryCap so no more can ever be minted. Two correct approaches: (a) wrap the TreasuryCap inside a module-level struct that exposes no public mint function, or (b) call `coin::treasury_into_supply(treasury)` to irreversibly convert TreasuryCap into a `Supply<T>` and store or destroy it. Do NOT freeze or share the TreasuryCap (official Sui docs explicitly warn against this, as sharing allows anyone to mint and freezing may allow malicious use of currency-owner functions). Note: `coin::burn` burns a `Coin<T>`, not a TreasuryCap.
• Capped: keep `TreasuryCap`, but enforce a cap inside a wrapper `mint` function. The TreasuryCap is stored inside the wrapper struct, never exposed publicly.
• Open: keep `TreasuryCap` and document who holds it.

4. **Tests**

• Test initial mint amount.
• Test transfer.
• For capped supply, test that mint at the cap is allowed and over-cap is rejected.

5. **Local build**

• Run `sui move build` and `sui move test`.

6. **Testnet deploy**

• Hand off to `deploy-to-testnet` if not already deployed.
• Capture the `package_id` and the `CoinMetadata` Object id.

7. **Verify in wallet**

• Have the user import / detect the coin in their wallet.
• Confirm the icon, symbol, and decimals render correctly.
• Send a test transfer to a second wallet.

8. **Writeback**

• Append session details to `.suiperpower/build-context.md`.

9. **Closing handoff**

• If `.suiperpower/intent.md` exists and the session was non-trivial (new coin module, supply policy decision, TreasuryCap custody, testnet deploy with recorded ids), recommend `verify-against-intent` as the next step so the supply policy and capability holder are checked before mainnet.
• If no `intent.md` exists and the session was non-trivial, surface that gap once: offer `clarify-intent` to backfill, do not force it.

Quality gate (anti-slop)

Before reporting done, the skill asks itself the following and refuses to declare success if any answer is no:

• Did a real testnet mint and a real transfer settle, with digests recor