@projectsolo/solo-mission-mcp 0.21.13 → 0.22.0

package/dist/verify-7EUVRUAS.js

@@ -0,0 +1,445 @@
+import {
+  base58Decode,
+  base58Encode,
+  ed25519Verify,
+  isEmptySignature,
+  isSignerIndex,
+  isWritableIndex,
+  parseWireTransaction
+} from "./chunk-NUGGTARW.js";
+
+// src/solana/verify.ts
+import { createHash } from "crypto";
+var SUPPORTED_ESCROW_INTERFACE = "v2";
+var DISCRIMINATORS = {
+  create_task: [194, 80, 6, 180, 232, 127, 48, 171],
+  cancel_task: [69, 228, 134, 187, 134, 105, 238, 48],
+  emergency_refund: [188, 73, 52, 195, 137, 70, 180, 147],
+  claim_refund: [15, 16, 30, 161, 255, 228, 97, 60],
+  /** The `Config` ACCOUNT discriminator (first 8 bytes of its data). */
+  Config: [155, 12, 170, 224, 30, 250, 204, 130]
+};
+var CREATE_TASK_V2_ACCOUNTS = [
+  "sponsor",
+  "config",
+  "whitelist",
+  "mint",
+  "task",
+  "vault",
+  "sponsor_token_account",
+  "token_program",
+  "system_program",
+  "operator",
+  "event_authority",
+  "program"
+];
+var CREATE_TASK_V2_DATA_LENGTH = 8 + 8 + 8 + 4 + 8 + 8 + 8 + 32 + 2;
+var TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+var SYSTEM_PROGRAM_ID = "11111111111111111111111111111111";
+function decodeCreateTaskV2(data) {
+  if (!data.subarray(0, 8).equals(Buffer.from(DISCRIMINATORS.create_task))) {
+    throw new Error(
+      `instruction discriminator is ${data.subarray(0, 8).toString("hex")}, not create_task's ` + Buffer.from(DISCRIMINATORS.create_task).toString("hex")
+    );
+  }
+  if (data.length !== CREATE_TASK_V2_DATA_LENGTH) {
+    throw new Error(
+      `create_task data is ${data.length} bytes, expected ${CREATE_TASK_V2_DATA_LENGTH} for the v2 interface` + (data.length === CREATE_TASK_V2_DATA_LENGTH - 2 ? " (84 bytes is the v1 layout, without max_fee_bps)" : "")
+    );
+  }
+  return {
+    budget: data.readBigUInt64LE(8).toString(),
+    base_pool: data.readBigUInt64LE(16).toString(),
+    lottery_winner_count: data.readUInt32LE(24),
+    lottery_prize_per_winner: data.readBigUInt64LE(28).toString(),
+    qualify_deadline: data.readBigInt64LE(36).toString(),
+    settlement_deadline: data.readBigInt64LE(44).toString(),
+    seed_commit: data.subarray(52, 84).toString("hex"),
+    max_fee_bps: data.readUInt16LE(84)
+  };
+}
+function decodeEscrowConfig(data, address) {
+  if (data.length < 155) throw new Error(`Config account is ${data.length} bytes, too short`);
+  if (!data.subarray(0, 8).equals(Buffer.from(DISCRIMINATORS.Config))) {
+    throw new Error("account at the Config address does not carry the Config discriminator");
+  }
+  const key = (o) => base58Encode(data.subarray(o, o + 32));
+  return {
+    address,
+    admin: key(8),
+    operator: key(40),
+    guardian: key(72),
+    treasury: key(104),
+    fee_bps: data.readUInt16LE(136),
+    min_review_window: Number(data.readBigInt64LE(138)),
+    paused: data[146] !== 0,
+    task_counter: data.readBigUInt64LE(147).toString()
+  };
+}
+async function configAddress(programId) {
+  const { PublicKey } = await import("@solana/web3.js");
+  return PublicKey.findProgramAddressSync([Buffer.from("config")], new PublicKey(programId))[0].toBase58();
+}
+async function getAccountInfo(rpcUrl, address, { attempts = 3, backoffMs = 500 } = {}) {
+  let lastError = "";
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    try {
+      const res = await fetch(rpcUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id: 1,
+          method: "getAccountInfo",
+          params: [address, { encoding: "base64", commitment: "confirmed" }]
+        }),
+        signal: AbortSignal.timeout(15e3)
+      });
+      if (res.status === 429 || res.status >= 500) {
+        lastError = `HTTP ${res.status}`;
+      } else {
+        const body = await res.json();
+        if (!body.error) return body.result?.value ?? null;
+        if (!/rate limit|too many/i.test(body.error.message)) {
+          throw new Error(`RPC getAccountInfo(${address}) failed: ${body.error.message}`);
+        }
+        lastError = body.error.message;
+      }
+    } catch (e) {
+      if (e.message.startsWith("RPC getAccountInfo")) throw e;
+      lastError = e.message;
+    }
+    if (attempt < attempts) await new Promise((r) => setTimeout(r, backoffMs * attempt));
+  }
+  throw new Error(`RPC getAccountInfo(${address}) failed: ${lastError}`);
+}
+async function readEscrowConfig(rpcUrl, programId, opts = {}) {
+  const address = await configAddress(programId);
+  const value = await getAccountInfo(rpcUrl, address, opts);
+  if (!value) throw new Error(`Config account ${address} does not exist on this cluster`);
+  if (value.owner !== programId) {
+    throw new Error(`Config account ${address} is owned by ${value.owner}, not the program ${programId}`);
+  }
+  return decodeEscrowConfig(Buffer.from(value.data[0], "base64"), address);
+}
+async function readMintDecimals(rpcUrl, mint, opts = {}) {
+  const value = await getAccountInfo(rpcUrl, mint, opts);
+  if (!value) throw new Error(`mint ${mint} does not exist on this cluster`);
+  if (value.owner !== TOKEN_PROGRAM_ID) {
+    throw new Error(`mint ${mint} is owned by ${value.owner}, not the SPL Token program`);
+  }
+  const data = Buffer.from(value.data[0], "base64");
+  if (data.length !== 82 || data[45] !== 1) {
+    throw new Error(`account ${mint} is not an initialized SPL Token mint`);
+  }
+  return data[44];
+}
+var eqAmount = (a, b) => {
+  try {
+    return BigInt(a) === BigInt(b);
+  } catch {
+    return false;
+  }
+};
+var hex = (s) => String(s ?? "").replace(/^0x/i, "").toLowerCase();
+async function verifyFundingTransaction(input) {
+  const { PublicKey } = await import("@solana/web3.js");
+  const problems = [];
+  const warnings = [];
+  const e = input.expected;
+  const d = input.declared;
+  const expectLottery = e.lottery_winner_count > 0;
+  const summary = {
+    escrow_interface: input.escrow_interface,
+    program_id: "(none)",
+    instruction_count: 0,
+    signers: [],
+    fee_payer: null,
+    budget: d.budget,
+    mint: input.accounts.mint,
+    task: input.accounts.task,
+    lottery: expectLottery,
+    max_fee_bps: null,
+    operator: null,
+    operator_signature: expectLottery ? "missing" : "not_required",
+    message_sha256: null
+  };
+  const done = () => ({ ok: problems.length === 0, problems, warnings, summary });
+  if (input.escrow_interface !== SUPPORTED_ESCROW_INTERFACE) {
+    problems.push(
+      `the funding response reports escrow_interface ${JSON.stringify(input.escrow_interface)}; this verifier decodes only the ${SUPPORTED_ESCROW_INTERFACE} create_task layout`
+    );
+  }
+  let tx;
+  try {
+    tx = parseWireTransaction(Buffer.from(input.transaction_base64, "base64"));
+  } catch (err) {
+    problems.push(`the transaction does not decode: ${err.message}`);
+    return done();
+  }
+  summary.instruction_count = tx.instructions.length;
+  summary.signers = tx.accountKeys.slice(0, tx.header.numRequiredSignatures);
+  summary.fee_payer = tx.accountKeys[0] ?? null;
+  summary.message_sha256 = createHash("sha256").update(tx.message).digest("hex");
+  if (tx.instructions.length !== 1) {
+    problems.push(
+      `expected exactly 1 instruction, found ${tx.instructions.length} \u2014 additional instructions would be authorised by the same signature`
+    );
+  }
+  const ix = tx.instructions[0];
+  const programId = ix ? tx.accountKeys[ix.programIdIndex] : "(none)";
+  summary.program_id = programId;
+  if (programId !== input.expected_program_id) {
+    problems.push(`program is ${programId}, expected ${input.expected_program_id}`);
+  }
+  if (programId !== input.accounts.program_id) {
+    problems.push(
+      `transaction program ${programId} disagrees with the quoted accounts.program_id ${input.accounts.program_id}`
+    );
+  }
+  if (input.message_sha256 !== void 0 && input.message_sha256.toLowerCase() !== summary.message_sha256) {
+    problems.push(
+      `the response's message_sha256 ${input.message_sha256} is not the hash of this transaction's message (${summary.message_sha256}) \u2014 confirm-funding would not recognise it`
+    );
+  }
+  let encoded = null;
+  try {
+    encoded = decodeCreateTaskV2(ix?.data ?? Buffer.alloc(0));
+    summary.max_fee_bps = encoded.max_fee_bps;
+    summary.lottery = encoded.lottery_winner_count > 0;
+  } catch (err) {
+    problems.push(`${err.message} \u2014 this is not the instruction it claims to be`);
+  }
+  const program = new PublicKey(input.expected_program_id);
+  const pda = (...seeds) => PublicKey.findProgramAddressSync(seeds, program)[0].toBase58();
+  let taskId = null;
+  try {
+    taskId = BigInt(input.task_id);
+    if (taskId < 0n || taskId > 0xffffffffffffffffn) throw new Error("out of range");
+  } catch {
+    problems.push(`task_id ${JSON.stringify(input.task_id)} is not a u64`);
+    taskId = null;
+  }
+  const u64le = (v) => {
+    const b = Buffer.alloc(8);
+    b.writeBigUInt64LE(v);
+    return b;
+  };
+  let mintKey = null;
+  try {
+    mintKey = base58Decode(e.mint);
+    if (mintKey.length !== 32) mintKey = null;
+  } catch {
+    mintKey = null;
+  }
+  if (!mintKey) problems.push(`expected mint ${e.mint} is not a valid address`);
+  const operatorSlot = CREATE_TASK_V2_ACCOUNTS.indexOf("operator");
+  const want = {
+    sponsor: e.sponsor,
+    config: pda(Buffer.from("config")),
+    whitelist: mintKey ? pda(Buffer.from("whitelist"), mintKey) : null,
+    mint: e.mint,
+    task: taskId !== null ? pda(Buffer.from("task"), u64le(taskId)) : null,
+    vault: taskId !== null ? pda(Buffer.from("vault"), u64le(taskId)) : null,
+    sponsor_token_account: e.sponsor_token_account,
+    token_program: TOKEN_PROGRAM_ID,
+    system_program: SYSTEM_PROGRAM_ID,
+    operator: null,
+    // checked below: depends on lottery vs not
+    event_authority: pda(Buffer.from("__event_authority")),
+    program: input.expected_program_id
+  };
+  const ixKeys = (ix?.accountIndexes ?? []).map((i) => tx.accountKeys[i]);
+  if (ix && ixKeys.length !== CREATE_TASK_V2_ACCOUNTS.length) {
+    problems.push(
+      `create_task lists ${ixKeys.length} accounts, expected ${CREATE_TASK_V2_ACCOUNTS.length} (${CREATE_TASK_V2_ACCOUNTS.join(", ")})`
+    );
+  } else if (ix) {
+    CREATE_TASK_V2_ACCOUNTS.forEach((name, i) => {
+      const expectedKey = want[name];
+      if (expectedKey !== null && ixKeys[i] !== expectedKey) {
+        problems.push(`account #${i} (${name}) is ${ixKeys[i]}, expected ${expectedKey}`);
+      }
+    });
+    if (!isSignerIndex(tx, ix.accountIndexes[0]) || !isWritableIndex(tx, ix.accountIndexes[0])) {
+      problems.push("the sponsor account is not a writable signer");
+    }
+  }
+  for (const [label, quoted, derived] of [
+    ["task", input.accounts.task, want.task],
+    ["vault", input.accounts.vault, want.vault],
+    ["config", input.accounts.config, want.config],
+    ["whitelist", input.accounts.whitelist, want.whitelist]
+  ]) {
+    if (derived !== null && quoted !== derived) {
+      problems.push(
+        `quoted ${label} ${quoted} is not the program-derived address ${derived} \u2014 an address that is not the PDA may be a wallet somebody holds the key to`
+      );
+    }
+  }
+  if (input.accounts.mint !== e.mint) {
+    problems.push(`quoted mint ${input.accounts.mint}, expected ${e.mint}`);
+  }
+  if (input.accounts.sponsor !== e.sponsor) {
+    problems.push(`quoted sponsor ${input.accounts.sponsor}, expected ${e.sponsor}`);
+  }
+  if (input.accounts.sponsor_token_account !== e.sponsor_token_account) {
+    problems.push(
+      `quoted sponsor_token_account ${input.accounts.sponsor_token_account}, expected ${e.sponsor_token_account}`
+    );
+  }
+  if (input.accounts.vault === input.accounts.sponsor_token_account) {
+    problems.push("escrow vault equals the sponsor token account \u2014 the budget would not be escrowed");
+  }
+  const feePayer = tx.accountKeys[0];
+  if (feePayer !== e.sponsor) {
+    const who = input.onchain_config && feePayer === input.onchain_config.operator ? " (the Operator)" : "";
+    problems.push(`fee payer is ${feePayer ?? "(unset)"}${who}, expected the sponsor ${e.sponsor}`);
+  }
+  const operatorKey = ix && ixKeys.length === CREATE_TASK_V2_ACCOUNTS.length ? ixKeys[operatorSlot] : void 0;
+  const operatorIndex = ix?.accountIndexes[operatorSlot];
+  const signers = summary.signers;
+  if (d.operator_cosigned !== void 0 && d.operator_cosigned !== expectLottery) {
+    problems.push(
+      `the response says operator_cosigned=${d.operator_cosigned}, but this is ` + (expectLottery ? "a lottery task, which must be co-signed" : "not a lottery task, which must not be")
+    );
+  }
+  if (!expectLottery) {
+    if (operatorKey !== void 0 && operatorKey !== input.expected_program_id) {
+      problems.push(
+        `the operator slot holds ${operatorKey}; a non-lottery create_task must pass the program id ${input.expected_program_id} (no co-signer)`
+      );
+    }
+    if (signers.length !== 1 || signers[0] !== e.sponsor) {
+      problems.push(
+        `expected the sponsor ${e.sponsor} to be the only signer, found [${signers.join(", ")}]`
+      );
+    }
+  } else {
+    summary.operator = operatorKey ?? null;
+    const cfg2 = input.onchain_config;
+    if (!cfg2) {
+      problems.push(
+        "cannot check the lottery co-signer: the on-chain Config.operator could not be read" + (input.onchain_config_error ? ` (${input.onchain_config_error})` : "")
+      );
+    } else if (operatorKey !== cfg2.operator) {
+      problems.push(
+        `the co-signer in the operator slot is ${operatorKey ?? "(none)"}, but the on-chain Config.operator is ${cfg2.operator}`
+      );
+    }
+    if (operatorKey !== void 0 && operatorKey === e.sponsor) {
+      problems.push("the operator slot holds the sponsor itself \u2014 the co-signature would be the agent's own");
+    }
+    const expectedSigners = operatorKey ? [e.sponsor, operatorKey] : [e.sponsor];
+    if (signers.length !== 2 || signers[0] !== expectedSigners[0] || signers[1] !== expectedSigners[1]) {
+      problems.push(
+        `expected exactly two signers, the sponsor ${e.sponsor} (fee payer) and the Operator ${operatorKey ?? "(none)"}, found [${signers.join(", ")}]`
+      );
+    }
+    if (operatorIndex === void 0 || !isSignerIndex(tx, operatorIndex)) {
+      problems.push("the operator slot is not a signer \u2014 a lottery create_task needs the Operator to sign");
+      summary.operator_signature = "missing";
+    } else {
+      const sig = tx.signatures[operatorIndex];
+      if (isEmptySignature(sig)) {
+        summary.operator_signature = "missing";
+        problems.push(
+          "the Operator co-signature is missing \u2014 a lottery create_task without it fails on chain (LotteryRequiresOperator), and an agent-added signature cannot fix that"
+        );
+      } else if (!ed25519Verify(sig, tx.message, operatorKey)) {
+        summary.operator_signature = "invalid";
+        problems.push(
+          "the Operator signature does not verify over this message \u2014 the transaction was altered after it was co-signed, or the signature is not the Operator's"
+        );
+      } else {
+        summary.operator_signature = "valid";
+      }
+    }
+  }
+  if (!eqAmount(d.budget, e.budget_raw)) {
+    problems.push(`budget is ${d.budget}, expected ${e.budget_raw}`);
+  }
+  if (!eqAmount(d.base_pool, e.base_pool_raw)) {
+    problems.push(`base_pool is ${d.base_pool}, expected ${e.base_pool_raw}`);
+  }
+  if (Number(d.lottery_winner_count) !== e.lottery_winner_count) {
+    problems.push(
+      `lottery_winner_count is ${d.lottery_winner_count}, expected ${e.lottery_winner_count}`
+    );
+  }
+  if (!eqAmount(d.lottery_prize_per_winner, e.lottery_prize_per_winner_raw)) {
+    problems.push(
+      `lottery_prize_per_winner is ${d.lottery_prize_per_winner}, expected ${e.lottery_prize_per_winner_raw}`
+    );
+  }
+  if (!eqAmount(d.qualify_deadline, String(e.qualify_deadline))) {
+    problems.push(`qualify_deadline is ${d.qualify_deadline}, expected ${e.qualify_deadline}`);
+  }
+  if (!eqAmount(d.settlement_deadline, String(e.settlement_deadline))) {
+    problems.push(
+      `settlement_deadline is ${d.settlement_deadline}, expected ${e.settlement_deadline}`
+    );
+  }
+  if (!/^[0-9a-f]{64}$/i.test(d.seed_commit)) {
+    problems.push(`seed_commit is not 32 bytes of hex: ${d.seed_commit}`);
+  } else if (e.seed_commit !== void 0 && hex(d.seed_commit) !== hex(e.seed_commit)) {
+    problems.push(`seed_commit is ${d.seed_commit}, expected ${hex(e.seed_commit)}`);
+  }
+  if (typeof e.max_fee_bps !== "number" || !Number.isInteger(e.max_fee_bps)) {
+    problems.push("no quoted fee rate to check max_fee_bps against \u2014 refusing to sign an unchecked fee ceiling");
+  } else if (d.max_fee_bps === void 0) {
+    problems.push("the funding response does not declare max_fee_bps \u2014 not a v2 funding transaction");
+  } else if (Number(d.max_fee_bps) !== e.max_fee_bps) {
+    problems.push(`max_fee_bps is ${d.max_fee_bps}, expected the quoted fee rate ${e.max_fee_bps}`);
+  }
+  if (encoded) {
+    for (const key of Object.keys(encoded)) {
+      const inBytes = String(encoded[key]);
+      const quotedRaw = d[key];
+      if (quotedRaw === void 0) continue;
+      const quoted = String(quotedRaw);
+      const same = key === "seed_commit" ? inBytes === hex(quoted) : key === "lottery_winner_count" || key === "max_fee_bps" ? Number(inBytes) === Number(quoted) : eqAmount(inBytes, quoted);
+      if (!same) {
+        problems.push(
+          `the transaction encodes ${key}=${inBytes} but the response quoted ${quoted} \u2014 the backend described one thing and built another`
+        );
+      }
+    }
+    if (typeof e.max_fee_bps === "number" && encoded.max_fee_bps !== e.max_fee_bps) {
+      problems.push(
+        `the transaction encodes max_fee_bps=${encoded.max_fee_bps}, not the quoted fee rate ${e.max_fee_bps}`
+      );
+    }
+    if (encoded.lottery_winner_count > 0 !== expectLottery) {
+      problems.push(
+        `the transaction encodes lottery_winner_count=${encoded.lottery_winner_count}, expected ${e.lottery_winner_count}`
+      );
+    }
+  }
+  const cfg = input.onchain_config;
+  if (cfg && encoded) {
+    if (cfg.fee_bps > encoded.max_fee_bps) {
+      warnings.push(
+        `the program's fee is now ${cfg.fee_bps} bps, above this transaction's max_fee_bps ${encoded.max_fee_bps}: create_task will fail with FeeAboveSponsorMax (6132). Cancel the mission and create a new one to get a fresh quote.`
+      );
+    }
+    if (cfg.paused) {
+      warnings.push("the escrow program is paused: create_task will fail until it is unpaused.");
+    }
+  }
+  return done();
+}
+export {
+  CREATE_TASK_V2_ACCOUNTS,
+  CREATE_TASK_V2_DATA_LENGTH,
+  DISCRIMINATORS,
+  SUPPORTED_ESCROW_INTERFACE,
+  SYSTEM_PROGRAM_ID,
+  TOKEN_PROGRAM_ID,
+  configAddress,
+  decodeCreateTaskV2,
+  decodeEscrowConfig,
+  readEscrowConfig,
+  readMintDecimals,
+  verifyFundingTransaction
+};

