bostrom-mcp/test-production.mjs

#!/usr/bin/env node
/**
 * Production scenario tests — real on-chain transactions.
 * Requires a funded BOSTROM_MNEMONIC in .env
 */

import { createServer } from "./dist/index.js";

const server = createServer();
const tools = server._registeredTools;

let passed = 0;
let failed = 0;
let skipped = 0;

function ok(msg) { passed++; console.log(`  ✅ ${msg}`); }
function fail(msg) { failed++; console.log(`  ❌ ${msg}`); }
function skip(msg) { skipped++; console.log(`  ⏭️  ${msg}`); }

async function call(name, args = {}) {
  const parsed = tools[name].inputSchema ? tools[name].inputSchema.parse(args) : args;
  return tools[name].handler(parsed, {});
}

function parse(result) {
  if (result.isError) throw new Error(result.content[0].text);
  return JSON.parse(result.content[0].text);
}

// Get wallet address
const walletData = parse(await call("wallet_info"));
const ADDR = walletData.address;
console.log(`\nWallet: ${ADDR}`);
console.log(`BOOT: ${walletData.balances.find(b => b.denom === "boot")?.amount}`);
console.log(`HYDROGEN: ${walletData.balances.find(b => b.denom === "hydrogen")?.amount}\n`);

// ─── Scenario 1: Self-send (wallet_send) ────────────────────
console.log("═══ Scenario 1: Send tokens (self-transfer) ═══");
try {
  const res = parse(await call("wallet_send", {
    to: ADDR,
    amount: "1",
    denom: "boot",
  }));
  ok(`wallet_send: txHash=${res.txHash}, height=${res.height}, gas=${res.gasUsed}/${res.gasWanted}`);

  // Verify via infra_tx_detail (param name is "txhash")
  const tx = parse(await call("infra_tx_detail", { txhash: res.txHash }));
  ok(`infra_tx_detail: confirmed tx code=${tx.code || 0}`);
} catch (e) {
  fail(`wallet_send: ${e.message}`);
}

// ─── Scenario 2: Delegate + Claim + Undelegate ──────────────
console.log("\n═══ Scenario 2: Staking lifecycle ═══");
// Find a validator
let validatorAddr;
try {
  const vals = parse(await call("gov_validators", {}));
  const list = vals.validators || vals;
  validatorAddr = list[0]?.operator_address;
  ok(`Found validator: ${validatorAddr} (${list[0]?.moniker})`);
} catch (e) {
  fail(`gov_validators: ${e.message}`);
}

if (validatorAddr) {
  // Delegate 1000 boot
  try {
    const res = parse(await call("wallet_delegate", {
      validator: validatorAddr,
      amount: "1000",
      denom: "boot",
    }));
    ok(`wallet_delegate: txHash=${res.txHash}, gas=${res.gasUsed}`);
  } catch (e) {
    fail(`wallet_delegate: ${e.message}`);
  }

  // Claim rewards (may be 0 right after delegation but should not error)
  try {
    const res = parse(await call("wallet_claim_rewards", {
      validator: validatorAddr,
    }));
    ok(`wallet_claim_rewards: txHash=${res.txHash}, gas=${res.gasUsed}`);
  } catch (e) {
    fail(`wallet_claim_rewards: ${e.message}`);
  }

  // Undelegate 1000 boot
  try {
    const res = parse(await call("wallet_undelegate", {
      validator: validatorAddr,
      amount: "1000",
      denom: "boot",
    }));
    ok(`wallet_undelegate: txHash=${res.txHash}, gas=${res.gasUsed}`);
  } catch (e) {
    fail(`wallet_undelegate: ${e.message}`);
  }
} else {
  skip("Staking: no validator found");
}

// ─── Scenario 3: Governance vote ────────────────────────────
console.log("\n═══ Scenario 3: Governance vote ═══");
try {
  const proposals = parse(await call("gov_proposals", { status: "PROPOSAL_STATUS_VOTING_PERIOD", limit: 1 }));
  const votingProposals = proposals.proposals || [];
  if (votingProposals.length > 0) {
    const pid = parseInt(votingProposals[0].id || votingProposals[0].proposal_id);
    const res = parse(await call("wallet_vote", {
      proposal_id: pid,
      option: "abstain",
    }));
    ok(`wallet_vote: proposal=${pid}, txHash=${res.txHash}`);
  } else {
    skip("No proposals in voting period");
  }
} catch (e) {
  fail(`wallet_vote: ${e.message}`);
}

