@execra/core 1.0.0

package/dist/handler/walletConnect.js

@@ -0,0 +1,623 @@
+#!/usr/bin/env node
+
+// 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/rpc.ts
+import { Connection, PublicKey, LAMPORTS_PER_SOL } from "@solana/web3.js";
+
+// src/vault/config.ts
+import fs2 from "fs";
+
+// src/vault/keystore.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+function getWalletDir() {
+  return path.join(os.homedir(), ".wallet");
+}
+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 });
+  }
+}
+
+// src/vault/accounts.ts
+import { derivePath } from "ed25519-hd-key";
+import nacl from "tweetnacl";
+import bs58 from "bs58";
+
+// src/vault/mnemonic.ts
+import * as bip39 from "bip39";
+
+// src/vault/config.ts
+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"
+};
+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 getRpcUrl() {
+  return loadConfig().rpcUrl;
+}
+
+// src/solana/rpc.ts
+var _connection = null;
+function getConnection(forceNew = false) {
+  if (!_connection || forceNew) {
+    const rpcUrl = getRpcUrl();
+    _connection = new Connection(rpcUrl, "confirmed");
+  }
+  return _connection;
+}
+
+// src/solana/simulate.ts
+async function simulateTransaction(serializedTx, signerPublicKey, conn) {
+  const connection = conn ?? getConnection();
+  try {
+    const txBuffer = Buffer.from(serializedTx, "base64");
+    let simulation;
+    try {
+      const versionedTx = VersionedTransaction.deserialize(txBuffer);
+      simulation = await connection.simulateTransaction(versionedTx, {
+        sigVerify: false,
+        // skip sig verification — wallet hasn't signed yet
+        replaceRecentBlockhash: true
+      });
+    } catch {
+      const legacyTx = Transaction.from(txBuffer);
+      simulation = await connection.simulateTransaction(legacyTx, []);
+    }
+    const { value } = simulation;
+    return parseSimulationResult(value, signerPublicKey, txBuffer);
+  } catch (err) {
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : "Simulation failed",
+      logs: [],
+      accountChanges: [],
+      tokenChanges: [],
+      computeUnitsConsumed: 0,
+      programIds: [],
+      fee: 0,
+      rawLogs: []
+    };
+  }
+}
+function parseSimulationResult(value, signerPublicKey, txBuffer) {
+  const success = !value.err;
+  const logs = value.logs ?? [];
+  const accountChanges = (value.accounts ?? []).map((account, i) => {
+    if (!account) return null;
+    const preBalance = account.lamports ?? 0;
+    const postBalance = account.lamports ?? 0;
+    return {
+      address: signerPublicKey,
+      // simplified — full impl maps account indices
+      preBalance,
+      postBalance,
+      solDelta: (postBalance - preBalance) / LAMPORTS_PER_SOL2,
+      isWritable: true,
+      isSigner: i === 0
+    };
+  }).filter(Boolean);
+  const programIds = extractProgramIds(logs);
+  const computeUnitsConsumed = extractComputeUnits(logs);
+  const fee = 5e3;
+  return {
+    success,
+    error: value.err ? JSON.stringify(value.err) : null,
+    logs: formatLogs(logs),
+    accountChanges,
+    tokenChanges: [],
+    // full SPL parsing requires additional RPC calls
+    computeUnitsConsumed,
+    programIds,
+    fee,
+    rawLogs: logs
+  };
+}
+function extractProgramIds(logs) {
+  const ids = /* @__PURE__ */ new Set();
+  const invokePattern = /Program (\w+) invoke/;
+  for (const log of logs) {
+    const match = log.match(invokePattern);
+    if (match) ids.add(match[1]);
+  }
+  return Array.from(ids);
+}
+function extractComputeUnits(logs) {
+  for (const log of logs) {
+    const match = log.match(/consumed (\d+) of/);
+    if (match) return parseInt(match[1], 10);
+  }
+  return 0;
+}
+function formatLogs(logs) {
+  return logs.map((log) => {
+    return log.replace(/\b([1-9A-HJ-NP-Za-km-z]{32,44})\b/g, (addr) => {
+      const known = KNOWN_PROGRAMS[addr];
+      return known ? known : `${addr.slice(0, 4)}..${addr.slice(-4)}`;
+    });
+  });
+}
+var KNOWN_PROGRAMS = {
+  "11111111111111111111111111111111": "System Program",
+  TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA: "SPL Token",
+  JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4: "Jupiter V6",
+  "9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin": "Serum DEX",
+  ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJe1bv: "Associated Token",
+  SysvarRent111111111111111111111111111111111: "Sysvar Rent",
+  SysvarC1ock11111111111111111111111111111111: "Sysvar Clock"
+};
+
+// src/solana/tx.ts
+import {
+  Transaction as Transaction2,
+  VersionedTransaction as VersionedTransaction2,
+  Keypair
+} from "@solana/web3.js";
+import nacl2 from "tweetnacl";
+import bs582 from "bs58";
+async function signTransaction(serializedTx, keypair) {
+  const txBuffer = Buffer.from(serializedTx, "base64");
+  const solanaKeypair = toSolanaKeypair(keypair);
+  try {
+    const versionedTx = VersionedTransaction2.deserialize(txBuffer);
+    versionedTx.sign([solanaKeypair]);
+    const serialized = Buffer.from(versionedTx.serialize()).toString("base64");
+    const signature = bs582.encode(versionedTx.signatures[0]);
+    return { serialized, signature };
+  } catch {
+    const legacyTx = Transaction2.from(txBuffer);
+    legacyTx.partialSign(solanaKeypair);
+    const serialized = legacyTx.serialize({ requireAllSignatures: false }).toString("base64");
+    const signature = bs582.encode(legacyTx.signature);
+    return { serialized, signature };
+  }
+}
+async function signAllTransactions(serializedTxs, keypair) {
+  return Promise.all(serializedTxs.map((tx) => signTransaction(tx, keypair)));
+}
+async function signAndSendTransaction(serializedTx, keypair, options = {}, conn) {
+  const { serialized } = await signTransaction(serializedTx, keypair);
+  return sendSignedTransaction(serialized, options, conn);
+}
+async function sendSignedTransaction(serializedSignedTx, options = {}, conn) {
+  const connection = conn ?? getConnection();
+  const txBuffer = Buffer.from(serializedSignedTx, "base64");
+  const sendOptions = {
+    skipPreflight: false,
+    // run preflight checks
+    preflightCommitment: "confirmed",
+    ...options
+  };
+  let txHash;
+  try {
+    const versionedTx = VersionedTransaction2.deserialize(txBuffer);
+    txHash = await connection.sendTransaction(versionedTx, sendOptions);
+  } catch {
+    const legacyTx = Transaction2.from(txBuffer);
+    txHash = await connection.sendRawTransaction(
+      legacyTx.serialize(),
+      sendOptions
+    );
+  }
+  const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
+  const confirmResult = await connection.confirmTransaction(
+    { signature: txHash, blockhash, lastValidBlockHeight },
+    "confirmed"
+  );
+  return {
+    txHash,
+    confirmed: !confirmResult.value.err
+  };
+}
+function signOffchainMessage(message, keypair) {
+  const signature = nacl2.sign.detached(message, keypair.secretKey);
+  return bs582.encode(Buffer.from(signature));
+}
+function toSolanaKeypair(keypair) {
+  return Keypair.fromSecretKey(keypair.secretKey);
+}
+
+// src/handler/index.ts
+import bs583 from "bs58";
+var ERROR_CODES = {
+  USER_REJECTED: 4001,
+  UNAUTHORIZED: 4100,
+  UNSUPPORTED_METHOD: 4200,
+  DISCONNECTED: 4900,
+  CHAIN_DISCONNECTED: 4901
+};
+var WalletRequestHandler = class {
+  vault;
+  constructor(vault) {
+    this.vault = vault;
+  }
+  /**
+   * Handle any incoming wallet request.
+   * This is the single entry point — all bridges call this.
+   */
+  async handle(request) {
+    try {
+      switch (request.method) {
+        case "solana_connect":
+          return this.handleConnect(request);
+        case "solana_disconnect":
+          return this.handleDisconnect(request);
+        case "solana_signTransaction":
+          return this.handleSignTransaction(request);
+        case "solana_signAndSendTransaction":
+          return this.handleSignAndSend(request);
+        case "solana_signAllTransactions":
+          return this.handleSignAll(request);
+        case "solana_signMessage":
+          return this.handleSignMessage(request);
+        default:
+          return this.errorResponse(
+            request.id,
+            ERROR_CODES.UNSUPPORTED_METHOD,
+            `Method not supported: ${request.method}`
+          );
+      }
+    } catch (err) {
+      return this.errorResponse(
+        request.id,
+        4e3,
+        err instanceof Error ? err.message : "Unknown error"
+      );
+    }
+  }
+  // ── Connect / Disconnect ───────────────────────────────────────────────────
+  async handleConnect(request) {
+    const keypair = this.vault.getActiveKeypair();
+    return {
+      id: request.id,
+      result: {
+        publicKey: keypair.publicKey
+      }
+    };
+  }
+  async handleDisconnect(request) {
+    return { id: request.id, result: { disconnected: true } };
+  }
+  // ── Sign Transaction ───────────────────────────────────────────────────────
+  async handleSignTransaction(request) {
+    const tx = request.params.transaction;
+    if (!tx) return this.errorResponse(request.id, 4e3, "Missing transaction");
+    const keypair = this.vault.getActiveKeypair();
+    const simulation = await simulateTransaction(tx, keypair.publicKey);
+    this.log(request, `simulate \u2192 ${simulation.success ? "ok" : "fail"}`);
+    if (!simulation.success) {
+      return this.errorResponse(
+        request.id,
+        4e3,
+        `Simulation failed: ${simulation.error}`
+      );
+    }
+    const signed = await signTransaction(tx, keypair);
+    this.log(request, `signed \u2192 ${signed.signature.slice(0, 8)}...`);
+    return {
+      id: request.id,
+      result: { signedTransaction: signed.serialized }
+    };
+  }
+  // ── Sign and Send ──────────────────────────────────────────────────────────
+  async handleSignAndSend(request) {
+    const tx = request.params.transaction;
+    if (!tx) return this.errorResponse(request.id, 4e3, "Missing transaction");
+    const keypair = this.vault.getActiveKeypair();
+    const simulation = await simulateTransaction(tx, keypair.publicKey);
+    this.log(request, `simulate \u2192 ${simulation.success ? "ok" : "fail"}`);
+    if (!simulation.success) {
+      return this.errorResponse(
+        request.id,
+        4e3,
+        `Simulation failed: ${simulation.error}`
+      );
+    }
+    const result = await signAndSendTransaction(tx, keypair);
+    this.log(request, `sent \u2192 ${result.txHash.slice(0, 8)}...`);
+    return {
+      id: request.id,
+      result: {
+        signature: result.txHash,
+        confirmed: result.confirmed
+      }
+    };
+  }
+  // ── Sign All Transactions ──────────────────────────────────────────────────
+  async handleSignAll(request) {
+    const txs = request.params.transactions;
+    if (!txs?.length)
+      return this.errorResponse(request.id, 4e3, "Missing transactions");
+    const keypair = this.vault.getActiveKeypair();
+    for (const tx of txs) {
+      const simulation = await simulateTransaction(tx, keypair.publicKey);
+      if (!simulation.success) {
+        return this.errorResponse(
+          request.id,
+          4e3,
+          `Simulation failed for tx in batch: ${simulation.error}`
+        );
+      }
+    }
+    const signed = await signAllTransactions(txs, keypair);
+    this.log(request, `signed ${signed.length} transactions`);
+    return {
+      id: request.id,
+      result: { signedTransactions: signed.map((s) => s.serialized) }
+    };
+  }
+  // ── Sign Message ───────────────────────────────────────────────────────────
+  async handleSignMessage(request) {
+    const message = request.params.message;
+    if (!message)
+      return this.errorResponse(request.id, 4e3, "Missing message");
+    const keypair = this.vault.getActiveKeypair();
+    let messageBytes;
+    try {
+      messageBytes = decodeMessage(message);
+    } catch {
+      return this.errorResponse(
+        request.id,
+        4e3,
+        "Could not decode message bytes"
+      );
+    }
+    const signature = signOffchainMessage(messageBytes, keypair);
+    this.log(request, "message signed");
+    return {
+      id: request.id,
+      result: {
+        signature,
+        publicKey: keypair.publicKey
+      }
+    };
+  }
+  // ── Helpers ────────────────────────────────────────────────────────────────
+  errorResponse(id, code, message) {
+    return { id, error: { code, message } };
+  }
+  // TODO: handle logging
+  log(request, note) {
+  }
+};
+function decodeMessage(message) {
+  try {
+    const decoded = bs583.decode(message);
+    if (decoded.length > 0) return decoded;
+  } catch {
+  }
+  try {
+    const decoded = Buffer.from(message, "base64");
+    if (decoded.length > 0) return decoded;
+  } catch {
+  }
+  return new TextEncoder().encode(message);
+}
+async function handleRequest(request, options) {
+  const handler = new WalletRequestHandler(options.vault);
+  return handler.handle(request);
+}
+
+// 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 saveSession(session) {
+  const store = read();
+  const idx = store.sessions.findIndex((s) => s.topic === session.topic);
+  if (idx >= 0) {
+    store.sessions[idx] = session;
+  } else {
+    store.sessions.push(session);
+  }
+  write(store);
+}
+function removeSession(topic) {
+  const store = read();
+  store.sessions = store.sessions.filter((s) => s.topic !== topic);
+  write(store);
+}
+function markInactive(topic) {
+  const store = read();
+  const sess = store.sessions.find((s) => s.topic === topic);
+  if (sess) {
+    sess.active = false;
+    write(store);
+  }
+}
+
+// src/handler/walletConnect.ts
+var SignClient = SignClientPkg.default ?? SignClientPkg;
+var CHAIN_ID = "solana:devnet";
+var signClient = null;
+async function initWalletConnect(opts) {
+  signClient = await SignClient.init({
+    projectId: opts.projectId,
+    metadata: {
+      name: "Agentic Wallet",
+      description: "Autonomous AI agent wallet for Solana",
+      url: "https://github.com/your-repo/agentic-wallet",
+      icons: []
+    }
+  });
+  console.log(chalk.green("[WC] WalletConnect initialized"));
+  signClient.on("session_proposal", async ({ id, params }) => {
+    const meta = params.proposer.metadata;
+    console.log(
+      chalk.cyan(`
+[WC] Session proposal from: ${meta.name} (${meta.url})`)
+    );
+    let approved = true;
+    if (opts.onSessionProposal) {
+      approved = await opts.onSessionProposal(meta);
+    }
+    if (!approved) {
+      await signClient.reject({ id, reason: getSdkError("USER_REJECTED") });
+      console.log(chalk.red("[WC] Session rejected"));
+      return;
+    }
+    const account = opts.handlerOptions.vault.getActiveKeypair();
+    const { topic, acknowledged } = await signClient.approve({
+      id,
+      namespaces: {
+        solana: {
+          accounts: [`${CHAIN_ID}:${account.publicKey}`],
+          methods: [
+            "solana_signTransaction",
+            "solana_signAndSendTransaction",
+            "solana_signAllTransactions",
+            "solana_signMessage"
+          ],
+          events: []
+        }
+      }
+    });
+    await acknowledged();
+    saveSession({
+      topic,
+      dappName: meta.name,
+      dappUrl: meta.url,
+      dappIcon: meta.icons?.[0],
+      connectedAccount: account.publicKey,
+      connectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      lastActivity: (/* @__PURE__ */ new Date()).toISOString(),
+      permissions: [
+        "solana_signTransaction",
+        "solana_signAndSendTransaction",
+        "solana_signAllTransactions",
+        "solana_signMessage"
+      ],
+      chainId: CHAIN_ID,
+      active: true
+    });
+    console.log(chalk.green(`[WC] Connected to ${meta.name}`));
+    console.log(chalk.dim(`     Address: ${account.publicKey}`));
+  });
+  signClient.on("session_request", async ({ id, topic, params }) => {
+    const session = signClient.session.get(topic);
+    const dapp = {
+      name: session.peer.metadata.name,
+      url: session.peer.metadata.url
+    };
+    console.log(
+      chalk.yellow(
+        `
+[WC] Request: ${params.request.method} from ${dapp.name}`
+      )
+    );
+    const request = {
+      id,
+      method: params.request.method,
+      params: params.request.params,
+      dapp,
+      topic
+    };
+    const response = await handleRequest(request, opts.handlerOptions);
+    const jsonRpcResponse = response.error ? {
+      id,
+      jsonrpc: "2.0",
+      error: { code: response.error.code, message: response.error.message }
+    } : { id, jsonrpc: "2.0", result: response.result ?? null };
+    await signClient.respond({ topic, response: jsonRpcResponse });
+    if (response.error) {
+      console.log(chalk.red(`[WC] Rejected: ${response.error.message}`));
+    } else {
+      console.log(chalk.green(`[WC] Request fulfilled`));
+    }
+  });
+  signClient.on("session_delete", ({ topic }) => {
+    markInactive(topic);
+    console.log(
+      chalk.dim(`[WC] dApp disconnected (topic: ${topic.slice(0, 8)}...)`)
+    );
+  });
+  return signClient;
+}
+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)}...`)
+  );
+}
+function getSignClient() {
+  return signClient;
+}
+export {
+  disconnectDapp,
+  getSignClient,
+  initWalletConnect,
+  pairWithDapp
+};
+//# sourceMappingURL=walletConnect.js.map