nebulon-escrow-cli 0.1.0

package/src/commands/reset.js

@@ -0,0 +1,102 @@
+const fs = require("fs");
+const { prompt } = require("enquirer");
+const {
+  activeCapsulePath,
+  capsuleRoot,
+  capsulesDir,
+  legacyConfigPath,
+  legacyWalletsDir,
+  nebulonHome,
+} = require("../paths");
+const {
+  getActiveCapsule,
+  listCapsules,
+  readActiveState,
+  writeActiveState,
+} = require("../capsules");
+
+const safeRemove = (targetPath) => {
+  if (!targetPath || !fs.existsSync(targetPath)) {
+    return false;
+  }
+  const stats = fs.statSync(targetPath);
+  if (stats.isDirectory()) {
+    fs.rmSync(targetPath, { recursive: true, force: true });
+  } else {
+    fs.rmSync(targetPath, { force: true });
+  }
+  return true;
+};
+
+const runReset = async (scope) => {
+  const resetAll = scope === "capsules";
+  if (scope && !resetAll) {
+    console.log("Usage: nebulon reset [capsules]");
+    return;
+  }
+
+  if (resetAll) {
+    console.log("This will reset all Nebulon CLI capsules.");
+  } else {
+    const capsule = getActiveCapsule();
+    console.log(`This will reset capsule "${capsule}".`);
+  }
+  console.log("Imported wallets in C:\\nebulon\\wallets are preserved.");
+
+  const answer = await prompt({
+    type: "confirm",
+    name: "confirm",
+    message: "Proceed with reset?",
+    initial: false,
+  });
+
+  if (!answer.confirm) {
+    console.log("Reset canceled.");
+    return;
+  }
+
+  if (resetAll) {
+    listCapsules().forEach((capsule) => {
+      safeRemove(capsuleRoot(capsule));
+    });
+    safeRemove(capsulesDir());
+    safeRemove(activeCapsulePath());
+    safeRemove(legacyConfigPath());
+    safeRemove(legacyWalletsDir());
+  } else {
+    const capsule = getActiveCapsule();
+    safeRemove(capsuleRoot(capsule));
+    const state = readActiveState();
+    const remaining = listCapsules().filter((name) => name !== capsule);
+    if (state.sessions) {
+      Object.keys(state.sessions).forEach((key) => {
+        if (state.sessions[key] === capsule) {
+          delete state.sessions[key];
+        }
+      });
+    }
+    state.lastUsed = remaining.length ? remaining[0] : null;
+    if (remaining.length) {
+      writeActiveState(state);
+    } else {
+      safeRemove(activeCapsulePath());
+      safeRemove(capsulesDir());
+    }
+  }
+
+  const home = nebulonHome();
+  if (fs.existsSync(home)) {
+    const remaining = fs.readdirSync(home);
+    if (remaining.length === 0) {
+      fs.rmSync(home, { recursive: true, force: true });
+    }
+  }
+
+  console.log(
+    "The Nebulon CLI has been reset successfully. Run nebulon init to get started."
+  );
+};
+
+module.exports = {
+  runReset,
+};

package/src/commands/status.js

@@ -0,0 +1,72 @@
+const { loadConfig } = require("../config");
+const { getActiveCapsule } = require("../capsules");
+const { loadWalletKeypair } = require("../wallets");
+const { me } = require("../hosted");
+const {
+  formatAmount,
+  getConnection,
+  getSolBalance,
+  getTokenBalance,
+  toPublicKey,
+} = require("../solana");
+const { keyValue } = require("../ui");
+
+const runStatus = async () => {
+  const config = loadConfig();
+
+  console.log("Nebulon Status");
+  console.log("");
+
+  keyValue("Capsule", getActiveCapsule());
+
+  let loggedIn = false;
+  let profile = null;
+  if (config.mode === "hosted" && config.auth && config.auth.token) {
+    try {
+      profile = await me(config.backendUrl, config.auth.token);
+      loggedIn = true;
+    } catch (error) {
+      loggedIn = false;
+    }
+  }
+
+  keyValue("LoggedIn", loggedIn ? "true" : "false");
+  keyValue(
+    "NebulonID",
+    loggedIn
+      ? profile.nebulonId || profile.handle || "none"
+      : "none"
+  );
+
+  if (!config.activeWallet) {
+    keyValue("SOL", "n/a");
+    keyValue("USDC", "n/a");
+  } else {
+    const keypair = loadWalletKeypair(config, config.activeWallet);
+    try {
+      const connection = getConnection(config.rpcUrl);
+      const sol = await getSolBalance(connection, keypair.publicKey);
+      const usdc = await getTokenBalance(
+        connection,
+        keypair.publicKey,
+        toPublicKey(config.usdcMint)
+      );
+      keyValue("SOL", `${formatAmount(sol, 6)} SOL`);
+      keyValue("USDC", `${formatAmount(usdc, 6)} USDC`);
+    } catch (error) {
+      keyValue("SOL", "unavailable");
+      keyValue("USDC", "unavailable");
+    }
+  }
+
+  console.log("");
+  keyValue("Mode", config.mode);
+  keyValue("Network", config.network);
+  console.log("");
+  keyValue("Pending Invites", "n/a");
+  keyValue("Active Contracts", "n/a");
+};
+
+module.exports = {
+  runStatus,
+};