// ─── Scenario 4: Investmint (HYDROGEN → millivolt) ──────────
console.log("\n═══ Scenario 4: Investmint HYDROGEN → millivolt ═══");
const hydrogenBal = walletData.balances.find(b => b.denom === "hydrogen");
const hydrogenAmount = hydrogenBal ? BigInt(hydrogenBal.amount) : 0n;
// Investmint requires substantial hydrogen (chain rejects small amounts with "insufficient resources return amount")
const investmintAmount = hydrogenAmount >= 100_000_000n ? "100000000"
  : hydrogenAmount >= 10_000_000n ? "10000000"
  : hydrogenAmount >= 1_000_000n ? "1000000"
  : null;

if (investmintAmount) {
  try {
    const res = parse(await call("graph_investmint", {
      amount: investmintAmount,
      resource: "millivolt",
      length: 1,
    }));
    ok(`graph_investmint: ${investmintAmount} hydrogen → millivolt, txHash=${res.txHash}, gas=${res.gasUsed}`);
  } catch (e) {
    if (e.message.includes("insufficient resources return amount")) {
      skip(`graph_investmint: ${investmintAmount} hydrogen still insufficient (need more hydrogen)`);
    } else {
      fail(`graph_investmint: ${e.message}`);
    }
  }

  // Also investmint milliampere if we have enough
  if (hydrogenAmount >= BigInt(investmintAmount) * 2n) {
    try {
      const res = parse(await call("graph_investmint", {
        amount: investmintAmount,
        resource: "milliampere",
        length: 1,
      }));
      ok(`graph_investmint: ${investmintAmount} hydrogen → milliampere, txHash=${res.txHash}`);
    } catch (e) {
      if (e.message.includes("insufficient resources return amount")) {
        skip(`graph_investmint milliampere: ${investmintAmount} hydrogen insufficient`);
      } else {
        fail(`graph_investmint milliampere: ${e.message}`);
      }
    }
  }
} else {
  skip("Not enough HYDROGEN for investmint (need ≥1,000,000)");
}

// ─── Scenario 5: IPFS pin + Cyberlink ───────────────────────
console.log("\n═══ Scenario 5: Pin content + Create cyberlink ═══");
let pinnedCid = null;
try {
  const res = parse(await call("graph_pin_content", {
    content: `bostrom-mcp production test ${Date.now()}`,
  }));
  pinnedCid = res.cid;
  ok(`graph_pin_content: CID=${pinnedCid}`);
} catch (e) {
  fail(`graph_pin_content: ${e.message}`);
}

if (pinnedCid) {
  const targetCid = "QmRX6hGPEBnBjVGsNMwcBRYmfab9q6xtQ5GKJY5i7MRJMi";

  // Single cyberlink
  try {
    const res = parse(await call("graph_create_cyberlink", {
      from_cid: pinnedCid,
      to_cid: targetCid,
    }));
    ok(`graph_create_cyberlink: txHash=${res.txHash}, from=${pinnedCid.slice(0, 12)}→${targetCid.slice(0, 12)}`);

    // Verify the link exists
    try {
      const particle = parse(await call("graph_particle", { cid: pinnedCid }));
      ok(`graph_particle: verified pinned content accessible`);
    } catch (e) {
      skip(`graph_particle: not yet indexed (expected for new content)`);
    }
  } catch (e) {
    if (e.message.includes("zero power")) {
      skip(`graph_create_cyberlink: neuron has zero power (need VOLT/AMPERE from investmint)`);
    } else {
      fail(`graph_create_cyberlink: ${e.message}`);
    }
  }

  // Batch cyberlinks (use a second pinned CID to avoid "already exists")
  try {
    const pin2 = parse(await call("graph_pin_content", {
      content: `batch-link-test-${Date.now()}`,
    }));
    const res = parse(await call("graph_create_cyberlinks", {
      links: [
        { from: pinnedCid, to: pin2.cid },
        { from: pin2.cid, to: targetCid },
      ],
    }));
    ok(`graph_create_cyberlinks: batch of 2, txHash=${res.txHash}`);
  } catch (e) {
    if (e.message.includes("zero power")) {
      skip(`graph_create_cyberlinks: neuron has zero power (need VOLT/AMPERE from investmint)`);
    } else if (e.message.includes("already exists")) {
      skip(`graph_create_cyberlinks: link already exists (re-run artifact)`);
    } else {
      fail(`graph_create_cyberlinks: ${e.message}`);
    }
  }
} else {
  skip("Cyberlink: no CID from pin step");
}

