@otonix/cli 0.1.0

package/README.md

@@ -0,0 +1,89 @@
+# @otonix/cli
+
+Otonix CLI — deploy autonomous agent tokens on Base chain via Clanker v3.1 (LP Legacy).
+
+## Install
+
+```bash
+npm install -g @otonix/cli
+```
+
+Or run locally (dev):
+
+```bash
+bash cli/otonix.sh <command>
+```
+
+## Quick Start
+
+```bash
+# 1. Generate a new Base creator wallet
+otonix wallet generate
+
+# 2. Fund the wallet
+#    → Send ≥200 $OTX (agent activation)
+#    → Send ETH for gas
+
+# 3. Create an agent (generates isolated Base wallet)
+otonix agent:create --name "MyAgent"
+
+# 4. Fund agent wallet with ~0.002 ETH (shown after create)
+
+# 5. Deploy a token!
+otonix launch token \
+  --agent MyAgent \
+  --name "CoolToken" \
+  --ticker "COOL" \
+  --description "My agent token"
+```
+
+## Commands
+
+### Wallet
+
+```bash
+otonix wallet generate     # Generate new Base creator wallet
+otonix wallet import       # Import wallet from private key
+otonix wallet export       # Show private key (careful!)
+otonix wallet balance      # Show ETH + $OTX balance
+otonix wallet address      # Show wallet address
+```
+
+### Agents
+
+```bash
+otonix agent:create --name MyAgent    # Create isolated agent wallet (requires 200 $OTX)
+otonix agent:info MyAgent             # Show agent address + balances
+otonix agent:list                     # List all agents
+otonix agent:remove MyAgent           # Remove agent from local config
+```
+
+### Launch
+
+```bash
+otonix launch token \
+  --agent MyAgent \
+  --name "CoolToken" \
+  --ticker "COOL" \
+  --image "https://..." \          # Optional
+  --description "My token" \      # Optional
+  --mcap 10 \                      # Initial market cap in ETH (default: 10)
+  --devbuy 0                       # Dev buy in ETH (default: 0)
+```
+
+## Config
+
+Stored at `~/.otonix/config.json`. Contains wallet and agent private keys — keep it safe.
+
+## Technical Details
+
+- **LP Protocol**: Clanker v4 (Uniswap v4, POOL_POSITIONS.Standard)
+- **Paired Token**: WETH on Base (`0x4200000000000000000000000000000000000006`)
+- **Fee split**: 80% creator (WETH) / 20% Otonix treasury
+- **Chain**: Base Mainnet
+
+## Requirements
+
+- Node.js ≥ 18
+- ≥200 $OTX on creator wallet (Base)
+- ETH in agent wallet for gas (~0.001–0.003 ETH per deploy)

package/dist/commands/agent.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function agentCommand(program: Command): void;

package/dist/commands/agent.js

