@execra/core 1.0.0

package/dist/cli/commands.d.ts

@@ -0,0 +1,21 @@
+import { WalletVault } from '../vault/index.js';
+import '../vault/accounts.js';
+import '../vault/config.js';
+import '../vault/mnemonic.js';
+import '../vault/keystore.js';
+
+declare function isUnlocked(): boolean;
+declare function cmdInit(): Promise<void>;
+declare function cmdUnlock(): Promise<void>;
+declare function cmdLock(): void;
+declare function cmdAccounts(): Promise<void>;
+declare function cmdNewAccount(name: string): Promise<void>;
+declare function cmdUseAccount(nameOrIndex: string): Promise<void>;
+declare function cmdAirdrop(sol?: number): Promise<void>;
+declare function cmdConnect(wcUri: string): Promise<void>;
+declare function cmdSessions(): void;
+declare function cmdDisconnect(dappName: string): Promise<void>;
+declare function cmdSend(to: string, sol: number, vault: WalletVault): Promise<void>;
+declare function cmdSetCluster(cluster: string): void;
+
+export { cmdAccounts, cmdAirdrop, cmdConnect, cmdDisconnect, cmdInit, cmdLock, cmdNewAccount, cmdSend, cmdSessions, cmdSetCluster, cmdUnlock, cmdUseAccount, isUnlocked };

package/dist/cli/commands.js