package/src/commands/tee.js

@@ -0,0 +1,169 @@
+const nacl = require("tweetnacl");
+const { Connection } = require("@solana/web3.js");
+const { getAuthToken } = require("@magicblock-labs/ephemeral-rollups-sdk");
+const { loadConfig } = require("../config");
+const { loadWalletKeypair } = require("../wallets");
+
+const normalizeEndpoint = (endpoint) => endpoint.replace(/\/$/, "");
+
+const checkTeeAvailability = async (config, keypair, options = {}) => {
+  const base = normalizeEndpoint(
+    config.ephemeralTeeEndpoint ||
+      config.ephemeralPermissionEndpoint ||
+      "https://tee.magicblock.app"
+  );
+  try {
+    const auth = await getAuthToken(
+      base,
+      keypair.publicKey,
+      (message) => nacl.sign.detached(message, keypair.secretKey)
+    );
+    if (!auth?.token) {
+      return { ok: false, reason: "no_token" };
+    }
+    const rpcEndpoint = `${base}?token=${auth.token}`;
+    let wsEndpoint =
+      config.ephemeralTeeWsEndpoint ||
+      rpcEndpoint.replace(/^https:/, "wss:").replace(/^http:/, "ws:");
+    if (!wsEndpoint.includes("token=")) {
+      wsEndpoint += wsEndpoint.includes("?")
+        ? `&token=${auth.token}`
+        : `?token=${auth.token}`;
+    }
+
+    const connection = new Connection(rpcEndpoint, {
+      commitment: "confirmed",
+      wsEndpoint,
+    });
+    await connection.getVersion();
+    let notified = false;
+    await new Promise((resolve) => {
+      const timeout = setTimeout(resolve, options.timeoutMs || 4000);
+      connection.onSlotChange((info) => {
+        if (!notified) {
+          notified = true;
+          clearTimeout(timeout);
+          resolve(info.slot);
+        }
+      });
+    });
+    if (!notified) {
+      return { ok: false, reason: "ws_timeout" };
+    }
+    return { ok: true };
+  } catch (error) {
+    if (options.debug) {
+      console.error(error);
+    }
+    return { ok: false, reason: "error" };
+  }
+};
+
+const runTestTee = async (options = {}) => {
+  const config = loadConfig();
+  if (!config.activeWallet) {
+    console.error("No active wallet. Run: nebulon init");
+    process.exit(1);
+  }
+  const keypair = loadWalletKeypair(config, config.activeWallet);
+  const base = normalizeEndpoint(
+    config.ephemeralTeeEndpoint ||
+      config.ephemeralPermissionEndpoint ||
+      "https://tee.magicblock.app"
+  );
+  const pubkey = keypair.publicKey.toBase58();
+
+  console.log("Testing TEE endpoints...");
+  console.log(`TEE base: ${base}`);
+  console.log(`Wallet: ${pubkey}`);
+
+  try {
+    const challengeUrl = `${base}/auth/challenge?pubkey=${pubkey}`;
+    const response = await fetch(challengeUrl);
+    const contentType = response.headers.get("content-type") || "unknown";
+    const bodyText = await response.text();
+    console.log(`Challenge status: ${response.status}`);
+    console.log(`Challenge content-type: ${contentType}`);
+    if (options.debug) {
+      console.log(
+        `Challenge body head: ${bodyText.slice(0, 200).replace(/\s+/g, " ")}`
+      );
+    }
+  } catch (error) {
+    console.error("Challenge request failed.");
+    if (options.debug) {
+      console.error(error);
+    }
+  }
+
+  let auth = null;
+  try {
+    auth = await getAuthToken(
+      base,
+      keypair.publicKey,
+      (message) => nacl.sign.detached(message, keypair.secretKey)
+    );
+    console.log("Auth token acquired.");
+    if (auth?.expiresAt) {
+      console.log(`Token expiresAt: ${auth.expiresAt}`);
+    }
+  } catch (error) {
+    console.error("Auth token request failed.");
+    if (options.debug) {
+      console.error(error);
+    }
+    return;
+  }
+
+  const token = auth?.token;
+  if (!token) {
+    console.error("No token returned from TEE.");
+    return;
+  }
+  const rpcEndpoint = `${base}?token=${token}`;
+  let wsEndpoint =
+    config.ephemeralTeeWsEndpoint ||
+    rpcEndpoint.replace(/^https:/, "wss:").replace(/^http:/, "ws:");
+  if (!wsEndpoint.includes("token=")) {
+    wsEndpoint += wsEndpoint.includes("?") ? `&token=${token}` : `?token=${token}`;
+  }
+
+  console.log(`TEE RPC: ${rpcEndpoint}`);
+  console.log(`TEE WS: ${wsEndpoint}`);
+
+  try {
+    const connection = new Connection(rpcEndpoint, {
+      commitment: "confirmed",
+      wsEndpoint,
+    });
+    const version = await connection.getVersion();
+    console.log(`TEE RPC OK. Solana version: ${version["solana-core"]}`);
+
+    let notified = false;
+    const slotPromise = new Promise((resolve) => {
+      const timeout = setTimeout(resolve, 4000);
+      connection.onSlotChange((info) => {
+        if (!notified) {
+          notified = true;
+          clearTimeout(timeout);
+          console.log(`TEE WS OK. Slot: ${info.slot}`);
+          resolve();
+        }
+      });
+    });
+    await slotPromise;
+    if (!notified) {
+      console.warn("TEE WS did not emit a slot notification within 4s.");
+    }
+  } catch (error) {
+    console.error("TEE RPC check failed.");
+    if (options.debug) {
+      console.error(error);
+    }
+  }
+};
+
+module.exports = {
+  runTestTee,
+  checkTeeAvailability,
+};

