@projectsolo/solo-mission-mcp 0.19.3 → 0.21.1

package/dist/chunk-NXOOPOSF.js

@@ -0,0 +1,79 @@
+// src/config.ts
+import "dotenv/config";
+var config = {
+  agentKey: process.env.SOLO_AGENT_KEY ?? "",
+  apiUrl: process.env.SOLO_MISSION_API_URL ?? "https://api.mission.projectsolo.ai"
+};
+if (!config.agentKey) {
+  console.warn("Warning: SOLO_AGENT_KEY is not set. Only register_agent will work until a key is configured.");
+}
+
+// src/api/client.ts
+var DEFAULT_HEADERS = {
+  "Content-Type": "application/json",
+  "X-Agent-Key": config.agentKey
+};
+var ApiResponseError = class extends Error {
+  status;
+  data;
+  constructor(status, data) {
+    const msg = data?.message || data?.error || `Request failed with status ${status}`;
+    super(status === 429 ? "Rate limit exceeded. Please slow down and retry after a moment." : msg);
+    this.status = status;
+    this.data = data;
+  }
+};
+async function parseErrorResponse(response) {
+  const data = await response.json().catch(() => ({}));
+  throw new ApiResponseError(response.status, data);
+}
+async function apiGet(path, params) {
+  const url = new URL(`${config.apiUrl}${path}`);
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      if (value != null) url.searchParams.set(key, String(value));
+    }
+  }
+  const response = await fetch(url.toString(), {
+    headers: DEFAULT_HEADERS,
+    signal: AbortSignal.timeout(3e4)
+  });
+  if (!response.ok) return parseErrorResponse(response);
+  return response.json();
+}
+async function apiPost(path, body) {
+  const response = await fetch(`${config.apiUrl}${path}`, {
+    method: "POST",
+    headers: DEFAULT_HEADERS,
+    body: body !== void 0 ? JSON.stringify(body) : void 0,
+    signal: AbortSignal.timeout(3e4)
+  });
+  if (!response.ok) return parseErrorResponse(response);
+  return response.json();
+}
+async function apiDelete(path) {
+  const response = await fetch(`${config.apiUrl}${path}`, {
+    method: "DELETE",
+    headers: DEFAULT_HEADERS,
+    signal: AbortSignal.timeout(3e4)
+  });
+  if (!response.ok) return parseErrorResponse(response);
+  return response.json();
+}
+async function publicApiPost(path, body) {
+  const response = await fetch(`${config.apiUrl}${path}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: body !== void 0 ? JSON.stringify(body) : void 0,
+    signal: AbortSignal.timeout(3e4)
+  });
+  if (!response.ok) return parseErrorResponse(response);
+  return response.json();
+}
+
+export {
+  apiGet,
+  apiPost,
+  apiDelete,
+  publicApiPost
+};

package/dist/client-2NLDPRAH.js

@@ -0,0 +1,12 @@
+import {
+  apiDelete,
+  apiGet,
+  apiPost,
+  publicApiPost
+} from "./chunk-NXOOPOSF.js";
+export {
+  apiDelete,
+  apiGet,
+  apiPost,
+  publicApiPost
+};

package/dist/index.js

@@ -1,4 +1,10 @@
 #!/usr/bin/env node
+import {
+  apiDelete,
+  apiGet,
+  apiPost,
+  publicApiPost
+} from "./chunk-NXOOPOSF.js";
 
 // src/index.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -8,79 +14,6 @@ import {
   ListToolsRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
 
-// src/config.ts
-import "dotenv/config";
-var config = {
-  agentKey: process.env.SOLO_AGENT_KEY ?? "",
-  apiUrl: process.env.SOLO_MISSION_API_URL ?? "https://api.mission.projectsolo.ai"
-};
-if (!config.agentKey) {
-  console.warn("Warning: SOLO_AGENT_KEY is not set. Only register_agent will work until a key is configured.");
-}
-
-// src/api/client.ts
-var DEFAULT_HEADERS = {
-  "Content-Type": "application/json",
-  "X-Agent-Key": config.agentKey
-};
-var ApiResponseError = class extends Error {
-  status;
-  data;
-  constructor(status, data) {
-    const msg = data?.message || data?.error || `Request failed with status ${status}`;
-    super(status === 429 ? "Rate limit exceeded. Please slow down and retry after a moment." : msg);
-    this.status = status;
-    this.data = data;
-  }
-};
-async function parseErrorResponse(response) {
-  const data = await response.json().catch(() => ({}));
-  throw new ApiResponseError(response.status, data);
-}
-async function apiGet(path, params) {
-  const url = new URL(`${config.apiUrl}${path}`);
-  if (params) {
-    for (const [key, value] of Object.entries(params)) {
-      if (value != null) url.searchParams.set(key, String(value));
-    }
-  }
-  const response = await fetch(url.toString(), {
-    headers: DEFAULT_HEADERS,
-    signal: AbortSignal.timeout(3e4)
-  });
-  if (!response.ok) return parseErrorResponse(response);
-  return response.json();
-}
-async function apiPost(path, body) {
-  const response = await fetch(`${config.apiUrl}${path}`, {
-    method: "POST",
-    headers: DEFAULT_HEADERS,
-    body: body !== void 0 ? JSON.stringify(body) : void 0,
-    signal: AbortSignal.timeout(3e4)
-  });
-  if (!response.ok) return parseErrorResponse(response);
-  return response.json();
-}
-async function apiDelete(path) {
-  const response = await fetch(`${config.apiUrl}${path}`, {
-    method: "DELETE",
-    headers: DEFAULT_HEADERS,
-    signal: AbortSignal.timeout(3e4)
-  });
-  if (!response.ok) return parseErrorResponse(response);
-  return response.json();
-}
-async function publicApiPost(path, body) {
-  const response = await fetch(`${config.apiUrl}${path}`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: body !== void 0 ? JSON.stringify(body) : void 0,
-    signal: AbortSignal.timeout(3e4)
-  });
-  if (!response.ok) return parseErrorResponse(response);
-  return response.json();
-}
-
 // src/tools/missions.ts
 var missionTools = [
   {
@@ -982,8 +915,282 @@ async function handleTrackTool(name, args) {
   }
 }
 
+// src/tools/solana.ts
+var solanaTools = [
+  {
+    name: "get_solana_config",
+    description: "Read the Solana escrow deployment: program id, cluster, RPC endpoint, accepted mints and their decimals, and the minimum first payout. Call this before funding so you use a whitelisted mint \u2014 a mint that is not whitelisted is rejected on chain, not by the API. Requires no wallet.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "get_solana_wallet",
+    description: "Show your Solana wallet address and its balances. Reports SOL (needed for transaction fees and for account rent) and the token balance for a given mint (the mission budget). Use this before funding: an agent needs BOTH, and the rent line has no equivalent on Base. Rent is a refundable deposit, not a fee \u2014 most of it returns when the task is closed. If no wallet is configured this explains how to set one up.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        mint: {
+          type: "string",
+          description: "Mint to report a balance for. Defaults to the deployment payout mint from get_solana_config."
+        }
+      }
+    }
+  },
+  {
+    name: "fund_solana_mission",
+    description: "Fund a Solana mission end to end: the backend builds the escrow transaction, this tool DECODES AND VERIFIES it against the parameters you expect, signs it locally with your wallet, and submits it. Your key never leaves this process.\n\nVerification is not optional and cannot be skipped. On Solana the backend builds the transaction rather than publishing a parameter set for you to rebuild, so without a decode you would be signing bytes you cannot read. This tool refuses to sign if anything differs from what you expect \u2014 a substituted mint, an altered budget, an extra instruction, a vault that is not a program-derived address \u2014 and returns the discrepancies instead.\n\nCall create_mission with chain='solana' first; pass that mission's id here.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        mission_id: { type: "string", description: 'Mission created with chain="solana".' },
+        expected_budget: {
+          type: "number",
+          description: "The total budget in whole tokens (e.g. 10 for 10 USDC) you expect to escrow. Verified against the transaction before signing. Pass what you intended, NOT what the API told you \u2014 comparing the API to itself proves nothing."
+        },
+        expected_mint: {
+          type: "string",
+          description: "The mint you expect the budget to be taken in. Verified before signing. Defaults to the deployment payout mint."
+        },
+        dry_run: {
+          type: "boolean",
+          description: "Build and verify, then stop without signing or submitting. Use this to inspect what would be signed. Nothing is escrowed and no fee is paid."
+        }
+      },
+      required: ["mission_id", "expected_budget"]
+    }
+  },
+  {
+    name: "refund_solana_mission",
+    description: "Get a Solana mission's escrowed funds back to the sponsor. Covers all three routes: cancel (while funded, before hiring closes), emergency_refund (once the settlement deadline passes and the platform has not settled), and claim_refund (leftover budget after a partial settle).\n\nSame flow as funding: the backend builds the transaction, this tool VERIFIES it, signs locally, and submits. Your key never leaves this process.\n\nCall with no action to ask what is currently available \u2014 the response lists the legal actions for the mission's state rather than guessing. Without this tool a funded Solana mission's money was unreachable except by hand-assembling an Anchor instruction, for which Solana has no `cast send` equivalent.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        mission_id: { type: "string" },
+        action: {
+          type: "string",
+          enum: ["cancel", "emergency_refund", "claim_refund"],
+          description: "Omit to query what is available for this mission right now instead of attempting one."
+        },
+        dry_run: {
+          type: "boolean",
+          description: "Build and verify without signing or submitting. Nothing moves, no fee."
+        }
+      },
+      required: ["mission_id"]
+    }
+  }
+];
+function toRawAmount(amount, decimals) {
+  const s = amount.toString();
+  if (!/^\d+(\.\d+)?$/.test(s)) {
+    throw new Error(`amount must be a non-negative decimal number, got ${s}`);
+  }
+  const [whole, frac = ""] = s.split(".");
+  if (frac.length > decimals) {
+    throw new Error(
+      `amount ${s} has ${frac.length} decimal places but the mint has only ${decimals}`
+    );
+  }
+  return (whole + frac.padEnd(decimals, "0")).replace(/^0+(?=\d)/, "");
+}
+var SOLANA_TOOL_NAMES = new Set(solanaTools.map((t) => t.name));
+async function handleSolanaTool(name, args) {
+  const { apiGet: apiGet2, apiPost: apiPost2 } = await import("./client-2NLDPRAH.js");
+  switch (name) {
+    case "get_solana_config":
+      return apiGet2("/agent/solana/config");
+    case "get_solana_wallet": {
+      const { hasSolanaWallet, loadSolanaWallet, associatedTokenAddress } = await import("./wallet-IUQWBW6F.js");
+      if (!hasSolanaWallet()) {
+        return {
+          configured: false,
+          how_to_configure: {
+            option_1: "SOLO_SOLANA_KEYPAIR \u2014 JSON byte array, as `solana-keygen new` writes it",
+            option_2: "SOLO_SOLANA_KEYPAIR_PATH \u2014 path to that file, e.g. ~/.config/solana/id.json"
+          },
+          what_you_need: "SOL for transaction fees and account rent, plus the payout token for the budget. Rent is a refundable deposit, not a fee \u2014 most of it returns on close_task. Roughly $0.58 is locked per mission and about $0.24 is permanent, which buys the on-chain record that makes the escrow verifiable by anyone."
+        };
+      }
+      const wallet = await loadSolanaWallet();
+      const cfg = await apiGet2("/agent/solana/config");
+      const symbol = Object.keys(cfg.mints)[0];
+      const mint = args.mint ?? cfg.mints[symbol];
+      const tokenAccount = await associatedTokenAddress(mint, wallet.publicKey);
+      const rpc = async (method, params) => {
+        const res = await fetch(cfg.rpc_url, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params })
+        });
+        return await res.json();
+      };
+      const solRes = await rpc("getBalance", [wallet.publicKey]);
+      const tokRes = await rpc("getTokenAccountBalance", [tokenAccount]);
+      const lamports = solRes.result?.value ?? 0;
+      const decimals = cfg.decimals[symbol] ?? 6;
+      return {
+        configured: true,
+        address: wallet.publicKey,
+        sol: lamports / 1e9,
+        // A token account only exists once tokens first arrive. create_task reads it, so funding
+        // fails without one — and the on-chain error names the account rather than the missing
+        // balance, which is confusing enough to call out explicitly.
+        token_account: tokenAccount,
+        token_account_exists: !tokRes.error,
+        token_balance: tokRes.result?.value?.uiAmountString ?? "0",
+        mint,
+        can_pay_fees: lamports > 1e7,
+        // ~0.01 SOL — comfortably covers rent plus fees
+        note: lamports === 0 ? 'No SOL. Funding will fail with "Attempt to debit an account but found no record of a prior credit", which does not mention SOL.' : void 0,
+        _decimals: decimals
+      };
+    }
+    case "fund_solana_mission": {
+      const { loadSolanaWallet, associatedTokenAddress, signTransaction } = await import("./wallet-IUQWBW6F.js");
+      const { verifyFundingTransaction } = await import("./verify-KAETIGV5.js");
+      const wallet = await loadSolanaWallet();
+      const cfg = await apiGet2("/agent/solana/config");
+      const symbol = Object.keys(cfg.mints)[0];
+      const mint = args.expected_mint ?? cfg.mints[symbol];
+      const decimals = cfg.decimals[symbol] ?? 6;
+      const tokenAccount = await associatedTokenAddress(mint, wallet.publicKey);
+      const built = await apiPost2(
+        `/agent/solana/missions/${args.mission_id}/funding-transaction`,
+        { sponsor_wallet: wallet.publicKey, sponsor_token_account: tokenAccount }
+      );
+      const expectedBudgetRaw = toRawAmount(args.expected_budget, decimals);
+      const verdict = await verifyFundingTransaction({
+        transaction_base64: built.transaction_base64,
+        declared: built.declared,
+        accounts: built.accounts,
+        expected: {
+          budget_raw: expectedBudgetRaw,
+          // base_pool is derived by the backend from reward × max_humans. The agent's check on it
+          // is the quoted value against the encoded bytes, which verifyFundingTransaction does —
+          // asserting a locally recomputed figure would require duplicating that arithmetic here
+          // and would fail on a legitimately rounded reward.
+          base_pool_raw: String(built.declared.base_pool),
+          lottery_winner_count: Number(built.declared.lottery_winner_count),
+          lottery_prize_per_winner_raw: String(built.declared.lottery_prize_per_winner),
+          qualify_deadline: Number(built.declared.qualify_deadline),
+          settlement_deadline: Number(built.declared.settlement_deadline),
+          mint,
+          sponsor: wallet.publicKey
+        },
+        expected_program_id: cfg.program_id
+      });
+      if (!verdict.ok) {
+        return {
+          funded: false,
+          refused_to_sign: true,
+          problems: verdict.problems,
+          summary: verdict.summary,
+          what_this_means: "The transaction does not match what you asked for, so it was NOT signed and nothing was escrowed. This is the verifier doing its job. Do not retry blindly \u2014 the discrepancy above is either a bug or an attempt to have you authorise something else."
+        };
+      }
+      if (args.dry_run) {
+        return {
+          funded: false,
+          dry_run: true,
+          verified: true,
+          task_id: built.task_id,
+          summary: verdict.summary,
+          would_escrow: `${args.expected_budget} (${expectedBudgetRaw} raw) of ${mint}`
+        };
+      }
+      const signed = await signTransaction(built.transaction_base64, wallet);
+      const confirmed = await apiPost2(
+        `/agent/solana/missions/${args.mission_id}/confirm-funding`,
+        { signed_transaction: signed, task_id: built.task_id }
+      );
+      return { funded: true, verified: true, ...confirmed };
+    }
+    case "refund_solana_mission": {
+      const { loadSolanaWallet, associatedTokenAddress, signTransaction } = await import("./wallet-IUQWBW6F.js");
+      const wallet = await loadSolanaWallet();
+      const cfg = await apiGet2("/agent/solana/config");
+      const mint = cfg.mints.TEST_USDC ?? Object.values(cfg.mints)[0];
+      const tokenAccount = await associatedTokenAddress(mint, wallet.publicKey);
+      if (!args.action) {
+        try {
+          await apiPost2(`/agent/solana/missions/${args.mission_id}/refund-transaction`, {
+            action: "claim_refund",
+            sponsor_wallet: wallet.publicKey,
+            sponsor_token_account: tokenAccount
+          });
+          return { available_actions: ["claim_refund"], note: "claim_refund is available now" };
+        } catch (e) {
+          const body = e?.response?.data ?? e?.body ?? {};
+          return {
+            available_actions: body.available_actions ?? [],
+            why_not_claim_refund: body.message,
+            note: (body.available_actions?.length ?? 0) === 0 ? "Nothing is refundable right now. cancel needs the hiring window still open; emergency_refund needs the settlement deadline to have passed." : "Re-run with one of available_actions."
+          };
+        }
+      }
+      const built = await apiPost2(
+        `/agent/solana/missions/${args.mission_id}/refund-transaction`,
+        {
+          action: args.action,
+          sponsor_wallet: wallet.publicKey,
+          sponsor_token_account: tokenAccount
+        }
+      );
+      const { Transaction, PublicKey } = await import("@solana/web3.js");
+      const tx = Transaction.from(Buffer.from(built.transaction_base64, "base64"));
+      const problems = [];
+      if (tx.instructions.length !== 1) {
+        problems.push(`expected 1 instruction, found ${tx.instructions.length}`);
+      }
+      const ix = tx.instructions[0];
+      if (ix?.programId?.toBase58() !== cfg.program_id) {
+        problems.push(`program is ${ix?.programId?.toBase58()}, expected ${cfg.program_id}`);
+      }
+      const signers = (ix?.keys ?? []).filter((k) => k.isSigner).map((k) => k.pubkey.toBase58());
+      if (signers.length !== 1 || signers[0] !== wallet.publicKey) {
+        problems.push(`expected only ${wallet.publicKey} to sign, found [${signers.join(", ")}]`);
+      }
+      const keys = (ix?.keys ?? []).map((k) => k.pubkey.toBase58());
+      if (!keys.includes(tokenAccount)) {
+        problems.push(
+          `the refund destination ${tokenAccount} is not in the transaction \u2014 the funds would go elsewhere`
+        );
+      }
+      if ((ix?.data?.length ?? 0) !== 8) {
+        problems.push(`instruction data is ${ix?.data?.length} bytes, expected 8`);
+      }
+      void PublicKey;
+      if (problems.length > 0) {
+        return {
+          refunded: false,
+          refused_to_sign: true,
+          problems,
+          what_this_means: "The refund transaction does not match what was asked for, so it was NOT signed and nothing moved. Do not retry blindly."
+        };
+      }
+      if (args.dry_run) {
+        return {
+          refunded: false,
+          dry_run: true,
+          verified: true,
+          action: args.action,
+          task_id: built.task_id,
+          destination: tokenAccount
+        };
+      }
+      const signed = await signTransaction(built.transaction_base64, wallet);
+      const confirmed = await apiPost2(
+        `/agent/solana/missions/${args.mission_id}/confirm-refund`,
+        { signed_transaction: signed, action: args.action }
+      );
+      return { refunded: true, verified: true, ...confirmed };
+    }
+    default:
+      throw new Error(`Unknown Solana tool: ${name}`);
+  }
+}
+
 // src/index.ts
-var ALL_TOOLS = [...agentTools, ...missionTools, ...humanTools, ...conversationTools, ...realtimeTools, ...trackTools];
+var ALL_TOOLS = [...agentTools, ...missionTools, ...humanTools, ...conversationTools, ...realtimeTools, ...trackTools, ...solanaTools];
 var AGENT_TOOL_NAMES = new Set(agentTools.map((t) => t.name));
 var MISSION_TOOL_NAMES = new Set(missionTools.map((t) => t.name));
 var HUMAN_TOOL_NAMES = new Set(humanTools.map((t) => t.name));
@@ -1013,6 +1220,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       result = await handleRealtimeTool(name, args);
     } else if (TRACK_TOOL_NAMES.has(name)) {
       result = await handleTrackTool(name, args);
+    } else if (SOLANA_TOOL_NAMES.has(name)) {
+      result = await handleSolanaTool(name, args);
     } else {
       return {
         content: [{ type: "text", text: `Unknown tool: ${name}` }],

package/dist/verify-KAETIGV5.js

@@ -0,0 +1,136 @@
+// src/solana/verify.ts
+var eqAmount = (a, b) => {
+  try {
+    return BigInt(a) === BigInt(b);
+  } catch {
+    return false;
+  }
+};
+async function verifyFundingTransaction(input) {
+  const { Transaction, PublicKey } = await import("@solana/web3.js");
+  const problems = [];
+  const tx = Transaction.from(Buffer.from(input.transaction_base64, "base64"));
+  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?.programId?.toBase58() ?? "(none)";
+  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}`
+    );
+  }
+  const signers = (ix?.keys ?? []).filter((k) => k.isSigner).map((k) => k.pubkey.toBase58());
+  if (signers.length !== 1 || signers[0] !== input.expected.sponsor) {
+    problems.push(
+      `expected the sponsor ${input.expected.sponsor} to be the only signer, found [${signers.join(", ")}]`
+    );
+  }
+  if (tx.feePayer?.toBase58() !== input.expected.sponsor) {
+    problems.push(
+      `fee payer is ${tx.feePayer?.toBase58() ?? "(unset)"}, expected ${input.expected.sponsor}`
+    );
+  }
+  const keyList = (ix?.keys ?? []).map((k) => k.pubkey.toBase58());
+  for (const [label, expected] of [
+    ["mint", input.expected.mint],
+    ["sponsor", input.expected.sponsor]
+  ]) {
+    if (!keyList.includes(expected)) {
+      problems.push(`${label} ${expected} does not appear in the transaction's accounts`);
+    }
+  }
+  if (input.accounts.mint !== input.expected.mint) {
+    problems.push(`quoted mint ${input.accounts.mint}, expected ${input.expected.mint}`);
+  }
+  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");
+  }
+  try {
+    for (const [label, addr] of [
+      ["task", input.accounts.task],
+      ["vault", input.accounts.vault]
+    ]) {
+      if (PublicKey.isOnCurve(new PublicKey(addr).toBytes())) {
+        problems.push(`${label} ${addr} is not a program-derived address \u2014 someone holds its key`);
+      }
+    }
+  } catch {
+    problems.push("task or vault is not a valid address");
+  }
+  const d = input.declared;
+  const e = input.expected;
+  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 (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}`);
+  }
+  const data = ix?.data ?? Buffer.alloc(0);
+  if (data.length !== 8 + 8 + 8 + 4 + 8 + 8 + 8 + 32) {
+    problems.push(
+      `instruction data is ${data.length} bytes, expected 84 for create_task \u2014 this is not the instruction it claims to be`
+    );
+  } else {
+    const encoded = {
+      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")
+    };
+    for (const key of Object.keys(encoded)) {
+      const inBytes = String(encoded[key]);
+      const quoted = String(d[key]);
+      const same = key === "seed_commit" || key === "lottery_winner_count" ? inBytes.toLowerCase() === quoted.toLowerCase() : 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`
+        );
+      }
+    }
+  }
+  return {
+    ok: problems.length === 0,
+    problems,
+    summary: {
+      program_id: programId,
+      instruction_count: tx.instructions.length,
+      signers,
+      budget: d.budget,
+      mint: input.accounts.mint,
+      task: input.accounts.task
+    }
+  };
+}
+export {
+  verifyFundingTransaction
+};