// ─── Scenario 6: Compound knowledge creation ────────────────
console.log("\n═══ Scenario 6: graph_create_knowledge (compound) ═══");
try {
  const res = parse(await call("graph_create_knowledge", {
    content: `Knowledge test: autonomous agent on bostrom ${Date.now()}`,
    from_cid: "QmRX6hGPEBnBjVGsNMwcBRYmfab9q6xtQ5GKJY5i7MRJMi",
  }));
  ok(`graph_create_knowledge: cid=${res.cid}, txHash=${res.txHash}`);
} catch (e) {
  if (e.message.includes("zero power")) {
    skip(`graph_create_knowledge: neuron has zero power (need VOLT/AMPERE from investmint)`);
  } else {
    fail(`graph_create_knowledge: ${e.message}`);
  }
}

// ─── Scenario 7: Contract execute (lithium submit_proof) ────
console.log("\n═══ Scenario 7: Contract execution ═══");
// li_submit_proof needs a real valid proof — we'll test with li_verify_proof first
try {
  // Generic contract query via contract_execute (expect it to fail gracefully with an on-chain error)
  const res = await call("contract_execute", {
    contract: "bostrom1vsfzcplds5z9xxl0llczeskxjxuddckksjm2u5ft2xt03qg28ups04mfes",
    msg: { stats: {} },
  });
  // This should fail because "stats" is a query, not an execute msg
  if (res.isError) {
    ok(`contract_execute: correctly rejected invalid execute msg`);
  } else {
    fail(`contract_execute: should have failed for query msg`);
  }
} catch (e) {
  ok(`contract_execute: correctly rejected invalid msg (${e.message.slice(0, 80)})`);
}

// ─── Scenario 8: LI staking lifecycle ───────────────────────
console.log("\n═══ Scenario 8: LI stake → claim → unstake ═══");
const liBal = walletData.balances.find(b =>
  b.denom === "factory/bostrom1wsgx32y0tx5rk6g89ffr8hg2wucnpwp650e9nrdm80jeyku5u4zq5ashgz/li"
);
if (liBal && BigInt(liBal.amount) >= 1000n) {
  try {
    const stakeRes = parse(await call("li_stake", { amount: "1000" }));
    ok(`li_stake: txHash=${stakeRes.txHash}, gas=${stakeRes.gasUsed}`);
  } catch (e) {
    fail(`li_stake: ${e.message}`);
  }

  try {
    const claimRes = parse(await call("li_claim_rewards"));
    ok(`li_claim_rewards: txHash=${claimRes.txHash}`);
  } catch (e) {
    fail(`li_claim_rewards: ${e.message}`);
  }

  try {
    const unstakeRes = parse(await call("li_unstake", { amount: "1000" }));
    ok(`li_unstake: txHash=${unstakeRes.txHash}`);
  } catch (e) {
    fail(`li_unstake: ${e.message}`);
  }

  // Verify via li_stake_info
  try {
    const info = parse(await call("li_stake_info", { address: ADDR }));
    ok(`li_stake_info: staked=${info.staked_amount || JSON.stringify(info).slice(0, 80)}`);
  } catch (e) {
    fail(`li_stake_info: ${e.message}`);
  }
} else {
  skip("LI staking: insufficient LI balance");
}

// ─── Scenario 9: LI set referrer ────────────────────────────
console.log("\n═══ Scenario 9: LI referrer ═══");
try {
  // Try setting referrer — may fail if already set (that's ok)
  const res = await call("li_set_referrer", {
    referrer: "bostrom1d8754xqa9245pctlfcyv8eah468neqzn3a0y0t",
  });
  const data = res.isError ? null : JSON.parse(res.content[0].text);
  if (res.isError) {
    const text = res.content[0].text;
    if (text.includes("already") || text.includes("referrer")) {
      ok(`li_set_referrer: correctly rejected (referrer already set)`);
    } else {
      fail(`li_set_referrer: ${text.slice(0, 120)}`);
    }
  } else {
    ok(`li_set_referrer: txHash=${data.txHash}`);
  }
} catch (e) {
  fail(`li_set_referrer: ${e.message}`);
}

