clanker-sdk 4.2.10 → 4.2.12

package/dist/cli/commands/setup.d.ts

@@ -0,0 +1,5 @@
+import { Command } from 'commander';
+
+declare function registerSetupCommand(program: Command): void;
+
+export { registerSetupCommand };

package/dist/cli/commands/setup.js

@@ -0,0 +1,314 @@
+// src/cli/commands/setup.ts
+import inquirer from "inquirer";
+import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
+
+// src/cli/utils/chains.ts
+import { arbitrum, base, baseSepolia, bsc, mainnet, unichain } from "viem/chains";
+
+// src/utils/chains/monad.ts
+import { defineChain } from "viem";
+var monad = /* @__PURE__ */ defineChain({
+  id: 143,
+  name: "Monad",
+  blockTime: 400,
+  nativeCurrency: {
+    name: "MON",
+    symbol: "MON",
+    decimals: 18
+  },
+  rpcUrls: {
+    default: {
+      http: ["https://rpc.monad.xyz"]
+    }
+  },
+  blockExplorers: {
+    default: {
+      name: "Monad explorer",
+      url: "TODO"
+    }
+  },
+  contracts: {},
+  testnet: false
+});
+
+// src/cli/utils/chains.ts
+var CHAIN_MAP = {
+  base,
+  "base-sepolia": baseSepolia,
+  arbitrum,
+  ethereum: mainnet,
+  bsc,
+  unichain,
+  monad
+};
+var CHAIN_NAMES = Object.keys(CHAIN_MAP);
+
+// src/cli/utils/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var CONFIG_DIR = join(homedir(), ".clanker");
+var CONFIG_PATH = join(CONFIG_DIR, "config.json");
+function ensureDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+function loadConfig() {
+  try {
+    if (!existsSync(CONFIG_PATH)) return {};
+    return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveConfig(config) {
+  ensureDir();
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 384 });
+}
+function getConfigPath() {
+  return CONFIG_PATH;
+}
+
+// src/cli/utils/style.ts
+var isColorSupported = process.env.NO_COLOR === void 0 && process.env.FORCE_COLOR !== "0" && process.env.TERM !== "dumb" && (process.env.FORCE_COLOR !== void 0 || process.stdout.isTTY === true);
+var ESC = "\x1B[";
+var RST = `${ESC}0m`;
+function wrap(code, text) {
+  if (!isColorSupported) return text;
+  return `${ESC}${code}m${text}${RST}`;
+}
+var bold = (s) => wrap("1", s);
+var dim = (s) => wrap("2", s);
+var red = (s) => wrap("31", s);
+var green = (s) => wrap("32", s);
+var yellow = (s) => wrap("33", s);
+var cyan = (s) => wrap("36", s);
+var gray = (s) => wrap("90", s);
+var brightCyan = (s) => wrap("96", s);
+var SYM = {
+  check: isColorSupported ? "\u2714" : "+",
+  cross: isColorSupported ? "\u2716" : "x",
+  arrow: isColorSupported ? "\u25B8" : ">",
+  dot: isColorSupported ? "\u25CF" : "*",
+  star: isColorSupported ? "\u2605" : "*",
+  info: isColorSupported ? "\u2139" : "i",
+  warn: isColorSupported ? "\u26A0" : "!",
+  rocket: isColorSupported ? "\u{1F680}" : "^"
+};
+var BOX = {
+  tl: "\u256D",
+  tr: "\u256E",
+  bl: "\u2570",
+  br: "\u256F",
+  h: "\u2500",
+  v: "\u2502",
+  lt: "\u251C",
+  rt: "\u2524"
+};
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function drawBox(lines, options) {
+  const color = options?.color || cyan;
+  const pad = options?.padding ?? 1;
+  const contentWidth = Math.max(
+    ...lines.map((l) => stripAnsi(l).length),
+    options?.title ? stripAnsi(options.title).length : 0,
+    20
+  );
+  const innerWidth = contentWidth + pad * 2;
+  const out = [];
+  out.push(color(`${BOX.tl}${BOX.h.repeat(innerWidth)}${BOX.tr}`));
+  if (options?.title) {
+    const titleLen = stripAnsi(options.title).length;
+    const titlePad = innerWidth - titleLen - pad;
+    out.push(
+      `${color(BOX.v)}${" ".repeat(pad)}${options.title}${" ".repeat(Math.max(0, titlePad))}${color(BOX.v)}`
+    );
+    out.push(color(`${BOX.lt}${BOX.h.repeat(innerWidth)}${BOX.rt}`));
+  }
+  for (const line of lines) {
+    const lineLen = stripAnsi(line).length;
+    const linePad = innerWidth - lineLen - pad;
+    out.push(
+      `${color(BOX.v)}${" ".repeat(pad)}${line}${" ".repeat(Math.max(0, linePad))}${color(BOX.v)}`
+    );
+  }
+  out.push(color(`${BOX.bl}${BOX.h.repeat(innerWidth)}${BOX.br}`));
+  return out.join("\n");
+}
+
+// src/cli/utils/output.ts
+function printSuccess(message, jsonMode, data) {
+  if (jsonMode) {
+    console.log(JSON.stringify({ success: true, message, ...data }, bigintReplacer, 2));
+    return;
+  }
+  const title = `${green(bold(SYM.check))} ${green(bold(message))}`;
+  if (data) {
+    const lines = Object.entries(data).map(([key, value]) => {
+      return `${brightCyan(key)} ${dim(BOX.v)} ${formatValue(value)}`;
+    });
+    console.log("");
+    console.log(drawBox(lines, { title, color: green }));
+    console.log("");
+  } else {
+    console.log(`
+  ${title}
+`);
+  }
+}
+function printStep(message, jsonMode) {
+  if (jsonMode) return;
+  console.log(`  ${cyan(SYM.arrow)} ${message}`);
+}
+function formatValue(value) {
+  if (typeof value === "bigint") return value.toString();
+  if (typeof value === "object" && value !== null) return JSON.stringify(value, bigintReplacer);
+  return String(value);
+}
+function bigintReplacer(_key, value) {
+  return typeof value === "bigint" ? value.toString() : value;
+}
+
+// src/cli/commands/setup.ts
+var PUBLIC_RPCS = {
+  base: "https://mainnet.base.org",
+  "base-sepolia": "https://sepolia.base.org",
+  arbitrum: "https://arb1.arbitrum.io/rpc",
+  ethereum: "https://eth.llamarpc.com",
+  bsc: "https://bsc-dataseed.binance.org",
+  unichain: "https://mainnet.unichain.org"
+};
+function registerSetupCommand(program) {
+  program.command("setup").description("Configure wallet and RPC settings").action(async (_opts, command) => {
+    const jsonMode = command.parent?.opts()?.json ?? false;
+    try {
+      await runSetup(jsonMode);
+    } catch (err) {
+      if (err instanceof Error && err.message === "prompt-cancelled") {
+        console.log(`
+  ${dim(gray("Setup cancelled."))}
+`);
+        return;
+      }
+      throw err;
+    }
+  });
+}
+async function runSetup(jsonMode) {
+  const existing = loadConfig();
+  const hasExisting = !!(existing.privateKey || existing.rpc);
+  if (hasExisting) {
+    const account = existing.privateKey ? privateKeyToAccount(existing.privateKey) : null;
+    printStep(`Existing config found at ${dim(getConfigPath())}`, jsonMode);
+    if (account) {
+      printStep(`Wallet: ${cyan(account.address)}`, jsonMode);
+    }
+    if (existing.rpc) {
+      for (const [chain, url] of Object.entries(existing.rpc)) {
+        printStep(`RPC ${chain}: ${dim(url)}`, jsonMode);
+      }
+    }
+    console.log("");
+  }
+  const { walletAction } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "walletAction",
+      message: "Wallet setup:",
+      choices: [
+        { name: "Create a new wallet", value: "create" },
+        { name: "Import existing private key", value: "import" },
+        ...existing.privateKey ? [{ name: "Keep current wallet", value: "keep" }] : [],
+        { name: "Skip (use --private-key or PRIVATE_KEY env)", value: "skip" }
+      ]
+    }
+  ]);
+  let privateKey = existing.privateKey;
+  if (walletAction === "create") {
+    privateKey = generatePrivateKey();
+    const account = privateKeyToAccount(privateKey);
+    console.log("");
+    console.log(`  ${green(bold("New wallet created"))}`);
+    console.log(`  ${cyan("Address:")} ${account.address}`);
+    console.log("");
+    console.log(`  ${red(bold("IMPORTANT:"))} Fund this address with ETH before deploying.`);
+    console.log(
+      `  ${yellow("Your private key is saved locally.")} Back up ${dim(getConfigPath())} securely.`
+    );
+    console.log("");
+  } else if (walletAction === "import") {
+    const { key } = await inquirer.prompt([
+      {
+        type: "password",
+        name: "key",
+        message: "Enter your private key (0x...):",
+        mask: "*",
+        validate: (v) => /^0x[a-fA-F0-9]{64}$/.test(v) || "Must be a 0x-prefixed 64-char hex string"
+      }
+    ]);
+    privateKey = key;
+    const account = privateKeyToAccount(key);
+    console.log(`
+  ${green("Imported:")} ${account.address}
+`);
+  }
+  const { defaultChain } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "defaultChain",
+      message: "Default chain:",
+      choices: CHAIN_NAMES,
+      default: existing.defaultChain || "base"
+    }
+  ]);
+  const { rpcAction } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "rpcAction",
+      message: `RPC for ${bold(defaultChain)}:`,
+      choices: [
+        ...PUBLIC_RPCS[defaultChain] ? [{ name: `Use public RPC (${dim(PUBLIC_RPCS[defaultChain])})`, value: "public" }] : [],
+        { name: "Enter a private RPC URL", value: "custom" },
+        ...existing.rpc?.[defaultChain] ? [{ name: `Keep current (${dim(existing.rpc[defaultChain])})`, value: "keep" }] : []
+      ]
+    }
+  ]);
+  const rpcMap = { ...existing.rpc };
+  if (rpcAction === "public" && PUBLIC_RPCS[defaultChain]) {
+    rpcMap[defaultChain] = PUBLIC_RPCS[defaultChain];
+  } else if (rpcAction === "custom") {
+    const { customRpc } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "customRpc",
+        message: "RPC URL:",
+        validate: (v) => {
+          try {
+            new URL(v);
+            return true;
+          } catch {
+            return "Must be a valid URL";
+          }
+        }
+      }
+    ]);
+    rpcMap[defaultChain] = customRpc;
+  }
+  saveConfig({
+    ...privateKey ? { privateKey } : {},
+    rpc: Object.keys(rpcMap).length > 0 ? rpcMap : void 0,
+    defaultChain
+  });
+  printSuccess("Configuration saved!", jsonMode, {
+    config: getConfigPath(),
+    chain: defaultChain,
+    rpc: rpcMap[defaultChain] || "default",
+    wallet: privateKey ? privateKeyToAccount(privateKey).address : "not configured"
+  });
+}
+export {
+  registerSetupCommand
+};

package/dist/cli/commands/token.d.ts

@@ -0,0 +1,5 @@
+import { Command } from 'commander';
+
+declare function registerTokenCommand(program: Command): Command;
+
+export { registerTokenCommand };