package/src/commands/wallet.js

@@ -0,0 +1,166 @@
+const fs = require("fs");
+const path = require("path");
+const { prompt } = require("enquirer");
+const { loadConfig, saveConfig } = require("../config");
+const { getConnection, getSolBalance, getTokenBalance, toPublicKey, formatAmount } = require("../solana");
+const { successMessage } = require("../ui");
+const {
+  addWalletEntry,
+  generateWallet,
+  importWalletFromFile,
+  listWallets,
+  setActiveWallet,
+  loadWalletKeypair,
+} = require("../wallets");
+
+const runWalletInit = async () => {
+  const config = loadConfig();
+  const actionAnswer = await prompt({
+    type: "select",
+    name: "action",
+    message: "Wallet action",
+    choices: [
+      { name: "generate", message: "Generate new wallet" },
+      { name: "import", message: "Import keypair file" },
+    ],
+  });
+  const nameAnswer = await prompt({
+    type: "input",
+    name: "name",
+    message: "Wallet name",
+    initial: "default",
+  });
+  const name = nameAnswer.name.trim();
+
+  if (actionAnswer.action === "generate") {
+    const { path } = generateWallet(name);
+    addWalletEntry(config, name, path);
+    setActiveWallet(config, name);
+    saveConfig(config);
+    console.log(`Generated wallet: ${name}`);
+    return;
+  }
+
+  const fileAnswer = await prompt({
+    type: "input",
+    name: "path",
+    message: "Keypair file path",
+    validate: (value) => {
+      const trimmed = value.trim();
+      if (!trimmed || !fs.existsSync(trimmed)) {
+        return "File not found.";
+      }
+      return true;
+    },
+  });
+  const { path } = importWalletFromFile(name, fileAnswer.path.trim());
+  addWalletEntry(config, name, path);
+  setActiveWallet(config, name);
+  saveConfig(config);
+  console.log(`Imported wallet: ${name}`);
+};
+
+const runWalletList = () => {
+  const config = loadConfig();
+  const wallets = listWallets(config);
+  if (!wallets.length) {
+    console.log("No wallets configured.");
+    return;
+  }
+  wallets.forEach((wallet) => {
+    const suffix = wallet.active ? " (active)" : "";
+    console.log(`${wallet.name}${suffix}`);
+  });
+};
+
+const runWalletUse = (name) => {
+  const config = loadConfig();
+  setActiveWallet(config, name);
+  saveConfig(config);
+  console.log(`Active wallet: ${name}`);
+};
+
+const runWalletShow = (name) => {
+  const config = loadConfig();
+  const target = name || config.activeWallet;
+  if (!target) {
+    console.error("No wallet specified.");
+    process.exit(1);
+  }
+  const keypair = loadWalletKeypair(config, target);
+  console.log(keypair.publicKey.toBase58());
+};
+
+const runWalletBalance = async () => {
+  const config = loadConfig();
+  const target = config.activeWallet;
+  if (!target) {
+    console.error("No active wallet. Run: nebulon init");
+    process.exit(1);
+  }
+  const keypair = loadWalletKeypair(config, target);
+  const walletKey = keypair.publicKey;
+  const connection = getConnection(config.rpcUrl);
+  const mintKey = toPublicKey(config.usdcMint);
+  const [sol, usdc] = await Promise.all([
+    getSolBalance(connection, walletKey),
+    getTokenBalance(connection, walletKey, mintKey),
+  ]);
+  console.log(`SOL: ${formatAmount(sol, 6)} SOL`);
+  console.log(`USDC: ${formatAmount(usdc, 6)} USDC`);
+};
+
+const runWalletExport = async () => {
+  const config = loadConfig();
+  const target = config.activeWallet;
+  if (!target) {
+    console.error("No active wallet. Run: nebulon init");
+    process.exit(1);
+  }
+  const keypair = loadWalletKeypair(config, target);
+  const exportDir = path.join("C:\\", "Nebulon", "Wallets");
+  if (!fs.existsSync(exportDir)) {
+    fs.mkdirSync(exportDir, { recursive: true });
+  }
+  const nameAnswer = await prompt({
+    type: "input",
+    name: "filename",
+    message: "Export filename",
+    initial: `${target}.json`,
+  });
+  let filename = (nameAnswer.filename || "").trim();
+  if (!filename) {
+    console.error("Filename required.");
+    process.exit(1);
+  }
+  if (!filename.toLowerCase().endsWith(".json")) {
+    filename = `${filename}.json`;
+  }
+  const targetPath = path.join(exportDir, filename);
+  if (fs.existsSync(targetPath)) {
+    console.log("Warning: a file already exists with that name.");
+    const overwrite = await prompt({
+      type: "confirm",
+      name: "overwrite",
+      message: "File exists. Overwrite?",
+      initial: false,
+    });
+    if (!overwrite.overwrite) {
+      console.log("Export canceled.");
+      return;
+    }
+  }
+  fs.writeFileSync(targetPath, JSON.stringify(Array.from(keypair.secretKey)));
+  console.log(`Exported to ${targetPath}`);
+  console.log("Store securely and delete the file when you're done.");
+  successMessage("Wallet exported.");
+};
+
+module.exports = {
+  runWalletInit,
+  runWalletList,
+  runWalletUse,
+  runWalletShow,
+  runWalletBalance,
+  runWalletExport,
+};