// ─── Scenario 10: Token factory lifecycle ───────────────────
console.log("\n═══ Scenario 10: TokenFactory create → metadata → mint → burn ═══");
const subdenom = `test${Date.now().toString(36)}`;
let fullDenom = null;
try {
  const res = parse(await call("token_create", { subdenom }));
  fullDenom = res.denom;
  ok(`token_create: denom=${fullDenom}, txHash=${res.txHash}`);
} catch (e) {
  fail(`token_create: ${e.message}`);
}

if (fullDenom) {
  try {
    const res = parse(await call("token_set_metadata", {
      denom: fullDenom,
      name: "Test Token",
      symbol: "TST",
      description: "bostrom-mcp production test token",
      exponent: 6,
    }));
    ok(`token_set_metadata: txHash=${res.txHash}`);
  } catch (e) {
    fail(`token_set_metadata: ${e.message}`);
  }

  try {
    const res = parse(await call("token_mint", {
      denom: fullDenom,
      amount: "10000000",
      mint_to: ADDR,
    }));
    ok(`token_mint: 10000000 minted, txHash=${res.txHash}`);
  } catch (e) {
    fail(`token_mint: ${e.message}`);
  }

  // Verify balance
  try {
    const bals = parse(await call("economy_balances", { address: ADDR }));
    const tokenBal = bals.find(b => b.denom === fullDenom);
    ok(`Verify mint: balance=${tokenBal?.amount || "not found"}`);
  } catch (e) {
    fail(`Verify mint balance: ${e.message}`);
  }

  try {
    const res = parse(await call("token_burn", {
      denom: fullDenom,
      amount: "1000000",
      burn_from: ADDR,
    }));
    ok(`token_burn: 1000000 burned, txHash=${res.txHash}`);
  } catch (e) {
    fail(`token_burn: ${e.message}`);
  }

  // Verify via token_list_created
  try {
    const list = parse(await call("token_list_created"));
    const found = list.denoms.includes(fullDenom);
    ok(`token_list_created: denom ${found ? "found" : "NOT found"} in list`);
  } catch (e) {
    fail(`token_list_created: ${e.message}`);
  }
}

// ─── Scenario 11: Liquidity pool ────────────────────────────
console.log("\n═══ Scenario 11: Liquidity pool create → deposit → swap → withdraw ═══");
if (fullDenom) {
  let poolId = null;
  try {
    const res = parse(await call("liquidity_create_pool", {
      denom_a: "boot",
      amount_a: "10000000",
      denom_b: fullDenom,
      amount_b: "1000000",
    }));
    ok(`liquidity_create_pool: txHash=${res.txHash}, gas=${res.gasUsed}`);

    // Find the created pool
    // Pool ID is typically in the events — let's query all pools for our denom
    const poolDetail = parse(await call("liquidity_pool_detail", { pool_id: 1 }));
    // Try to find our pool by iterating a few IDs
    for (let pid = 1; pid <= 100; pid++) {
      try {
        const pd = parse(await call("liquidity_pool_detail", { pool_id: pid }));
        const coins = pd.pool?.reserve_coin_denoms || [];
        if (coins.includes(fullDenom)) {
          poolId = pid;
          break;
        }
      } catch { break; }
    }
    if (poolId) ok(`Found pool ID: ${poolId}`);
    else skip("Could not find pool ID (may need block confirmation)");
  } catch (e) {
    fail(`liquidity_create_pool: ${e.message}`);
  }

  if (poolId) {
    // Deposit
    try {
      const res = parse(await call("liquidity_deposit", {
        pool_id: poolId,
        denom_a: "boot",
        amount_a: "100000",
        denom_b: fullDenom,
        amount_b: "25000",
      }));
      ok(`liquidity_deposit: txHash=${res.txHash}`);
    } catch (e) {
      fail(`liquidity_deposit: ${e.message}`);
    }

    // Swap
    try {
      const res = parse(await call("liquidity_swap", {
        pool_id: poolId,
        offer_denom: "boot",
        offer_amount: "10000",
        demand_denom: fullDenom,
        order_price: "0.25",
      }));
      ok(`liquidity_swap: txHash=${res.txHash}`);
    } catch (e) {
      fail(`liquidity_swap: ${e.message}`);
    }

    // Pool detail (read)
    try {
      const detail = parse(await call("liquidity_pool_detail", { pool_id: poolId }));
      ok(`liquidity_pool_detail: pool type=${detail.pool?.type_id}`);
    } catch (e) {
      fail(`liquidity_pool_detail: ${e.message}`);
    }
  }
} else {
  skip("Liquidity: no token created");
}