@@ -0,0 +1,173 @@
+import { confirm } from "@inquirer/prompts";
+import ora from "ora";
+import chalk from "chalk";
+import { loadConfig, saveConfig } from "../lib/config.js";
+import { generateWallet, getEthBalance, getOtxBalance, formatOtx, getOtxBalance as checkOtx, OTX_REQUIRED, } from "../lib/chain.js";
+import { header, row, success, failure, info, br, warn, mono } from "../lib/display.js";
+export function agentCommand(program) {
+    program
+        .command("agent:create")
+        .description("Create a new autonomous agent with an isolated Base wallet")
+        .requiredOption("--name <name>", "Agent name (alphanumeric, no spaces)")
+        .action(async (opts) => {
+        header("Create Agent");
+        const name = opts.name.trim();
+        if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
+            failure("Agent name must be alphanumeric (a-z, 0-9, _, -)");
+            process.exit(1);
+        }
+        const cfg = loadConfig();
+        if (!cfg.wallet) {
+            failure("No wallet. Run: otonix wallet generate first.");
+            process.exit(1);
+        }
+        const spinner = ora("Checking $OTX balance...").start();
+        let otxBal;
+        try {
+            otxBal = await checkOtx(cfg.wallet.address);
+        }
+        catch {
+            spinner.stop();
+            failure("Failed to check $OTX balance. Check your connection.");
+            process.exit(1);
+        }
+        spinner.stop();
+        if (otxBal < OTX_REQUIRED) {
+            const have = formatOtx(otxBal);
+            failure(`Insufficient $OTX. Need 200.000, have ${have}.`);
+            info("Buy $OTX at: https://app.uniswap.org or on DexScreener");
+            process.exit(1);
+        }
+        if (cfg.agents[name]) {
+            const overwrite = await confirm({
+                message: `Agent "${name}" already exists. Replace it?`,
+                default: false,
+            });
+            if (!overwrite) {
+                info("Cancelled.");
+                return;
+            }
+        }
+        const genSpinner = ora("Generating isolated agent wallet on Base...").start();
+        await new Promise(r => setTimeout(r, 600));
+        const agent = generateWallet();
+        genSpinner.stop();
+        cfg.agents[name] = {
+            address: agent.address,
+            privateKey: agent.privateKey,
+            createdAt: new Date().toISOString(),
+        };
+        saveConfig(cfg);
+        success(`Agent "${name}" created!`);
+        br();
+        row("Agent name", name);
+        row("Agent address", agent.address);
+        row("Created at", new Date().toLocaleString());
+        br();
+        console.log(chalk.dim("Next step — fund the agent wallet with ETH for gas:"));
+        console.log("  " + chalk.dim("Send") + " " + chalk.yellow("~0.001 ETH") + " " + chalk.dim("(Base) to:"));
+        console.log("  " + chalk.white(agent.address));
+        br();
+        console.log(chalk.dim("Then deploy a token:"));
+        console.log("  " + mono(`otonix launch token --agent ${name} --name "MyToken" --ticker "MTK"`));
+    });
+    program
+        .command("agent:info")
+        .description("Show info and balances for an agent")
+        .argument("<name>", "Agent name")
+        .action(async (name) => {
+        header(`Agent: ${name}`);
+        const cfg = loadConfig();
+        const agent = cfg.agents[name];
+        if (!agent) {
+            failure(`Agent "${name}" not found. Run: otonix agent:list`);
+            process.exit(1);
+        }
+        const spinner = ora("Fetching balances from Base...").start();
+        try {
+            const [eth, otx] = await Promise.all([
+                getEthBalance(agent.address),
+                getOtxBalance(agent.address),
+            ]);
+            spinner.stop();
+            br();
+            row("Agent name", name);
+            row("Address", agent.address);
+            row("Created at", new Date(agent.createdAt).toLocaleString());
+            br();
+            row("ETH balance", parseFloat(eth).toFixed(6) + " ETH");
+            row("$OTX balance", formatOtx(otx) + " OTX");
+            br();
+            const ethNum = parseFloat(eth);
+            if (ethNum < 0.0005) {
+                console.log(warn("⚠ ") + chalk.dim("Low ETH — fund this address with ≥0.001 ETH for gas:"));
+                console.log("  " + chalk.white(agent.address));
+            }
+            else {
+                console.log(chalk.green("✓ ") + chalk.dim("Ready to deploy tokens"));
+            }
+        }
+        catch {
+            spinner.stop();
+            failure("Failed to fetch balances.");
+            process.exit(1);
+        }
+    });
+    program
+        .command("agent:list")
+        .description("List all your agents")
+        .action(async () => {
+        header("Your Agents");
+        const cfg = loadConfig();
+        const names = Object.keys(cfg.agents);
+        if (names.length === 0) {
+            br();
+            info("No agents yet. Create one:");
+            info('  otonix agent:create --name "MyAgent"');
+            return;
+        }
+        br();
+        const spinner = ora(`Fetching balances for ${names.length} agent(s)...`).start();
+        const results = await Promise.all(names.map(async (n) => {
+            const a = cfg.agents[n];
+            try {
+                const eth = await getEthBalance(a.address);
+                return { name: n, address: a.address, eth: parseFloat(eth).toFixed(5) };
+            }
+            catch {
+                return { name: n, address: a.address, eth: "—" };
+            }
+        }));
+        spinner.stop();
+        for (const r of results) {
+            console.log(chalk.bold.white(r.name.padEnd(18)) +
+                chalk.dim(r.address.slice(0, 10) + "...") +
+                "  " +
+                chalk.yellow(r.eth + " ETH"));
+        }
+        br();
+        info(`${names.length} agent(s) total`);
+    });
+    program
+        .command("agent:remove")
+        .description("Remove an agent from local config")
+        .argument("<name>", "Agent name")
+        .action(async (name) => {
+        const cfg = loadConfig();
+        if (!cfg.agents[name]) {
+            failure(`Agent "${name}" not found.`);
+            process.exit(1);
+        }
+        const ok = await confirm({
+            message: `Remove agent "${name}" (${cfg.agents[name].address})? This only removes local config, not on-chain.`,
+            default: false,
+        });
+        if (!ok) {
+            info("Cancelled.");
+            return;
+        }
+        delete cfg.agents[name];
+        saveConfig(cfg);
+        success(`Agent "${name}" removed from local config.`);
+    });
+}

