@baseline-markets/cli 0.2.0

package/README.md

@@ -0,0 +1,97 @@
+# Baseline CLI
+
+CLI for building and executing Baseline token launch calls.
+
+## Install
+
+Run without installing:
+
+```sh
+npx @baseline-markets/cli launch --help
+```
+
+Or install globally:
+
+```sh
+npm install -g @baseline-markets/cli
+```
+
+For local development:
+
+```sh
+bun run --cwd packages/cli dev --help
+```
+
+## Launch Calls
+
+Build launch calls without sending transactions:
+
+```sh
+baseline launch \
+  --chain-id 84532 \
+  --name "Smoke Test" \
+  --symbol SMOKE \
+  --reserve 0xB85885897D297000A74eA2e4711C3Ca729461ABC \
+  --total-supply 1000000 \
+  --format json
+```
+
+## Execute A Launch
+
+Execute with a private key:
+
+```sh
+baseline launch \
+  --chain-id 84532 \
+  --name "Smoke Test" \
+  --symbol SMOKE \
+  --reserve 0xB85885897D297000A74eA2e4711C3Ca729461ABC \
+  --total-supply 1000000 \
+  --execute \
+  --private-key 0x...
+```
+
+Or use `.env`:
+
+```env
+BASELINE_PRIVATE_KEY=0x...
+```
+
+The deployer account is derived from the private key when `--execute` is used
+and `--account` is omitted.
+
+## Launch Modes
+
+`zrp` is the default zero-reserve launch:
+
+```sh
+--mode zrp
+```
+
+The pool BToken amount is derived from `--total-supply`.
+
+`standard` launches with initial reserve liquidity:
+
+```sh
+--mode standard \
+  --initial-pool-btokens 950000 \
+  --initial-pool-reserves 10
+```
+
+## Environment
+
+- `BASELINE_PRIVATE_KEY`: signer used by `--execute`
+- `RPC_URL`: Base Sepolia fork source for integration tests
+
+## Tests
+
+```sh
+bun run --cwd packages/cli test
+bun run --cwd packages/cli typecheck
+```
+
+Fork integration tests:
+
+```sh
+RPC_URL=https://sepolia.base.org bun run --cwd packages/cli test:integration
+```

package/dist/index.js