// ─── Scenario 12: Energy grid ───────────────────────────────
console.log("\n═══ Scenario 12: Grid route create → edit → delete ═══");
const gridDest = "bostrom1d8754xqa9245pctlfcyv8eah468neqzn3a0y0t";
try {
  const res = parse(await call("grid_create_route", {
    destination: gridDest,
    name: "test-route",
  }));
  ok(`grid_create_route: txHash=${res.txHash}`);
} catch (e) {
  const msg = e.message;
  if (msg.includes("already") || msg.includes("exist")) {
    ok(`grid_create_route: route already exists (expected if re-running)`);
  } else {
    fail(`grid_create_route: ${msg.slice(0, 120)}`);
  }
}

try {
  const res = parse(await call("grid_edit_route", {
    destination: gridDest,
    amount: "100",
    denom: "millivolt",
  }));
  ok(`grid_edit_route: txHash=${res.txHash}`);
} catch (e) {
  fail(`grid_edit_route: ${e.message.slice(0, 120)}`);
}

// Verify
try {
  const routes = parse(await call("grid_list_routes"));
  const found = routes.routes?.some(r => r.destination === gridDest);
  ok(`grid_list_routes: route ${found ? "found" : "not found"}`);
} catch (e) {
  fail(`grid_list_routes: ${e.message}`);
}

try {
  const res = parse(await call("grid_delete_route", { destination: gridDest }));
  ok(`grid_delete_route: txHash=${res.txHash}`);
} catch (e) {
  fail(`grid_delete_route: ${e.message.slice(0, 120)}`);
}

// ─── Scenario 13: IBC channels (read) ──────────────────────
console.log("\n═══ Scenario 13: IBC ═══");
try {
  const channels = parse(await call("ibc_channels"));
  const open = channels.filter(c => c.state === "STATE_OPEN");
  ok(`ibc_channels: ${channels.length} total, ${open.length} open`);
  if (open.length > 0) {
    console.log(`    Sample: ${open[0].channel_id} ↔ ${open[0].counterparty?.channel_id} (${open[0].port_id})`);
  }
} catch (e) {
  fail(`ibc_channels: ${e.message}`);
}
// Skip actual IBC transfer to avoid losing tokens cross-chain
skip("ibc_transfer: skipped (irreversible cross-chain transfer)");

// ─── Scenario 14: contract_execute_multi ────────────────────
console.log("\n═══ Scenario 14: Multi-contract execute ═══");
try {
  const LITIUM_MINE = "bostrom1vsfzcplds5z9xxl0llczeskxjxuddckksjm2u5ft2xt03qg28ups04mfes";
  const LITIUM_STAKE = "bostrom1z0s6rxw8eq4wy25kaucy5jydlphlpzpglsle5n7nx2gaqd60rmgqs67tnz";
  // Multi-query simulation — use two read-like contract calls that will fail at execute
  // This tests the multi-msg infrastructure
  const res = await call("contract_execute_multi", {
    operations: [
      { contract: LITIUM_MINE, msg: { config: {} } },
      { contract: LITIUM_STAKE, msg: { config: {} } },
    ],
  });
  if (res.isError) {
    ok(`contract_execute_multi: correctly handled (query msgs rejected as execute)`);
  } else {
    ok(`contract_execute_multi: txHash=${JSON.parse(res.content[0].text).txHash}`);
  }
} catch (e) {
  ok(`contract_execute_multi: infrastructure works (${e.message.slice(0, 60)})`);
}

// ─── Summary ────────────────────────────────────────────────
console.log("\n═══════════════════════════════════════════════════");
console.log(`  ✅ Passed: ${passed}`);
console.log(`  ❌ Failed: ${failed}`);
console.log(`  ⏭️  Skipped: ${skipped}`);
console.log("═══════════════════════════════════════════════════\n");

process.exit(failed > 0 ? 1 : 0);