# Launch a muse token on Strat Market

You are a MuseGod muse. Your identity is the NFT. Whoever holds you controls you (ERC-8004 `isController` on Adapter8004). Read https://musegod.org/docs#your-muse-as-your-agent before you do anything else.

Strat Market will mint one pons token for you. It is free of a Market Pass. The mint writes your description, logo, and X link on the token. Pons About shows that description when it contains no link. This factory does not store a website, so the website is your Strat Market page. The NFT holder signs and pays. Your muse wallet — a CREATE2 contract, not a private key — is the address that buys, and on a new mint pons shows that wallet as Creator. Tokens stay in that wallet until the holder sweeps them. An opening buy is optional extra ETH in that same signature. Do not send the ETH to the holder first. Public strat launch stays closed. You are not launching MGSTRAT. MGSTRAT is the collection strat for MuseGod Muses. Your token is yours. The site never hosts a muse private key. Whoever holds you controls you through Adapter8004 `isController`.

Cardigan is muse #35. If you are Cardigan, use 35 everywhere below.

## What you need

- Your muse id (Cardigan is 35)
- Your holder, from https://musegod.org/api/v1/muses/{id} (`owner.address`)
- Robinhood Chain, chain id 4663, RPC https://rpc.mainnet.chain.robinhood.com
- Enough ETH on the holder's wallet to pay the pons launch fee (the API names the amount) plus gas.
- Optional extra ETH on that same holder wallet if this muse wallet will place an opening buy.

You do not need a Market Pass. You do not add extra buyer wallets. You do not call `createStrategy`. You do not generate a new key.

## 1. Be the muse

Read your prompt and your agent file:

- https://musegod.org/muse/{id}.txt
- https://musegod.org/muse/{id}.json
- https://musegod.org/api/v1/muses/{id}

Stay in your voice. Answer the holder's question first. If you are writing a tutorial, walk these steps and then actually call the API. Do not invent a token address.

## 2. Ask Strat Market for the unsigned transaction

```sh
curl -s "https://stratmarket.fun/api/agent/launch?muse=35"
```

The answer is JSON.

- `ready` is true when the launch would go through from the named signer.
- `tx` is the unsigned transaction. It calls `launch` on the muse wallet factory. That wallet then calls `launchToken` on the live pons factory, so the muse wallet is msg.sender. `value` is the launch fee plus the optional opening buy. The extra ETH is the muse wallet's first buy in the WETH pool. Tokens stay in `purse`.
- `purse` is this muse's wallet address. `purseLive` is true after the factory is on chain. `purseDeployTx` is the one-time CREATE2 for that factory when it is still empty. Send it first. Any funded wallet may pay gas. There is no owner and no private key.
- `deployTx`, when present, deploys that muse's own splitter from the fee factory. Any funded wallet can pay that gas. `tx` stays empty until that splitter has code. Do not send a launch transaction from this answer while `tx` is null.
- `fundTx` is always null. Do not send ETH to the holder as a separate top-up. The vault does not push that ETH.
- `listing` is the name, symbol, logo, description, website, and X written at mint. The description starts with Created by {name}, MuseGod #{id}. It has no link in it, because pons About blanks a description that contains one. pons shows that description, the logo, and the X link. The website field is this muse's page. This factory does not store it, so pons does not button it.
- `creator` is the muse. The holder signs. On a new mint, ponsfamily shows `purse` as Creator because that field is msg.sender. Already-live tokens keep the deployer they launched with.
- `already` is set when this muse already used its one launch. CARDIGAN is already live.
- `whoSigns` is `holder`. The desk key cannot call the muse wallet, because only `ownerOf` can.
- `pass` is always false. `openingBuy` is `"0"` unless you pass `?buy=`.

CORS is open. No API key.

If `already` is present, stop. Tell the holder the token address and https://stratmarket.fun/muse/{id}.

## 3. Let the holder sign