package/dist/commands/launch.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function launchCommand(program: Command): void;

package/dist/commands/launch.js

@@ -0,0 +1,208 @@
+import { confirm } from "@inquirer/prompts";
+import ora from "ora";
+import chalk from "chalk";
+import { loadConfig, OTONIX_TREASURY } from "../lib/config.js";
+import { getEthBalance, getOtxBalance, formatOtx, OTX_REQUIRED, BASE_RPC, } from "../lib/chain.js";
+import { header, row, failure, info, br, warn, } from "../lib/display.js";
+const WETH_BASE = "0x4200000000000000000000000000000000000006";
+const OTONIX_TWITTER = "otonix_tech";
+export function launchCommand(program) {
+    const launch = program.command("launch").description("Launch tokens via autonomous agents");
+    launch
+        .command("token")
+        .description("Deploy a token on Base via your agent (Clanker v4 / Uniswap v4)")
+        .requiredOption("--agent <name>", "Agent name to deploy with")
+        .requiredOption("--name <name>", "Token name (e.g. CoolToken)")
+        .requiredOption("--ticker <ticker>", "Token ticker/symbol (e.g. COOL)")
+        .requiredOption("--image <url>", "Token logo URL (https:// or ipfs://)")
+        .requiredOption("--description <text>", "Token description")
+        .option("--twitter <handle>", "Your Twitter/X handle (e.g. yourname) — shown in metadata")
+        .option("--devbuy <eth>", "Initial dev buy in ETH (default: 0)", "0")
+        .action(async (opts) => {
+        header("Launch Token");
+        const cfg = loadConfig();
+        if (!cfg.wallet) {
+            failure("No wallet. Run: otonix wallet generate");
+            process.exit(1);
+        }
+        const agent = cfg.agents[opts.agent];
+        if (!agent) {
+            failure(`Agent "${opts.agent}" not found. Run: otonix agent:list`);
+            process.exit(1);
+        }
+        const devBuyEth = parseFloat(opts.devbuy) || 0;
+        const minEthNeeded = 0.001 + devBuyEth;
+        const twitterHandle = opts.twitter?.replace(/^@/, "") ?? "";
+        const checkSpinner = ora("Checking requirements...").start();
+        let otxBal;
+        let agentEth;
+        try {
+            [otxBal, agentEth] = await Promise.all([
+                getOtxBalance(cfg.wallet.address),
+                getEthBalance(agent.address),
+            ]);
+        }
+        catch {
+            checkSpinner.stop();
+            failure("Failed to fetch balances. Check your connection.");
+            process.exit(1);
+        }
+        checkSpinner.stop();
+        let passed = true;
+        if (otxBal < OTX_REQUIRED) {
+            console.log(warn("⚠ ") + chalk.dim(`$OTX: ${formatOtx(otxBal)} / 200 required`));
+            passed = false;
+        }
+        else {
+            console.log(chalk.green("✓ ") + chalk.dim(`$OTX: ${formatOtx(otxBal)} (eligible)`));
+        }
+        if (parseFloat(agentEth) < minEthNeeded) {
+            console.log(warn("⚠ ") + chalk.dim(`Agent ETH: ${agentEth} — need ≥${minEthNeeded} ETH for gas${devBuyEth > 0 ? " + devbuy" : ""}`));
+            console.log(chalk.dim("  Send ETH to: ") + chalk.white(agent.address));
+            passed = false;
+        }
+        else {
+            console.log(chalk.green("✓ ") + chalk.dim(`Agent ETH: ${agentEth} (sufficient)`));
+        }
+        if (!passed) {
+            br();
+            failure("Pre-flight checks failed. Fix the issues above and try again.");
+            process.exit(1);
+        }
+        br();
+        console.log(chalk.bold.white("Token to deploy:"));
+        row("Name", opts.name);
+        row("Ticker", "$" + opts.ticker.toUpperCase());
+        row("Description", opts.description.slice(0, 60) + (opts.description.length > 60 ? "..." : ""));
+        row("Logo URL", opts.image.slice(0, 55) + (opts.image.length > 55 ? "..." : ""));
+        if (twitterHandle)
+            row("Twitter", "@" + twitterHandle);
+        row("Agent", opts.agent + "  (" + agent.address.slice(0, 10) + "...)");
+        row("Chain", "Base Mainnet");
+        row("LP protocol", "Clanker v4  (Uniswap v4)");
+        row("Paired token", "WETH");
+        if (devBuyEth > 0)
+            row("Dev buy", devBuyEth + " ETH");
+        row("Fee split", "80% → you (WETH)  /  20% → $OTX burn");
+        row("Verified by", "✓ Otonix (@" + OTONIX_TWITTER + ")");
+        br();
+        const confirmed = await confirm({
+            message: "Deploy this token? (agent wallet signs & pays gas)",
+            default: true,
+        });
+        if (!confirmed) {
+            info("Cancelled.");
+            return;
+        }
+        const deploySpinner = ora("Deploying token on Base (Clanker v4 / Uniswap v4)...").start();
+        try {
+            const { createWalletClient, createPublicClient, http } = await import("viem");
+            const { base } = await import("viem/chains");
+            const { privateKeyToAccount } = await import("viem/accounts");
+            const { Clanker } = await import("clanker-sdk/v4");
+            const { POOL_POSITIONS, FEE_CONFIGS } = await import("clanker-sdk");
+            const agentAccount = privateKeyToAccount(agent.privateKey);
+            const publicClient = createPublicClient({
+                chain: base,
+                transport: http(BASE_RPC),
+            });
+            const walletClient = createWalletClient({
+                account: agentAccount,
+                chain: base,
+                transport: http(BASE_RPC),
+            });
+            const clanker = new Clanker({
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                wallet: walletClient,
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                publicClient: publicClient,
+            });
+            const socialUrls = [
+                { platform: "x", url: `https://x.com/${OTONIX_TWITTER}` },
+            ];
+            if (twitterHandle) {
+                socialUrls.push({ platform: "x", url: `https://x.com/${twitterHandle}` });
+            }
+            const tokenConfig = {
+                name: opts.name,
+                symbol: opts.ticker.toUpperCase(),
+                tokenAdmin: cfg.wallet.address,
+                image: opts.image,
+                metadata: {
+                    description: opts.description,
+                    socialMediaUrls: socialUrls,
+                    auditUrls: [],
+                },
+                context: {
+                    interface: "Otonix",
+                    platform: "twitter",
+                    messageId: OTONIX_TWITTER,
+                    id: OTONIX_TWITTER,
+                },
+                pool: {
+                    pairedToken: WETH_BASE,
+                    positions: POOL_POSITIONS.Standard,
+                },
+                fees: FEE_CONFIGS.StaticBasic,
+                ...(devBuyEth > 0 ? { devBuy: { ethAmount: devBuyEth } } : {}),
+                rewards: {
+                    recipients: [
+                        {
+                            recipient: cfg.wallet.address,
+                            admin: cfg.wallet.address,
+                            bps: 8000,
+                            token: "Paired",
+                        },
+                        {
+                            recipient: OTONIX_TREASURY,
+                            admin: OTONIX_TREASURY,
+                            bps: 2000,
+                            token: "Both",
+                        },
+                    ],
+                },
+            };
+            const result = await clanker.deploy(tokenConfig);
+            if ("error" in result && result.error) {
+                deploySpinner.stop();
+                failure("Deploy failed: " + String(result.error.message ?? result.error));
+                process.exit(1);
+            }
+            const txHash = result.txHash;
+            deploySpinner.text = "Transaction sent — waiting for confirmation (~30s)...";
+            const waitResult = await result.waitForTransaction();
+            const tokenAddress = waitResult.address;
+            deploySpinner.stop();
+            br();
+            console.log(chalk.bold.hex("#4d6fff")("◈ Token deployed — Verified by Otonix ✓"));
+            console.log(chalk.dim("─".repeat(44)));
+            br();
+            row("Token name", opts.name);
+            row("Ticker", "$" + opts.ticker.toUpperCase());
+            row("Contract", tokenAddress ?? "—");
+            row("Tx hash", txHash.slice(0, 20) + "...");
+            row("Verified by", "✓ Otonix (@" + OTONIX_TWITTER + ")");
+            br();
+            row("Basescan", `https://basescan.org/token/${tokenAddress ?? ""}`);
+            row("DexScreener", `https://dexscreener.com/base/${tokenAddress ?? ""}`);
+            row("Clanker", `https://www.clanker.world/token/${tokenAddress ?? ""}`);
+            row("Otonix", `https://otonix.tech/launch`);
+            br();
+        }
+        catch (e) {
+            deploySpinner.stop();
+            if (e instanceof Error) {
+                failure("Deploy failed: " + e.message.slice(0, 300));
+                if (e.message.includes("insufficient funds")) {
+                    br();
+                    info("Agent ETH too low for gas. Send more ETH to:");
+                    info("  " + agent.address);
+                }
+            }
+            else {
+                failure("Unexpected error: " + String(e));
+            }
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/wallet.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function walletCommand(program: Command): void;

package/dist/commands/wallet.js

@@ -0,0 +1,166 @@
+import { password, confirm } from "@inquirer/prompts";
+import ora from "ora";
+import { loadConfig, saveConfig } from "../lib/config.js";
+import { getEthBalance, getOtxBalance, formatOtx, generateWallet, addressFromKey, OTX_REQUIRED, } from "../lib/chain.js";
+import { header, row, success, failure, info, br, warn } from "../lib/display.js";
+import chalk from "chalk";
+export function walletCommand(program) {
+    const wallet = program.command("wallet").description("Manage your Otonix creator wallet");
+    wallet
+        .command("generate")
+        .description("Generate a new Base wallet (creator wallet for token launches)")
+        .action(async () => {
+        header("Generate Creator Wallet");
+        const cfg = loadConfig();
+        if (cfg.wallet) {
+            const overwrite = await confirm({
+                message: `Wallet ${chalk.dim(cfg.wallet.address)} already exists. Replace it?`,
+                default: false,
+            });
+            if (!overwrite) {
+                info("Cancelled. Existing wallet kept.");
+                return;
+            }
+        }
+        const spinner = ora("Generating new Base wallet...").start();
+        await new Promise(r => setTimeout(r, 500));
+        const { address, privateKey } = generateWallet();
+        spinner.stop();
+        cfg.wallet = { address, privateKey };
+        saveConfig(cfg);
+        success("Creator wallet generated!");
+        br();
+        row("Address", address);
+        row("Network", "Base Mainnet");
+        row("Stored at", "~/.otonix/config.json");
+        br();
+        console.log(chalk.dim("Private key is stored locally. Never share it."));
+        console.log(chalk.dim("To view your private key: ") + chalk.white("otonix wallet export"));
+        br();
+        console.log(chalk.dim("Fund this address with:"));
+        console.log("  " + chalk.yellow("≥200 $OTX") + chalk.dim(" — to activate agents"));
+        console.log("  " + chalk.yellow("ETH") + chalk.dim(" — for gas fees on Base"));
+        br();
+    });
+    wallet
+        .command("import")
+        .description("Import an existing wallet using a private key")
+        .action(async () => {
+        header("Import Wallet");
+        info("Your private key is stored locally at ~/.otonix/config.json");
+        info("Never share it. Otonix never transmits it.");
+        br();
+        const cfg = loadConfig();
+        if (cfg.wallet) {
+            const overwrite = await confirm({
+                message: `Wallet ${chalk.dim(cfg.wallet.address)} already connected. Replace it?`,
+                default: false,
+            });
+            if (!overwrite) {
+                info("Cancelled.");
+                return;
+            }
+        }
+        const pk = await password({
+            message: "Enter your private key (0x...):",
+            mask: "•",
+        });
+        if (!pk.startsWith("0x") || pk.length !== 66) {
+            failure("Invalid private key format. Must be 0x followed by 64 hex chars.");
+            process.exit(1);
+        }
+        const spinner = ora("Verifying key...").start();
+        try {
+            const address = addressFromKey(pk);
+            cfg.wallet = { address, privateKey: pk };
+            saveConfig(cfg);
+            spinner.stop();
+            success("Wallet imported!");
+            br();
+            row("Address", address);
+            row("Config", "~/.otonix/config.json");
+        }
+        catch {
+            spinner.stop();
+            failure("Invalid private key.");
+            process.exit(1);
+        }
+    });
+    wallet
+        .command("export")
+        .description("Show your private key (keep it safe!)")
+        .action(async () => {
+        const cfg = loadConfig();
+        if (!cfg.wallet) {
+            failure("No wallet. Run: otonix wallet generate");
+            process.exit(1);
+        }
+        const confirmed = await confirm({
+            message: chalk.red("⚠ This will display your private key. Continue?"),
+            default: false,
+        });
+        if (!confirmed) {
+            info("Cancelled.");
+            return;
+        }
+        header("Wallet Export");
+        br();
+        row("Address", cfg.wallet.address);
+        row("Private key", cfg.wallet.privateKey);
+        br();
+        console.log(chalk.red("Never share this key. Anyone with it controls your wallet."));
+        br();
+    });
+    wallet
+        .command("balance")
+        .description("Show ETH and $OTX balance of your wallet")
+        .action(async () => {
+        header("Wallet Balance");
+        const cfg = loadConfig();
+        if (!cfg.wallet) {
+            failure("No wallet. Run: otonix wallet generate");
+            process.exit(1);
+        }
+        const address = cfg.wallet.address;
+        const spinner = ora("Fetching balances from Base...").start();
+        try {
+            const [eth, otx] = await Promise.all([
+                getEthBalance(address),
+                getOtxBalance(address),
+            ]);
+            spinner.stop();
+            br();
+            row("Address", address);
+            row("Network", "Base Mainnet");
+            row("ETH balance", parseFloat(eth).toFixed(6) + " ETH");
+            row("$OTX balance", formatOtx(otx) + " OTX");
+            br();
+            if (otx >= OTX_REQUIRED) {
+                console.log(chalk.green("✓ ") + chalk.dim("Eligible to create agents (≥200 $OTX)"));
+            }
+            else {
+                const need = formatOtx(OTX_REQUIRED - otx);
+                console.log(warn("⚠ ") + chalk.dim(`Need ${need} more $OTX to activate agents`));
+            }
+        }
+        catch {
+            spinner.stop();
+            failure("Failed to fetch balances. Check your internet connection.");
+            process.exit(1);
+        }
+    });
+    wallet
+        .command("address")
+        .description("Show your connected wallet address")
+        .action(() => {
+        const cfg = loadConfig();
+        if (!cfg.wallet) {
+            failure("No wallet. Run: otonix wallet generate");
+            process.exit(1);
+        }
+        header("Wallet Address");
+        br();
+        row("Address", cfg.wallet.address);
+        row("Network", "Base Mainnet");
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};