package/dist/{wallet-V4T4NTCM.js → wallet-LX7SI5RE.js}

@@ -1,6 +1,8 @@
 // src/solana/wallet.ts
 import { readFileSync } from "fs";
 import { createDecipheriv, pbkdf2Sync } from "crypto";
+var KEY_STORAGE_GUIDANCE = "Keep the keyfile and the passphrase in your secret manager and have it write the files when the MCP server starts: for example 1Password (`op inject`, `op read --out-file`), a HashiCorp Vault Agent template, GCP Secret Manager (`gcloud secrets versions access`), or the macOS Keychain (`security find-generic-password -w`). Never paste the key or the passphrase into chat, a command line or shell history.";
+var REMOVED_INLINE_KEY_VAR = "SOLO_SOLANA_KEYPAIR";
 var SolanaWalletUnavailable = class extends Error {
   constructor(reason) {
     super(
@@ -8,10 +10,13 @@ var SolanaWalletUnavailable = class extends Error {
 
 Set one of:
   SOLO_SOLANA_KEYPAIR_ENCRYPTED_PATH + SOLO_SOLANA_KEYPAIR_PASSWORD_FILE
-                            - recommended: an openssl-aes-256-cbc-pbkdf2-encrypted
-                              keyfile plus a separate passphrase file (chmod 600 both)
-  SOLO_SOLANA_KEYPAIR       - JSON byte array, as \`solana-keygen\` writes it (plaintext)
-  SOLO_SOLANA_KEYPAIR_PATH  - path to that file (e.g. ~/.config/solana/id.json), plaintext
+                            - recommended: a keyfile encrypted with
+                              \`openssl enc -aes-256-cbc -pbkdf2 -iter 10000 -md sha256\`
+                              plus a separate passphrase file (chmod 600 both)
+  SOLO_SOLANA_KEYPAIR_PATH  - path to a plaintext \`solana-keygen\` keyfile
+                              (e.g. ~/.config/solana/id.json, chmod 600)
+
+${KEY_STORAGE_GUIDANCE}
 
 The wallet needs SOL for rent and fees, and USDC for the mission budget. Rent is a
 refundable deposit, not a fee: most of it returns when the task is closed.`
@@ -19,6 +24,13 @@ refundable deposit, not a fee: most of it returns when the task is closed.`
     this.name = "SolanaWalletUnavailable";
   }
 };
+function assertNoInlineKeyVar() {
+  if ((process.env[REMOVED_INLINE_KEY_VAR] ?? "").trim() !== "") {
+    throw new SolanaWalletUnavailable(
+      `${REMOVED_INLINE_KEY_VAR} (the raw key in an environment variable) is no longer supported. Unset it, and move the key into a file referenced by SOLO_SOLANA_KEYPAIR_ENCRYPTED_PATH + SOLO_SOLANA_KEYPAIR_PASSWORD_FILE (recommended) or SOLO_SOLANA_KEYPAIR_PATH.`
+    );
+  }
+}
 function decryptOpenSslAes256CbcPbkdf2(encrypted, password) {
   const MAGIC = "Salted__";
   if (encrypted.length < 16 || encrypted.subarray(0, 8).toString("utf8") !== MAGIC) {
@@ -68,9 +80,9 @@ function expandHome(path) {
 var cachedWallet;
 async function loadSolanaWallet() {
   if (cachedWallet) return cachedWallet;
+  assertNoInlineKeyVar();
   const encryptedPath = process.env.SOLO_SOLANA_KEYPAIR_ENCRYPTED_PATH;
   const passwordFile = process.env.SOLO_SOLANA_KEYPAIR_PASSWORD_FILE;
-  const inline = process.env.SOLO_SOLANA_KEYPAIR;
   const path = process.env.SOLO_SOLANA_KEYPAIR_PATH;
   let raw;
   if (encryptedPath && encryptedPath.trim() !== "" || passwordFile && passwordFile.trim() !== "") {
@@ -92,8 +104,6 @@ async function loadSolanaWallet() {
       throw new SolanaWalletUnavailable(`cannot read ${passwordFile}: ${e.message}`);
     }
     raw = decryptOpenSslAes256CbcPbkdf2(encrypted, password).toString("utf8");
-  } else if (inline && inline.trim() !== "") {
-    raw = inline;
   } else if (path && path.trim() !== "") {
     try {
       raw = readFileSync(expandHome(path), "utf8");
@@ -102,7 +112,7 @@ async function loadSolanaWallet() {
     }
   } else {
     throw new SolanaWalletUnavailable(
-      "no wallet source configured (checked SOLO_SOLANA_KEYPAIR_ENCRYPTED_PATH, SOLO_SOLANA_KEYPAIR, SOLO_SOLANA_KEYPAIR_PATH)"
+      "no wallet source configured (checked SOLO_SOLANA_KEYPAIR_ENCRYPTED_PATH, SOLO_SOLANA_KEYPAIR_PATH)"
     );
   }
   const secretKey = parseKeypairBytes(raw);
@@ -113,7 +123,7 @@ async function loadSolanaWallet() {
 }
 function hasSolanaWallet() {
   return Boolean(
-    cachedWallet || (process.env.SOLO_SOLANA_KEYPAIR_ENCRYPTED_PATH ?? "").trim() && (process.env.SOLO_SOLANA_KEYPAIR_PASSWORD_FILE ?? "").trim() || (process.env.SOLO_SOLANA_KEYPAIR ?? "").trim() || (process.env.SOLO_SOLANA_KEYPAIR_PATH ?? "").trim()
+    cachedWallet || (process.env[REMOVED_INLINE_KEY_VAR] ?? "").trim() || (process.env.SOLO_SOLANA_KEYPAIR_ENCRYPTED_PATH ?? "").trim() && (process.env.SOLO_SOLANA_KEYPAIR_PASSWORD_FILE ?? "").trim() || (process.env.SOLO_SOLANA_KEYPAIR_PATH ?? "").trim()
   );
 }
 async function associatedTokenAddress(mint, owner) {
@@ -127,14 +137,18 @@ async function associatedTokenAddress(mint, owner) {
   return address.toBase58();
 }
 async function signTransaction(transactionBase64, wallet) {
-  const { Keypair, Transaction } = await import("@solana/web3.js");
-  const kp = Keypair.fromSecretKey(wallet.secretKey);
-  const tx = Transaction.from(Buffer.from(transactionBase64, "base64"));
-  tx.partialSign(kp);
-  return tx.serialize().toString("base64");
+  const { addOwnSignature } = await import("./wire-RLDY4AJR.js");
+  return addOwnSignature(
+    Buffer.from(transactionBase64, "base64"),
+    wallet.secretKey,
+    wallet.publicKey
+  ).toString("base64");
 }
 export {
+  KEY_STORAGE_GUIDANCE,
+  REMOVED_INLINE_KEY_VAR,
   SolanaWalletUnavailable,
+  assertNoInlineKeyVar,
   associatedTokenAddress,
   decryptOpenSslAes256CbcPbkdf2,
   hasSolanaWallet,

package/dist/wire-RLDY4AJR.js

@@ -0,0 +1,24 @@
+import {
+  addOwnSignature,
+  base58Decode,
+  base58Encode,
+  ed25519Sign,
+  ed25519Verify,
+  isEmptySignature,
+  isSignerIndex,
+  isWritableIndex,
+  parseWireTransaction,
+  publicKeyOfSecret
+} from "./chunk-NUGGTARW.js";
+export {
+  addOwnSignature,
+  base58Decode,
+  base58Encode,
+  ed25519Sign,
+  ed25519Verify,
+  isEmptySignature,
+  isSignerIndex,
+  isWritableIndex,
+  parseWireTransaction,
+  publicKeyOfSecret
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@projectsolo/solo-mission-mcp",
-  "version": "0.21.13",
+  "version": "0.22.0",
   "description": "MCP server for Solo Mission Platform — lets AI agents create missions, browse humans, and chat.",
   "type": "module",
   "main": "dist/index.js",

package/src/config.ts

@@ -8,3 +8,14 @@ export const config = {
 if (!config.agentKey) {
   console.warn('Warning: SOLO_AGENT_KEY is not set. Only register_agent will work until a key is configured.');
 }
+
+// Solana tools load the wallet lazily and fail there with the full explanation; this startup line
+// makes sure an operator running only off-chain tools still learns the raw key is sitting in env.
+if ((process.env.SOLO_SOLANA_KEYPAIR ?? '').trim() !== '') {
+  console.warn(
+    'Warning: SOLO_SOLANA_KEYPAIR (the raw key in an environment variable) is no longer supported, ' +
+      'and Solana tools will refuse to run while it is set. Unset it and use ' +
+      'SOLO_SOLANA_KEYPAIR_ENCRYPTED_PATH + SOLO_SOLANA_KEYPAIR_PASSWORD_FILE (recommended) or ' +
+      'SOLO_SOLANA_KEYPAIR_PATH.',
+  );
+}

package/src/index.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 /**
  * Solo Mission MCP Server
- * Exposes 15 tools for AI agents to interact with the Solo Mission Platform.
+ * Exposes MCP tools for AI agents to interact with the Solo Mission Platform.
  */
 
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';

package/src/scripts/check-tools-against-spec.ts

@@ -132,9 +132,9 @@ try {
  * The check's original premise, "every route the spec documents must be called by something here",
  * held only while the spec happened to annotate agent routes exclusively. It broke the moment
  * solo-firebase documented `GET /human/solana/rewards` and `POST /profile/wallet/solana/bind` —
- * correctly, since a published API should describe its human surface too. The Base equivalents
- * (`/human/rewards`, `/profile/wallet/bind`) are simply not annotated yet, which is why this never
- * fired before rather than the rule ever having been right.
+ * correctly, since a published API should describe its human surface too. The older non-Solana
+ * routes (`/human/rewards`, `/profile/wallet/bind`) are simply not annotated yet, which is why this
+ * never fired before rather than the rule ever having been right.
  *
  * Scoped by path prefix rather than an allowlist of specific routes, so the next human endpoint
  * does not fail a release for the same reason.