package/src/config.js

@@ -0,0 +1,80 @@
+const fs = require("fs");
+const path = require("path");
+const { capsuleConfigPath, capsuleRoot } = require("./paths");
+const { getActiveCapsule, ensureCapsuleDirs } = require("./capsules");
+const { DEFAULT_CONFIG } = require("./constants");
+
+const ensureDirs = (capsuleName) => {
+  const capsule = getActiveCapsule(capsuleName);
+  ensureCapsuleDirs(capsule);
+};
+
+const mergeDefaults = (config) => {
+  return {
+    ...DEFAULT_CONFIG,
+    ...config,
+    wallets: config.wallets || {},
+    sessions: config.sessions || {},
+    privacy: {
+      ...(DEFAULT_CONFIG.privacy || {}),
+      ...(config.privacy || {}),
+      contractKeys: (config.privacy && config.privacy.contractKeys) || {},
+    },
+    auth: {
+      ...DEFAULT_CONFIG.auth,
+      ...(config.auth || {}),
+    },
+  };
+};
+
+const loadConfig = (capsuleName) => {
+  const capsule = getActiveCapsule(capsuleName);
+  ensureDirs(capsule);
+  const filePath = capsuleConfigPath(capsule);
+  if (!fs.existsSync(filePath)) {
+    const initial = mergeDefaults({});
+    fs.writeFileSync(filePath, JSON.stringify(initial, null, 2));
+    return initial;
+  }
+  const raw = JSON.parse(fs.readFileSync(filePath, "utf8"));
+  return mergeDefaults(raw);
+};
+
+const saveConfig = (config, capsuleName) => {
+  const capsule = getActiveCapsule(capsuleName);
+  ensureDirs(capsule);
+  const filePath = capsuleConfigPath(capsule);
+  fs.writeFileSync(filePath, JSON.stringify(config, null, 2));
+};
+
+const setNestedValue = (obj, key, value) => {
+  const parts = key.split(".").filter(Boolean);
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i += 1) {
+    const part = parts[i];
+    if (!current[part] || typeof current[part] !== "object") {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  current[parts[parts.length - 1]] = value;
+};
+
+const resolveWalletPath = (walletEntry, capsuleName) => {
+  if (!walletEntry || !walletEntry.path) {
+    return null;
+  }
+  const capsule = getActiveCapsule(capsuleName);
+  const baseDir = capsuleRoot(capsule);
+  return path.isAbsolute(walletEntry.path)
+    ? walletEntry.path
+    : path.join(baseDir, walletEntry.path);
+};
+
+module.exports = {
+  ensureDirs,
+  loadConfig,
+  saveConfig,
+  setNestedValue,
+  resolveWalletPath,
+};

package/src/constants.js

@@ -0,0 +1,70 @@
+const PROGRAM_ID_DEFAULT = "6UqkmQ2iCkf3acBB71DdXtVd49EyuaftMz8V3E74USbC";
+const TUSDC_MINT_DEFAULT = "HwhrDAorVU2YSHUghNQgxHKBWJyYbvEYC9EC5XBoKNEM";
+const USDC_MINT_MAINNET = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+
+const NETWORK_PRESETS = {
+  localnet: {
+    rpcUrl: "http://127.0.0.1:8899",
+    wsUrl: "ws://127.0.0.1:8900",
+    usdcMint: TUSDC_MINT_DEFAULT,
+  },
+  devnet: {
+    rpcUrl: "https://api.devnet.solana.com",
+    wsUrl: "wss://api.devnet.solana.com",
+    usdcMint: TUSDC_MINT_DEFAULT,
+  },
+  mainnet: {
+    rpcUrl: "https://api.mainnet-beta.solana.com",
+    wsUrl: "wss://api.mainnet-beta.solana.com",
+    usdcMint: USDC_MINT_MAINNET,
+  },
+};
+
+const DEFAULT_CONFIG = {
+  mode: "hosted",
+  network: "localnet",
+  rpcUrl: NETWORK_PRESETS.localnet.rpcUrl,
+  wsUrl: NETWORK_PRESETS.localnet.wsUrl,
+  programId: PROGRAM_ID_DEFAULT,
+  backendUrl: "http://174.138.42.117:3333",
+  usdcMint: NETWORK_PRESETS.localnet.usdcMint,
+  programIdSource: "custom",
+  usdcMintSource: "custom",
+  rpcUrlSource: "custom",
+  wsUrlSource: "custom",
+  ephemeralProviderUrlSource: "custom",
+  ephemeralWsUrlSource: "custom",
+  ephemeralValidatorIdentitySource: "custom",
+  ephemeralPermissionEndpointSource: "custom",
+  ephemeralTeeEndpointSource: "custom",
+  ephemeralTeeWsEndpointSource: "custom",
+  networkSource: "custom",
+  backendSource: "official",
+  ephemeralProviderUrl: "",
+  ephemeralWsUrl: "",
+  ephemeralValidatorIdentity: "",
+  ephemeralPermissionEndpoint: "",
+  ephemeralTeeEndpoint: "",
+  ephemeralTeeWsEndpoint: "",
+  activeWallet: null,
+  wallets: {},
+  sessions: {},
+  privacy: {
+    contractKeys: {},
+  },
+  auth: {
+    token: null,
+    wallet: null,
+    handle: null,
+    role: null,
+    lastAuthAt: null,
+  },
+};
+
+module.exports = {
+  DEFAULT_CONFIG,
+  NETWORK_PRESETS,
+  PROGRAM_ID_DEFAULT,
+  TUSDC_MINT_DEFAULT,
+  USDC_MINT_MAINNET,
+};