@otonix/cli 1.7.0 → 2.1.1

package/dist/commands/launch.js

@@ -0,0 +1,207 @@
+import { confirm } from "@inquirer/prompts";
+import ora from "ora";
+import chalk from "chalk";
+import { loadConfig, OTONIX_TREASURY } from "../lib/config.js";
+import { getEthBalance, 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);
+        }
+        if (!agent.registered) {
+            br();
+            failure(`Agent "${opts.agent}" is not registered.`);
+            console.log(chalk.dim("  Send 200 $OTX from your creator wallet to:"));
+            console.log("  " + chalk.white(OTONIX_TREASURY));
+            console.log(chalk.dim("  Then submit the tx hash to activate:"));
+            console.log("  " + chalk.cyan(`otonix agent:register --name ${opts.agent} --tx <txhash>`));
+            process.exit(1);
+        }
+        const devBuyEth = parseFloat(opts.devbuy) || 0;
+        const minEthNeeded = 0.001 + devBuyEth;
+        const twitterHandle = opts.twitter?.replace(/^@/, "") ?? "";
+        const checkSpinner = ora("Checking agent wallet...").start();
+        let agentEth;
+        try {
+            agentEth = await getEthBalance(agent.address);
+        }
+        catch {
+            checkSpinner.stop();
+            failure("Failed to fetch agent balance. Check your connection.");
+            process.exit(1);
+        }
+        checkSpinner.stop();
+        let passed = true;
+        console.log(chalk.green("✓ ") + chalk.dim(`Agent registered (tx: ${agent.registerTxHash?.slice(0, 18)}...)`));
+        if (parseFloat(agentEth) < minEthNeeded) {
+            console.log(warn("⚠ ") + chalk.dim(`Agent ETH: ${agentEth} — need ≥${minEthNeeded} ETH for gas`));
+            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 {};

package/dist/index.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import chalk from "chalk";
+import { printBanner } from "./lib/display.js";
+import { walletCommand } from "./commands/wallet.js";
+import { agentCommand } from "./commands/agent.js";
+import { launchCommand } from "./commands/launch.js";
+const args = process.argv.slice(2);
+const showBanner = args.length === 0 ||
+    args.includes("--help") ||
+    args.includes("-h");
+if (showBanner)
+    printBanner();
+const program = new Command();
+program
+    .name("otonix")
+    .description(chalk.bold.hex("#4d6fff")("OTONIX CLI") + chalk.dim(" — Web4 Autonomous Agent Infrastructure"))
+    .version("2.1.1", "-v, --version")
+    .configureOutput({
+    writeOut: str => process.stdout.write(str),
+    writeErr: str => process.stderr.write(str),
+});
+walletCommand(program);
+agentCommand(program);
+launchCommand(program);
+program
+    .command("config")
+    .description("Show current config file location and settings")
+    .action(async () => {
+    const { loadConfig, configPath } = await import("./lib/config.js");
+    const cfg = loadConfig();
+    console.log("\n" + chalk.bold.hex("#4d6fff")("◈ OTONIX") + "  " + chalk.dim("Config") + "\n" + chalk.dim("─".repeat(44)));
+    console.log(chalk.dim("File:      ") + chalk.white(configPath()));
+    console.log(chalk.dim("Wallet:    ") + chalk.white(cfg.wallet?.address ?? "(none)"));
+    console.log(chalk.dim("Agents:    ") + chalk.white(Object.keys(cfg.agents).join(", ") || "(none)"));
+    console.log(chalk.dim("API base:  ") + chalk.white(cfg.apiBase));
+    console.log(chalk.dim("Deployer:  ") + chalk.white(cfg.deployerAddress));
+    console.log(chalk.dim("Treasury:  ") + chalk.white(cfg.treasuryAddress));
+    console.log();
+});
+program.parse(process.argv);
+if (!args.length) {
+    program.outputHelp();
+}