@@ -0,0 +1,686 @@
+#!/usr/bin/env node
+
+// src/cli/commands.ts
+import chalk2 from "chalk";
+
+// src/vault/mnemonic.ts
+import * as bip39 from "bip39";
+function generateMnemonic2(strength = 12) {
+  const mnemonic = bip39.generateMnemonic(strength == 12 ? 128 : 256);
+  const wordCount = strength;
+  return { mnemonic, wordCount };
+}
+function validateMnemonic2(mnemonic) {
+  const cleaned = cleanMnemonic(mnemonic);
+  return bip39.validateMnemonic(cleaned);
+}
+async function mnemonicToSeed2(mnemonic, passphrase = "") {
+  const cleaned = cleanMnemonic(mnemonic);
+  if (!validateMnemonic2(cleaned)) {
+    throw new Error("Invalid mnemonic: failed wordlist or checksum validation");
+  }
+  return bip39.mnemonicToSeed(cleaned, passphrase);
+}
+function cleanMnemonic(mnemonic) {
+  return mnemonic.trim().toLowerCase().replace(/\s+/g, " ");
+}
+
+// src/vault/keystore.ts
+import crypto from "crypto";
+import fs from "fs";
+import os from "os";
+import path from "path";
+var VAULT_VERSION = 1;
+var PBKDF2_ITERATIONS = 21e4;
+var PBKDF2_DIGEST = "sha512";
+var KEY_LENGTH = 32;
+var SALT_LENGTH = 32;
+var IV_LENGTH = 16;
+var CIPHER = "aes-256-gcm";
+function getWalletDir() {
+  return path.join(os.homedir(), ".wallet");
+}
+function getVaultPath() {
+  return path.join(getWalletDir(), "vault.enc");
+}
+function getConfigPath() {
+  return path.join(getWalletDir(), "config.json");
+}
+function getSessionsPath() {
+  return path.join(getWalletDir(), "sessions.json");
+}
+var SESSIONS_FILE = getSessionsPath();
+function ensureWalletDir() {
+  const dir = getWalletDir();
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  }
+}
+function vaultExists() {
+  return fs.existsSync(getVaultPath());
+}
+async function saveVault(data, password) {
+  ensureWalletDir();
+  const salt = crypto.randomBytes(SALT_LENGTH);
+  const iv = crypto.randomBytes(IV_LENGTH);
+  const key = await deriveKey(password, salt);
+  const plaintext = JSON.stringify(data);
+  const cipher = crypto.createCipheriv(CIPHER, key, iv);
+  const encrypted = Buffer.concat([
+    cipher.update(plaintext, "utf8"),
+    cipher.final()
+  ]);
+  const authTag = cipher.getAuthTag();
+  const vault = {
+    version: VAULT_VERSION,
+    salt: salt.toString("hex"),
+    iv: iv.toString("hex"),
+    authTag: authTag.toString("hex"),
+    ciphertext: encrypted.toString("hex")
+  };
+  fs.writeFileSync(getVaultPath(), JSON.stringify(vault, null, 2), {
+    mode: 384
+    // owner read/write only
+  });
+}
+async function loadVault(password) {
+  if (!vaultExists()) {
+    throw new Error("No vault found. Run `wallet init` to create one.");
+  }
+  const raw = fs.readFileSync(getVaultPath(), "utf8");
+  const vault = JSON.parse(raw);
+  if (vault.version !== VAULT_VERSION) {
+    throw new Error(`Unsupported vault version: ${vault.version}`);
+  }
+  const salt = Buffer.from(vault.salt, "hex");
+  const iv = Buffer.from(vault.iv, "hex");
+  const authTag = Buffer.from(vault.authTag, "hex");
+  const ciphertext = Buffer.from(vault.ciphertext, "hex");
+  const key = await deriveKey(password, salt);
+  try {
+    const decipher = crypto.createDecipheriv(CIPHER, key, iv);
+    decipher.setAuthTag(authTag);
+    const decrypted = Buffer.concat([
+      decipher.update(ciphertext),
+      decipher.final()
+    ]);
+    return JSON.parse(decrypted.toString("utf8"));
+  } catch {
+    throw new Error("Decryption failed: wrong password or vault is corrupted.");
+  }
+}
+function deriveKey(password, salt) {
+  return new Promise((resolve, reject) => {
+    crypto.pbkdf2(
+      password,
+      salt,
+      PBKDF2_ITERATIONS,
+      KEY_LENGTH,
+      PBKDF2_DIGEST,
+      (err, key) => {
+        if (err) reject(err);
+        else resolve(key);
+      }
+    );
+  });
+}
+
+// src/vault/accounts.ts
+import { derivePath } from "ed25519-hd-key";
+import nacl from "tweetnacl";
+import bs58 from "bs58";
+function deriveAccount(seed, index, name = `Account ${index + 1}`) {
+  const path2 = derivationPath(index);
+  const { key: privateKeyBytes } = derivePath(path2, seed.toString("hex"));
+  const keypair = nacl.sign.keyPair.fromSeed(privateKeyBytes);
+  const publicKey = bs58.encode(Buffer.from(keypair.publicKey));
+  return {
+    index,
+    name,
+    publicKey,
+    secretKey: keypair.secretKey,
+    // 64 bytes: seed + public key
+    derivationPath: path2,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function createAccountStore(firstAccountName = "Account 1") {
+  return {
+    accounts: [
+      {
+        index: 0,
+        name: firstAccountName,
+        publicKey: "",
+        // filled in after derivation
+        derivationPath: derivationPath(0),
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    ],
+    activeIndex: 0
+  };
+}
+function derivationPath(index) {
+  return `m/44'/501'/${index}'/0'`;
+}
+
+// src/solana/rpc.ts
+import { Connection, PublicKey, LAMPORTS_PER_SOL } from "@solana/web3.js";
+
+// src/vault/config.ts
+import fs2 from "fs";
+var HELIUS_API_KEY = process.env.HELIUS_API_KEY;
+var RPC_URLS = {
+  "mainnet-beta": HELIUS_API_KEY ? `https://mainnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}` : "https://api.mainnet-beta.solana.com",
+  devnet: HELIUS_API_KEY ? `https://devnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}` : "https://api.devnet.solana.com",
+  testnet: "https://api.testnet.solana.com",
+  localnet: "http://localhost:8899"
+};
+var CONFIG_VERSION = 1;
+function configExists() {
+  return fs2.existsSync(getConfigPath());
+}
+function loadConfig() {
+  if (!configExists()) {
+    throw new Error("No config found. Run `wallet init` first.");
+  }
+  const raw = fs2.readFileSync(getConfigPath(), "utf8");
+  return JSON.parse(raw);
+}
+function saveConfig(config) {
+  ensureWalletDir();
+  const updated = { ...config, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  fs2.writeFileSync(getConfigPath(), JSON.stringify(updated, null, 2), {
+    mode: 384
+  });
+}
+function createConfig(walletConnectProjectId = "", cluster = "devnet") {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    version: CONFIG_VERSION,
+    cluster,
+    rpcUrl: RPC_URLS[cluster],
+    walletConnectProjectId,
+    accountStore: createAccountStore("Account 1"),
+    createdAt: now,
+    updatedAt: now
+  };
+}
+function updateCluster(cluster) {
+  const config = loadConfig();
+  config.cluster = cluster;
+  config.rpcUrl = RPC_URLS[cluster];
+  saveConfig(config);
+}
+function updateAccountStore(accountStore) {
+  const config = loadConfig();
+  config.accountStore = accountStore;
+  saveConfig(config);
+}
+function getRpcUrl() {
+  return loadConfig().rpcUrl;
+}
+function getCluster() {
+  return loadConfig().cluster;
+}
+
+// src/solana/rpc.ts
+var _connection = null;
+function getConnection(forceNew = false) {
+  if (!_connection || forceNew) {
+    const rpcUrl = getRpcUrl();
+    _connection = new Connection(rpcUrl, "confirmed");
+  }
+  return _connection;
+}
+async function getBalance(publicKeyStr) {
+  const connection = getConnection();
+  const pubkey = new PublicKey(publicKeyStr);
+  const lamports = await connection.getBalance(pubkey);
+  return {
+    lamports,
+    sol: lamports / LAMPORTS_PER_SOL
+  };
+}
+async function requestAirdrop(publicKeyStr, solAmount = 1) {
+  const cluster = getCluster();
+  if (cluster === "mainnet-beta") {
+    throw new Error("Airdrops are not available on mainnet.");
+  }
+  const connection = getConnection();
+  const pubkey = new PublicKey(publicKeyStr);
+  const lamports = solAmount * LAMPORTS_PER_SOL;
+  const signature = await connection.requestAirdrop(pubkey, lamports);
+  await connection.confirmTransaction(signature, "confirmed");
+  return signature;
+}
+
+// src/handler/walletConnect.ts
+import SignClientPkg from "@walletconnect/sign-client";
+import { getSdkError } from "@walletconnect/utils";
+import chalk from "chalk";
+
+// src/solana/simulate.ts
+import {
+  Transaction,
+  VersionedTransaction,
+  LAMPORTS_PER_SOL as LAMPORTS_PER_SOL2
+} from "@solana/web3.js";
+
+// src/solana/tx.ts
+import {
+  Transaction as Transaction2,
+  VersionedTransaction as VersionedTransaction2,
+  Keypair
+} from "@solana/web3.js";
+import nacl2 from "tweetnacl";
+import bs582 from "bs58";
+
+// src/handler/index.ts
+import bs583 from "bs58";
+
+// src/session/index.ts
+import * as fs3 from "fs";
+function read() {
+  ensureWalletDir();
+  if (!fs3.existsSync(SESSIONS_FILE)) return { sessions: [] };
+  return JSON.parse(fs3.readFileSync(SESSIONS_FILE, "utf8"));
+}
+function write(store) {
+  ensureWalletDir();
+  fs3.writeFileSync(SESSIONS_FILE, JSON.stringify(store, null, 2));
+}
+function removeSession(topic) {
+  const store = read();
+  store.sessions = store.sessions.filter((s) => s.topic !== topic);
+  write(store);
+}
+function getAllSessions() {
+  return read().sessions.filter((s) => s.active);
+}
+
+// src/handler/walletConnect.ts
+var SignClient = SignClientPkg.default ?? SignClientPkg;
+var signClient = null;
+async function pairWithDapp(uri) {
+  if (!signClient) throw new Error("WalletConnect not initialised");
+  console.log(chalk.dim("[WC] Connecting to dApp..."));
+  await new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      signClient.off("session_proposal", onProposal);
+      reject(new Error("WalletConnect pairing timed out after 30s"));
+    }, 3e4);
+    const onProposal = ({ params }) => {
+      clearTimeout(timeout);
+      signClient.off("session_proposal", onProposal);
+      const meta = params.proposer.metadata;
+      console.log(
+        chalk.cyan(
+          `[WC] Request from: ${chalk.bold(meta.name)} (${meta.url})`,
+          params
+        )
+      );
+      resolve();
+    };
+    signClient.on("session_proposal", onProposal);
+    signClient.core.pairing.pair({ uri }).catch((err) => {
+      clearTimeout(timeout);
+      signClient.off("session_proposal", onProposal);
+      reject(err);
+    });
+  });
+}
+async function disconnectDapp(topic) {
+  if (!signClient) throw new Error("WalletConnect not initialised");
+  await signClient.disconnect({
+    topic,
+    reason: getSdkError("USER_DISCONNECTED")
+  });
+  removeSession(topic);
+  console.log(
+    chalk.dim(`[WC] Disconnected from topic ${topic.slice(0, 8)}...`)
+  );
+}
+
+// src/cli/prompts.tsx
+import React, { useState, useRef } from "react";
+import { render, Box, Text, useInput, useApp } from "ink";
+function inkPassword(question) {
+  return new Promise((resolve) => {
+    let result = "";
+    function PasswordPrompt() {
+      const { exit } = useApp();
+      const valueRef = useRef("");
+      const [maskLen, setMaskLen] = useState(0);
+      useInput((input, key) => {
+        if (key.return) {
+          result = valueRef.current;
+          exit();
+          return;
+        }
+        if (key.backspace || key.delete) {
+          if (valueRef.current.length > 0) {
+            valueRef.current = valueRef.current.slice(0, -1);
+            setMaskLen(valueRef.current.length);
+          }
+          return;
+        }
+        if (input && !key.ctrl && !key.meta) {
+          valueRef.current += input;
+          setMaskLen(valueRef.current.length);
+        }
+      });
+      return /* @__PURE__ */ React.createElement(Box, null, /* @__PURE__ */ React.createElement(Text, { bold: true }, question, " "), /* @__PURE__ */ React.createElement(Text, { color: "gray" }, "*".repeat(maskLen)));
+    }
+    const { waitUntilExit } = render(/* @__PURE__ */ React.createElement(PasswordPrompt, null));
+    waitUntilExit().then(() => resolve(result));
+  });
+}
+function inkSelect(message, choices) {
+  return new Promise((resolve) => {
+    let result = choices[0].value;
+    function SelectPrompt() {
+      const { exit } = useApp();
+      const cursorRef = useRef(0);
+      const [cursor, setCursor] = useState(0);
+      useInput((_, key) => {
+        if (key.upArrow) {
+          const n = Math.max(0, cursorRef.current - 1);
+          cursorRef.current = n;
+          setCursor(n);
+        }
+        if (key.downArrow) {
+          const n = Math.min(choices.length - 1, cursorRef.current + 1);
+          cursorRef.current = n;
+          setCursor(n);
+        }
+        if (key.return) {
+          result = choices[cursorRef.current].value;
+          exit();
+        }
+      });
+      return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Text, { bold: true }, message), choices.map((choice, i) => /* @__PURE__ */ React.createElement(Box, { key: i }, /* @__PURE__ */ React.createElement(Text, { color: i === cursor ? "cyan" : "gray" }, i === cursor ? "\u276F " : "  ", choice.name))));
+    }
+    const { waitUntilExit } = render(/* @__PURE__ */ React.createElement(SelectPrompt, null));
+    waitUntilExit().then(() => resolve(result));
+  });
+}
+function inkConfirm(message, defaultYes = false) {
+  return new Promise((resolve) => {
+    let result = defaultYes;
+    function ConfirmPrompt() {
+      const { exit } = useApp();
+      useInput((input, key) => {
+        if (key.return) {
+          result = defaultYes;
+          exit();
+          return;
+        }
+        const ch = input.toLowerCase();
+        if (ch === "y") {
+          result = true;
+          exit();
+        } else if (ch === "n") {
+          result = false;
+          exit();
+        }
+      });
+      const hint = defaultYes ? "Y/n" : "y/N";
+      return /* @__PURE__ */ React.createElement(Box, null, /* @__PURE__ */ React.createElement(Text, { bold: true }, message, " "), /* @__PURE__ */ React.createElement(Text, { color: "gray" }, "[", hint, "] "));
+    }
+    const { waitUntilExit } = render(/* @__PURE__ */ React.createElement(ConfirmPrompt, null));
+    waitUntilExit().then(() => resolve(result));
+  });
+}
+
+// src/cli/commands.ts
+var sessionPassword = null;
+var sessionMnemonic = null;
+function isUnlocked() {
+  return sessionMnemonic !== null;
+}
+async function requireUnlocked() {
+  if (!sessionPassword || !sessionMnemonic) {
+    throw new Error("Wallet is locked. Run: wallet unlock");
+  }
+  return { password: sessionPassword, mnemonic: sessionMnemonic };
+}
+async function cmdInit() {
+  if (vaultExists()) {
+    console.log(
+      chalk2.yellow("Vault already exists. Use `wallet unlock` to access it.")
+    );
+    return;
+  }
+  const wordCount = await inkSelect("Mnemonic length:", [
+    { name: "12 words (standard)", value: 12 },
+    { name: "24 words (extra secure)", value: 24 }
+  ]);
+  const { mnemonic } = generateMnemonic2(wordCount);
+  console.log(
+    chalk2.bold("\n\u26A0\uFE0F  Write down your seed phrase. Store it safely.\n")
+  );
+  console.log(chalk2.yellow(mnemonic));
+  console.log();
+  const confirmed = await inkConfirm(
+    "I have written down my seed phrase",
+    false
+  );
+  if (!confirmed) {
+    console.log(chalk2.red("Aborted."));
+    return;
+  }
+  const password = await inkPassword("Set vault password:");
+  const confirm = await inkPassword("Confirm password:");
+  if (password !== confirm) {
+    console.log(chalk2.red("Passwords do not match."));
+    return;
+  }
+  const seed = await mnemonicToSeed2(mnemonic);
+  const firstKp = deriveAccount(seed, 0, "Main");
+  await saveVault(
+    { mnemonic, createdAt: (/* @__PURE__ */ new Date()).toISOString(), version: 1 },
+    password
+  );
+  const config = createConfig("");
+  config.accountStore.accounts[0] = {
+    index: 0,
+    name: "Main",
+    publicKey: firstKp.publicKey,
+    derivationPath: `m/44'/501'/0'/0'`,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  saveConfig(config);
+  sessionPassword = password;
+  sessionMnemonic = mnemonic;
+  console.log(chalk2.green("\n\u2713 Wallet created"));
+  console.log(chalk2.dim(`  Address: ${firstKp.publicKey}`));
+}
+async function cmdUnlock() {
+  if (!vaultExists()) {
+    console.log(chalk2.red("No vault found. Run: wallet init"));
+    return;
+  }
+  const password = await inkPassword("Vault password:");
+  try {
+    const vault = await loadVault(password);
+    sessionPassword = password;
+    sessionMnemonic = vault.mnemonic;
+    console.log(chalk2.green("\u2713 Wallet unlocked"));
+  } catch {
+    console.log(chalk2.red("Wrong password."));
+  }
+}
+function cmdLock() {
+  sessionPassword = null;
+  sessionMnemonic = null;
+  console.log(chalk2.green("\u2713 Wallet locked"));
+}
+async function cmdAccounts() {
+  await requireUnlocked();
+  const config = loadConfig();
+  console.log(chalk2.bold("\n\u2500\u2500 Accounts \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  for (const entry of config.accountStore.accounts) {
+    const active = entry.index === config.accountStore.activeIndex;
+    const marker = active ? chalk2.green("\u25CF") : chalk2.dim("\u25CB");
+    let balance = "...";
+    try {
+      const { sol } = await getBalance(entry.publicKey);
+      balance = sol.toFixed(4) + " SOL";
+    } catch {
+    }
+    console.log(
+      `  ${marker} [${entry.index}] ${entry.name.padEnd(16)} ${entry.publicKey}  ${balance}`
+    );
+  }
+  console.log(chalk2.dim(`
+  Network: ${config.cluster} (${config.rpcUrl})`));
+  console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
+}
+async function cmdNewAccount(name) {
+  const { mnemonic } = await requireUnlocked();
+  const config = loadConfig();
+  const nextIndex = config.accountStore.accounts.length;
+  const accountName = name || `Account ${nextIndex + 1}`;
+  const seed = await mnemonicToSeed2(mnemonic);
+  const keypair = deriveAccount(seed, nextIndex, accountName);
+  updateAccountStore({
+    ...config.accountStore,
+    accounts: [
+      ...config.accountStore.accounts,
+      {
+        index: nextIndex,
+        name: accountName,
+        publicKey: keypair.publicKey,
+        derivationPath: `m/44'/501'/${nextIndex}'/0'`,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    ]
+  });
+  console.log(chalk2.green(`\u2713 Account created: ${accountName}`));
+  console.log(chalk2.dim(`  Address: ${keypair.publicKey}`));
+}
+async function cmdUseAccount(nameOrIndex) {
+  await requireUnlocked();
+  const config = loadConfig();
+  const found = config.accountStore.accounts.find(
+    (a) => a.name === nameOrIndex || a.index === parseInt(nameOrIndex)
+  );
+  if (!found) {
+    console.log(chalk2.red(`Account not found: ${nameOrIndex}`));
+    return;
+  }
+  updateAccountStore({ ...config.accountStore, activeIndex: found.index });
+  console.log(
+    chalk2.green(`\u2713 Active account: ${found.name} (${found.publicKey})`)
+  );
+}
+async function cmdAirdrop(sol = 1) {
+  await requireUnlocked();
+  const config = loadConfig();
+  const active = config.accountStore.accounts.find(
+    (a) => a.index === config.accountStore.activeIndex
+  );
+  if (!active) {
+    console.log(chalk2.red("No active account."));
+    return;
+  }
+  console.log(chalk2.dim(`Requesting ${sol} SOL airdrop...`));
+  try {
+    const sig = await requestAirdrop(active.publicKey, sol);
+    console.log(chalk2.green(`\u2713 Airdrop complete`));
+    console.log(chalk2.dim(`  tx: ${sig}`));
+  } catch (err) {
+    console.log(chalk2.red(`Airdrop failed: ${err.message}`));
+  }
+}
+async function cmdConnect(wcUri) {
+  if (!wcUri || !wcUri.startsWith("wc:")) {
+    console.log(chalk2.red("Invalid WalletConnect URI. Must start with wc:"));
+    return;
+  }
+  console.log(chalk2.dim("Pairing with dApp..."));
+  await pairWithDapp(wcUri);
+}
+function cmdSessions() {
+  const sessions = getAllSessions();
+  if (sessions.length === 0) {
+    console.log(chalk2.dim("No active sessions."));
+    return;
+  }
+  console.log(chalk2.bold("\n\u2500\u2500 Connected dApps \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  sessions.forEach((s) => {
+    console.log(
+      `  ${chalk2.cyan(s.dappName.padEnd(20))} ${s.connectedAccount.slice(0, 8)}...  since ${s.connectedAt.slice(0, 10)}`
+    );
+    console.log(
+      chalk2.dim(`    ${s.dappUrl}  topic: ${s.topic.slice(0, 8)}...`)
+    );
+  });
+  console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
+}
+async function cmdDisconnect(dappName) {
+  const sessions = getAllSessions();
+  const session = sessions.find(
+    (s) => s.dappName.toLowerCase().includes(dappName.toLowerCase())
+  );
+  if (!session) {
+    console.log(chalk2.red(`No session found for: ${dappName}`));
+    return;
+  }
+  await disconnectDapp(session.topic);
+  console.log(chalk2.green(`\u2713 Disconnected from ${session.dappName}`));
+}
+async function cmdSend(to, sol, vault) {
+  const { PublicKey: PublicKey2, SystemProgram, Transaction: Transaction3, LAMPORTS_PER_SOL: LAMPORTS_PER_SOL3 } = await import("@solana/web3.js");
+  const keypair = vault.getActiveKeypair();
+  const { Keypair: Keypair2 } = await import("@solana/web3.js");
+  const solanaKeypair = Keypair2.fromSecretKey(keypair.secretKey);
+  const connection = getConnection();
+  const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash("confirmed");
+  const tx = new Transaction3().add(
+    SystemProgram.transfer({
+      fromPubkey: solanaKeypair.publicKey,
+      toPubkey: new PublicKey2(to),
+      lamports: Math.round(sol * LAMPORTS_PER_SOL3)
+    })
+  );
+  tx.recentBlockhash = blockhash;
+  tx.feePayer = solanaKeypair.publicKey;
+  tx.sign(solanaKeypair);
+  const raw = tx.serialize();
+  const sig = await connection.sendRawTransaction(raw, {
+    skipPreflight: false,
+    preflightCommitment: "confirmed"
+  });
+  await connection.confirmTransaction(
+    { signature: sig, blockhash, lastValidBlockHeight },
+    "confirmed"
+  );
+  console.log(chalk2.green(`\u2713 Sent ${sol} SOL to ${to}`));
+  console.log(chalk2.dim(`  tx: ${sig}`));
+}
+function cmdSetCluster(cluster) {
+  const valid = ["mainnet-beta", "devnet", "testnet"];
+  if (!valid.includes(cluster)) {
+    console.log(chalk2.red(`Valid clusters: ${valid.join(", ")}`));
+    return;
+  }
+  updateCluster(cluster);
+  console.log(chalk2.green(`\u2713 Cluster set to: ${cluster}`));
+}
+export {
+  cmdAccounts,
+  cmdAirdrop,
+  cmdConnect,
+  cmdDisconnect,
+  cmdInit,
+  cmdLock,
+  cmdNewAccount,
+  cmdSend,
+  cmdSessions,
+  cmdSetCluster,
+  cmdUnlock,
+  cmdUseAccount,
+  isUnlocked
+};
+//# sourceMappingURL=commands.js.map