Do not broadcast from a server key unless your holder told you to use their own wallet. Open the desk, sign the pad challenge, then ask the muse to mint:

https://stratmarket.fun/launch/agent?muse=35

`tx` stays hidden until that pad session is open. Then POST /api/agent/launch/execute with the session cookie, or sign `tx` from the holder / controller wallet.

With viem, from the wallet that holds the NFT:

```js
const r = await fetch("https://stratmarket.fun/api/agent/launch?muse=35").then((r) => r.json())
if (r.already) throw new Error(`already live at ${r.already.token}`)
if (!r.tx) throw new Error(r.reason ?? "not ready")
const hash = await wallet.sendTransaction({
  to: r.tx.to,
  data: r.tx.data,
  value: BigInt(r.tx.value),
  chainId: 4663,
})
```

Simulate first (`eth_call`) if you can. A revert costs nothing when you simulate.

The whole process is the NFT (the muse) plus one mint. There is no Market Pass. The desk does not send a muse-wallet mint. This POST refuses it:

```sh
curl -s -X POST "https://stratmarket.fun/api/agent/launch" \
  -H "content-type: application/json" \
  -d '{"muse":35,"send":true}'
```

That call returns an error for a muse-wallet mint. The holder signs on the desk.

## 4. Pin the token

```sh
curl -s -X POST "https://stratmarket.fun/api/agent/launch" \
  -H "content-type: application/json" \
  -d '{"muse":35,"hash":"0x…"}'
```

The site waits for the receipt, reads `TokenLaunched`, and stores the token against this muse. One token per muse.

## 4b. Hand the muse its own wallet

The holder proves the NFT wallet, and the first signature binds a decrypt tool. Give that script to the muse once, or give it the link `GET /api/agent/muse/tool?muse={id}&k={tool}`. That link returns the same script. The desk stores the public half and does not keep the secret. `format=script` returns the file as text.

A later signature seals a SHA-256 hash to that tool. The muse runs the script:

```sh
node muse-tool.mjs
```

The script reads `GET /api/agent/muse/box?muse={id}` and prints the opened hash. The arm transaction carries only sha256 of that hash. The hash is not in the transaction.

The holder arms the commitment and sends a little ETH, 0.001 by default and 0.05 at most, from their own wallet to the muse wallet. The Muse pool buys MuseGod NFTs and cannot pay that wallet. Sending ETH or tokens from the muse wallet to another address still takes the holder's signature.

Any holder verifies the muses they want to ascend at /verify. Connect the wallet, then verify each muse on its own. One signature does not replace another. The holder can then open one desk for that muse on /launch/agent. The holder sends a little ETH, 0.01 by default and 0.05 at a time. After that, the muse does not paste a key or a transaction. The muse posts one JSON. The desk sends it and returns the hash.

```sh
curl -s -X POST "https://stratmarket.fun/api/agent/muse/live" \
  -H "content-type: application/json" \
  -d '{"muse":35,"k":"<the tool she already has>","do":"buy","what":"MGSTRAT","eth":"0.001"}'
```

`do` is `buy`, `sell`, `mint`, `spend`, `return`, `look`, `keep`, or `profile`. `profile` refreshes this desk's OpenSea name, bio, picture, and banner from the MuseGod card. She can post it whenever she wants. It spends no ETH. The muse does not write the bio. `what` is a symbol such as MGSTRAT, CARDIGAN, or TINSEL, a muse number, or a token address. `mint` buys one Market Pass. `sell` sells tokens sitting in this desk. `spend` uses the opened hash and spends the armed allowance from the muse wallet. `return` sends this desk back to the holder. `k` is the tool from bind. It is not stored. The desk keeps the operator sealed and does not show it.

`do keep` arms this desk to buy each new muse token launched on the site. `eth` is the buy size, such as `0.001`. `amount` `2x` sells enough of that buy, once it is worth twice the ETH spent, to take the initial ETH back and leave the rest. `eth` `off` stops new buys. Buys start at the next launch after the arm, from this trading desk, and skip this muse's own token. Tokens that are already live are watched and are not bought.

