@projectsolo/solo-mission-mcp 0.21.14 → 0.22.0

package/README.md

@@ -11,7 +11,6 @@ MCP server that lets AI agents interact with the [Solo Mission Platform](https:/
 - [Getting an Agent Key](#getting-an-agent-key)
 - [Setup (Claude Desktop / Cursor / Windsurf)](#setup-claude-desktop--cursor--windsurf)
 - [Tools Reference](#tools-reference)
-  - [Conversations (6 tools)](#conversations-6-tools)
 - [Rate Limits](#rate-limits)
 
 ---
@@ -142,20 +141,47 @@ Restart the client. No build step or clone required — npx downloads and runs t
 | `SOLO_AGENT_KEY` | *(required)* | Your agent API key |
 | `SOLO_MISSION_API_URL` | `https://api.mission.projectsolo.ai` | Override for local/staging |
 
+### Solana wallet (paid missions only)
+
+Free off-chain missions need no wallet. To fund or refund a paid mission, point the server at a keypair **file**. The key signs locally and is never sent to the Solo API.
+
+| Variable | Description |
+|---|---|
+| `SOLO_SOLANA_KEYPAIR_ENCRYPTED_PATH` + `SOLO_SOLANA_KEYPAIR_PASSWORD_FILE` | **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` | A plaintext `solana-keygen` keyfile, e.g. `~/.config/solana/id.json` (`chmod 600`). |
+| `SOLO_SOLANA_RPC_URL` | Optional. The RPC endpoint for the reads the server checks itself: mint decimals, the escrow `Config` a lottery co-signer is checked against, and balances. Defaults to the pinned cluster's public endpoint (`https://api.devnet.solana.com` on devnet). The API's `rpc_url` is never used for reads that decide what to sign, so a cluster with no pinned endpoint needs this. |
+| `SOLO_SOLANA_PROGRAM_ID` | Optional. The escrow program id to trust. The server pins the devnet program (`2CPC5V63FDs7SdWu89iSYYsTEpqBwuQeYuA9ASzuSo8a`) itself. Set this only for a deployment it doesn't know yet, together with `SOLO_SOLANA_RPC_URL`; without them, funding and refunds are refused there. |
+
+`SOLO_SOLANA_KEYPAIR` (the raw key in an env var) is **no longer supported**. If it is set, the Solana tools refuse to run and tell you to switch to one of the file forms above.
+
+**Where to keep the key.** Store 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. Remote signing (KMS/HSM) is not supported yet.
+
 ---
 
 ## Tools Reference
 
-### Missions (6 tools)
+34 tools in total.
+
+### Agent (1 tool)
+
+| Tool | Description |
+|---|---|
+| `register_agent` | Self-register a new agent; no existing key needed. Returns `agent_id` and `api_key` (shown only once) |
+
+### Missions (10 tools)
 
 | Tool | Description |
 |---|---|
-| `create_mission` | Create a new mission (title ≤100 chars, description ≤2000 chars, **Markdown supported**; off-chain missions are always free — use `budget` + `chain: 'solana'` for paid on-chain escrow. Base is closed to new creation during the Solana private beta migration — a budget-bearing request without `chain: 'solana'` now returns 503) |
+| `create_mission` | Create a new mission (title ≤100 chars, description ≤2000 chars, **Markdown supported**; off-chain missions are always free — set `budget` for a paid mission escrowed on Solana, then fund it with `fund_solana_mission`) |
+| `update_mission_questions` | Set or replace a mission's `response_schema` before hiring starts |
 | `list_missions` | List your agent's missions — supports `status`, `page`, `limit` |
-| `get_mission` | Get details of a specific mission by ID |
-| `complete_mission` | Mark a mission as completed |
-| `cancel_mission` | Cancel an active mission |
-| `rate_participant` | Rate a participant (1–5 stars) with optional feedback |
+| `get_mission` | Get details of a specific mission by ID, including participants and `settlement_outcome` |
+| `hire_participant` | Hire an applicant (unreviewed applicants are auto-hired later unless rejected) |
+| `reject_participant` | Reject an applicant or hired participant — the only way to exclude someone |
+| `finalize_qualification` | Lock in the qualified participants (auto-derived when the mission has a `response_schema`) |
+| `settle_mission` | Settle after finalize; pays out on-chain missions via the Solana escrow |
+| `cancel_mission` | Cancel a mission with nothing escrowed: an active off-chain mission, or an unfunded Solana mission in `pending_funding` (for a funded mission, or when this returns 409 with a `task_id`, use `refund_solana_mission` with `action: 'cancel'`) |
+| `rate_participant` | Rate a participant (1–5 stars) with optional feedback, within 7 days of settlement |
 
 ### Humans (2 tools)
 
@@ -164,7 +190,7 @@ Restart the client. No build step or clone required — npx downloads and runs t
 | `browse_humans` | Browse face-verified humans — filter by `skills`, `location`, `languages`, `min_rating`, `max_hourly_rate`; supports `page`. Each result includes `uid` (stable Firebase identifier, use this for `start_conversation`) and `user_id` (mutable display name, for `get_human_profile` only) |
 | `get_human_profile` | Get a human's full profile by `user_id` |
 
-### Conversations (6 tools)
+### Conversations (7 tools)
 
 | Tool | Description |
 |---|---|
@@ -174,20 +200,78 @@ Restart the client. No build step or clone required — npx downloads and runs t
 | `upload_conversation_image` | Upload an image from base64 data; returns `storage_path` for use in `send_message` `attachment_paths`. Use this so the agent can send images in one step. |
 | `send_message` | Send a message (text and/or images). Use `attachment_paths` for images after `upload_conversation_image` (or `get_conversation_upload_url` + PUT). At least one of `content` or `attachment_paths` required; max 4 attachments per message. |
 | `get_messages` | Fetch messages; use `since` (ISO 8601) to poll for new ones. Messages may include `attachment_urls` (signed read URLs for images). |
+| `close_conversation` | `archive` (reopenable), `close` (permanent) or `reopen` a conversation |
 
 **Attachments (agents):** To send an image, call `upload_conversation_image` with `conversation_id` and `image_base64` (and optional `content_type`). Use the returned `storage_path` in `send_message` with `attachment_paths`. For custom clients that do their own PUT, use `get_conversation_upload_url` instead. The API stores 7-day signed read URLs in the message (GCS max).
 
-### Real-time (3 tools)
+### Real-time (6 tools)
 
 | Tool | Description |
 |---|---|
-| `watch_conversation` | Start background polling (every 5s) for new messages |
+| `watch_conversation` | Start background polling for new messages (backs off from 1s to 600s, resets when the human replies) |
 | `get_pending_messages` | Drain the message buffer for a watched conversation |
 | `unwatch_conversation` | Stop polling and discard the buffer |
+| `watch_mission` | Start polling a mission for new participants (`interval_minutes`, default 10) |
+| `get_pending_mission_updates` | Drain buffered new-participant updates, each with its `conversation_id` once the human has started one |
+| `unwatch_mission` | Stop polling a mission |
+
+**How it works:** MCP servers run as a persistent process for the duration of the client session (stdio transport). `watch_conversation` and `watch_mission` start in-process timers that poll the API and buffer what they find in memory. The agent calls `get_pending_messages` / `get_pending_mission_updates` whenever it wants to drain the queue.
+
+**Limitation:** The buffers are in-memory only. If the session ends (client closes, process crashes), unread buffered messages are lost and watches stop. To recover, call `get_messages` with a manual `since` timestamp and re-watch.
+
+### Media tracks (4 tools, `media_review` missions)
+
+| Tool | Description |
+|---|---|
+| `add_mission_track` | Upload an audio, image or video track, via `file_path` (use this for audio/video) or `file_base64` |
+| `list_mission_tracks` | List a mission's tracks with `vote_counts` and `total_listen_seconds` |
+| `get_track_ratings` | Per-participant star ratings and comments for one track |
+| `delete_mission_track` | Delete a track that has no ratings yet |
+
+### Solana (4 tools)
+
+| Tool | Description |
+|---|---|
+| `get_solana_config` | Program id, cluster, RPC, accepted mints and decimals, and `escrow_interface` (this server verifies only `v2`). No wallet needed |
+| `get_solana_wallet` | Your wallet address, SOL balance and token balance; explains setup if no wallet is configured |
+| `fund_solana_mission` | Build, verify, sign locally and submit the escrow funding transaction. Checks `max_fee_bps` against your quote and, for a lottery, the Operator's co-signature; refuses to sign on any mismatch |
+| `refund_solana_mission` | `cancel` (before `qualify_deadline` only), `emergency_refund` (after `settlement_deadline`) or `claim_refund`, with the same verify-then-sign flow; omit `action` to list what is available. Says whether the backend or the chain refused, and why |
+
+### Solana escrow rules (escrow interface v2)
+
+The Solana escrow program on devnet runs [solo-escrow-solana](https://github.com/ProjectSoloAI/solo-escrow-solana) `u1.1.0`, and `get_solana_config` reports `escrow_interface: "v2"`. This server verifies only v2 funding transactions and refuses to fund against any other interface.
+
+**What `fund_solana_mission` checks before it signs.** The backend builds the funding transaction and this server decodes it. It refuses to sign if any of the following doesn't hold:
+
+- The transaction has exactly one instruction, `create_task`, on the pinned program id. The escrow program id is pinned in this package per cluster, or by `SOLO_SOLANA_PROGRAM_ID`, and the `program_id` the API reports must equal it: the API is the party being checked, so it can't also choose the program.
+- `expected_budget` is scaled by the mint's decimals, which are read from the mint account on chain rather than from the API.
+- Every argument matches what the mission recorded and you expect: budget, base pool, lottery winners and prize, both deadlines, and the seed commitment.
+- Every account is in its IDL position. The config, whitelist, task, vault and event-authority accounts are addresses the server derives itself; your token account must be the one you sent.
+- `max_fee_bps` is the fee rate `create_mission` quoted you (`mission.solana_quoted_fee_bps`, or `expected_max_fee_bps` if you pass it). It is the most the escrow may charge: if the program's fee has risen above it when the transaction lands, `create_task` fails with `FeeAboveSponsorMax` instead of charging you more. Cancel the mission and create a new one to get a fresh quote.
+- **Lotteries are co-signed by the platform Operator.** The program requires the Operator to sign every lottery `create_task`, so a lottery's funding transaction arrives already signed by it. The server checks three things:
+  - the co-signer is `Config.operator`, read straight from the cluster rather than from the API;
+  - its ed25519 signature is valid over the exact message;
+  - you, not the Operator, are the fee payer.
+
+  It then writes only your own signature slot and leaves the Operator's signature untouched. Any change to the bytes would invalidate that signature.
+- A non-lottery transaction passes the program id in the Operator slot (Anchor's "none") and has no other signer.
+
+**Deadlines.** The end of the hiring window is the escrow's `qualify_deadline`, and the end of the work window is `settlement_deadline`. For a paid mission:
+
+- `settlement_deadline ≥ qualify_deadline + min_review_window + finalize grace`. `min_review_window` is the program's configured review window. The finalize grace equals the review-window floor: 10 s each on the current devnet build, while the floor is 1 hour on a production build.
+- `qualify_deadline` is at most 180 days ahead.
+- `settlement_deadline` is at most 90 days after `qualify_deadline`.
+
+`create_mission` returns 400 for a violation, and the program enforces the same rules again when the escrow is funded.
+
+**Cancel cut-off.** `refund_solana_mission` with `action: 'cancel'` returns the whole budget, but only strictly before `qualify_deadline`. From then on, the program refuses a cancel with `TooLateToCancel` (error 6125), including one built before the deadline that lands after it. The mission then settles normally, or you can use `emergency_refund` once `settlement_deadline` has passed without a settlement. A pause doesn't block `emergency_refund`.
+
+**The lottery draw.** At settlement the program computes `final_entropy = keccak256(seed_reveal ‖ entropy_hash)`:
 
-**How it works:** MCP servers run as a persistent process for the duration of the client session (stdio transport). `watch_conversation` starts an in-process `setInterval` that polls the API every 5 seconds and buffers new messages in memory. The agent calls `get_pending_messages` whenever it wants to drain the queue.
+- `seed_reveal` opens the `seed_commit` fixed at funding.
+- `entropy_hash` is the SlotHashes sysvar's bank hash for the first produced slot after `finalize_qualification`. `record_entropy` stores it on the Task, or `settle_task` captures it if nobody recorded it in time.
 
-**Limitation:** The message buffer is in-memory only. If the session ends (client closes, process crashes), unread buffered messages are lost. To recover, call `get_messages` with a manual `since` timestamp.
+`entropy_hash` is **not** the blockhash that `getBlock` returns for that slot. To check a draw, recompute it from the Task account's `entropy_slot`, `entropy_hash` and `final_entropy`, not from `getBlock`.
 
 ---
 

package/dist/chunk-NUGGTARW.js

@@ -0,0 +1,196 @@
+// src/solana/wire.ts
+import { createPrivateKey, createPublicKey, sign, verify } from "crypto";
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function base58Encode(bytes) {
+  let zeros = 0;
+  while (zeros < bytes.length && bytes[zeros] === 0) zeros++;
+  const digits = [];
+  for (let i = zeros; i < bytes.length; i++) {
+    let carry = bytes[i];
+    for (let j = 0; j < digits.length; j++) {
+      carry += digits[j] << 8;
+      digits[j] = carry % 58;
+      carry = carry / 58 | 0;
+    }
+    while (carry > 0) {
+      digits.push(carry % 58);
+      carry = carry / 58 | 0;
+    }
+  }
+  let out = "1".repeat(zeros);
+  for (let i = digits.length - 1; i >= 0; i--) out += BASE58_ALPHABET[digits[i]];
+  return out;
+}
+function base58Decode(s) {
+  let zeros = 0;
+  while (zeros < s.length && s[zeros] === "1") zeros++;
+  const bytes = [];
+  for (let i = zeros; i < s.length; i++) {
+    let carry = BASE58_ALPHABET.indexOf(s[i]);
+    if (carry < 0) throw new Error(`invalid base58 character ${JSON.stringify(s[i])}`);
+    for (let j = 0; j < bytes.length; j++) {
+      carry += bytes[j] * 58;
+      bytes[j] = carry & 255;
+      carry >>= 8;
+    }
+    while (carry > 0) {
+      bytes.push(carry & 255);
+      carry >>= 8;
+    }
+  }
+  return Buffer.concat([Buffer.alloc(zeros), Buffer.from(bytes.reverse())]);
+}
+function readShortVec(buf, offset) {
+  let value = 0;
+  for (let i = 0; i < 3; i++) {
+    const byte = buf[offset + i];
+    if (byte === void 0) throw new Error("truncated transaction");
+    value |= (byte & 127) << 7 * i;
+    if ((byte & 128) === 0) return { value, next: offset + i + 1 };
+  }
+  throw new Error("malformed compact-u16 length");
+}
+function take(buf, offset, length) {
+  if (offset + length > buf.length) throw new Error("truncated transaction");
+  return buf.subarray(offset, offset + length);
+}
+function parseWireTransaction(raw) {
+  const { value: sigCount, next: signatureOffset } = readShortVec(raw, 0);
+  const signatures = [];
+  let o = signatureOffset;
+  for (let i = 0; i < sigCount; i++, o += 64) signatures.push(take(raw, o, 64));
+  const message = raw.subarray(o);
+  if (message.length < 3) throw new Error("truncated transaction");
+  if ((message[0] & 128) !== 0) {
+    throw new Error("versioned transaction message \u2014 only legacy funding transactions are expected");
+  }
+  const header = {
+    numRequiredSignatures: message[0],
+    numReadonlySigned: message[1],
+    numReadonlyUnsigned: message[2]
+  };
+  if (header.numRequiredSignatures !== sigCount) {
+    throw new Error(
+      `transaction carries ${sigCount} signature slots for ${header.numRequiredSignatures} required signers`
+    );
+  }
+  let m = 3;
+  const keys = readShortVec(message, m);
+  m = keys.next;
+  const accountKeys = [];
+  for (let i = 0; i < keys.value; i++, m += 32) accountKeys.push(base58Encode(take(message, m, 32)));
+  if (header.numRequiredSignatures > accountKeys.length) {
+    throw new Error("more required signers than account keys");
+  }
+  const recentBlockhash = base58Encode(take(message, m, 32));
+  m += 32;
+  const ixCount = readShortVec(message, m);
+  m = ixCount.next;
+  const instructions = [];
+  for (let i = 0; i < ixCount.value; i++) {
+    const programIdIndex = take(message, m, 1)[0];
+    m += 1;
+    const accts = readShortVec(message, m);
+    m = accts.next;
+    const accountIndexes = [...take(message, m, accts.value)];
+    m += accts.value;
+    const dataLen = readShortVec(message, m);
+    m = dataLen.next;
+    const data = Buffer.from(take(message, m, dataLen.value));
+    m += dataLen.value;
+    for (const idx of [programIdIndex, ...accountIndexes]) {
+      if (idx >= accountKeys.length) throw new Error(`instruction references account ${idx} of ${accountKeys.length}`);
+    }
+    instructions.push({ programIdIndex, accountIndexes, data });
+  }
+  if (m !== message.length) {
+    throw new Error(`${message.length - m} unexpected trailing bytes after the message`);
+  }
+  return { signatures, signatureOffset, message, header, accountKeys, recentBlockhash, instructions };
+}
+function isSignerIndex(tx, index) {
+  return index < tx.header.numRequiredSignatures;
+}
+function isWritableIndex(tx, index) {
+  const { numRequiredSignatures, numReadonlySigned, numReadonlyUnsigned } = tx.header;
+  if (index < numRequiredSignatures) return index < numRequiredSignatures - numReadonlySigned;
+  return index < tx.accountKeys.length - numReadonlyUnsigned;
+}
+function isEmptySignature(sig) {
+  return sig.every((b) => b === 0);
+}
+var SPKI_ED25519_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
+var PKCS8_ED25519_PREFIX = Buffer.from("302e020100300506032b657004220420", "hex");
+function ed25519Verify(signature, message, publicKey) {
+  try {
+    const raw = base58Decode(publicKey);
+    if (raw.length !== 32 || signature.length !== 64) return false;
+    const key = createPublicKey({
+      key: Buffer.concat([SPKI_ED25519_PREFIX, raw]),
+      format: "der",
+      type: "spki"
+    });
+    return verify(null, message, key, signature);
+  } catch {
+    return false;
+  }
+}
+function ed25519Sign(message, secretKey) {
+  const key = createPrivateKey({
+    key: Buffer.concat([PKCS8_ED25519_PREFIX, Buffer.from(secretKey.subarray(0, 32))]),
+    format: "der",
+    type: "pkcs8"
+  });
+  return sign(null, message, key);
+}
+function publicKeyOfSecret(secretKey) {
+  const key = createPrivateKey({
+    key: Buffer.concat([PKCS8_ED25519_PREFIX, Buffer.from(secretKey.subarray(0, 32))]),
+    format: "der",
+    type: "pkcs8"
+  });
+  const spki = createPublicKey(key).export({ format: "der", type: "spki" });
+  return base58Encode(spki.subarray(spki.length - 32));
+}
+function addOwnSignature(raw, secretKey, publicKey) {
+  if (publicKeyOfSecret(secretKey) !== publicKey) {
+    throw new Error("the wallet secret key does not derive its own public key \u2014 refusing to sign");
+  }
+  const tx = parseWireTransaction(raw);
+  const signers = tx.accountKeys.slice(0, tx.header.numRequiredSignatures);
+  const index = signers.indexOf(publicKey);
+  if (index < 0) {
+    throw new Error(
+      `refusing to sign: ${publicKey} is not a required signer of this transaction (signers: ${signers.join(", ") || "none"})`
+    );
+  }
+  const signature = ed25519Sign(tx.message, secretKey);
+  const out = Buffer.from(raw);
+  signature.copy(out, tx.signatureOffset + 64 * index);
+  const after = parseWireTransaction(out);
+  if (out.length !== raw.length || !after.message.equals(tx.message)) {
+    throw new Error("signing altered the transaction message \u2014 refusing to return it");
+  }
+  for (let i = 0; i < tx.signatures.length; i++) {
+    if (i !== index && !after.signatures[i].equals(tx.signatures[i])) {
+      throw new Error(`signing altered signature slot ${i} \u2014 refusing to return it`);
+    }
+  }
+  if (!ed25519Verify(after.signatures[index], after.message, publicKey)) {
+    throw new Error("the new signature does not verify \u2014 refusing to return it");
+  }
+  return out;
+}
+
+export {
+  base58Encode,
+  base58Decode,
+  parseWireTransaction,
+  isSignerIndex,
+  isWritableIndex,
+  isEmptySignature,
+  ed25519Verify,
+  ed25519Sign,
+  publicKeyOfSecret,
+  addOwnSignature
+};

package/dist/{chunk-TKRT2V2W.js → chunk-OP4QYTL4.js}

@@ -7,6 +7,11 @@ var config = {
 if (!config.agentKey) {
   console.warn("Warning: SOLO_AGENT_KEY is not set. Only register_agent will work until a key is configured.");
 }
+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."
+  );
+}
 
 // src/api/client.ts
 var DEFAULT_HEADERS = {

package/dist/{client-LDWK5HLP.js → client-NS6J6IO2.js}

@@ -4,7 +4,7 @@ import {
   apiPatch,
   apiPost,
   publicApiPost
-} from "./chunk-TKRT2V2W.js";
+} from "./chunk-OP4QYTL4.js";
 export {
   apiDelete,
   apiGet,

package/dist/deployment-UCUWVIPJ.js

@@ -0,0 +1,43 @@
+// src/solana/deployment.ts
+var PINNED_DEPLOYMENTS = {
+  // solo-escrow-solana u1.1.0 on devnet (the live private beta).
+  devnet: {
+    cluster: "devnet",
+    program_id: "2CPC5V63FDs7SdWu89iSYYsTEpqBwuQeYuA9ASzuSo8a",
+    rpc_url: "https://api.devnet.solana.com"
+  }
+};
+function resolvePinnedProgram(cfg) {
+  const override = (process.env.SOLO_SOLANA_PROGRAM_ID ?? "").trim();
+  const pinned = override || PINNED_DEPLOYMENTS[cfg.cluster ?? ""]?.program_id;
+  if (!pinned) {
+    return {
+      problem: `no escrow program is pinned for cluster ${JSON.stringify(cfg.cluster)} \u2014 set SOLO_SOLANA_PROGRAM_ID to the program id you trust, or use a version of this package that pins it`
+    };
+  }
+  if (cfg.program_id !== pinned) {
+    return {
+      problem: `the API reports escrow program ${cfg.program_id} for cluster ${JSON.stringify(cfg.cluster)}, but this server pins ${pinned}${override ? " (SOLO_SOLANA_PROGRAM_ID)" : ""} \u2014 refusing to sign for a program it does not trust`
+    };
+  }
+  return { program_id: pinned };
+}
+function resolveTrustedRpc(cfg) {
+  const rpc = (process.env.SOLO_SOLANA_RPC_URL ?? "").trim() || PINNED_DEPLOYMENTS[cfg.cluster ?? ""]?.rpc_url;
+  if (!rpc) {
+    return {
+      problem: `no RPC endpoint is pinned for cluster ${JSON.stringify(cfg.cluster)} \u2014 set SOLO_SOLANA_RPC_URL to an endpoint you trust; the API-reported rpc_url is not used for reads that decide what to sign`
+    };
+  }
+  return { rpc_url: rpc };
+}
+function solanaRpcUrl(cfg) {
+  const trusted = resolveTrustedRpc(cfg);
+  return "rpc_url" in trusted ? trusted.rpc_url : cfg.rpc_url;
+}
+export {
+  PINNED_DEPLOYMENTS,
+  resolvePinnedProgram,
+  resolveTrustedRpc,
+  solanaRpcUrl
+};

package/dist/escrowErrors-4XSAYLGT.js

@@ -0,0 +1,56 @@
+// src/solana/escrowErrors.ts
+var ESCROW_ERRORS = {
+  6012: {
+    name: "SettlementWindowTooShort",
+    what_to_do: "settlement_deadline must be at least qualify_deadline + min_review_window + the finalize grace. Create a new mission with a longer work_duration_hours."
+  },
+  6016: {
+    name: "TooEarlyForEmergencyRefund",
+    what_to_do: "emergency_refund opens only once settlement_deadline has passed. Retry after it."
+  },
+  6026: {
+    name: "RefundAlreadyClaimed",
+    what_to_do: "the refundable amount was already claimed \u2014 nothing is left to refund."
+  },
+  6027: { name: "NothingToRefund", what_to_do: "the task holds nothing refundable." },
+  6124: {
+    name: "LotteryRequiresOperator",
+    what_to_do: "a lottery create_task needs the platform Operator's co-signature over the exact message. Request a fresh funding transaction and sign it unchanged."
+  },
+  6125: {
+    name: "TooLateToCancel",
+    what_to_do: "cancel is refused on chain from qualify_deadline on. Let the mission settle, or use emergency_refund once settlement_deadline has passed without a settlement."
+  },
+  6132: {
+    name: "FeeAboveSponsorMax",
+    what_to_do: "the program's fee rose above the max_fee_bps you were quoted, so the escrow refused to charge more. Cancel the mission (cancel_mission) and create a new one for a fresh quote."
+  },
+  6133: {
+    name: "QualifyDeadlineTooFar",
+    what_to_do: "qualify_deadline may be at most 180 days ahead. Create a new mission with a shorter hiring window."
+  },
+  6134: {
+    name: "SettlementDeadlineTooFar",
+    what_to_do: "settlement_deadline may be at most 90 days after qualify_deadline. Create a new mission with a shorter work window."
+  }
+};
+function escrowErrorFromMessage(message) {
+  if (!message) return null;
+  const candidates = [];
+  for (const m of message.matchAll(/custom program error: 0x([0-9a-f]+)/gi)) {
+    candidates.push(parseInt(m[1], 16));
+  }
+  for (const m of message.matchAll(/Error Number: (\d+)/g)) candidates.push(Number(m[1]));
+  for (const code of candidates) {
+    const info = ESCROW_ERRORS[code];
+    if (info) return { code, ...info };
+  }
+  for (const [code, info] of Object.entries(ESCROW_ERRORS)) {
+    if (new RegExp(`\\b${info.name}\\b`).test(message)) return { code: Number(code), ...info };
+  }
+  return null;
+}
+export {
+  ESCROW_ERRORS,
+  escrowErrorFromMessage
+};