@@ -0,0 +1,464 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Cli } from "incur";
+
+// src/commands/info.ts
+import { BaselineSDK } from "@baseline-markets/sdk";
+
+// ../chains/index.ts
+import { defineChain } from "viem";
+import {
+  arbitrum as arbitrumMainnet,
+  base as baseMainnet,
+  baseSepolia as baseTestnet,
+  mainnet as ethereumMainnet
+} from "viem/chains";
+var chains = {
+  mainnet: defineChain({
+    ...ethereumMainnet,
+    name: "ethereum",
+    rpcUrls: {
+      default: {
+        http: [
+          "https://wispy-hidden-knowledge.quiknode.pro/744cca7e0d6ab60a5bff9c19aee2599dbff70471",
+          "https://alien-intensive-butterfly.quiknode.pro/05e4b943102cba88219029212abcd33ee4d95b16"
+        ],
+        webSocket: [
+          "wss://wispy-hidden-knowledge.quiknode.pro/744cca7e0d6ab60a5bff9c19aee2599dbff70471"
+        ]
+      }
+    }
+  }),
+  arbitrum: defineChain({
+    ...arbitrumMainnet,
+    name: "arbitrum",
+    rpcUrls: {
+      default: {
+        http: [
+          "https://wispy-hidden-knowledge.arbitrum-mainnet.quiknode.pro/744cca7e0d6ab60a5bff9c19aee2599dbff70471",
+          "https://alien-intensive-butterfly.arbitrum-mainnet.quiknode.pro/05e4b943102cba88219029212abcd33ee4d95b16"
+        ],
+        webSocket: [
+          "wss://wispy-hidden-knowledge.arbitrum-mainnet.quiknode.pro/744cca7e0d6ab60a5bff9c19aee2599dbff70471"
+        ]
+      }
+    }
+  }),
+  base: defineChain({
+    ...baseMainnet,
+    name: "base",
+    rpcUrls: {
+      default: {
+        http: [
+          "https://wispy-hidden-knowledge.base-mainnet.quiknode.pro/744cca7e0d6ab60a5bff9c19aee2599dbff70471/",
+          "https://lb.routeme.sh/rpc/8453/251d0417-55cf-4ce5-bab5-3e105247084a",
+          "https://alien-intensive-butterfly.base-mainnet.quiknode.pro/05e4b943102cba88219029212abcd33ee4d95b16"
+        ],
+        webSocket: [
+          "wss://wispy-hidden-knowledge.base-mainnet.quiknode.pro/744cca7e0d6ab60a5bff9c19aee2599dbff70471"
+        ]
+      }
+    }
+  }),
+  baseSepolia: defineChain({
+    ...baseTestnet,
+    name: "base-sepolia",
+    rpcUrls: {
+      default: {
+        http: [
+          "https://wispy-hidden-knowledge.base-sepolia.quiknode.pro/744cca7e0d6ab60a5bff9c19aee2599dbff70471"
+        ],
+        webSocket: [
+          "wss://wispy-hidden-knowledge.base-sepolia.quiknode.pro/744cca7e0d6ab60a5bff9c19aee2599dbff70471"
+        ]
+      }
+    }
+  })
+};
+var chains_default = chains;
+
+// src/commands/info.ts
+import { z as z2 } from "incur";
+import { createPublicClient, formatUnits, http } from "viem";
+
+// src/commands/common.ts
+import { z } from "incur";
+import { isAddress } from "viem";
+var chainById = {
+  [chains_default.mainnet.id]: chains_default.mainnet,
+  [chains_default.base.id]: chains_default.base,
+  [chains_default.baseSepolia.id]: chains_default.baseSepolia
+};
+function getChain(chainId) {
+  const chain = chainById[chainId];
+  if (!chain) {
+    throw new Error(`Unsupported chain ID: ${chainId}`);
+  }
+  return chain;
+}
+var address = (label) => z.string().refine((value) => isAddress(value), {
+  message: `Invalid ${label} address`
+});
+function buildTokenLinks(chain, token) {
+  const appBaseUrl = chain.id === chains_default.baseSepolia.id ? "https://dev.app.baseline.markets" : "https://app.baseline.markets";
+  const explorerBaseUrl = chain.blockExplorers?.default.url;
+  return {
+    appUrl: `${appBaseUrl}/tokens/${chain.id}/${token}`,
+    explorerUrl: explorerBaseUrl ? `${explorerBaseUrl}/address/${token}` : undefined
+  };
+}
+
+// src/commands/info.ts
+var optionSchema = z2.object({
+  chainId: z2.coerce.number().default(chains_default.baseSepolia.id).describe("Chain ID for the token."),
+  rpcUrl: z2.string().optional().describe("RPC URL for read calls."),
+  token: address("token").optional().describe("Token address to inspect.")
+});
+var argsSchema = z2.object({
+  token: address("token").optional().describe("Token address to inspect.")
+});
+var infoCommand = {
+  description: "Inspect a deployed Baseline token.",
+  args: argsSchema,
+  options: optionSchema,
+  async run(c) {
+    const chain = getChain(c.options.chainId);
+    const token = c.options.token ?? c.args.token;
+    if (!token) {
+      throw new Error("Token address is required. Pass it as an argument or --token.");
+    }
+    const sdk = new BaselineSDK(createPublicClient({
+      chain,
+      transport: http(c.options.rpcUrl)
+    }));
+    const info = await sdk.getBTokenInfo(token);
+    return serializeBTokenInfo(info, buildTokenLinks(chain, info.bToken));
+  }
+};
+function serializeBTokenInfo(info, links) {
+  const decimals = info.decimals ?? 18;
+  const reserveDecimals = info.reserveDecimals ?? 18;
+  return {
+    chainId: info.chainId,
+    relay: info.relay,
+    bToken: info.bToken,
+    status: info.status,
+    bytecode: info.bytecode,
+    name: info.name,
+    symbol: info.symbol,
+    decimals: info.decimals,
+    totalSupply: stringify(info.totalSupply),
+    totalSupplyFormatted: formatTokenAmount(info.totalSupply, decimals),
+    reserve: info.reserve,
+    reserveDecimals: info.reserveDecimals,
+    creator: info.creator,
+    poolFeeRecipient: info.poolFeeRecipient,
+    creatorFeePct: stringify(info.creatorFeePct),
+    creatorFeePctFormatted: formatPct(info.creatorFeePct),
+    swapFee: stringify(info.swapFee),
+    swapFeeFormatted: formatPct(info.swapFee),
+    totalBTokens: stringify(info.totalBTokens),
+    totalBTokensFormatted: formatTokenAmount(info.totalBTokens, decimals),
+    totalReserves: stringify(info.totalReserves),
+    totalReservesFormatted: formatTokenAmount(info.totalReserves, reserveDecimals),
+    maker: info.maker ? {
+      initialized: info.maker.initialized,
+      blvPrice: info.maker.blvPrice.toString(),
+      swapFee: info.maker.swapFee.toString(),
+      maxCirc: info.maker.maxCirc.toString(),
+      maxReserves: info.maker.maxReserves.toString(),
+      convexityExp: info.maker.convexityExp.toString(),
+      lastInvariant: info.maker.lastInvariant.toString()
+    } : undefined,
+    links
+  };
+}
+function stringify(value) {
+  return value === undefined ? undefined : value.toString();
+}
+function formatTokenAmount(value, decimals) {
+  return value === undefined ? undefined : trimDecimal(formatUnits(value, decimals));
+}
+function formatPct(value) {
+  if (value === undefined)
+    return;
+  return `${trimDecimal(formatUnits(value * 100n, 18))}%`;
+}
+function trimDecimal(value) {
+  return value.includes(".") ? value.replace(/\.?0+$/, "") : value;
+}
+
+// src/commands/launch.ts
+import { BaselineSDK as BaselineSDK2, serializeCalls } from "@baseline-markets/sdk";
+import { z as z3 } from "incur";
+import { writeFile } from "node:fs/promises";
+import {
+  createPublicClient as createPublicClient3,
+  http as http3,
+  parseUnits
+} from "viem";
+import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
+
+// src/commands/tx.ts
+import {
+  createPublicClient as createPublicClient2,
+  createWalletClient,
+  http as http2
+} from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+function parsePrivateKey(value) {
+  if (!/^0x[0-9a-fA-F]{64}$/.test(value)) {
+    throw new Error("BASELINE_PRIVATE_KEY must be a 32-byte hex private key.");
+  }
+  return value;
+}
+async function estimateCallGas(estimate, retryDelayMs = 1000) {
+  let lastError;
+  for (let attempt = 0;attempt < 5; attempt++) {
+    try {
+      return await estimate();
+    } catch (error) {
+      lastError = error;
+      await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+    }
+  }
+  throw lastError;
+}
+async function executeCalls(input) {
+  const account = privateKeyToAccount(input.privateKey);
+  if (input.expectedAccount && account.address.toLowerCase() !== input.expectedAccount.toLowerCase()) {
+    throw new Error(`Private key address ${account.address} does not match expected account ${input.expectedAccount}.`);
+  }
+  const transport = http2(input.rpcUrl);
+  const publicClient = createPublicClient2({ chain: input.chain, transport });
+  const walletClient = createWalletClient({
+    account,
+    chain: input.chain,
+    transport
+  });
+  const transactions = [];
+  for (const [index, call] of input.calls.entries()) {
+    const gas = await estimateCallGas(() => publicClient.estimateGas({
+      account: account.address,
+      to: call.to,
+      data: call.data,
+      value: call.value ?? 0n
+    })) + 50000n;
+    const hash = await walletClient.sendTransaction({
+      account,
+      chain: input.chain,
+      to: call.to,
+      data: call.data,
+      value: call.value ?? 0n,
+      gas
+    });
+    const receipt = await publicClient.waitForTransactionReceipt({ hash });
+    if (receipt.status !== "success") {
+      throw new Error(`Transaction ${index} reverted: ${hash}`);
+    }
+    transactions.push({
+      index,
+      hash,
+      status: receipt.status,
+      blockNumber: receipt.blockNumber.toString(),
+      gasUsed: receipt.gasUsed.toString()
+    });
+  }
+  return { transactions };
+}
+
+// src/commands/launch.ts
+var ZERO_BYTES32 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+var optionSchema2 = z3.object({
+  mode: z3.enum(["zrp", "standard"]).default("zrp").describe("Launch mode."),
+  chainId: z3.coerce.number().default(chains_default.baseSepolia.id).describe("Chain ID for the launch calls."),
+  rpcUrl: z3.string().optional().describe("RPC URL for read calls."),
+  account: address("account").optional().describe("Deployer address. Derived from the private key when executing."),
+  name: z3.string().describe("BToken name."),
+  symbol: z3.string().describe("BToken symbol."),
+  reserve: address("reserve").describe("Reserve token address."),
+  totalSupply: z3.string().describe("Total BToken supply in token units."),
+  initialPoolBtokens: z3.string().optional().describe("Initial BTokens deposited into the pool for standard launches, in token units."),
+  initialPoolReserves: z3.string().optional().describe("Initial reserve amount for standard launches."),
+  creator: address("creator").optional().describe("Creator address."),
+  feeRecipient: address("feeRecipient").optional().describe("Protocol fee recipient, defaults to creator."),
+  creatorFeePct: z3.string().default("50").describe("Creator fee percentage, for example 50 for 50%."),
+  swapFeePct: z3.string().default("1").describe("Swap fee percentage, for example 1 for 1%."),
+  salt: z3.string().optional().describe("Optional bytes32 salt."),
+  reserveDecimals: z3.coerce.number().default(18).describe("Reserve token decimals."),
+  execute: z3.boolean().default(false).describe("Execute the launch calls with a private key signer."),
+  privateKey: z3.string().optional().describe("Private key used with --execute. Falls back to BASELINE_PRIVATE_KEY."),
+  output: z3.string().optional().describe("Optional path to write JSON calls.")
+});
+var launchCommand = {
+  description: "Build wallet_sendCalls-compatible calls for a Baseline launch.",
+  options: optionSchema2,
+  async run(c) {
+    const artifact = await buildLaunchArtifact(c.options);
+    const result = {
+      ...artifact,
+      calls: serializeCalls(artifact.calls),
+      ...c.options.execute ? { execution: await executeLaunchArtifact(artifact, c.options) } : {}
+    };
+    if (c.options.output) {
+      await writeFile(c.options.output, `${JSON.stringify(result, null, 2)}
+`);
+    }
+    return result;
+  }
+};
+async function buildLaunchArtifact(options) {
+  const chain = getChain(options.chainId);
+  const account = resolveAccount(options);
+  const reserve = options.reserve;
+  const creator = options.creator ?? account;
+  const feeRecipient = options.feeRecipient ?? creator;
+  const totalSupply = parseUnits(options.totalSupply, 18);
+  const initialPoolBTokens = resolveInitialPoolBTokens(options, totalSupply);
+  const salt = options.salt ? parseSalt(options.salt) : ZERO_BYTES32;
+  const launchInput = {
+    mode: options.mode,
+    name: options.name,
+    symbol: options.symbol,
+    reserve,
+    totalSupply,
+    initialPoolBTokens,
+    initialPoolReserves: options.initialPoolReserves ? parseUnits(options.initialPoolReserves, options.reserveDecimals) : 0n,
+    creator,
+    feeRecipient,
+    creatorFeePct: parsePctToWad(options.creatorFeePct),
+    swapFeePct: parsePctToWad(options.swapFeePct),
+    salt,
+    reserveDecimals: options.reserveDecimals
+  };
+  const publicClient = createPublicClient3({
+    chain,
+    transport: http3(options.rpcUrl)
+  });
+  const sdk = new BaselineSDK2(publicClient);
+  const bToken = await sdk.precomputeBTokenAddress({
+    name: launchInput.name,
+    symbol: launchInput.symbol,
+    totalSupply,
+    salt,
+    deployer: account
+  });
+  const calls = await sdk.calls.launch(launchInput, { account });
+  return {
+    chainId: options.chainId,
+    chain: chain.name,
+    account,
+    bToken,
+    calls
+  };
+}
+function resolveAccount(options) {
+  if (options.account)
+    return options.account;
+  if (!options.execute) {
+    throw new Error("--account is required unless --execute is used.");
+  }
+  const privateKey = options.privateKey ?? process.env.BASELINE_PRIVATE_KEY;
+  if (!privateKey) {
+    throw new Error("--account is required when no --private-key or BASELINE_PRIVATE_KEY is set.");
+  }
+  return privateKeyToAccount2(parsePrivateKey(privateKey)).address;
+}
+function resolveInitialPoolBTokens(options, totalSupply) {
+  if (options.mode === "zrp") {
+    if (options.initialPoolBtokens) {
+      throw new Error("--initial-pool-btokens is not needed for zrp launches.");
+    }
+    return totalSupply;
+  }
+  if (!options.initialPoolBtokens) {
+    throw new Error("--initial-pool-btokens is required for standard launches.");
+  }
+  return parseUnits(options.initialPoolBtokens, 18);
+}
+function parseSalt(value) {
+  if (!/^0x[0-9a-fA-F]{64}$/.test(value)) {
+    throw new Error("Salt must be a bytes32 hex string.");
+  }
+  return value;
+}
+function parsePctToWad(value) {
+  const pct = parseUnits(value, 16);
+  if (pct < 0n || pct > 10n ** 18n) {
+    throw new Error(`Percentage must be between 0 and 100: ${value}`);
+  }
+  return pct;
+}
+async function executeLaunchArtifact(artifact, options) {
+  const chain = getChain(artifact.chainId);
+  const privateKey = options.privateKey ?? process.env.BASELINE_PRIVATE_KEY;
+  if (!privateKey) {
+    throw new Error("--private-key or BASELINE_PRIVATE_KEY is required when using --execute.");
+  }
+  return executeCalls({
+    chain,
+    calls: artifact.calls,
+    privateKey: parsePrivateKey(privateKey),
+    rpcUrl: options.rpcUrl,
+    expectedAccount: artifact.account
+  });
+}
+
+// src/env.ts
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+var packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+var workspaceRoot = resolve(packageRoot, "../..");
+var skillsGlob = resolve(packageRoot, "skills/*");
+function loadCliEnv() {
+  for (const path of [
+    resolve(workspaceRoot, ".env"),
+    resolve(packageRoot, ".env")
+  ]) {
+    loadEnv(path);
+  }
+}
+function loadEnv(path) {
+  if (!existsSync(path))
+    return;
+  if (typeof process.loadEnvFile === "function") {
+    process.loadEnvFile(path);
+    return;
+  }
+  for (const line of readFileSync(path, "utf8").split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#"))
+      continue;
+    const match = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/.exec(trimmed);
+    if (!match)
+      continue;
+    const key = match[1];
+    const rawValue = match[2];
+    if (!key || rawValue === undefined)
+      continue;
+    const value = rawValue.replace(/^['"]|['"]$/g, "");
+    process.env[key] ??= value;
+  }
+}
+
+// src/index.ts
+loadCliEnv();
+var cli = Cli.create("baseline", {
+  version: "0.1.0",
+  description: "Baseline Markets CLI",
+  sync: {
+    include: [skillsGlob],
+    suggestions: [
+      "build launch calls for a new Baseline token",
+      "output launch calls as JSON for wallet_sendCalls"
+    ]
+  }
+}).command("launch", launchCommand).command("info", infoCommand);
+if (import.meta.url === `file://${process.argv[1]}`) {
+  await cli.serve();
+}
+export {
+  cli
+};

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@baseline-markets/cli",
+  "version": "0.2.0",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/0xBaseline/baseline-mono.git",
+    "directory": "packages/cli"
+  },
+  "bin": {
+    "baseline": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "skills"
+  ],
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "scripts": {
+    "dev": "bun src/index.ts",
+    "build": "bun build src/index.ts --target=node --outdir=dist --external @baseline-markets/sdk --external incur --external viem",
+    "prepublishOnly": "bun run build",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "test:integration": "bun test tests/*.integration.test.ts"
+  },
+  "dependencies": {
+    "@baseline-markets/sdk": "^1.1.0",
+    "incur": "^0.4.8",
+    "viem": "^2.31.6"
+  },
+  "devDependencies": {
+    "@baseline/chains": "workspace:*",
+    "@types/bun": "latest",
+    "typescript": "^5.8.3"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/skills/aeon-baseline/SKILL.md

@@ -0,0 +1,154 @@
+---
+name: aeon-baseline
+description: Execute a Baseline launch call artifact through an Aeon operator workflow.
+var: ""
+tags: [crypto, onchain]
+capabilities: [external_api, writes_external_host, onchain_writes, sends_notifications]
+---
+
+> **${var}** - Path to a saved `baseline launch` JSON artifact, or empty
+> when `run.vars.launchArtifact` already contains the artifact object. If
+> neither is available, notify `LAUNCH_BASELINE_NO_ARTIFACT` and stop.
+
+Today is ${today}. Execute a Baseline launch call artifact through the
+configured Aeon operator surface without inventing calldata, signers, or wallet
+policy.
+
+## Required Config
+
+- `AEON_RUN_URL` is required only when dispatching this skill through the
+  repository CLI executor.
+- `AEON_AUTH_TOKEN` is optional and is sent as `Authorization: Bearer ...` by
+  the CLI executor when configured.
+- The launch artifact must already be produced by `baseline launch`.
+- Aeon execution is Base mainnet only in v1.
+- Register this skill in an Aeon instance by copying this folder under
+  `skills/`, running `./generate-skills-json`, and adding an `aeon.yml` entry
+  with `enabled: false` and `schedule: "manual"` until an operator explicitly
+  enables it.
+
+## CLI Artifact Contract
+
+`baseline launch` builds and validates the canonical call artifact. The
+`--output` file is the source of truth:
+
+```json
+{
+  "chainId": 8453,
+  "chain": "base",
+  "account": "0xAeonOperatorWallet",
+  "bToken": "0x...",
+  "calls": [{ "to": "0x...", "data": "0x...", "value": "0x0" }]
+}
+```
+
+Required Aeon launch inputs:
+
+- `--mode zrp` or `--mode standard`
+- `--chain-id 8453`
+- `--account "$AEON_OPERATOR_WALLET"`
+- `--name "$TOKEN_NAME"`
+- `--symbol "$TOKEN_SYMBOL"`
+- `--reserve 0x4200000000000000000000000000000000000006`
+- `--total-supply "$TOTAL_SUPPLY"`
+- `--initial-pool-btokens "$POOL_BTOKENS"` for `standard`
+- `--initial-pool-reserves "$RESERVE_SEED"` for `standard`
+- `--output .context/launches/aeon-launch.json`
+
+Key optional controls:
+
+- Fees: `--swap-fee-pct` and `--creator-fee-pct`.
+- Parties and salt: `--creator`, `--fee-recipient`, and `--salt`.
+
+Build the handoff artifact before running this skill:
+
+```sh
+baseline launch \
+  --mode zrp \
+  --chain-id 8453 \
+  --account "$AEON_OPERATOR_WALLET" \
+  --name "$TOKEN_NAME" \
+  --symbol "$TOKEN_SYMBOL" \
+  --reserve 0x4200000000000000000000000000000000000006 \
+  --total-supply "$TOTAL_SUPPLY" \
+  --output .context/launches/aeon-launch.json
+```
+
+Before Aeon execution, verify `chainId`, `account`, call count, call order,
+allowed targets, and selected mode economics. `zrp` artifacts use
+three calls and all BTokens in the pool. `standard` artifacts use four calls,
+a nonzero reserve seed, and `createPool`.
+
+## Steps
+
+1. **Load the artifact.** If `run.vars.launchArtifact` exists, use it.
+   Otherwise read the JSON file path from `${var}`. If both are absent, run:
+
+```sh
+./notify "LAUNCH_BASELINE_NO_ARTIFACT: provide var=<path-to-launch-artifact.json> or run.vars.launchArtifact"
+```
+
+Then stop.
+
+2. **Validate the artifact.** Confirm:
+
+- `chainId` is `8453`.
+- `account` is present and is the expected Aeon operator wallet.
+- `calls` is an array with exactly three or four items.
+- Every call has `to`, `data`, and `value`.
+
+3. **Validate transaction shape.** Confirm the call order matches the selected
+   mode:
+
+- `zrp`: Relay `createBToken`, BToken `approve`, Relay
+  `createPoolFromInvariant`.
+- `standard`: Relay `createBToken`, BToken `approve`, reserve `approve`, Relay
+  `createPool`.
+
+Reject any artifact whose targets are outside the Baseline Relay, precomputed
+BToken, and reserve token.
+
+4. **Respect the executor boundary.** Do not sign directly, do not ask for a
+   private key, and do not rebuild calldata by hand. Use the artifact calls
+   exactly as produced by the CLI or abort with a notification explaining the
+   mismatch.
+
+5. **Submit through the configured Aeon operator workflow.** If this skill is
+   running inside Aeon with a wallet-capable operator surface, submit the
+   ordered Base mainnet calls according to that operator's configured wallet
+   policy. If no wallet execution surface is configured, emit a handoff
+   notification and stop without broadcasting.
+
+6. **Verify on-chain state.** After a successful run, perform read-only checks:
+
+- BToken code is non-empty.
+- Maker initialization is true.
+- Reserve equals Base WETH.
+- Creator and fee recipient match the artifact expectations.
+- For `zrp`, total reserves and deployer BToken balance are `0`.
+
+7. **Log.** Append to `memory/logs/${today}.md`:
+
+```markdown
+## aeon-baseline
+- Artifact: ARTIFACT_PATH_OR_INLINE
+- Chain ID: 8453
+- Account: ACCOUNT
+- Status: SUBMITTED | HANDOFF_READY | VERIFIED | REJECTED
+- Transaction hashes: HASHES_OR_NONE
+```
+
+8. **Notify.** Send a notification under 4000 characters:
+
+```text
+Baseline launch: STATUS
+Account: ACCOUNT
+Txs: HASHES_OR_HANDOFF
+Next: verification summary or rejection reason
+```
+
+## Sandbox Note
+
+Authenticated wallet or run APIs may not be reachable from the Claude sandbox.
+If secrets are unavailable, do not fail noisily or fabricate execution. Notify
+`LAUNCH_BASELINE_HANDOFF_READY`, write the handoff details to memory, and stop.

package/skills/bankr-baseline/SKILL.md

@@ -0,0 +1,260 @@
+---
+name: bankr-baseline
+description: Build Baseline launch call artifacts and submit them with Bankr Wallet API
+tags: [crypto, baseline, token, erc20]
+version: 1
+---
+
+# Bankr Baseline
+
+Use this skill when a user wants an agent to plan and deploy a Baseline token
+with this repository's `baseline` CLI and Bankr's Wallet API.
+
+## Skill Contract
+
+| Field | Requirement |
+|---|---|
+| Purpose | Build, review, and submit explicit Baseline launch calls. |
+| Supported chain | Confirmed Bankr execution uses Base mainnet, chain ID `8453`. |
+| Pending validation | Base Sepolia `84532` needs authenticated Wallet API validation before Bankr execution. |
+| Planner | The local `baseline` CLI is the launch calldata builder. |
+| Protocol surface | The CLI uses Baseline SDK/protocol helpers for economics, addresses, and calldata. |
+| Wallet executor | Bankr provides wallet identity, signing, and transaction submission only. |
+| Allowed Bankr endpoints | `GET /wallet/me` and `POST /wallet/submit`. |
+| Canonical artifact | `baseline launch` call artifact with `{ chainId, chain, account, bToken, calls }`. |
+| Hard stops | No private keys, Bankr native launches, Agent API prompts, or hand-built calldata. |
+
+Base MCP remains the confirmed Sepolia test executor in this repository. Bankr
+Wallet API docs document explicit transaction submission by `chainId`, but do
+not currently document Base Sepolia `84532` as supported. Do not use Bankr for
+Base Sepolia execution until an authenticated validation run proves support.
+
+## Protocol Constants
+
+| Chain | Chain ID | Reserve | Use |
+|---|---:|---|---|
+| Base Sepolia | `84532` | `0xB85885897D297000A74eA2e4711C3Ca729461ABC` | Pending Bankr validation. |
+| Base mainnet | `8453` | `0x4200000000000000000000000000000000000006` | Approved production launches. |
+
+Baseline Relay proxy on both profiles:
+`0xc81Fd894C0acE037d133aF4886550aC8133568E8`.
+
+## Required Setup
+
+- `BANKR_API_KEY` must be set only in the local execution environment or secret
+  manager.
+- Optional: `BANKR_API_BASE`, defaulting to `https://api.bankr.bot`.
+- The Bankr key must have Wallet API write access enabled and must not be
+  read-only.
+- Raw `/wallet/submit` cannot be used when the key has `allowedRecipients`
+  restrictions, because Bankr blocks raw submissions for those keys.
+- The Bankr EVM wallet returned by `/wallet/me` is the Baseline launch
+  `account` unless the user explicitly chooses another supported policy.
+
+## CLI Artifact Contract
+
+The CLI is the only Baseline launch calldata builder in this workflow. It
+collects launch inputs, applies defaults, calls SDK-backed protocol helpers,
+builds ordered raw calls, and writes a JSON artifact. It does not custody keys
+or sign transactions.
+
+`baseline launch` writes the canonical artifact:
+
+```json
+{
+  "chainId": 8453,
+  "chain": "base",
+  "account": "0xBankrWallet",
+  "bToken": "0x...",
+  "calls": [{ "to": "0x...", "data": "0x...", "value": "0x0" }]
+}
+```
+
+Required Bankr launch flags:
+
+| Flag | Required value | Description |
+|---|---|---|
+| `--mode` | `zrp` by default, `standard` when a reserve seed is required | Selects the Baseline launch path. |
+| `--chain-id` | `8453` | Keeps Bankr on the confirmed Base mainnet execution chain. |
+| `--account` | `"$BANKR_WALLET"` | Uses the EVM wallet returned by Bankr `/wallet/me`. |
+| `--name` | `"$TOKEN_NAME"` | Sets the BToken name passed to the Baseline Relay. |
+| `--symbol` | `"$TOKEN_SYMBOL"` | Sets the BToken symbol passed to the Baseline Relay. |
+| `--reserve` | Base mainnet WETH | Uses the confirmed reserve token. |
+| `--total-supply` | Launch-specific supply | Sets human-unit total supply. |
+| `--initial-pool-btokens` | Required for `standard`; omit for `zrp` | Sets the pool BToken amount while leaving circulating supply. |
+| `--initial-pool-reserves` | Required for `standard` | Sets the reserve seed. |
+| `--output` | `.context/launches/bankr-launch.json` | Saves the artifact under `.context/`. |
+
+Important optional launch flags:
+
+| Category | Flags | Description |
+|---|---|---|
+| Fees | `--swap-fee-pct`, `--creator-fee-pct` | Defaults are `1%` and `50%`; swap fee protocol bounds are `0.15%` to `50%`. |
+| Parties | `--creator`, `--fee-recipient` | Creator defaults to `account`; fee recipient defaults to creator. |
+| Salt | `--salt` | Sets deterministic BToken salt; empty input uses zero `bytes32`. |
+
+## Default Launch Profile
+
+### ZRP
+
+| Setting | Default | Notes |
+|---|---|---|
+| Mode | `zrp` | Default launch path. |
+| Chain ID | `8453` for Bankr | Bankr remains Base mainnet only. |
+| Supply | `100B` | Human-unit total supply when not overridden. |
+| Pool BTokens | Derived from `totalSupply` | Deployer BToken balance is `0`. |
+| Pool reserves | `0` | No reserve approval is expected. |
+| Reserve | Base mainnet WETH | `0x4200000000000000000000000000000000000006`. |
+| Swap fee | `1%` | Must stay within protocol bounds. |
+| Creator fee share | `50%` | Creator share of pool fees. |
+| Creator | Bankr EVM wallet | Override only when explicitly requested. |
+| Fee recipient | Creator | Override only when explicitly requested. |
+| `createHook` | `true` | Matches the current SDK launch params. |
+
+### Standard
+
+| Setting | Default | Notes |
+|---|---|---|
+| Mode | `standard` | Explicit standard launch path. |
+| Chain ID | `8453` for Bankr | Bankr remains Base mainnet only. |
+| Pool BTokens | User supplied | Must leave circulating supply. |
+| Pool reserves | User supplied | Must be nonzero. |
+| Pool creation | `createPool` | Uses the `createPool` Relay flow. |
+| Shared fees and parties | Same as `zrp` | Override only with explicit fee, creator, or recipient flags. |
+| `createHook` | `true` | Matches the current SDK launch params. |
+
+## Baseline Launch Call Sequence
+
+The Baseline protocol launch is represented as an ordered call sequence inside
+the CLI-generated artifact. Bankr does not decide this sequence. Bankr only
+identifies the wallet and signs/submits the explicit calls that the CLI
+produces.
+
+For `zrp`, the sequence is:
+
+| Order | Step | Transaction purpose |
+|---|---|---|
+| 1 | `createBToken` | Deploy the planned BToken through the Baseline Relay. |
+| 2 | BToken `approve` | Approve the Baseline Relay to move the full BToken supply for pool creation. |
+| 3 | `createPoolFromInvariant` | Create the pool from the computed invariant and planned params. |
+
+For `standard`, the sequence is:
+
+| Order | Step | Transaction purpose |
+|---|---|---|
+| 1 | `createBToken` | Deploy the planned BToken through the Baseline Relay. |
+| 2 | BToken `approve` | Approve the Baseline Relay to move the planned BToken pool allocation. |
+| 3 | Reserve `approve` | Approve the Baseline Relay to move the planned reserve seed. |
+| 4 | `createPool` | Create the pool with standard params, fees, creator, and fee recipient. |
+
+These calls are dependent. If a live run partially completes, do not replay the
+full sequence blindly. Verify the last completed on-chain step and recover from
+that exact state.
+
+## Execution Plan
+
+1. Resolve the Bankr EVM wallet with `/wallet/me`.
+2. Use that wallet as `--account` for the local CLI artifact builder.
+3. Confirm the user explicitly approved a Bankr Base mainnet run.
+4. Run `baseline launch --chain-id 8453` and save the artifact.
+5. Review the saved artifact: `chainId`, `account`, ordered call count, call
+   targets, and call data.
+6. Submit each artifact call through Bankr Wallet API `/wallet/submit` in
+   order. Wait for each submission result before sending the next dependent
+   call.
+7. Verify on-chain state and store one-off run notes under `.context/`.
+
+## Commands
+
+Read the Bankr wallet identity:
+
+```sh
+BANKR_API_BASE="${BANKR_API_BASE:-https://api.bankr.bot}"
+curl -s "$BANKR_API_BASE/wallet/me" \
+  -H "X-API-Key: $BANKR_API_KEY"
+```
+
+Build a Bankr Base mainnet artifact with the local CLI:
+
+```sh
+baseline launch \
+  --mode zrp \
+  --chain-id 8453 \
+  --account "$BANKR_WALLET" \
+  --name "$TOKEN_NAME" \
+  --symbol "$TOKEN_SYMBOL" \
+  --reserve 0x4200000000000000000000000000000000000006 \
+  --total-supply "$TOTAL_SUPPLY" \
+  --output .context/launches/bankr-launch.json
+```
+
+For a `standard` launch, include `--initial-pool-reserves "$RESERVE_SEED"` and
+set `--initial-pool-btokens` below `--total-supply`.
+
+Submit each call in order through Bankr:
+
+```http
+POST /wallet/submit
+X-API-Key: $BANKR_API_KEY
+Content-Type: application/json
+
+{
+  "chainId": 8453,
+  "to": "<call.to>",
+  "data": "<call.data>",
+  "value": "<call.value>"
+}
+```
+
+## Review Checklist
+
+Before any live submission, confirm:
+
+- The user explicitly authorized Bankr live execution on Base mainnet.
+- `BANKR_API_KEY` is set for a live run and is not exposed in tracked files.
+- `/wallet/me` returns an EVM wallet address.
+- `artifact.chainId` is `8453`.
+- `artifact.account` equals the Bankr EVM wallet unless the user explicitly
+  chose another supported policy.
+- The transaction order and count match the selected CLI mode.
+- Transaction targets are limited to the Baseline Relay, precomputed BToken,
+  and reserve token.
+- `zrp` artifacts use all BTokens in the pool and no reserve approval.
+- `standard` artifacts include the intended reserve seed and circulating supply.
+
+## Verification
+
+After a successful live run, perform read-only verification:
+
+- BToken code is non-empty.
+- `bLens.getMaker(bToken).initialized` is true.
+- `bLens.reserve(bToken)` equals the planned chain reserve.
+- `bLens.creator(bToken)` equals the planned creator.
+- `bLens.poolFeeRecipient(bToken)` equals the planned fee recipient.
+- For `zrp`, total reserves and deployer BToken balance are both `0`.
+- For `standard`, deployer BToken balance matches the planned circulating
+  allocation, allowing for integer division.
+
+## Rejection Rules
+
+Stop before live submission if:
+
+- The user has not explicitly authorized Bankr live execution.
+- Base mainnet execution is implied but not explicitly approved.
+- `BANKR_API_KEY` is missing for a live run.
+- `/wallet/me` does not return an EVM wallet address.
+- The artifact is not for chain ID `8453`.
+- The prepared transaction order or count differs from the selected CLI mode.
+- Any requested flow involves raw private keys, seed phrases, local production
+  signing, Bankr native launch endpoints, or Agent API prompts.
+
+## Troubleshooting
+
+- `403`: confirm Wallet API write access, read-only mode, IP allowlist, and
+  absence of `allowedRecipients` restrictions.
+- Base Sepolia requested: use Base MCP for the confirmed Sepolia path, or run a
+  separate authenticated Bankr validation task before enabling Bankr Sepolia.
+- Missing transaction hash: treat the phase as ambiguous and perform read-only
+  on-chain verification before retrying.
+- Partial failure: do not replay the full sequence blindly. Recover from the
+  exact last verified phase.

package/skills/base-mcp-baseline/SKILL.md

@@ -0,0 +1,33 @@
+---
+name: base-mcp-baseline
+description: Vendors the Baseline plugin for Base MCP so agents can launch Baseline tokens with the Baseline CLI and Base Account approval. Use when a user wants to use Base MCP, Base Account, send_calls, or the Baseline CLI to prepare and submit a Baseline token launch.
+---
+
+# Baseline Base MCP
+
+This skill packages the Baseline Base MCP plugin with `@baseline-markets/cli`.
+The plugin file is the source of truth; do not duplicate or improvise the launch
+workflow here.
+
+## Quick Start
+
+1. If the installed Base MCP skill already includes a native `baseline` plugin,
+   use that native plugin.
+2. Otherwise, read and follow [plugins/baseline.md](plugins/baseline.md).
+3. Use the local `baseline` binary when available; otherwise use the `npx`
+   command documented in the plugin.
+
+## Boundary
+
+- The installed Base MCP skill/server is still required.
+- The Baseline CLI prepares unsigned launch call artifacts.
+- Base MCP provides wallet identity, Base Account approval, submission, and
+  request-status polling.
+- Do not use `baseline launch --execute` in the Base MCP flow.
+- Do not ask for, load, print, or use a private key.
+
+## Distribution
+
+This wrapper exists so users who discover Baseline through the CLI can install
+the same Base MCP plugin instructions before the plugin is available natively in
+their Base MCP skill bundle.

package/skills/base-mcp-baseline/plugins/baseline.md

@@ -0,0 +1,240 @@
+---
+title: "Baseline Plugin"
+description: "Launch Baseline tokens with the Baseline CLI, then submit unsigned calls through Base MCP send_calls."
+tags: [token-launches, liquidity]
+name: baseline
+version: 0.1.0
+integration: cli-only
+chains: [base, base-sepolia]
+requires:
+  shell: required
+  allowlist: []
+  externalMcp: null
+  cliPackage: "npx @baseline-markets/cli@latest"
+auth: none
+risk: [irreversible, local-exec, low-liquidity]
+---
+
+# Baseline Plugin
+
+> [!IMPORTANT]
+> Run Base MCP onboarding first (defined by the installed Base MCP SKILL.md). This plugin requires a shell-capable harness and a connected Base Account.
+
+## Overview
+
+Baseline is an onchain AMM for leveraged tokens. This plugin launches a
+Baseline token on Base or Base Sepolia by running the Baseline CLI to prepare
+unsigned launch calls, then submitting those calls through Base MCP
+`send_calls` for Base Account approval and execution.
+
+## Installation
+
+No additional MCP server is required. The plugin shells out to the Baseline CLI
+for each prepare step.
+
+Use an installed CLI when available:
+
+```sh
+baseline launch --help
+```
+
+Otherwise invoke the package with `npx`:
+
+```sh
+npx @baseline-markets/cli@latest launch --help
+```
+
+## Surface Routing
+
+| Capability | Shell-capable surfaces | Shell-less / chat-only surfaces |
+|---|---|---|
+| Build launch calldata | Run `baseline launch` or `npx @baseline-markets/cli@latest launch`. | Stop. This plugin is CLI-only and must not use `web_request`, user-paste, or hand-built calldata as a workaround. |
+| Submit prepared calls | Use Base MCP `send_calls`. | Stop unless the surface exposes both Base MCP tools and a way to run the CLI. |
+| Check request status | Use Base MCP `get_request_status` after the user approves in Base Account. | Stop unless the pending request came from a supported CLI prepare flow. |
+
+## Commands
+
+`baseline launch` writes an unsigned call artifact:
+
+```json
+{
+  "chainId": 84532,
+  "chain": "base-sepolia",
+  "account": "0xBaseAccount",
+  "bToken": "0xBToken",
+  "calls": [
+    { "to": "0xTarget", "data": "0xCalldata", "value": "0x0" }
+  ]
+}
+```
+
+Default Base Sepolia zero-reserve launch:
+
+```sh
+baseline launch \
+  --mode zrp \
+  --chain-id 84532 \
+  --account "$BASE_ACCOUNT" \
+  --name "$TOKEN_NAME" \
+  --symbol "$TOKEN_SYMBOL" \
+  --reserve 0xB85885897D297000A74eA2e4711C3Ca729461ABC \
+  --total-supply "$TOTAL_SUPPLY" \
+  --output .context/launches/baseline-launch.json
+```
+
+Standard launch with reserve liquidity:
+
+```sh
+baseline launch \
+  --mode standard \
+  --chain-id 84532 \
+  --account "$BASE_ACCOUNT" \
+  --name "$TOKEN_NAME" \
+  --symbol "$TOKEN_SYMBOL" \
+  --reserve 0xB85885897D297000A74eA2e4711C3Ca729461ABC \
+  --total-supply "$TOTAL_SUPPLY" \
+  --initial-pool-btokens "$POOL_BTOKENS" \
+  --initial-pool-reserves "$RESERVE_SEED" \
+  --output .context/launches/baseline-launch.json
+```
+
+Base mainnet uses `--chain-id 8453` and WETH reserve
+`0x4200000000000000000000000000000000000006`. Treat mainnet as production and
+confirm the user explicitly requested it before preparing calls.
+
+Do not pass `--execute` or `--private-key` in this plugin flow. Base MCP is the
+only submission path.
+
+## Orchestration
+
+### Launch
+
+1. Complete Base MCP onboarding and confirm Base MCP tools are available.
+2. Call `get_wallets`, confirm the selected chain is in `supportedChains`, and
+   use the in-session Base Account address as `BASE_ACCOUNT`. If the Base
+   Account is not in session, stop and ask the user to reconnect Base MCP.
+3. Gather token name, symbol, total supply, launch mode, and chain. Default to
+   Base Sepolia `84532` and `zrp` unless the user explicitly chooses otherwise.
+4. For `standard`, require both `POOL_BTOKENS` and a nonzero `RESERVE_SEED`.
+   `POOL_BTOKENS` must be less than `TOTAL_SUPPLY` so some supply remains
+   circulating.
+5. Run `baseline launch` with `--output`. If the CLI exits nonzero, fix inputs
+   and rerun; do not salvage partial output.
+6. Parse the artifact JSON and validate it before submission:
+   - `account` equals the connected Base Account.
+   - `chainId` is `84532` or `8453`.
+   - `chain` is `base-sepolia` or `base`.
+   - `bToken` is a valid address.
+   - `calls` is an ordered array and every call has `to`, `data`, and `value`.
+   - No `execution` field is present.
+   - `zrp` has three calls; `standard` has four calls.
+7. Submit the calls through `send_calls` as described in `## Submission`.
+8. Show the returned `approvalUrl` as an "Approve Transaction" link and open it
+   with the local shell when the harness supports that.
+9. Wait for the user to confirm they approved in Base Account, then call
+    `get_request_status(requestId)`. If it is still `pending`, retry with a
+    short delay; never report success until the request is `completed`.
+10. After completion, run
+    `baseline info "$BTOKEN" --chain-id "$CHAIN_ID"` using the artifact
+    `bToken` and `chainId`.
+
+## Submission
+
+Submit with Base MCP `send_calls`.
+
+Map the artifact exactly:
+
+```json
+{
+  "chain": "base-sepolia",
+  "calls": [
+    { "to": "0xTarget", "data": "0xCalldata", "value": "0x0" }
+  ]
+}
+```
+
+Use `artifact.chain` directly. Preserve call order and do not edit calldata. Do
+not include `artifact.account` in the `send_calls` payload; Base MCP uses the
+connected Base Account session for approval and execution.
+
+Expected call sequences:
+
+- `zrp`: Relay `createBToken`, BToken `approve`, Relay
+  `createPoolFromInvariant`.
+- `standard`: Relay `createBToken`, BToken `approve`, reserve `approve`, Relay
+  `createPool`.
+
+Any `send_calls` approval URL follows the Base MCP approval flow: show an
+"Approve Transaction" link, open it from shell-capable harnesses, wait for the
+user to approve in Base Account, then poll `get_request_status`.
+
+## Example Prompts
+
+Launch a Base Sepolia test token:
+
+1. Get the Base Account with `get_wallets`.
+2. Run the `zrp` Base Sepolia `baseline launch` command with the requested name,
+   symbol, and supply.
+3. Validate the artifact and call count.
+4. Submit `artifact.calls` to `send_calls` with `chain: artifact.chain`.
+5. Wait for approval, poll status, then run `baseline info`.
+
+Launch a standard token with seed liquidity:
+
+1. Require `POOL_BTOKENS` and `RESERVE_SEED`.
+2. Run `baseline launch --mode standard`.
+3. Confirm the artifact has four ordered calls.
+4. Submit the batch with `send_calls`.
+5. Wait for approval, poll status, then run `baseline info`.
+
+Launch on Base mainnet:
+
+1. Confirm the user explicitly requested Base mainnet production execution.
+2. Use chain ID `8453` and reserve
+   `0x4200000000000000000000000000000000000006`.
+3. Validate the artifact carefully before `send_calls`.
+4. Submit with `chain: "base"` only after the user confirms the mainnet launch.
+
+User asks to run from a phone or chat-only app:
+
+1. Stop.
+2. Explain that this plugin is CLI-only and requires a shell-capable harness.
+3. Do not use HTTP, pasted URLs, private keys, or hand-built calldata as a
+   workaround.
+
+## Risks & Warnings
+
+- `irreversible`: A submitted launch cannot be undone through this plugin.
+  Confirm chain, token name, symbol, supply, reserve, fees, creator, and fee
+  recipient before `send_calls`.
+- `local-exec`: The plugin runs the Baseline CLI on the user's machine. Use the
+  installed `baseline` binary when trusted by the user, or the documented `npx`
+  package invocation.
+- `low-liquidity`: New token pools may have thin liquidity and volatile prices.
+  Do not imply liquidity, execution quality, or market safety beyond the
+  explicit launch inputs.
+
+## Notes
+
+Constants:
+
+```text
+base.chain: base
+base.chainId: 8453
+base.reserve: 0x4200000000000000000000000000000000000006
+baseSepolia.chain: base-sepolia
+baseSepolia.chainId: 84532
+baseSepolia.reserve: 0xB85885897D297000A74eA2e4711C3Ca729461ABC
+relay: 0xc81Fd894C0acE037d133aF4886550aC8133568E8
+zeroBytes32: 0x0000000000000000000000000000000000000000000000000000000000000000
+```
+
+Default launch assumptions:
+
+- `zrp` is the default launch mode.
+- Swap fee defaults to `1%`; protocol bounds are `0.15%` to `50%`.
+- Creator fee share defaults to `50%`.
+- Creator defaults to the launch account.
+- Fee recipient defaults to creator.
+- Salt defaults to zero `bytes32`.
+- Reserve decimals default to `18`.

package/skills/launch/SKILL.md

@@ -0,0 +1,106 @@
+---
+name: launch
+description: Builds Baseline token launch artifacts with the Baseline CLI and optionally executes them with an explicit signer. Use when a user wants to launch a Baseline token, generate launch calls, create wallet_sendCalls JSON, or use `baseline launch`.
+---
+
+# Launch
+
+Use this skill to guide agents through `baseline launch`. The default workflow
+is to build and review an unsigned call artifact; execute only when the user
+explicitly asks for live submission.
+
+## Quick Start
+
+Show the command surface first when inputs are unclear:
+
+```sh
+baseline launch --help
+```
+
+Build a ZRP launch artifact:
+
+```sh
+baseline launch \
+  --mode zrp \
+  --chain-id "$CHAIN_ID" \
+  --account "$ACCOUNT" \
+  --name "$TOKEN_NAME" \
+  --symbol "$TOKEN_SYMBOL" \
+  --reserve "$RESERVE" \
+  --total-supply "$TOTAL_SUPPLY" \
+  --output .context/launches/baseline-launch.json
+```
+
+## Artifact Contract
+
+`baseline launch` writes wallet_sendCalls-compatible JSON:
+
+```json
+{
+  "chainId": 84532,
+  "chain": "base-sepolia",
+  "account": "0x...",
+  "bToken": "0x...",
+  "calls": [{ "to": "0x...", "data": "0x...", "value": "0x0" }]
+}
+```
+
+Before handing the artifact to any wallet or execution layer, verify:
+
+- `chainId`, `chain`, and `account` match the intended wallet and chain.
+- `chain` is the executor chain slug, for example `base-sepolia`.
+- `bToken` is the predicted address, not proof of deployment.
+- `calls` is ordered and every call has `to`, `data`, and `value`.
+- `zrp` has three calls; `standard` has four calls.
+- No `execution` field is present unless the user intentionally used
+  `--execute`.
+
+After submission, inspect deployment status and links with:
+
+```sh
+baseline info "$BTOKEN" --chain-id "$CHAIN_ID"
+```
+
+## Launch Modes
+
+`zrp` is the default zero-reserve launch mode. It derives pool BTokens from
+`--total-supply`, has no reserve seed, and has no reserve approval call.
+
+`standard` launches with reserve liquidity and requires both pool BTokens and a
+reserve seed:
+
+```sh
+baseline launch \
+  --mode standard \
+  --chain-id "$CHAIN_ID" \
+  --account "$ACCOUNT" \
+  --name "$TOKEN_NAME" \
+  --symbol "$TOKEN_SYMBOL" \
+  --reserve "$RESERVE" \
+  --total-supply "$TOTAL_SUPPLY" \
+  --initial-pool-btokens "$POOL_BTOKENS" \
+  --initial-pool-reserves "$RESERVE_SEED" \
+  --output .context/launches/baseline-launch.json
+```
+
+## Execution
+
+Only execute when the user explicitly asks for local signer submission.
+
+Reuse the artifact command and add `--execute --private-key "$PRIVATE_KEY"`.
+`BASELINE_PRIVATE_KEY` may be used instead of `--private-key`. `--account` is
+optional with `--execute` because the CLI can derive it from the private key.
+The CLI sends sequential transactions and returns `execution.transactions`.
+Do not use `--execute` for external executors such as Base MCP, Bankr, or Aeon;
+those consume `artifact.calls`.
+Never print, commit, or persist private keys.
+
+## Defaults And Notes
+
+- `--chain-id` must be a chain supported by the installed Baseline CLI/SDK.
+- `--reserve` must be the intended reserve token on that chain.
+- Require explicit user approval before preparing or executing a production
+  launch.
+- Swap fee defaults to `1%`; creator fee share defaults to `50%`.
+- Creator defaults to `account`; fee recipient defaults to creator.
+- Salt is optional and must be bytes32 when provided.