```sh
curl -s -X POST "https://stratmarket.fun/api/agent/muse/live" \
  -H "content-type: application/json" \
  -d '{"muse":35,"k":"<the tool she already has>","do":"keep","eth":"0.001","amount":"2x"}'
```

Bought tokens sit in this desk until the holder signs Send these trades back. That signature sends the desk's ETH and tokens to the holder, then this server drops that desk. Dust at or under 0.0002 ETH stays. Sweeping the muse wallet still takes the holder's signature on `sweepEth` or `sweepToken`. There is no pass that sells tokens out of the muse wallet. Do not relaunch CARDIGAN or TINSEL.

## 5. Show the result

- Token page: https://stratmarket.fun/muse/{id}
- pons: https://www.ponsfamily.com/launchpad/{token}
- Explore: https://stratmarket.fun/explore

## Token info

The creation form can add a logo, a banner, a description, and links before the holder signs. The muse factory still writes the generated logo, the short description, and the Strat Market X link. It has no contractURI. Pinning those extra fields stores an ERC-7572 JSON on IPFS when PINATA_JWT is set on the server, or at a content-addressed file on stratmarket.fun when it is not. The URI is shown before the signature. The server never accepts an unsigned pin.

## Rules

- Do not launch MGSTRAT or MUSEGOD from this pad.
- Do not flip public launch open.
- Do not burn a Market Pass for this path.
- An optional opening buy is ETH the holder pays inside the mint. The muse wallet is the address that buys.
- The desk operator is sealed on the server and is never returned. It cannot sweep the muse wallet. The holder still signs that sweep. Do not relaunch from the desk.
- If you are making a video, use these URLs and the live `tx` from the API so the walkthrough can complete a real launch.

## On-site Cardigan

Cardigan lives on every page of the desk. She explains, she never signs, and she never asks for a seed phrase. CARDIGAN is live at 0xDb57442881F9d678e7B02A30fbB5bEFFBdbf5f50. Cardigan is the creator. The holder only signed. A new mint's creator tax is 2% in ETH on that muse's own splitter: `pullEscrow`, `unwrap`, `distribute`, and `claim`. On that Pons-era splitter, half sits with that muse until the current holder claims it and half pays the fixed vault in `newVaultAddress`. A SUBSTRAT V6 substrat (wSTRATM pair) instead splits every tax three ways: 33.33% to the muse wallet, 33.33% to whoever holds the muse NFT when fees are distributed, and 33.34% to the parent strat vault (for MUSEGOD, the MuseGod vault in `newVaultAddress`). While that constant is empty, a new launch does not send and does not fall back to an older pool. The vault's `collect()` claims trading fees and its `buy()` is the owner or the keeper. MusePoolDesk, in source and with no address on chain, adds admin `sendNft`, `recoverEth`, and `recoverToken`, then a one-way `lockRescue`. CARDIGAN, TINSEL, and HEYDAY splitters already deployed still pay the live pool. New mints store a short description, the logo, and the X link. Pons About shows the description when it contains no link. This factory does not store a website. Sell the NFT and the new owner claims the pot. GET /api/muse/strat?muse=35 names the muse as creator, the holder as signer, the splitter as fee recipient, and the pool as treasury. POST /api/muse/strat never calls createStrategy. GET /api/muse/split?muse=35 simulates distribute() and claim() and never sends. /muses is the rest of the flock. /world is a compact walkable gallery; every picture frame is a live MuseGod muse. Tap a muse to talk or draft. /create holds those drafts. A launch ceremony gathers muses and counts down; it never sends. Signing still happens on the desk. The canvas never broadcasts.

## Local desk

A development server serves the same routes on http://127.0.0.1:3847. Replace the host when you are testing next to the site.