@continuumdao/ctm-mpc-defi 0.2.49 → 0.2.51

package/dist/protocols/evm/trueo/index.js

@@ -0,0 +1,2725 @@
+import { getAddress, parseAbi, encodeFunctionData, encodeAbiParameters, parseUnits, defineChain, createPublicClient, http, parseGwei, serializeTransaction, keccak256 } from 'viem';
+import { fetchChainFeeParams, gasLimitFromEstimateAndChainConfig, gweiToDecimalString, proposalTxParamsToFeeSnapshot, alignEip1559FeesWithLatestBase, getClientIdFromKeyGenResult } from '@continuumdao/continuum-node-sdk';
+
+// src/core/registry.ts
+var modules = [];
+function registerProtocolModule(mod) {
+  const existing = modules.findIndex((m) => m.id === mod.id);
+  if (existing >= 0) {
+    modules[existing] = mod;
+  } else {
+    modules.push(mod);
+  }
+}
+var TRUEO_PROTOCOL_ID = "trueo";
+var PREDICTION_MARKETS_PROTOCOL_ID = "prediction-markets";
+var TRUEO_BASE_CHAIN_ID = 8453;
+var TRUEO_CHAIN_IDS = [TRUEO_BASE_CHAIN_ID];
+var TRUEO_NETWORK = "base-mainnet";
+var TRUEO_API_ORIGIN = "https://api.trueo.com";
+var TRUEO_MARKET_API_PREFIX = "/market";
+function trueoMarketApiPath(suffix) {
+  const s = suffix.startsWith("/") ? suffix : `/${suffix}`;
+  return `${TRUEO_MARKET_API_PREFIX}${s}`;
+}
+var TRUEO_TYD = getAddress("0xb13CF163d916917d9cD6E836905cA5f12a1dEF4B");
+var TRUEO_TRUE = getAddress("0x21CFCFc3d8F98fC728f48341D10Ad8283F6EB7AB");
+var TRUEO_USDC = getAddress("0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913");
+var TRUEO_TRUTH_MARKET_MANAGER = getAddress("0x61A98Bef11867c69489B91f340fE545eEfc695d7");
+var TRUEO_ORDER_MANAGER = getAddress("0x1cdB1C43eB64e99780EA9d3C7162C23432C59a1A");
+var TRUEO_UNIVERSAL_ROUTER_ADAPTER = getAddress("0x0A1AFc2121B4441127a02DEF72928F61f564034a");
+var TRUEO_TRUTH_MARKET_ADAPTER = getAddress("0x6E08d24AEf78F6d1a97503F64E84fDF65f8125E1");
+var TRUEO_V4_HOOK = getAddress("0x3E83479B2276EcFb7C7181F67b5d092d3511e0C4");
+var TRUEO_PERMIT2 = getAddress("0x000000000022D473030F116dDEE9F6B43aC78BA3");
+var TRUEO_TYD_DECIMALS = 6;
+var TRUEO_OUTCOME_TOKEN_DECIMALS = 18;
+var TRUEO_BET_CLOSE_BUFFER_SECONDS = 5 * 60;
+var TRUEO_PERMIT2_APPROVAL_SECONDS = 30 * 60;
+var TRUEO_BET_ACTIONS = ["swap", "createOrder"];
+function isTrueoChainSupported(chainId) {
+  return TRUEO_CHAIN_IDS.includes(chainId);
+}
+function assertTrueoChainId(chainId) {
+  if (!isTrueoChainSupported(chainId)) {
+    throw new Error(`Trueo is Base-only (chainId ${TRUEO_BASE_CHAIN_ID}).`);
+  }
+}
+function isTrueoCoreToken(address) {
+  try {
+    const n = getAddress(address);
+    return n === TRUEO_TYD || n === TRUEO_TRUE;
+  } catch {
+    return false;
+  }
+}
+function normalizeTrueoAddress(address) {
+  return getAddress(address);
+}
+var trueoErc20Abi = parseAbi([
+  "function allowance(address owner, address spender) view returns (uint256)",
+  "function approve(address spender, uint256 amount) returns (bool)",
+  "function balanceOf(address account) view returns (uint256)",
+  "function decimals() view returns (uint8)",
+  "function symbol() view returns (string)"
+]);
+var trueoMarketAbi = parseAbi([
+  "function mint(uint256 paymentTokenAmount)",
+  "function burn(uint256 amount)",
+  "function redeem(uint256 amount)",
+  "function paymentToken() view returns (address)",
+  "function yesToken() view returns (address)",
+  "function noToken() view returns (address)",
+  "function getCurrentStatus() view returns (uint8)",
+  "function winningPosition() view returns (uint256)",
+  "function paused() view returns (bool)"
+]);
+var trueoMarketV2Abi = parseAbi([
+  "function getPoolKeys() view returns ((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) yesPoolKey, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) noPoolKey)",
+  "function getPoolIds() view returns (bytes32 yesPoolId, bytes32 noPoolId)"
+]);
+var trueoAdapterMintAbi = parseAbi([
+  "function mint(address truthMarket, uint256 assetAmount)",
+  "function burn(address truthMarket, uint256 amount)",
+  "function redeem(address truthMarket, uint256 amount)"
+]);
+var trueoTydVaultAbi = parseAbi([
+  "function asset() view returns (address)",
+  "function deposit(uint256 assets, address receiver) returns (uint256 shares)",
+  "function redeem(uint256 shares, address receiver, address owner) returns (uint256 assets)"
+]);
+var trueoUniversalRouterAdapterAbi = parseAbi([
+  "function execute(bytes commands, bytes[] inputs, uint256 deadline) payable"
+]);
+var trueoPermit2ApproveAbi = parseAbi([
+  "function approve(address token, address spender, uint160 amount, uint48 expiration)",
+  "function allowance(address owner, address token, address spender) view returns (uint160 amount, uint48 expiration, uint48 nonce)"
+]);
+var trueoOrderManagerAbi = parseAbi([
+  "function createOrder((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) poolKey, uint128 amountIn, int24 tickLower, int24 tickUpper, bool zeroForOne, bool enablePartialFill) returns (uint32 orderId)",
+  "function cancelOrder((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) poolKey, uint32 orderId, uint128 amount0Min, uint128 amount1Min)",
+  "function pendingOrder(bytes32 poolId, uint32 orderId) view returns (address owner, bool zeroForOne, int24 tickLower, int24 tickUpper, uint256 liquidity, bool enablePartialFill)"
+]);
+var trueoOrderManagerStructAbi = parseAbi([
+  "function createOrder(((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) poolKey, uint128 amountIn, int24 tickLower, int24 tickUpper, bool zeroForOne, bool enablePartialFill) params) returns (uint32 orderId)",
+  "function cancelOrder(((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) poolKey, uint32 orderId, uint128 amount0Min, uint128 amount1Min) params)"
+]);
+var UR_COMMAND_V4_SWAP = 16;
+var V4_ACTION_SWAP_EXACT_IN_SINGLE = 6;
+var V4_ACTION_SETTLE = 11;
+var V4_ACTION_TAKE = 12;
+var poolKeyComponents = [
+  { name: "currency0", type: "address" },
+  { name: "currency1", type: "address" },
+  { name: "fee", type: "uint24" },
+  { name: "tickSpacing", type: "int24" },
+  { name: "hooks", type: "address" }
+];
+function encodeErc20Approve(spender, amount) {
+  return encodeFunctionData({
+    abi: trueoErc20Abi,
+    functionName: "approve",
+    args: [getAddress(spender), amount]
+  });
+}
+function encodePermit2Approve(args) {
+  return encodeFunctionData({
+    abi: trueoPermit2ApproveAbi,
+    functionName: "approve",
+    args: [getAddress(args.token), getAddress(args.spender), args.amount, args.expiration]
+  });
+}
+function encodeTrueoTydDeposit(assets, receiver) {
+  return encodeFunctionData({
+    abi: trueoTydVaultAbi,
+    functionName: "deposit",
+    args: [assets, getAddress(receiver)]
+  });
+}
+function encodeTrueoTydRedeem(shares, receiver, owner) {
+  return encodeFunctionData({
+    abi: trueoTydVaultAbi,
+    functionName: "redeem",
+    args: [shares, getAddress(receiver), getAddress(owner)]
+  });
+}
+function encodeTrueoMint(paymentTokenAmount) {
+  return encodeFunctionData({
+    abi: trueoMarketAbi,
+    functionName: "mint",
+    args: [paymentTokenAmount]
+  });
+}
+function encodeTrueoBurn(amount) {
+  return encodeFunctionData({
+    abi: trueoMarketAbi,
+    functionName: "burn",
+    args: [amount]
+  });
+}
+function encodeTrueoRedeem(amount) {
+  return encodeFunctionData({
+    abi: trueoMarketAbi,
+    functionName: "redeem",
+    args: [amount]
+  });
+}
+function encodeTrueoAdapterMint(market, assetAmount) {
+  return encodeFunctionData({
+    abi: trueoAdapterMintAbi,
+    functionName: "mint",
+    args: [getAddress(market), assetAmount]
+  });
+}
+function encodeTrueoAdapterBurn(market, amount) {
+  return encodeFunctionData({
+    abi: trueoAdapterMintAbi,
+    functionName: "burn",
+    args: [getAddress(market), amount]
+  });
+}
+function encodeTrueoAdapterRedeem(market, amount) {
+  return encodeFunctionData({
+    abi: trueoAdapterMintAbi,
+    functionName: "redeem",
+    args: [getAddress(market), amount]
+  });
+}
+function encodeTrueoV4ExactInInput(args) {
+  const poolKey = {
+    currency0: getAddress(args.poolKey.currency0),
+    currency1: getAddress(args.poolKey.currency1),
+    fee: args.poolKey.fee,
+    tickSpacing: args.poolKey.tickSpacing,
+    hooks: getAddress(args.poolKey.hooks)
+  };
+  const settleCurrency = args.zeroForOne ? poolKey.currency0 : poolKey.currency1;
+  const takeCurrency = args.zeroForOne ? poolKey.currency1 : poolKey.currency0;
+  const swapParams = encodeAbiParameters(
+    [
+      {
+        type: "tuple",
+        components: [
+          { name: "poolKey", type: "tuple", components: [...poolKeyComponents] },
+          { name: "zeroForOne", type: "bool" },
+          { name: "amountIn", type: "uint128" },
+          { name: "amountOutMinimum", type: "uint128" },
+          { name: "hookData", type: "bytes" }
+        ]
+      }
+    ],
+    [
+      {
+        poolKey,
+        zeroForOne: args.zeroForOne,
+        amountIn: args.amountIn,
+        amountOutMinimum: args.amountOutMinimum,
+        hookData: "0x"
+      }
+    ]
+  );
+  const settleParams = encodeAbiParameters(
+    [
+      { name: "currency", type: "address" },
+      { name: "amount", type: "uint256" },
+      { name: "payerIsUser", type: "bool" }
+    ],
+    [settleCurrency, args.amountIn, true]
+  );
+  const takeParams = encodeAbiParameters(
+    [
+      { name: "currency", type: "address" },
+      { name: "recipient", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    [takeCurrency, getAddress(args.recipient), 0n]
+  );
+  const actions = `0x${[V4_ACTION_SWAP_EXACT_IN_SINGLE, V4_ACTION_SETTLE, V4_ACTION_TAKE].map((b) => b.toString(16).padStart(2, "0")).join("")}`;
+  return encodeAbiParameters(
+    [
+      { name: "actions", type: "bytes" },
+      { name: "params", type: "bytes[]" }
+    ],
+    [actions, [swapParams, settleParams, takeParams]]
+  );
+}
+function encodeTrueoUniversalRouterExecute(args) {
+  return encodeFunctionData({
+    abi: trueoUniversalRouterAdapterAbi,
+    functionName: "execute",
+    args: [args.commands, [...args.inputs], args.deadline]
+  });
+}
+function encodeTrueoV4ExactInSwap(args) {
+  const commands = `0x${UR_COMMAND_V4_SWAP.toString(16).padStart(2, "0")}`;
+  const inputs = [
+    encodeTrueoV4ExactInInput({
+      poolKey: args.poolKey,
+      zeroForOne: args.zeroForOne,
+      amountIn: args.amountIn,
+      amountOutMinimum: args.amountOutMinimum,
+      recipient: args.recipient
+    })
+  ];
+  const data = encodeTrueoUniversalRouterExecute({
+    commands,
+    inputs,
+    deadline: args.deadline
+  });
+  return { commands, inputs, deadline: args.deadline, data, to: TRUEO_UNIVERSAL_ROUTER_ADAPTER };
+}
+function encodeTrueoCreateOrder(args) {
+  return encodeFunctionData({
+    abi: trueoOrderManagerStructAbi,
+    functionName: "createOrder",
+    args: [
+      {
+        poolKey: {
+          currency0: getAddress(args.poolKey.currency0),
+          currency1: getAddress(args.poolKey.currency1),
+          fee: args.poolKey.fee,
+          tickSpacing: args.poolKey.tickSpacing,
+          hooks: getAddress(args.poolKey.hooks)
+        },
+        amountIn: args.amountIn,
+        tickLower: args.tickLower,
+        tickUpper: args.tickUpper,
+        zeroForOne: args.zeroForOne,
+        enablePartialFill: args.enablePartialFill
+      }
+    ]
+  });
+}
+function encodeTrueoCancelOrder(args) {
+  return encodeFunctionData({
+    abi: trueoOrderManagerStructAbi,
+    functionName: "cancelOrder",
+    args: [
+      {
+        poolKey: {
+          currency0: getAddress(args.poolKey.currency0),
+          currency1: getAddress(args.poolKey.currency1),
+          fee: args.poolKey.fee,
+          tickSpacing: args.poolKey.tickSpacing,
+          hooks: getAddress(args.poolKey.hooks)
+        },
+        orderId: args.orderId,
+        amount0Min: args.amount0Min ?? 0n,
+        amount1Min: args.amount1Min ?? 0n
+      }
+    ]
+  });
+}
+function trueoPermit2Expiration(nowSec = Math.floor(Date.now() / 1e3)) {
+  return nowSec + TRUEO_PERMIT2_APPROVAL_SECONDS;
+}
+function trueoSwapDeadline(nowSec = Math.floor(Date.now() / 1e3)) {
+  return BigInt(nowSec + TRUEO_PERMIT2_APPROVAL_SECONDS);
+}
+
+// src/protocols/evm/trueo/prices.ts
+var Q96 = 2n ** 96n;
+function trueoImpliedPriceFromSqrtX96(sqrtPriceX96, token0Decimals = TRUEO_OUTCOME_TOKEN_DECIMALS, token1Decimals = TRUEO_TYD_DECIMALS) {
+  if (sqrtPriceX96 == null) return null;
+  let sqrt;
+  try {
+    sqrt = typeof sqrtPriceX96 === "bigint" ? sqrtPriceX96 : BigInt(String(sqrtPriceX96));
+  } catch {
+    return null;
+  }
+  if (sqrt <= 0n) return null;
+  const raw = Number(sqrt) / Number(Q96);
+  if (!Number.isFinite(raw) || raw <= 0) return null;
+  const price = raw * raw * 10 ** (token0Decimals - token1Decimals);
+  return Number.isFinite(price) && price > 0 ? price : null;
+}
+var TRUEO_SANE_IMPLIED_PRICE_MAX = 1.05;
+function trueoIsSaneImpliedPrice(price) {
+  return price != null && Number.isFinite(price) && price >= 0 && price <= TRUEO_SANE_IMPLIED_PRICE_MAX;
+}
+function trueoSanitizeBinaryPrices(yes, no) {
+  const y = trueoIsSaneImpliedPrice(yes) ? yes : null;
+  const n = trueoIsSaneImpliedPrice(no) ? no : null;
+  if (y != null && n == null) return { yes: y, no: Math.min(1, Math.max(0, 1 - y)) };
+  if (n != null && y == null) return { yes: Math.min(1, Math.max(0, 1 - n)), no: n };
+  return { yes: y, no: n };
+}
+function trueoPercentLabel(price) {
+  if (!trueoIsSaneImpliedPrice(price)) return null;
+  const pct = Math.min(100, Math.max(0, price * 100));
+  return `${pct.toFixed(1)}%`;
+}
+function trueoCompactVolumeLabel(size) {
+  if (size == null || size === "") return "";
+  const n = typeof size === "number" ? size : Number(String(size).replace(/,/g, ""));
+  if (!Number.isFinite(n) || n < 0) return "";
+  if (n >= 1e6) return `${(n / 1e6).toFixed(n >= 1e7 ? 0 : 1)}M`;
+  if (n >= 1e5) return `${(n / 1e3).toFixed(0)}k`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}k`;
+  if (n >= 10) return n.toFixed(0);
+  if (n >= 1) return n.toFixed(1);
+  if (n === 0) return "0";
+  return n.toFixed(2);
+}
+function trueoExpiresAtIso(endOfTrading) {
+  if (!Number.isFinite(endOfTrading) || endOfTrading <= 0) return null;
+  return new Date(endOfTrading * 1e3).toISOString();
+}
+function trueoExpiresAtLabel(endOfTrading) {
+  if (!Number.isFinite(endOfTrading) || endOfTrading <= 0) return null;
+  const d = new Date(endOfTrading * 1e3);
+  const y = d.getUTCFullYear();
+  const m = String(d.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(d.getUTCDate()).padStart(2, "0");
+  const hh = String(d.getUTCHours()).padStart(2, "0");
+  const mm = String(d.getUTCMinutes()).padStart(2, "0");
+  return `${y}-${m}-${day} ${hh}:${mm} UTC`;
+}
+var UTC_MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+function trueoTradingDeadlineLabel(endOfTrading) {
+  if (!Number.isFinite(endOfTrading) || endOfTrading <= 0) return null;
+  const d = new Date(endOfTrading * 1e3);
+  const day = d.getUTCDate();
+  const mon = UTC_MONTHS[d.getUTCMonth()];
+  const y = d.getUTCFullYear();
+  const hh = String(d.getUTCHours()).padStart(2, "0");
+  const mm = String(d.getUTCMinutes()).padStart(2, "0");
+  return `${day} ${mon} ${y}, ${hh}:${mm} UTC`;
+}
+function trueoTimeUntilTradingEndsLabel(endOfTrading, nowSec = Math.floor(Date.now() / 1e3)) {
+  if (!Number.isFinite(endOfTrading) || endOfTrading <= 0) return null;
+  const sec = Math.floor(endOfTrading) - nowSec;
+  if (sec <= 0) return "ended";
+  const days = Math.floor(sec / 86400);
+  const hours = Math.floor(sec % 86400 / 3600);
+  if (days >= 60) {
+    const months = Math.max(1, Math.round(days / 30));
+    return `in ${months} month${months === 1 ? "" : "s"}`;
+  }
+  if (days >= 2) return `in ${days} days`;
+  if (days === 1) return hours > 0 ? `in 1 day ${hours}h` : "in 1 day";
+  if (hours >= 2) return `in ${hours} hours`;
+  const mins = Math.max(1, Math.floor(sec / 60));
+  return `in ${mins} min`;
+}
+
+// src/protocols/evm/trueo/marketScope.ts
+var TRUEO_RECENT_MARKET_WINDOW_SECONDS = 14 * 24 * 60 * 60;
+function trueoFinishedAtSec(row, nowSec) {
+  if (row.endOfTrading > 0 && nowSec >= row.endOfTrading) return row.endOfTrading;
+  if (row.statusUpdatedAt?.trim()) {
+    const ms = Date.parse(row.statusUpdatedAt);
+    if (Number.isFinite(ms) && ms <= nowSec * 1e3) return Math.floor(ms / 1e3);
+  }
+  return null;
+}
+function isTrueoMarketLiveOrRecent(row, nowSec = Math.floor(Date.now() / 1e3), recentWindowSec = TRUEO_RECENT_MARKET_WINDOW_SECONDS) {
+  if (row.endOfTrading > 0 && nowSec < row.endOfTrading) return true;
+  const status = Number(row.status);
+  if (status === 0 && row.endOfTrading <= 0) return true;
+  const finishedAt = trueoFinishedAtSec(row, nowSec);
+  if (finishedAt == null) return false;
+  return nowSec - finishedAt <= recentWindowSec;
+}
+function applyTrueoMarketSearchScope(rows, args) {
+  if (args?.includeAll === true) return rows;
+  return rows.filter((row) => isTrueoMarketLiveOrRecent(row, args?.nowSec));
+}
+function isTrueoMarketTradingOpen(row, nowSec = Math.floor(Date.now() / 1e3)) {
+  const status = Number(row.status);
+  if (status !== 0) return false;
+  if (row.endOfTrading > 0 && nowSec >= row.endOfTrading) return false;
+  return true;
+}
+function preferOpenTrueoTitleMatches(rows, args) {
+  if (args?.includeAll === true || rows.length === 0) return rows;
+  const open = rows.filter((row) => isTrueoMarketTradingOpen(row, args?.nowSec));
+  return open.length > 0 ? open : rows;
+}
+function trueoSearchScopeNote(includeAll) {
+  return includeAll ? "Includes closed and resolved markets." : "Live and recently finished only (last 14 days). Set includeAll to include older closed markets.";
+}
+
+// src/protocols/evm/trueo/marketApi.ts
+function trueoHeaders() {
+  return { Accept: "application/json" };
+}
+async function trueoJsonFetch(path, opts) {
+  const url = path.startsWith("http") ? path : `${TRUEO_API_ORIGIN}${path}`;
+  const res = await fetch(url, { headers: trueoHeaders(), signal: opts?.signal });
+  if (!res.ok) {
+    throw new Error(`Trueo API ${res.status} for ${path}`);
+  }
+  return await res.json();
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function asString(value, fallback = "") {
+  return value == null ? fallback : String(value);
+}
+function asNumber(value, fallback = 0) {
+  const n = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(n) ? n : fallback;
+}
+function asNumberOrNull(value) {
+  if (value == null || value === "") return null;
+  const n = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(n) ? n : null;
+}
+function asStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map((v) => String(v)).filter(Boolean);
+}
+function normalizeTrueoMarketRow(raw) {
+  const r = asRecord(raw) ?? {};
+  const address = asString(r.address).toLowerCase();
+  const endOfTrading = asNumber(r.endOfTrading, 0);
+  const yesSqrt = r.yesPoolSqrtPriceX96 == null ? null : asString(r.yesPoolSqrtPriceX96);
+  const noSqrt = r.noPoolSqrtPriceX96 == null ? null : asString(r.noPoolSqrtPriceX96);
+  const { yes: yesPrice, no: noPrice } = trueoSanitizeBinaryPrices(
+    trueoImpliedPriceFromSqrtX96(yesSqrt),
+    trueoImpliedPriceFromSqrtX96(noSqrt)
+  );
+  return {
+    address,
+    question: asString(r.question),
+    rules: asString(r.rules),
+    source: asString(r.source),
+    categories: asStringArray(r.categories),
+    size: asString(r.size, "0"),
+    tvl: asNumberOrNull(r.tvl),
+    yesTokenAddress: asString(r.yesTokenAddress).toLowerCase(),
+    noTokenAddress: asString(r.noTokenAddress).toLowerCase(),
+    yesPoolAddress: asString(r.yesPoolAddress).toLowerCase(),
+    noPoolAddress: asString(r.noPoolAddress).toLowerCase(),
+    paymentTokenAddress: asString(r.paymentTokenAddress).toLowerCase(),
+    paymentTokenSymbol: asString(r.paymentTokenSymbol, "TYD"),
+    paymentTokenDecimals: asNumber(r.paymentTokenDecimals, 6),
+    endOfTrading,
+    status: asNumber(r.status, 0),
+    outcome: asNumber(r.outcome, 0),
+    statusUpdatedAt: r.statusUpdatedAt == null || r.statusUpdatedAt === "" ? null : asString(r.statusUpdatedAt),
+    imageUrl: r.imageUrl == null ? null : asString(r.imageUrl),
+    yesPoolTick: asNumberOrNull(r.yesPoolTick),
+    noPoolTick: asNumberOrNull(r.noPoolTick),
+    yesPoolSqrtPriceX96: yesSqrt,
+    noPoolSqrtPriceX96: noSqrt,
+    yesPrice,
+    noPrice,
+    yesPriceLabel: trueoPercentLabel(yesPrice),
+    noPriceLabel: trueoPercentLabel(noPrice),
+    expiresAt: trueoExpiresAtIso(endOfTrading),
+    expiresAtLabel: trueoExpiresAtLabel(endOfTrading),
+    chainId: TRUEO_BASE_CHAIN_ID,
+    network: asString(r.network, TRUEO_NETWORK)
+  };
+}
+var TRUEO_QUERY_STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "for",
+  "any",
+  "all",
+  "and",
+  "search",
+  "find",
+  "show",
+  "list",
+  "market",
+  "markets",
+  "prediction",
+  "live",
+  "recent",
+  "trending",
+  "trueo",
+  "topic",
+  "about"
+]);
+function trueoQueryTokens(query) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const raw of query.toLowerCase().split(/[^a-z0-9]+/)) {
+    const t = raw.trim();
+    if (t.length < 3 || TRUEO_QUERY_STOPWORDS.has(t) || seen.has(t)) continue;
+    seen.add(t);
+    out.push(t);
+  }
+  return out;
+}
+function filterTrueoMarkets(rows, args) {
+  const q = args.query?.trim().toLowerCase() ?? "";
+  const tokens = q ? trueoQueryTokens(q) : [];
+  const category = args.category?.trim().toLowerCase() ?? "";
+  return rows.filter((row) => {
+    if (category) {
+      const hit = row.categories.some((c) => c.toLowerCase() === category || c.toLowerCase().includes(category));
+      if (!hit) return false;
+    }
+    if (!q) return true;
+    const hay = [
+      row.question,
+      row.rules,
+      row.source,
+      row.address,
+      row.yesTokenAddress,
+      row.noTokenAddress,
+      ...row.categories
+    ].join(" ").toLowerCase();
+    if (hay.includes(q)) return true;
+    return tokens.some((t) => hay.includes(t));
+  });
+}
+async function fetchTrueoCategories(opts) {
+  const raw = await trueoJsonFetch(trueoMarketApiPath("categories"), opts);
+  if (!Array.isArray(raw)) return [];
+  return raw.map((item) => {
+    const r = asRecord(item);
+    if (!r) return null;
+    const name = asString(r.name).trim();
+    if (!name) return null;
+    return { id: asNumber(r.id, 0), name };
+  }).filter((c) => c != null);
+}
+var TRUEO_TRENDING_MAX_LIMIT = 10;
+var TRUEO_MARKET_PAGE_SIZE = 10;
+function trueoSearchFetchLimit(requested, includeAll) {
+  const cap = 100;
+  if (includeAll) return Math.min(requested, cap);
+  return Math.min(Math.max(requested * 4, 40), cap);
+}
+async function fetchTrueoTrending(args) {
+  const requested = Math.min(Math.max(args?.limit ?? 20, 1), TRUEO_TRENDING_MAX_LIMIT);
+  const includeAll = args?.includeAll === true;
+  const raw = await trueoJsonFetch(
+    `${trueoMarketApiPath(`${TRUEO_NETWORK}/trending`)}?limit=${requested}`,
+    args?.opts
+  );
+  if (!Array.isArray(raw)) return [];
+  const rows = applyTrueoMarketSearchScope(raw.map(normalizeTrueoMarketRow), { includeAll });
+  return rows.slice(0, requested);
+}
+var TRUEO_TITLE_SEARCH_PAGE_SIZE = 100;
+var TRUEO_TITLE_SEARCH_MAX_PAGES = 16;
+async function searchTrueoMarketsPage(args) {
+  const requested = Math.min(Math.max(args.limit ?? TRUEO_MARKET_PAGE_SIZE, 1), 100);
+  const includeAll = args.includeAll === true;
+  const titleQuery = Boolean(args.query?.trim());
+  const pageSize = titleQuery ? TRUEO_TITLE_SEARCH_PAGE_SIZE : trueoSearchFetchLimit(requested, includeAll);
+  const maxPages = titleQuery ? TRUEO_TITLE_SEARCH_MAX_PAGES : 3;
+  let offset = Math.max(args.offset ?? 0, 0);
+  const exclude = new Set((args.excludeAddresses ?? []).map((a) => a.toLowerCase()));
+  const collected = [];
+  let apiExhausted = false;
+  for (let page = 0; page < maxPages && collected.length < requested; page++) {
+    const params = new URLSearchParams();
+    params.set("limit", String(pageSize));
+    params.set("offset", String(offset));
+    if (args.category?.trim()) params.set("category", args.category.trim());
+    const raw = await trueoJsonFetch(
+      `${trueoMarketApiPath(TRUEO_NETWORK)}?${params.toString()}`,
+      args.opts
+    );
+    const pageRows = Array.isArray(raw) ? raw.map(normalizeTrueoMarketRow) : [];
+    const scoped = applyTrueoMarketSearchScope(
+      filterTrueoMarkets(pageRows, { query: args.query, category: args.category }),
+      { includeAll }
+    );
+    let filled = false;
+    for (const row of scoped) {
+      if (exclude.has(row.address)) continue;
+      exclude.add(row.address);
+      collected.push(row);
+      const enough = titleQuery && !includeAll ? collected.filter((r) => isTrueoMarketTradingOpen(r)).length >= requested : collected.length >= requested;
+      if (enough) {
+        filled = true;
+        break;
+      }
+    }
+    if (filled) break;
+    offset += pageRows.length;
+    if (pageRows.length < pageSize) {
+      apiExhausted = true;
+      break;
+    }
+  }
+  const ranked = titleQuery ? preferOpenTrueoTitleMatches(collected, { includeAll }) : collected;
+  const markets = ranked.slice(0, requested);
+  return {
+    markets,
+    hasMore: !apiExhausted,
+    nextOffset: offset
+  };
+}
+async function searchTrueoMarkets(args) {
+  return (await searchTrueoMarketsPage(args)).markets;
+}
+function trueoListUsesTrending(args) {
+  if (args.query?.trim() || args.category?.trim()) return false;
+  const offset = Math.max(args.offset ?? 0, 0);
+  return args.trending === true || offset === 0 && args.trending !== false;
+}
+async function listTrueoMarketsPage(args) {
+  const offset = Math.max(args.offset ?? 0, 0);
+  const includeAll = args.includeAll === true;
+  const useTrending = trueoListUsesTrending(args);
+  if (useTrending) {
+    const markets = await fetchTrueoTrending({ limit: TRUEO_TRENDING_MAX_LIMIT, includeAll, opts: args.opts });
+    if (includeAll || markets.length >= TRUEO_TRENDING_MAX_LIMIT) {
+      return { markets, hasMore: true, nextOffset: 0 };
+    }
+    const fill = await searchTrueoMarketsPage({
+      limit: TRUEO_TRENDING_MAX_LIMIT - markets.length,
+      includeAll,
+      excludeAddresses: [...args.excludeAddresses ?? [], ...markets.map((m) => m.address)],
+      opts: args.opts
+    });
+    return {
+      markets: [...markets, ...fill.markets],
+      hasMore: fill.hasMore,
+      nextOffset: fill.nextOffset
+    };
+  }
+  return searchTrueoMarketsPage({
+    query: args.query,
+    category: args.category,
+    limit: TRUEO_MARKET_PAGE_SIZE,
+    offset,
+    includeAll,
+    excludeAddresses: args.excludeAddresses,
+    opts: args.opts
+  });
+}
+async function fetchTrueoMarket(args) {
+  const address = getAddress(args.marketAddress).toLowerCase();
+  const raw = await trueoJsonFetch(trueoMarketApiPath(`${TRUEO_NETWORK}/${address}`), args.opts);
+  return normalizeTrueoMarketRow(raw);
+}
+var TRUEO_CHANCE_SERIES_RESOLUTION = "3600";
+var TRUEO_CHANCE_SERIES_LOOKBACK_SECONDS = 14 * 24 * 60 * 60;
+var TRUEO_OHLC_CALENDAR_ALIASES = /* @__PURE__ */ new Set(["1h", "1d", "1w", "all", "hour", "day", "week"]);
+function normalizeTrueoOhlcResolution(raw) {
+  const v = raw?.trim() ?? "";
+  if (!v || TRUEO_OHLC_CALENDAR_ALIASES.has(v.toLowerCase())) {
+    return TRUEO_CHANCE_SERIES_RESOLUTION;
+  }
+  return v;
+}
+async function fetchTrueoOhlc(args) {
+  const poolId = args.poolId.startsWith("0x") ? args.poolId.toLowerCase() : args.poolId;
+  const resolution = normalizeTrueoOhlcResolution(args.resolution);
+  const raw = await trueoJsonFetch(
+    `${trueoMarketApiPath(`${TRUEO_NETWORK}/${poolId}/ohlc`)}?from=${Math.floor(args.from)}&to=${Math.floor(args.to)}&resolution=${encodeURIComponent(resolution)}`,
+    args.opts
+  );
+  if (!Array.isArray(raw)) return [];
+  return raw.map((item) => {
+    const r = asRecord(item);
+    if (!r) return null;
+    return {
+      timestamp: asNumber(r.timestamp, 0),
+      open: asNumber(r.open, 0),
+      high: asNumber(r.high, 0),
+      low: asNumber(r.low, 0),
+      close: asNumber(r.close, 0)
+    };
+  }).filter((b) => b != null && b.timestamp > 0);
+}
+async function fetchTrueoTransactions(args) {
+  const address = getAddress(args.marketAddress).toLowerCase();
+  const limit = Math.min(Math.max(args.limit ?? 20, 1), 100);
+  const raw = await trueoJsonFetch(
+    `${trueoMarketApiPath("transactions")}?marketAddress=${address}&limit=${limit}`,
+    args.opts
+  );
+  return Array.isArray(raw) ? raw : [];
+}
+async function trueoFetchCategoriesSummary() {
+  const categories = await fetchTrueoCategories();
+  return { categories, chainId: TRUEO_BASE_CHAIN_ID };
+}
+async function trueoFetchTrendingSummary(input = {}) {
+  const includeAll = input.includeAll === true;
+  const markets = await fetchTrueoTrending({ limit: input.limit, includeAll });
+  return {
+    markets,
+    hasMore: true,
+    nextOffset: 0,
+    notes: `Trueo trending on Base (max ${TRUEO_TRENDING_MAX_LIMIT}; API does not page trending). More: ctm_trueo_search_markets with offset=0, skip listed addresses. ${trueoSearchScopeNote(includeAll)}`
+  };
+}
+async function trueoSearchMarketsSummary(input) {
+  const includeAll = input.includeAll === true;
+  const page = await searchTrueoMarketsPage({ ...input, includeAll });
+  const q = input.query?.trim() ?? "";
+  let notes = `Trueo search on Base (page ${TRUEO_MARKET_PAGE_SIZE}). ${page.hasMore ? `More: same tool with offset=${page.nextOffset}.` : "End of results."} ${trueoSearchScopeNote(includeAll)}`;
+  if (q && page.markets.length === 0) {
+    notes = `No live or recent title match for ${JSON.stringify(q)} after scanning the catalog (vendor search text is ignored). Do not list trending unless the operator asked.`;
+  }
+  return {
+    markets: page.markets,
+    hasMore: page.hasMore,
+    nextOffset: page.nextOffset,
+    notes
+  };
+}
+async function trueoFetchMarketSummary(input) {
+  return fetchTrueoMarket({ marketAddress: input.marketAddress });
+}
+async function fetchTrueoChanceSeries(args) {
+  const to = Math.floor(Date.now() / 1e3);
+  const lookback = Math.max(3600, args.lookbackSeconds ?? TRUEO_CHANCE_SERIES_LOOKBACK_SECONDS);
+  const bars = await fetchTrueoOhlc({
+    poolId: args.poolId,
+    from: to - lookback,
+    to,
+    resolution: TRUEO_CHANCE_SERIES_RESOLUTION,
+    opts: args.opts
+  });
+  return bars.filter((b) => trueoIsSaneImpliedPrice(b.close));
+}
+async function trueoFetchChanceSeriesSummary(input) {
+  const resolution = normalizeTrueoOhlcResolution(input.resolution);
+  const to = input.to ?? Math.floor(Date.now() / 1e3);
+  const from = input.from ?? to - Math.max(1, input.lookbackDays ?? TRUEO_CHANCE_SERIES_LOOKBACK_SECONDS / 86400) * 86400;
+  const bars = await fetchTrueoOhlc({
+    poolId: input.poolId,
+    from,
+    to,
+    resolution
+  });
+  return {
+    poolId: input.poolId,
+    bars,
+    from,
+    to,
+    resolution,
+    notes: "Chance samples (not candlesticks). resolution is seconds; default 3600 (hourly). 1H/1D/1W/All coerce to hourly."
+  };
+}
+var TRUEO_BET_CLOSE_ERROR = "Market closes within 5 minutes.";
+var TRUEO_BET_EXPIRED_ERROR = "Market expired. Cannot Get Sig or Execute.";
+function trueoMarketStatusLabel(row, nowSec = Math.floor(Date.now() / 1e3)) {
+  const status = Number(row.status);
+  if (status === 7) return "resolved";
+  if (status >= 4) return "closed";
+  if (status >= 1) return "resolving";
+  if (row.endOfTrading > 0 && nowSec >= row.endOfTrading) return "closed";
+  return "open";
+}
+function trueoTradingEndsCopy(row, nowSec = Math.floor(Date.now() / 1e3)) {
+  const when = trueoTradingDeadlineLabel(row.endOfTrading);
+  if (!when) {
+    return trueoMarketStatusLabel(row, nowSec) === "open" ? "Trading end unknown" : "Trading ended";
+  }
+  const remain = trueoTimeUntilTradingEndsLabel(row.endOfTrading, nowSec);
+  return remain && remain !== "ended" ? `Trading ends ${when} \xB7 ${remain}` : `Trading ended ${when}`;
+}
+function trueoResolvedSide(outcome) {
+  if (outcome === 1) return "yes";
+  if (outcome === 2) return "no";
+  return null;
+}
+function statusUpdatedAtLabel(raw) {
+  if (!raw?.trim()) return null;
+  const ms = Date.parse(raw);
+  if (!Number.isFinite(ms)) return null;
+  return trueoTradingDeadlineLabel(Math.floor(ms / 1e3));
+}
+function trueoResolutionCopy(row, nowSec = Math.floor(Date.now() / 1e3)) {
+  const status = Number(row.status);
+  const when = statusUpdatedAtLabel(row.statusUpdatedAt);
+  const side = trueoResolvedSide(row.outcome);
+  const sideWord = side === "yes" ? "Yes" : side === "no" ? "No" : null;
+  if (status === 7) {
+    const who = sideWord ?? "unknown outcome";
+    return when ? `Resolved ${who} \xB7 ${when}` : `Resolved ${who}`;
+  }
+  if (status >= 1 && status < 4) {
+    return when ? `This market is being resolved \xB7 since ${when}` : "This market is being resolved";
+  }
+  if (status >= 4) {
+    if (sideWord) return when ? `Closed ${sideWord} \xB7 ${when}` : `Closed ${sideWord}`;
+    return when ? `Closed without a Yes/No result \xB7 ${when}` : "Closed without a Yes/No result";
+  }
+  if (row.endOfTrading > 0 && nowSec >= row.endOfTrading) {
+    return "This market is being resolved";
+  }
+  return null;
+}
+function isTrueoBetAction(action) {
+  return TRUEO_BET_ACTIONS.includes(action);
+}
+function trueoMarketVotingOpen(row, nowSec = Math.floor(Date.now() / 1e3)) {
+  return trueoBetCreateBlockedReason(row, nowSec) == null;
+}
+function trueoBetCreateBlockedReason(row, nowSec = Math.floor(Date.now() / 1e3)) {
+  const label = trueoMarketStatusLabel(row, nowSec);
+  if (label !== "open") return TRUEO_BET_CLOSE_ERROR;
+  if (row.endOfTrading > 0 && nowSec + TRUEO_BET_CLOSE_BUFFER_SECONDS >= row.endOfTrading) {
+    return TRUEO_BET_CLOSE_ERROR;
+  }
+  return null;
+}
+function trueoBetExecuteBlockedReason(row, nowSec = Math.floor(Date.now() / 1e3)) {
+  const label = trueoMarketStatusLabel(row, nowSec);
+  if (label === "resolved" || label === "closed") return TRUEO_BET_EXPIRED_ERROR;
+  if (row.endOfTrading > 0 && nowSec >= row.endOfTrading) return TRUEO_BET_EXPIRED_ERROR;
+  return null;
+}
+function assertTrueoBetCanCreate(row, nowSec = Math.floor(Date.now() / 1e3)) {
+  const reason = trueoBetCreateBlockedReason(row, nowSec);
+  if (reason) throw new Error(reason);
+}
+function assertTrueoBetCanExecute(row, nowSec = Math.floor(Date.now() / 1e3)) {
+  const reason = trueoBetExecuteBlockedReason(row, nowSec);
+  if (reason) throw new Error(reason);
+}
+async function assertTrueoBetStillOpen(marketAddress) {
+  const row = await fetchTrueoMarket({ marketAddress: getAddress(marketAddress) });
+  assertTrueoBetCanExecute(row);
+  return row;
+}
+function buildTrueoBetExtraJson(args) {
+  return {
+    protocolId: "trueo",
+    trueoAction: args.action,
+    marketAddress: getAddress(args.marketAddress),
+    endOfTrading: args.endOfTrading
+  };
+}
+function parseTrueoBetExtraJson(raw) {
+  let obj = null;
+  if (typeof raw === "string" && raw.trim()) {
+    try {
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        obj = parsed;
+      }
+    } catch {
+      return null;
+    }
+  } else if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+    obj = raw;
+  }
+  if (!obj) return null;
+  if (obj.protocolId !== "trueo") return null;
+  const action = String(obj.trueoAction ?? "");
+  if (!isTrueoBetAction(action)) return null;
+  const marketAddress = String(obj.marketAddress ?? "").trim();
+  if (!marketAddress) return null;
+  const endOfTrading = Number(obj.endOfTrading ?? 0);
+  return {
+    protocolId: "trueo",
+    trueoAction: action,
+    marketAddress,
+    endOfTrading: Number.isFinite(endOfTrading) ? endOfTrading : 0
+  };
+}
+function extraJsonFromSignRequest(detail) {
+  return detail?.ExtraJSON ?? detail?.extraJSON ?? null;
+}
+function defiEvmTransport(rpcUrl, opts) {
+  const url = rpcUrl.trim();
+  return http(url, opts);
+}
+
+// src/protocols/evm/trueo/orderbook.ts
+function publicClient(rpcUrl, chainId) {
+  const chain = defineChain({
+    id: chainId,
+    name: "Base",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpcUrl] } }
+  });
+  return createPublicClient({ chain, transport: defiEvmTransport(rpcUrl) });
+}
+async function readTrueoPoolKeys(args) {
+  const client2 = publicClient(args.rpcUrl, TRUEO_BASE_CHAIN_ID);
+  try {
+    const [yes, no] = await client2.readContract({
+      address: getAddress(args.marketAddress),
+      abi: trueoMarketV2Abi,
+      functionName: "getPoolKeys"
+    });
+    return {
+      yes: {
+        currency0: yes.currency0,
+        currency1: yes.currency1,
+        fee: Number(yes.fee),
+        tickSpacing: Number(yes.tickSpacing),
+        hooks: yes.hooks
+      },
+      no: {
+        currency0: no.currency0,
+        currency1: no.currency1,
+        fee: Number(no.fee),
+        tickSpacing: Number(no.tickSpacing),
+        hooks: no.hooks
+      }
+    };
+  } catch {
+    return null;
+  }
+}
+async function probePendingOrders(args) {
+  const client2 = publicClient(args.rpcUrl, TRUEO_BASE_CHAIN_ID);
+  const levels = [];
+  const ids = [1, 2, 3, 4, 5, 6, 7, 8];
+  const reads = await Promise.all(
+    ids.map(async (orderId) => {
+      try {
+        const order = await client2.readContract({
+          address: TRUEO_ORDER_MANAGER,
+          abi: trueoOrderManagerAbi,
+          functionName: "pendingOrder",
+          args: [args.poolId, orderId]
+        });
+        const [owner, zeroForOne, tickLower, , liquidity] = order;
+        if (!owner || owner === "0x0000000000000000000000000000000000000000") return null;
+        if (liquidity === 0n) return null;
+        return {
+          tick: Number(tickLower),
+          price: null,
+          orderId,
+          owner,
+          zeroForOne: Boolean(zeroForOne)
+        };
+      } catch {
+        return null;
+      }
+    })
+  );
+  for (const row of reads) {
+    if (row) levels.push(row);
+  }
+  return levels;
+}
+function recentTradesFromApi(raw, _side, poolId) {
+  return raw.map((item) => {
+    if (!item || typeof item !== "object") return null;
+    const r = item;
+    const swap = r.v4PoolSwapData && typeof r.v4PoolSwapData === "object" ? r.v4PoolSwapData : null;
+    const tradePool = swap ? String(swap.poolId ?? "").toLowerCase() : "";
+    if (tradePool && tradePool !== poolId.toLowerCase()) return null;
+    return {
+      timestamp: r.timestamp == null ? null : String(r.timestamp),
+      price: swap && typeof swap.price === "number" ? swap.price : null,
+      usdValue: r.usdValue == null ? null : String(r.usdValue),
+      poolId: tradePool || null
+    };
+  }).filter((t) => t != null).slice(0, 12);
+}
+async function fetchTrueoOrderbook(args) {
+  const market = await fetchTrueoMarket({ marketAddress: args.marketAddress });
+  const side = args.side === "no" ? "no" : "yes";
+  const poolId = side === "yes" ? market.yesPoolAddress : market.noPoolAddress;
+  const impliedPrice = side === "yes" ? market.yesPrice : market.noPrice;
+  const currentTick = side === "yes" ? market.yesPoolTick : market.noPoolTick;
+  const txs = await fetchTrueoTransactions({ marketAddress: market.address, limit: 20 }).catch(() => []);
+  let levels = [];
+  if (args.rpcUrl && poolId.startsWith("0x") && poolId.length === 66) {
+    levels = await probePendingOrders({ rpcUrl: args.rpcUrl, poolId });
+  }
+  return {
+    marketAddress: market.address,
+    side,
+    poolId,
+    currentTick,
+    impliedPrice,
+    impliedPriceLabel: side === "yes" ? market.yesPriceLabel : market.noPriceLabel,
+    levels,
+    recentTrades: recentTradesFromApi(txs, side, poolId),
+    notes: levels.length ? "On-chain OrderManager pending orders plus recent pool trades." : "Depth from live tick / implied price and recent pool trades. Pending OrderManager rows are included when rpcUrl can read them."
+  };
+}
+async function trueoFetchOrderbookSummary(input) {
+  return fetchTrueoOrderbook(input);
+}
+function outcomeTokensFromMarkets(markets) {
+  const out = /* @__PURE__ */ new Set();
+  for (const m of markets) {
+    if (m.yesTokenAddress) out.add(m.yesTokenAddress.toLowerCase());
+    if (m.noTokenAddress) out.add(m.noTokenAddress.toLowerCase());
+  }
+  return [...out];
+}
+function isTrueoOutcomeTokenLabel(symbol, name) {
+  const s = (symbol ?? "").trim().toUpperCase();
+  if (s === "YES" || s === "NO") return true;
+  const n = (name ?? "").trim().toLowerCase();
+  return n.startsWith("trueo yes") || n.startsWith("trueo no");
+}
+function clipQuestion(question) {
+  const t = (question ?? "").trim();
+  if (!t) return "Trueo market";
+  return t.length <= 48 ? t : `${t.slice(0, 45).trim()}\u2026`;
+}
+function outcomeToken(address, kind, question) {
+  const label = clipQuestion(question);
+  const side = kind === "no" ? "No" : "Yes";
+  return {
+    address: getAddress(address),
+    name: `Trueo ${side} \u2014 ${label}`,
+    symbol: kind === "no" ? "NO" : "YES",
+    decimals: TRUEO_OUTCOME_TOKEN_DECIMALS,
+    kind
+  };
+}
+function suggestTrueoTokensToAdd(args) {
+  const tyd = {
+    address: TRUEO_TYD,
+    name: "True Yield Dollar",
+    symbol: "TYD",
+    decimals: TRUEO_TYD_DECIMALS,
+    kind: "tyd"
+  };
+  const usdc = {
+    address: TRUEO_USDC,
+    name: "USD Coin",
+    symbol: "USDC",
+    decimals: 6,
+    kind: "usdc"
+  };
+  if (args.action === "wrapTyd") return [tyd];
+  if (args.action === "unwrapTyd") return [usdc];
+  if (!args.market) return [];
+  try {
+    const yes = outcomeToken(args.market.yesTokenAddress, "yes", args.market.question);
+    const no = outcomeToken(args.market.noTokenAddress, "no", args.market.question);
+    switch (args.action) {
+      case "swap":
+      case "createOrder":
+        return [args.side === "no" ? no : yes];
+      case "mint":
+        return [yes, no];
+      case "burn":
+      case "redeem":
+        return [tyd];
+      default:
+        return [];
+    }
+  } catch {
+    return [];
+  }
+}
+
+// src/protocols/evm/hyperliquid/support.ts
+var HYPERLIQUID_SUPPORTED_CHAIN_IDS = [999, 998];
+function isHyperliquidChainSupported(chainId) {
+  return HYPERLIQUID_SUPPORTED_CHAIN_IDS.includes(chainId);
+}
+function hyperliquidApiBaseUrl(chainId) {
+  return chainId === 998 ? "https://api.hyperliquid-testnet.xyz" : "https://api.hyperliquid.xyz";
+}
+
+// src/protocols/evm/hyperliquidOutcome/model.ts
+function outcomeEncoding(outcome, side) {
+  const o = Math.trunc(outcome);
+  const s = Math.trunc(side);
+  if (!Number.isFinite(o) || o < 0) throw new Error("outcome must be a non-negative integer");
+  if (s !== 0 && s !== 1) throw new Error("side must be 0 or 1");
+  return 10 * o + s;
+}
+function outcomeTradeCoin(encoding) {
+  return `#${encoding}`;
+}
+function outcomeBalanceCoin(encoding) {
+  return `+${encoding}`;
+}
+function outcomeAssetId(encoding) {
+  return 1e8 + encoding;
+}
+function outcomeSideName(name, fallback) {
+  const raw = (name ?? "").trim();
+  const stripped = raw.replace(/^template:/i, "").trim();
+  return stripped || fallback;
+}
+function parseHyperliquidPipeFields(description) {
+  const out = {};
+  for (const part of (description ?? "").split("|")) {
+    const i = part.indexOf(":");
+    if (i <= 0) continue;
+    const key = part.slice(0, i).trim();
+    const value = part.slice(i + 1).trim();
+    if (key && value) out[key] = value;
+  }
+  return out;
+}
+function parseHyperliquidStamp(raw) {
+  const m = /^(\d{4})(\d{2})(\d{2})-(\d{2})(\d{2})$/.exec((raw ?? "").trim());
+  if (!m) return null;
+  const ms = Date.parse(`${m[1]}-${m[2]}-${m[3]}T${m[4]}:${m[5]}:00Z`);
+  return Number.isFinite(ms) ? Math.floor(ms / 1e3) : null;
+}
+function formatHyperliquidStamp(unixSec) {
+  if (unixSec == null || !Number.isFinite(unixSec) || unixSec <= 0) return null;
+  const d = new Date(unixSec * 1e3);
+  if (Number.isNaN(d.getTime())) return null;
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())} ${pad(d.getUTCHours())}:${pad(d.getUTCMinutes())} UTC`;
+}
+function questionForOutcome(outcomeId, questions) {
+  for (const q of questions) {
+    if (q.fallbackOutcome === outcomeId) return q;
+    if ((q.namedOutcomes ?? []).includes(outcomeId)) return q;
+  }
+  return void 0;
+}
+function formatOutcomeQuestion(outcome, question) {
+  const fields = parseHyperliquidPipeFields(outcome.description);
+  const qFields = parseHyperliquidPipeFields(question?.description);
+  const when = formatHyperliquidStamp(
+    parseHyperliquidStamp(fields.time) ?? parseHyperliquidStamp(qFields.resolutionDeadline)
+  );
+  const whenSuffix = when ? ` at ${when}` : "";
+  if (outcome.name === "template:binaryPrice") {
+    const asset = fields.priceDescription || fields.perp || "the asset";
+    const threshold = fields.threshold ?? "";
+    return `Will ${asset} be above ${threshold}${whenSuffix}?`.replace(/\s+/g, " ").trim();
+  }
+  if (outcome.name === "template:priceTouch") {
+    const asset = fields.priceDescription || fields.perp || "the asset";
+    const target = fields.target ?? "";
+    return `Will ${asset} touch ${target}${when ? ` by ${when}` : ""}?`.replace(/\s+/g, " ").trim();
+  }
+  if (outcome.name === "template:sportsTournamentParticipant") {
+    const participant = fields.participant || "this participant";
+    const competition = qFields.competition;
+    return competition ? `Will ${participant} win ${competition}?` : `Will ${participant} win?`;
+  }
+  const desc = (outcome.description ?? "").trim();
+  if (desc && desc !== "other") return desc;
+  return outcome.name || `Outcome ${outcome.outcome}`;
+}
+var STAMP_FIELDS = /* @__PURE__ */ new Set([
+  "time",
+  "dateTime",
+  "resolutionDeadline",
+  "scheduledStart",
+  "scheduledDecision",
+  "expiry",
+  "decisionDeadline"
+]);
+function outcomeTemplateId(name) {
+  return (name ?? "").replace(/^template:/, "").trim();
+}
+function outcomeFieldMap(outcome, question) {
+  return {
+    ...parseHyperliquidPipeFields(question?.description),
+    ...parseHyperliquidPipeFields(outcome.description)
+  };
+}
+function displayField(key, raw) {
+  if (STAMP_FIELDS.has(key)) {
+    const formatted = formatHyperliquidStamp(parseHyperliquidStamp(raw));
+    if (formatted) return formatted;
+  }
+  return raw.trim();
+}
+function fillOutcomeTemplate(text, fields) {
+  return text.replace(/\{([A-Za-z0-9_]+)\}/g, (token, key) => {
+    const raw = fields[key];
+    if (raw == null || !raw.trim()) return token;
+    return displayField(key, raw);
+  });
+}
+function stripTemplateMetadata(text) {
+  return (text.split(/\smetadata=/)[0] ?? text).replace(/\bprice price\b/g, "price").trim();
+}
+function templateById(templates, id) {
+  return templates?.find((template) => template.id === id);
+}
+function parentTemplateId(template) {
+  const role = template?.role;
+  if (!role || typeof role !== "object") return null;
+  const parent = role.questionOutcome?.parent?.trim();
+  return parent || null;
+}
+function resolveOutcomeSideLabel(specName, fields, fallback) {
+  const raw = outcomeSideName(specName, fallback);
+  const filled = fillOutcomeTemplate(raw, fields).trim();
+  return filled || fallback;
+}
+function recurringRules(outcome, fields) {
+  const when = fields.expiry ? displayField("expiry", fields.expiry) : "expiry";
+  const asset = fields.underlying || "the asset";
+  if (outcome.name === "Recurring" && fields.class === "priceBinary") {
+    const period = fields.period ? ` Period ${fields.period}.` : "";
+    return `Yes if the ${asset} HyperCore mark at ${when} is at or above ${fields.targetPrice ?? "\u2014"}. Otherwise No. The mark is the linear interpolation of the HyperCore mark updates immediately before and after that time.${period}`;
+  }
+  if (outcome.name === "Recurring Fallback") {
+    return `Yes if none of the named ${asset} price buckets contain the mark at ${when}. Otherwise No. Thresholds: ${fields.priceThresholds || "\u2014"}.`;
+  }
+  if (outcome.name === "Recurring Named Outcome") {
+    return `Yes if bucket ${fields.index ?? "\u2014"} is the ${asset} price range that contains the interpolated HyperCore mark at ${when}. Otherwise No. Thresholds: ${fields.priceThresholds || "\u2014"}.`;
+  }
+  return null;
+}
+function fallbackRules(outcome, fields) {
+  const id = outcomeTemplateId(outcome.name);
+  const when = fields.time ? displayField("time", fields.time) : "the settlement time";
+  const feed = fields.priceDescription || fields.perp || "the price";
+  if (id === "binaryPrice") {
+    const twap = fields.seconds ? ` Settlement uses the ${fields.seconds}-second TWAP of ${feed} ending at ${when}.` : "";
+    return `Yes if the ${fields.perp || feed} price is above ${fields.threshold ?? "\u2014"} at ${when}. Otherwise No.${twap}`.replace(
+      /\bprice price\b/g,
+      "price"
+    );
+  }
+  if (id === "priceTouch") {
+    return `Yes if the ${fields.perp || feed} price touches ${fields.target ?? "\u2014"} at or before ${when}. Otherwise No. A touch is the ${fields.seconds || "\u2014"}-second TWAP of ${feed} equaling or crossing the target.`;
+  }
+  if (id === "companyIpoConfirmed") {
+    const at = fields.dateTime ? displayField("dateTime", fields.dateTime) : "the deadline";
+    return `Yes if ${fields.company || "the company"}'s first public listing is confirmed at or before ${at}. Otherwise No.`;
+  }
+  if (id === "sportsTournamentParticipant" || id === "sportsContestParticipant2") {
+    return `Yes if ${fields.participant || "this participant"} is the sole winner. Otherwise No.`;
+  }
+  if (id === "sportsContestDraw2") return "Yes if the contest is a draw. Otherwise No.";
+  if (id === "policyRateNoChange") return "Yes if the announced policy value equals the prior value. Otherwise No.";
+  if (id === "policyRateDecrease") return "Yes if the announced policy value is lower than the prior value. Otherwise No.";
+  if (id === "policyRateIncrease") return "Yes if the announced policy value is higher than the prior value. Otherwise No.";
+  if (id === "sportsContestWinner") {
+    const a = fields.shortNameA || fields.participantA || "Side A";
+    const b = fields.shortNameB || fields.participantB || "Side B";
+    return `${a} wins if ${fields.participantA || a} wins the contest. ${b} wins if ${fields.participantB || b} wins. Counted play: ${fields.countedPlay || "the scheduled contest"}.`;
+  }
+  return "";
+}
+function formatOutcomeRules(outcome, question, templates) {
+  const fields = outcomeFieldMap(outcome, question);
+  const recurring = recurringRules(outcome, fields);
+  if (recurring) return recurring;
+  const template = templateById(templates, outcomeTemplateId(outcome.name));
+  const ownRaw = template?.description?.trim();
+  const own = ownRaw ? stripTemplateMetadata(fillOutcomeTemplate(ownRaw, fields)) : fallbackRules(outcome, fields);
+  const parentRaw = templateById(templates, parentTemplateId(template) ?? "")?.description?.trim();
+  const parent = parentRaw ? stripTemplateMetadata(fillOutcomeTemplate(parentRaw, fields)) : "";
+  if (own && parent) return `${own}
+
+${parent}`;
+  return own;
+}
+function outcomeExpiryUnix(outcome, question) {
+  const fields = parseHyperliquidPipeFields(outcome.description);
+  const qFields = parseHyperliquidPipeFields(question?.description);
+  return parseHyperliquidStamp(fields.time) ?? parseHyperliquidStamp(qFields.resolutionDeadline) ?? 0;
+}
+
+// src/protocols/evm/hyperliquidOutcome/api.ts
+var HYPERLIQUID_OUTCOME_MAINNET_CHAIN_ID = 999;
+var META_TTL_MS = 15e3;
+var metaCache = /* @__PURE__ */ new Map();
+function outcomeFetchFailure(error) {
+  if (!(error instanceof Error)) return "request failed";
+  const cause = error.cause;
+  if (cause instanceof Error && cause.message.trim()) return cause.message;
+  return error.message;
+}
+function outcomeErrorCode(error) {
+  if (!error || typeof error !== "object") return "";
+  if ("code" in error && error.code != null) return String(error.code);
+  if (error instanceof Error && error.cause && typeof error.cause === "object" && "code" in error.cause) {
+    return String(error.cause.code ?? "");
+  }
+  return "";
+}
+var OUTCOME_RETRYABLE_CODES = /* @__PURE__ */ new Set([
+  "UND_ERR_CONNECT_TIMEOUT",
+  "UND_ERR_CONNECT",
+  "ECONNRESET",
+  "ECONNREFUSED",
+  "ETIMEDOUT",
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "EPIPE"
+]);
+function outcomeFetchRetryable(error) {
+  if (error && typeof error === "object" && "outcomeFinal" in error) return false;
+  const code = outcomeErrorCode(error);
+  return OUTCOME_RETRYABLE_CODES.has(code) || error instanceof Error && (error.message === "fetch failed" || error.message === "connect timeout");
+}
+var outcomeHttpsAgent = null;
+async function outcomeNodeModules() {
+  const importer = new Function("specifier", "return import(specifier)");
+  const [http2, https] = await Promise.all([importer("node:http"), importer("node:https")]);
+  return { http: http2, https };
+}
+async function outcomeNodePost(urlString, payload) {
+  const { http: http2, https } = await outcomeNodeModules();
+  if (!outcomeHttpsAgent) {
+    outcomeHttpsAgent = new https.Agent({ keepAlive: true, maxSockets: 4, timeout: 2e4 });
+  }
+  const url = new URL(urlString);
+  const lib = url.protocol === "http:" ? http2 : https;
+  return new Promise((resolve, reject) => {
+    const req = lib.request(
+      {
+        protocol: url.protocol,
+        hostname: url.hostname,
+        port: url.port || void 0,
+        path: `${url.pathname}${url.search}`,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(payload)
+        },
+        agent: url.protocol === "https:" ? outcomeHttpsAgent ?? void 0 : void 0,
+        timeout: 2e4
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(chunk));
+        res.on("end", () => {
+          resolve({ status: res.statusCode ?? 0, text: Buffer.concat(chunks).toString("utf8") });
+        });
+      }
+    );
+    req.on("timeout", () => {
+      const error = new Error("connect timeout");
+      error.code = "ETIMEDOUT";
+      req.destroy(error);
+    });
+    req.on("error", reject);
+    req.write(payload);
+    req.end();
+  });
+}
+async function outcomeFetchPost(url, payload) {
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: payload,
+    cache: "no-store"
+  });
+  return { status: res.status, text: await res.text() };
+}
+async function outcomeInfoPost(chainId, body) {
+  if (!isHyperliquidChainSupported(chainId)) {
+    throw new Error(`Hyperliquid outcome markets require chainId 999 or 998 (got ${chainId}).`);
+  }
+  const url = `${hyperliquidApiBaseUrl(chainId)}/info`;
+  const payload = JSON.stringify(body);
+  let last;
+  for (let attempt = 0; attempt < 3; attempt++) {
+    try {
+      const res = typeof window !== "undefined" || process.env.VITEST ? await outcomeFetchPost(url, payload) : await outcomeNodePost(url, payload);
+      if (res.status < 200 || res.status >= 300) {
+        const error = new Error(`Hyperliquid info API failed (${res.status}): ${res.text.slice(0, 200)}`);
+        if (res.status !== 429 && res.status !== 502 && res.status !== 503 && res.status !== 504) {
+          error.outcomeFinal = true;
+        }
+        throw error;
+      }
+      return JSON.parse(res.text);
+    } catch (error) {
+      last = error;
+      if (!outcomeFetchRetryable(error) || attempt === 2) break;
+      await new Promise((resolve) => setTimeout(resolve, 250 * (attempt + 1)));
+    }
+  }
+  throw new Error(`Hyperliquid info API failed: ${outcomeFetchFailure(last)}`);
+}
+function priceNumber(raw) {
+  if (raw == null || raw === "") return null;
+  const n = Number.parseFloat(raw);
+  return Number.isFinite(n) ? n : null;
+}
+function priceLabel(n) {
+  if (n == null) return null;
+  if (n >= 0 && n <= 1) return `${(n * 100).toFixed(1)}%`;
+  return String(n);
+}
+function marketFromMeta(outcome, question, mids, nowSec, templates) {
+  const fields = outcomeFieldMap(outcome, question);
+  const yesEncoding = outcomeEncoding(outcome.outcome, 0);
+  const noEncoding = outcomeEncoding(outcome.outcome, 1);
+  const yesCoin = outcomeTradeCoin(yesEncoding);
+  const noCoin = outcomeTradeCoin(noEncoding);
+  const yesPrice = priceNumber(mids[yesCoin]);
+  const noPrice = priceNumber(mids[noCoin]);
+  const endOfTrading = outcomeExpiryUnix(outcome, question);
+  const closed = endOfTrading > 0 && nowSec >= endOfTrading;
+  const template = outcome.name.replace(/^template:/, "");
+  const categories = [template, outcome.venue].filter((v) => Boolean(v && v.trim()));
+  return {
+    outcome: outcome.outcome,
+    name: outcome.name,
+    description: outcome.description,
+    question: formatOutcomeQuestion(outcome, question),
+    questionId: question?.question ?? null,
+    sideNames: [
+      resolveOutcomeSideLabel(outcome.sideSpecs?.[0]?.name, fields, "Yes"),
+      resolveOutcomeSideLabel(outcome.sideSpecs?.[1]?.name, fields, "No")
+    ],
+    quoteToken: outcome.quoteToken?.trim() || "USDC",
+    venue: outcome.venue ?? "",
+    categories,
+    yesEncoding,
+    noEncoding,
+    yesCoin,
+    noCoin,
+    yesAssetId: outcomeAssetId(yesEncoding),
+    noAssetId: outcomeAssetId(noEncoding),
+    yesBalanceCoin: outcomeBalanceCoin(yesEncoding),
+    noBalanceCoin: outcomeBalanceCoin(noEncoding),
+    yesPrice,
+    noPrice,
+    yesPriceLabel: priceLabel(yesPrice),
+    noPriceLabel: priceLabel(noPrice),
+    expiresAt: formatHyperliquidStamp(endOfTrading > 0 ? endOfTrading : null),
+    endOfTrading,
+    status: closed ? "closed" : "live",
+    tradable: !closed,
+    rules: formatOutcomeRules(outcome, question, templates)
+  };
+}
+async function loadOutcomeSnapshot(chainId) {
+  const hit = metaCache.get(chainId);
+  if (hit && Date.now() - hit.at < META_TTL_MS) {
+    return {
+      outcomes: hit.data.outcomes ?? [],
+      questions: hit.data.questions ?? [],
+      mids: hit.mids,
+      templates: hit.templates
+    };
+  }
+  const meta = await outcomeInfoPost(chainId, { type: "outcomeMeta" });
+  let mids = {};
+  try {
+    mids = await outcomeInfoPost(chainId, { type: "allMids" });
+  } catch {
+    mids = {};
+  }
+  let templates = [];
+  try {
+    const raw = await outcomeInfoPost(chainId, { type: "outcomeTemplates" });
+    templates = Array.isArray(raw) ? raw : [];
+  } catch {
+    templates = [];
+  }
+  metaCache.set(chainId, { at: Date.now(), data: meta, mids, templates });
+  return { outcomes: meta.outcomes ?? [], questions: meta.questions ?? [], mids, templates };
+}
+function hyperliquidOutcomeMatchesQuery(market, query) {
+  const q = query.trim().toLowerCase();
+  if (!q) return true;
+  const hay = [market.question, market.description, market.name, market.sideNames.join(" "), String(market.outcome)].join(" ").toLowerCase();
+  return hay.includes(q);
+}
+async function listHyperliquidOutcomeMarkets(args) {
+  const chainId = args.chainId ?? HYPERLIQUID_OUTCOME_MAINNET_CHAIN_ID;
+  const snap = await loadOutcomeSnapshot(chainId);
+  const nowSec = Math.floor(Date.now() / 1e3);
+  const markets = snap.outcomes.map(
+    (outcome) => marketFromMeta(
+      outcome,
+      questionForOutcome(outcome.outcome, snap.questions),
+      snap.mids,
+      nowSec,
+      snap.templates
+    )
+  ).filter((market) => hyperliquidOutcomeMatchesQuery(market, args.query ?? ""));
+  return { markets, questions: snap.questions };
+}
+async function getHyperliquidOutcomeMarket(args) {
+  const { markets } = await listHyperliquidOutcomeMarkets({ chainId: args.chainId });
+  const found = markets.find((m) => m.outcome === args.outcomeId);
+  if (!found) throw new Error(`Hyperliquid outcome ${args.outcomeId} is not in outcomeMeta.`);
+  return found;
+}
+function normalizeLevels(rows) {
+  return (rows ?? []).map((row) => ({
+    px: String(row.px ?? ""),
+    sz: String(row.sz ?? ""),
+    n: Number(row.n ?? 0)
+  }));
+}
+var CHANCE_LOOKBACK_MS = 14 * 24 * 60 * 60 * 1e3;
+async function fetchHyperliquidOutcomeChanceSeries(args) {
+  const chainId = args.chainId ?? HYPERLIQUID_OUTCOME_MAINNET_CHAIN_ID;
+  const endTime = Date.now();
+  const raw = await outcomeInfoPost(chainId, {
+    type: "candleSnapshot",
+    req: {
+      coin: args.coin,
+      interval: "1h",
+      startTime: endTime - CHANCE_LOOKBACK_MS,
+      endTime
+    }
+  });
+  if (!Array.isArray(raw)) return [];
+  return raw.map((bar) => {
+    const timestamp = Number(bar.t);
+    const open = Number(bar.o);
+    const high = Number(bar.h);
+    const low = Number(bar.l);
+    const close = Number(bar.c);
+    if (![timestamp, open, high, low, close].every(Number.isFinite)) return null;
+    return { timestamp, open, high, low, close };
+  }).filter((bar) => bar != null);
+}
+async function fetchHyperliquidOutcomeBook(args) {
+  const chainId = args.chainId ?? HYPERLIQUID_OUTCOME_MAINNET_CHAIN_ID;
+  const raw = await outcomeInfoPost(chainId, { type: "l2Book", coin: args.coin });
+  if (raw == null || typeof raw !== "object") {
+    return { coin: args.coin, time: null, bids: [], asks: [] };
+  }
+  return {
+    coin: raw.coin ?? args.coin,
+    time: typeof raw.time === "number" ? raw.time : null,
+    bids: normalizeLevels(raw.levels?.[0]),
+    asks: normalizeLevels(raw.levels?.[1])
+  };
+}
+
+// src/protocols/evm/hyperliquidOutcome/mcpSummaries.ts
+function hyperliquidOutcomeToPredictionFields(market, chainId) {
+  return {
+    venue: "hyperliquid",
+    venueMarketId: String(market.outcome),
+    question: market.question,
+    categories: market.categories,
+    yesPrice: market.yesPrice,
+    noPrice: market.noPrice,
+    yesPriceLabel: market.yesPriceLabel,
+    noPriceLabel: market.noPriceLabel,
+    volume: "\u2014",
+    tvl: null,
+    expiresAt: market.expiresAt,
+    expiresAtLabel: market.expiresAt,
+    tradingEndsLabel: market.expiresAt ? `Settles ${market.expiresAt}` : "Settlement time not listed",
+    endOfTrading: market.endOfTrading,
+    status: market.status,
+    outcome: market.outcome,
+    statusUpdatedAt: null,
+    resolutionLabel: null,
+    chainId,
+    paymentSymbol: market.quoteToken,
+    tradable: market.tradable,
+    rules: market.rules,
+    source: market.name
+  };
+}
+
+// src/protocols/evm/trueo/predictionSearch.ts
+var PREDICTION_MARKET_V1_KIND = "continuum/prediction-market/v1";
+function trueoMarketToPredictionRow(row) {
+  const status = trueoMarketStatusLabel(row);
+  return {
+    venue: "trueo",
+    venueMarketId: row.address,
+    question: row.question,
+    categories: row.categories,
+    yesPrice: row.yesPrice,
+    noPrice: row.noPrice,
+    yesPriceLabel: row.yesPriceLabel,
+    noPriceLabel: row.noPriceLabel,
+    volume: trueoCompactVolumeLabel(row.size),
+    tvl: row.tvl,
+    expiresAt: row.expiresAt,
+    expiresAtLabel: row.expiresAtLabel,
+    tradingEndsLabel: trueoTradingEndsCopy(row),
+    endOfTrading: row.endOfTrading,
+    status,
+    outcome: row.outcome,
+    statusUpdatedAt: row.statusUpdatedAt,
+    resolutionLabel: trueoResolutionCopy(row),
+    chainId: row.chainId,
+    paymentSymbol: row.paymentTokenSymbol,
+    tradable: trueoMarketVotingOpen(row),
+    rules: row.rules,
+    source: row.source,
+    imageUrl: row.imageUrl
+  };
+}
+async function searchPredictionMarkets(args) {
+  const venues = (args.venues ?? ["trueo", "hyperliquid"]).map((v) => v.trim().toLowerCase()).filter(Boolean);
+  const wantTrueo = venues.includes("trueo");
+  const wantHl = venues.includes("hyperliquid");
+  if (!wantTrueo && !wantHl) {
+    return {
+      markets: [],
+      notes: "No supported venues in the filter. Use trueo and/or hyperliquid.",
+      hasMore: false,
+      includeAll: false,
+      nextOffset: 0,
+      nextIndexBase: 0
+    };
+  }
+  const includeAll = args.includeAll === true;
+  const offset = Math.max(args.offset ?? 0, 0);
+  const indexBase = Math.max(args.indexBase ?? 0, 0);
+  const limit = args.limit ?? TRUEO_MARKET_PAGE_SIZE;
+  const exclude = new Set((args.excludeAddresses ?? []).map((id) => id.trim().toLowerCase()).filter(Boolean));
+  let hlAll = [];
+  let hlError = "";
+  if (wantHl) {
+    try {
+      const listed = await listHyperliquidOutcomeMarkets({ query: args.query });
+      hlAll = listed.markets.map((market) => hyperliquidOutcomeToPredictionFields(market, HYPERLIQUID_OUTCOME_MAINNET_CHAIN_ID)).filter((row) => !exclude.has(row.venueMarketId.toLowerCase()));
+    } catch (error) {
+      hlError = error instanceof Error ? error.message : "Hyperliquid outcome search failed.";
+    }
+  }
+  if (!wantTrueo) {
+    const page2 = hlAll.slice(offset, offset + limit).map((row, i) => ({ ...row, index: indexBase + i + 1 }));
+    const nextOffset = offset + page2.length;
+    const nextIndexBase2 = indexBase + page2.length;
+    const more2 = nextOffset < hlAll.length;
+    return {
+      markets: page2,
+      hasMore: more2,
+      nextOffset,
+      nextIndexBase: nextIndexBase2,
+      includeAll: false,
+      notes: hlError ? hlError : page2.length ? `Hyperliquid outcome markets. ${more2 ? `More: offset=${nextOffset}, indexBase=${nextIndexBase2}.` : "End of results."} Pick #N then get_prediction_market with venue hyperliquid.` : `No Hyperliquid outcome title match for ${JSON.stringify(args.query?.trim() ?? "")}.`
+    };
+  }
+  const hlPrefix = offset === 0 ? hlAll.slice(0, limit) : [];
+  const page = await listTrueoMarketsPage({
+    query: args.query,
+    category: args.category,
+    offset,
+    includeAll,
+    trending: args.trending,
+    excludeAddresses: args.excludeAddresses
+  });
+  const trueoRows = page.markets.map(trueoMarketToPredictionRow).filter((row) => !exclude.has(row.venueMarketId.toLowerCase())).slice(0, limit);
+  const markets = [...hlPrefix, ...trueoRows].map((row, i) => ({ ...row, index: indexBase + i + 1 }));
+  const nextIndexBase = indexBase + markets.length;
+  const scope = trueoSearchScopeNote(includeAll);
+  const q = args.query?.trim() ?? "";
+  const hlNote = hlPrefix.length > 0 ? `Included ${hlPrefix.length} Hyperliquid outcome match(es) on this page (venue hyperliquid).` : hlError;
+  if (q && markets.length === 0) {
+    return {
+      markets,
+      hasMore: page.hasMore,
+      nextOffset: page.nextOffset,
+      nextIndexBase,
+      includeAll,
+      notes: `No live or recent title match for ${JSON.stringify(q)} after scanning Trueo${wantHl ? " and Hyperliquid" : ""}. Do not list trending unless the operator asked. ${scope} ${hlError}`.trim()
+    };
+  }
+  const more = page.hasMore ? `More Trueo: search_prediction_markets with offset=${page.nextOffset}, trending=false, indexBase=${nextIndexBase}, excludeAddresses from this page's venueMarketIds.` : "End of Trueo results.";
+  return {
+    markets,
+    hasMore: page.hasMore,
+    nextOffset: page.nextOffset,
+    nextIndexBase,
+    includeAll,
+    notes: `${hlNote} ${scope} ${more} Pick #N then get_prediction_market.`.replace(/\s+/g, " ").trim()
+  };
+}
+function buildPredictionMarketEnvelope(market) {
+  return { kind: PREDICTION_MARKET_V1_KIND, market };
+}
+async function searchPredictionMarketsSummary(input) {
+  return searchPredictionMarkets(input);
+}
+function trueoHoldingTokenAddressesFromRegistry(tokens) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const t of tokens) {
+    const addr = String(t.contractAddress ?? "").trim().toLowerCase();
+    if (!addr || seen.has(addr)) continue;
+    if (!isTrueoOutcomeTokenLabel(t.symbol, t.name)) continue;
+    seen.add(addr);
+    out.push(addr);
+  }
+  return out;
+}
+async function listPredictionMarketsForHoldings(args) {
+  const marketIds = new Set(
+    (args.marketAddresses ?? []).map((a) => a.trim().toLowerCase()).filter((a) => a.startsWith("0x"))
+  );
+  const tokens = (args.tokenAddresses ?? []).map((a) => a.trim().toLowerCase()).filter((a) => a.startsWith("0x"));
+  for (const token of tokens) {
+    try {
+      const page = await searchTrueoMarketsPage({
+        query: token,
+        includeAll: true,
+        limit: TRUEO_MARKET_PAGE_SIZE
+      });
+      for (const row of page.markets) {
+        if (row.yesTokenAddress === token || row.noTokenAddress === token || row.address === token) {
+          marketIds.add(row.address);
+        }
+      }
+    } catch {
+    }
+  }
+  const markets = [];
+  let i = 0;
+  for (const id of marketIds) {
+    try {
+      const row = await fetchTrueoMarket({ marketAddress: id });
+      markets.push({ ...trueoMarketToPredictionRow(row), index: ++i });
+    } catch {
+    }
+  }
+  const notes = markets.length === 0 ? "No matching holdings. Pass YES/NO token addresses from get_token_registry (or add_to_token_registry after a bet) and/or marketAddresses from prior bets." : `Live status for ${markets.length} market(s) you hold or named. Pick #N then get_prediction_market.`;
+  return {
+    markets,
+    notes,
+    hasMore: false,
+    nextOffset: 0,
+    nextIndexBase: markets.length,
+    includeAll: true
+  };
+}
+async function listMyPredictionMarketsSummary(input) {
+  return listPredictionMarketsForHoldings(input);
+}
+async function getPredictionMarketSummary(input) {
+  const venue = (input.venue ?? "trueo").trim().toLowerCase();
+  if (venue === "hyperliquid") {
+    const outcomeId = Number.parseInt(input.venueMarketId, 10);
+    if (!Number.isFinite(outcomeId)) {
+      throw new Error("Hyperliquid venueMarketId must be the outcome id.");
+    }
+    const market2 = await getHyperliquidOutcomeMarket({ outcomeId });
+    const [yesBook, noBook] = await Promise.all([
+      fetchHyperliquidOutcomeBook({ coin: market2.yesCoin }),
+      fetchHyperliquidOutcomeBook({ coin: market2.noCoin })
+    ]);
+    let ohlc2 = [];
+    try {
+      ohlc2 = await fetchHyperliquidOutcomeChanceSeries({ coin: market2.yesCoin });
+    } catch {
+      ohlc2 = [];
+    }
+    const row2 = {
+      ...hyperliquidOutcomeToPredictionFields(market2, HYPERLIQUID_OUTCOME_MAINNET_CHAIN_ID),
+      yesBook,
+      noBook,
+      ohlc: ohlc2
+    };
+    return {
+      kind: PREDICTION_MARKET_V1_KIND,
+      ...row2,
+      envelope: buildPredictionMarketEnvelope(row2)
+    };
+  }
+  if (venue !== "trueo") {
+    throw new Error(`Venue "${venue}" is not supported. Use trueo or hyperliquid.`);
+  }
+  const row = await fetchTrueoMarket({ marketAddress: input.venueMarketId });
+  let ohlc = [];
+  let orderbook = null;
+  try {
+    ohlc = await fetchTrueoChanceSeries({
+      poolId: row.yesPoolAddress
+    });
+  } catch {
+    ohlc = [];
+  }
+  try {
+    orderbook = await fetchTrueoOrderbook({ marketAddress: row.address, side: "yes" });
+  } catch {
+    orderbook = null;
+  }
+  const market = {
+    ...trueoMarketToPredictionRow(row),
+    rules: row.rules,
+    source: row.source,
+    yesTokenAddress: row.yesTokenAddress,
+    noTokenAddress: row.noTokenAddress,
+    yesPoolAddress: row.yesPoolAddress,
+    noPoolAddress: row.noPoolAddress,
+    paymentTokenAddress: row.paymentTokenAddress,
+    endOfTrading: row.endOfTrading,
+    ohlc,
+    orderbook
+  };
+  return {
+    kind: PREDICTION_MARKET_V1_KIND,
+    ...market,
+    envelope: buildPredictionMarketEnvelope(market)
+  };
+}
+
+// src/protocols/evm/trueo/purpose.ts
+function buildTrueoPurposePrefill(args) {
+  const chainId = args.chainId ?? TRUEO_BASE_CHAIN_ID;
+  const q = args.question?.trim() ? ` on ${args.question.trim()}` : "";
+  const amt = args.amountHuman?.trim() ?? "";
+  const sym = args.paymentSymbol?.trim() || "TYD";
+  const side = args.side === "no" ? "No" : "Yes";
+  switch (args.action) {
+    case "wrapTyd":
+      return `Trueo: mint ${amt || ""} TYD from USDC on Base (chainId ${chainId})`.replace(/\s+/g, " ").trim();
+    case "unwrapTyd":
+      return `Trueo: unwrap ${amt || ""} TYD to USDC on Base (chainId ${chainId})`.replace(/\s+/g, " ").trim();
+    case "mint":
+      return `Trueo: mint ${amt || "YES+NO"} ${sym}${q} on Base (chainId ${chainId})`;
+    case "burn":
+      return `Trueo: burn ${amt || "YES+NO"}${q} on Base (chainId ${chainId})`;
+    case "redeem":
+      return `Trueo: redeem ${amt || "winning tokens"}${q} on Base (chainId ${chainId})`;
+    case "swap":
+      return `Trueo: buy ${side} ${amt || ""} ${sym}${q} on Base (chainId ${chainId})`.replace(/\s+/g, " ").trim();
+    case "createOrder":
+      return `Trueo: limit ${side} ${amt || ""} ${sym}${q} on Base (chainId ${chainId})`.replace(/\s+/g, " ").trim();
+    case "cancelOrder":
+      return `Trueo: cancel order${q} on Base (chainId ${chainId})`;
+    default:
+      return `Trueo${q} on Base (chainId ${chainId})`;
+  }
+}
+
+// src/core/expiry.ts
+var DEFAULT_DEFI_MULTISIGN_EXPIRY_SECONDS = 30 * 60;
+var DEFI_PROTOCOLS_WITH_30MIN_EXPIRY = /* @__PURE__ */ new Set([
+  "uniswap-v4",
+  "gmx",
+  "hyperliquid",
+  "arcus",
+  "curve-dao",
+  "aerodrome",
+  "pendle",
+  "derive",
+  "trueo",
+  "hyperliquidOutcome"
+]);
+function defiMultisignExpiryUnixSeconds(protocolId, explicitExpiryDate) {
+  if (typeof explicitExpiryDate === "number" && Number.isFinite(explicitExpiryDate) && explicitExpiryDate > 0) {
+    return Math.floor(explicitExpiryDate);
+  }
+  if (DEFI_PROTOCOLS_WITH_30MIN_EXPIRY.has(protocolId)) {
+    return Math.floor(Date.now() / 1e3) + DEFAULT_DEFI_MULTISIGN_EXPIRY_SECONDS;
+  }
+  return void 0;
+}
+
+// src/core/purpose.ts
+function mergePurposeText(purposeText, purposeSuffix) {
+  const t = (purposeText ?? "").trim();
+  const suffix = (purposeSuffix ?? "").trim();
+  if (!suffix) return t;
+  return t ? `${t}
+
+${suffix}` : suffix;
+}
+
+// src/core/envelope.ts
+function finalizeMultisign(input) {
+  const { keyGen, destinationChainID, legs } = input;
+  if (legs.length === 0) {
+    throw new Error("finalizeMultisign requires at least one leg");
+  }
+  const ph = (keyGen.pubkeyhex ?? "").trim();
+  if (!ph) throw new Error("keyGen pubKey (pubkeyhex) is required");
+  const keyList = keyGen.keylist ?? [];
+  const clientId = getClientIdFromKeyGenResult(keyGen);
+  const first = legs[0];
+  const messageHashes = legs.map((l) => l.msgHash);
+  const messageRawBatch = legs.map((l) => l.msgRaw);
+  const batchMeta = legs.map((l) => ({
+    destinationAddress: l.destinationAddress,
+    signatureText: l.signatureText,
+    ...l.audit
+  }));
+  const proposalTxParams = legs.map((l) => l.proposalTxParams).filter((p) => p != null && typeof p === "object");
+  const extraPayload = {
+    batchMeta,
+    ...input.extraJSON ?? {}
+  };
+  const extraJSON = JSON.stringify(extraPayload, (_, v) => typeof v === "bigint" ? v.toString() : v);
+  const bodyForSign = {
+    keyList,
+    pubKey: ph,
+    msgHash: messageHashes[0],
+    msgRaw: first.msgRaw,
+    destinationChainID,
+    destinationAddress: input.destinationAddress ?? first.destinationAddress,
+    extraJSON,
+    signatureText: first.signatureText,
+    purpose: mergePurposeText(input.purposeText, input.purposeSuffix),
+    ...first.feeSnapshot
+  };
+  if (legs.length > 1) {
+    bodyForSign.messageHashes = messageHashes;
+    bodyForSign.messageRawBatch = messageRawBatch;
+  }
+  if (proposalTxParams.length > 0) {
+    bodyForSign.proposalTxParams = proposalTxParams;
+  }
+  const valueWei = first.valueWei;
+  if (valueWei != null && valueWei > 0n) {
+    bodyForSign.value = valueWei.toString();
+  }
+  if (clientId) bodyForSign.clientId = clientId;
+  if (input.expiryDate != null && input.expiryDate > 0) {
+    bodyForSign.expiryDate = Math.floor(input.expiryDate);
+  }
+  return { bodyForSign, messageToSign: JSON.stringify(bodyForSign) };
+}
+function routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimit) {
+  if (chainGasLimit != null && Number.isFinite(chainGasLimit) && chainGasLimit > 0) {
+    return gasLimitFromEstimateAndChainConfig(estimatedGas, chainGasLimit);
+  }
+  return (estimatedGas * 12n + 9n) / 10n;
+}
+
+// src/chains/evm/buildBatch.ts
+async function buildEvmMultisignBatch(args) {
+  const { context, steps } = args;
+  const {
+    chainId,
+    rpcUrl,
+    executorAddress,
+    chainDetail,
+    useCustomGas,
+    customGasChainDetails,
+    keyGen,
+    purposeText
+  } = context;
+  if (steps.length === 0) throw new Error("buildEvmMultisignBatch requires at least one step");
+  const ch = defineChain({
+    id: chainId,
+    name: "Destination",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpcUrl] } }
+  });
+  const publicClient2 = createPublicClient({ chain: ch, transport: defiEvmTransport(rpcUrl) });
+  const feeParams = await fetchChainFeeParams(rpcUrl, chainId);
+  const legacy = Boolean(chainDetail?.legacy) || !feeParams.isEip1559;
+  const latestBaseFeeWei = !legacy ? (await publicClient2.getBlock({ blockTag: "latest" })).baseFeePerGas ?? 0n : 0n;
+  const gasLimitConfig = useCustomGas && chainDetail?.gasLimit != null ? Number(chainDetail.gasLimit) : void 0;
+  const chainGasLimitRouter = chainDetail?.gasLimit != null && Number.isFinite(Number(chainDetail.gasLimit)) && Number(chainDetail.gasLimit) > 0 ? Number(chainDetail.gasLimit) : void 0;
+  const gasFeeMultiplier = useCustomGas && chainDetail?.gasMultiplier != null ? Number(chainDetail.gasMultiplier) : void 0;
+  const executor = getAddress(executorAddress);
+  const baseNonce = await publicClient2.getTransactionCount({ address: executor, blockTag: "pending" });
+  const legs = [];
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    const currentNonce = baseNonce + i;
+    let estimatedGas;
+    if (args.estimateGasForStep) {
+      estimatedGas = await args.estimateGasForStep({ step, index: i, publicClient: publicClient2, executor });
+    } else {
+      try {
+        estimatedGas = await publicClient2.estimateGas({
+          to: step.to,
+          data: step.data,
+          value: step.value,
+          account: executor
+        });
+      } catch {
+        estimatedGas = step.fallbackGas ?? 100000n;
+      }
+    }
+    let gasLimitI;
+    if (args.resolveGasLimit) {
+      gasLimitI = await args.resolveGasLimit({ step, index: i, estimatedGas, publicClient: publicClient2 });
+    } else if (step.routerSwap) {
+      gasLimitI = routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimitRouter);
+    } else {
+      gasLimitI = useCustomGas ? gasLimitFromEstimateAndChainConfig(estimatedGas, gasLimitConfig) : estimatedGas;
+    }
+    let proposalTxParams;
+    let feeSnapshot;
+    let serialized;
+    if (legacy) {
+      let gasPriceWei = await publicClient2.getGasPrice();
+      if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+        gasPriceWei = gasPriceWei * BigInt(100 + gasFeeMultiplier) / 100n;
+      }
+      if (useCustomGas && chainDetail?.gasPrice != null && chainDetail.gasPrice > 0) {
+        const configured = parseGwei(gweiToDecimalString(Number(chainDetail.gasPrice)));
+        if (configured > gasPriceWei) gasPriceWei = configured;
+      }
+      serialized = serializeTransaction({
+        type: "legacy",
+        to: step.to,
+        data: step.data,
+        value: step.value,
+        gas: gasLimitI,
+        gasPrice: gasPriceWei,
+        nonce: currentNonce,
+        chainId
+      });
+      proposalTxParams = {
+        nonce: currentNonce,
+        gasLimit: gasLimitI.toString(),
+        txType: "legacy",
+        gasPrice: gasPriceWei.toString()
+      };
+      feeSnapshot = proposalTxParamsToFeeSnapshot(proposalTxParams);
+    } else {
+      const fetchedBase = feeParams.baseFeeGwei ?? 0;
+      const fetchedPriority = feeParams.priorityFeeGwei ?? 0;
+      const configuredBase = useCustomGas && chainDetail?.baseFee != null ? Number(chainDetail.baseFee) : 0;
+      const configuredPriority = useCustomGas && chainDetail?.priorityFee != null ? Number(chainDetail.priorityFee) : 0;
+      const effectiveBaseFeeGwei = Math.max(fetchedBase, configuredBase);
+      const effectivePriorityFeeGwei = Math.max(fetchedPriority, configuredPriority);
+      const baseFeeMultiplierPct = useCustomGas && chainDetail?.baseFeeMultiplier != null ? Math.max(100, Number(chainDetail.baseFeeMultiplier)) : 100;
+      const baseComponentGwei = effectiveBaseFeeGwei * baseFeeMultiplierPct / 100;
+      const maxFeePerGasGwei = baseComponentGwei + effectivePriorityFeeGwei;
+      let maxPriorityFeePerGas = effectivePriorityFeeGwei > 0 ? parseGwei(gweiToDecimalString(effectivePriorityFeeGwei)) : parseGwei("1");
+      let maxFeePerGas = parseGwei(gweiToDecimalString(maxFeePerGasGwei));
+      if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+        maxPriorityFeePerGas = maxPriorityFeePerGas * BigInt(100 + gasFeeMultiplier) / 100n;
+        maxFeePerGas = maxFeePerGas * BigInt(100 + gasFeeMultiplier) / 100n;
+      }
+      ({ maxFeePerGas, maxPriorityFeePerGas } = alignEip1559FeesWithLatestBase(
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        latestBaseFeeWei
+      ));
+      serialized = serializeTransaction({
+        type: "eip1559",
+        to: step.to,
+        data: step.data,
+        value: step.value,
+        gas: gasLimitI,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce: currentNonce,
+        chainId
+      });
+      proposalTxParams = {
+        nonce: currentNonce,
+        gasLimit: gasLimitI.toString(),
+        txType: "eip1559",
+        maxFeePerGas: maxFeePerGas.toString(),
+        maxPriorityFeePerGas: maxPriorityFeePerGas.toString()
+      };
+      feeSnapshot = i === 0 ? proposalTxParamsToFeeSnapshot(proposalTxParams) : {};
+    }
+    const h = keccak256(serialized);
+    const msgHash = h.startsWith("0x") ? h.slice(2) : h;
+    const batchMetaExtra = args.buildBatchMeta({ step, index: i, gasLimit: gasLimitI });
+    legs.push({
+      msgHash,
+      msgRaw: i === 0 && args.firstMsgRawNo0x != null ? args.firstMsgRawNo0x : serialized,
+      destinationAddress: step.to,
+      signatureText: typeof batchMetaExtra.signatureText === "string" ? batchMetaExtra.signatureText : JSON.stringify(batchMetaExtra.signatureText ?? {}),
+      audit: batchMetaExtra,
+      feeSnapshot: i === 0 ? feeSnapshot : {},
+      proposalTxParams,
+      valueWei: i === 0 ? step.value : void 0
+    });
+    if (i === 0 && args.firstMsgRawNo0x != null) {
+      legs[0].msgRaw = args.firstMsgRawNo0x;
+    }
+  }
+  const extraJSON = {};
+  if (useCustomGas && customGasChainDetails && Object.keys(customGasChainDetails).length > 0) {
+    extraJSON.customGasChainDetails = customGasChainDetails;
+  }
+  const result = finalizeMultisign({
+    keyGen,
+    purposeText,
+    purposeSuffix: args.purposeSuffix,
+    destinationChainID: String(chainId),
+    destinationAddress: args.destinationAddress ?? steps[0].to,
+    legs,
+    extraJSON: Object.keys(extraJSON).length > 0 ? extraJSON : void 0,
+    expiryDate: context.expiryDate
+  });
+  const pv = args.payableValueWei;
+  if (pv != null && pv > 0n) {
+    result.bodyForSign.value = pv.toString();
+  }
+  return result;
+}
+
+// src/protocols/evm/trueo/multisign.ts
+var TRUEO_APPROVE_FALLBACK_GAS = 80000n;
+var TRUEO_MINT_FALLBACK_GAS = 450000n;
+var TRUEO_TYD_VAULT_FALLBACK_GAS = 350000n;
+var TRUEO_SWAP_FALLBACK_GAS = 650000n;
+var TRUEO_ORDER_FALLBACK_GAS = 520000n;
+function client(rpcUrl) {
+  const chain = defineChain({
+    id: TRUEO_BASE_CHAIN_ID,
+    name: "Base",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpcUrl] } }
+  });
+  return createPublicClient({ chain, transport: defiEvmTransport(rpcUrl) });
+}
+async function allowance(args) {
+  return client(args.rpcUrl).readContract({
+    address: args.token,
+    abi: trueoErc20Abi,
+    functionName: "allowance",
+    args: [args.owner, args.spender]
+  });
+}
+async function pushApproveIfNeeded(args) {
+  const current = await allowance({
+    rpcUrl: args.rpcUrl,
+    token: args.token,
+    owner: args.owner,
+    spender: args.spender
+  });
+  if (current >= args.amount) return;
+  if (current > 0n) {
+    args.steps.push({
+      kind: "approve_zero",
+      to: args.token,
+      data: encodeErc20Approve(args.spender, 0n),
+      value: 0n,
+      fallbackGas: TRUEO_APPROVE_FALLBACK_GAS
+    });
+  }
+  args.steps.push({
+    kind: "approve",
+    to: args.token,
+    data: encodeErc20Approve(args.spender, args.amount),
+    value: 0n,
+    fallbackGas: TRUEO_APPROVE_FALLBACK_GAS
+  });
+}
+function mergeExtraJson(result, extra) {
+  const body = result.bodyForSign;
+  const existing = typeof body.extraJSON === "string" ? JSON.parse(body.extraJSON) : body.extraJSON ?? {};
+  body.extraJSON = JSON.stringify({ ...existing, ...extra });
+}
+async function finalizeTrueo(args) {
+  const expiryDate = defiMultisignExpiryUnixSeconds(TRUEO_PROTOCOL_ID, args.expiryDate);
+  const first = args.steps[0];
+  if (!first) throw new Error("Trueo: no transaction steps.");
+  const firstDataNo0x = first.data.startsWith("0x") ? first.data.slice(2) : first.data;
+  const result = await buildEvmMultisignBatch({
+    context: {
+      chainCategory: "evm",
+      keyGen: args.keyGen,
+      purposeText: args.purposeText,
+      chainId: TRUEO_BASE_CHAIN_ID,
+      rpcUrl: args.rpcUrl,
+      executorAddress: args.executorAddress,
+      chainDetail: args.chainDetail,
+      useCustomGas: args.useCustomGas,
+      customGasChainDetails: args.customGasChainDetails,
+      expiryDate
+    },
+    steps: args.steps,
+    purposeSuffix: args.purposeSuffix,
+    firstMsgRawNo0x: firstDataNo0x,
+    destinationAddress: first.to,
+    buildBatchMeta: ({ step, index }) => {
+      const s = step;
+      return {
+        signatureText: JSON.stringify({
+          kind: "Trueo",
+          name: s.kind,
+          index,
+          chainId: TRUEO_BASE_CHAIN_ID
+        }),
+        evm: { type: `trueo_${s.kind}`, version: 1, chainId: String(TRUEO_BASE_CHAIN_ID) }
+      };
+    }
+  });
+  if (args.betExtra) mergeExtraJson(result, args.betExtra);
+  return result;
+}
+function parseAmount(human, decimals) {
+  const amt = parseUnits(String(human).trim(), decimals);
+  if (amt <= 0n) throw new Error("Amount must be greater than zero.");
+  return amt;
+}
+async function assertTrueoTydVaultUnderlying(rpcUrl) {
+  const underlying = await client(rpcUrl).readContract({
+    address: TRUEO_TYD,
+    abi: trueoTydVaultAbi,
+    functionName: "asset"
+  });
+  if (getAddress(underlying) !== TRUEO_USDC) {
+    throw new Error("TYD vault underlying is not Base USDC.");
+  }
+}
+async function buildEvmMultisignBodyTrueoWrapTyd(args) {
+  assertTrueoChainId(args.chainId);
+  const executor = getAddress(args.executorAddress);
+  const amount = parseAmount(args.amountHuman, 6);
+  await assertTrueoTydVaultUnderlying(args.rpcUrl);
+  const steps = [];
+  await pushApproveIfNeeded({
+    steps,
+    rpcUrl: args.rpcUrl,
+    token: TRUEO_USDC,
+    owner: executor,
+    spender: TRUEO_TYD,
+    amount
+  });
+  steps.push({
+    kind: "wrap_tyd",
+    to: TRUEO_TYD,
+    data: encodeTrueoTydDeposit(amount, executor),
+    value: 0n,
+    fallbackGas: TRUEO_TYD_VAULT_FALLBACK_GAS
+  });
+  const purposeText = args.purposeText.trim() || buildTrueoPurposePrefill({ action: "wrapTyd", amountHuman: args.amountHuman, paymentSymbol: "USDC" });
+  return finalizeTrueo({
+    ...args,
+    executorAddress: executor,
+    purposeText,
+    purposeSuffix: "Trueo: mint TYD from USDC (Yearn ERC-4626 deposit).",
+    steps
+  });
+}
+async function buildEvmMultisignBodyTrueoUnwrapTyd(args) {
+  assertTrueoChainId(args.chainId);
+  const executor = getAddress(args.executorAddress);
+  const amount = parseAmount(args.amountHuman, TRUEO_TYD_DECIMALS);
+  await assertTrueoTydVaultUnderlying(args.rpcUrl);
+  const steps = [
+    {
+      kind: "unwrap_tyd",
+      to: TRUEO_TYD,
+      data: encodeTrueoTydRedeem(amount, executor, executor),
+      value: 0n,
+      fallbackGas: TRUEO_TYD_VAULT_FALLBACK_GAS
+    }
+  ];
+  const purposeText = args.purposeText.trim() || buildTrueoPurposePrefill({ action: "unwrapTyd", amountHuman: args.amountHuman, paymentSymbol: "TYD" });
+  return finalizeTrueo({
+    ...args,
+    executorAddress: executor,
+    purposeText,
+    purposeSuffix: "Trueo: unwrap TYD to USDC (Yearn ERC-4626 redeem).",
+    steps
+  });
+}
+async function buildEvmMultisignBodyTrueoMint(args) {
+  assertTrueoChainId(args.chainId);
+  const executor = getAddress(args.executorAddress);
+  const market = getAddress(args.marketAddress);
+  const paymentKind = args.paymentKind === "usdc" ? "usdc" : "tyd";
+  const decimals = paymentKind === "usdc" ? 6 : TRUEO_TYD_DECIMALS;
+  const amount = parseAmount(args.amountHuman, decimals);
+  const row = await fetchTrueoMarket({ marketAddress: market });
+  const steps = [];
+  if (paymentKind === "usdc") {
+    await pushApproveIfNeeded({
+      steps,
+      rpcUrl: args.rpcUrl,
+      token: TRUEO_USDC,
+      owner: executor,
+      spender: TRUEO_TRUTH_MARKET_ADAPTER,
+      amount
+    });
+    steps.push({
+      kind: "adapter_mint",
+      to: TRUEO_TRUTH_MARKET_ADAPTER,
+      data: encodeTrueoAdapterMint(market, amount),
+      value: 0n,
+      fallbackGas: TRUEO_MINT_FALLBACK_GAS
+    });
+  } else {
+    await pushApproveIfNeeded({
+      steps,
+      rpcUrl: args.rpcUrl,
+      token: TRUEO_TYD,
+      owner: executor,
+      spender: market,
+      amount
+    });
+    steps.push({
+      kind: "mint",
+      to: market,
+      data: encodeTrueoMint(amount),
+      value: 0n,
+      fallbackGas: TRUEO_MINT_FALLBACK_GAS
+    });
+  }
+  const purposeText = args.purposeText.trim() || buildTrueoPurposePrefill({
+    action: "mint",
+    amountHuman: args.amountHuman,
+    paymentSymbol: paymentKind === "usdc" ? "USDC" : "TYD",
+    question: row.question
+  });
+  return finalizeTrueo({
+    ...args,
+    executorAddress: executor,
+    purposeText,
+    purposeSuffix: `Trueo: mint YES+NO on ${row.question || market}.`,
+    steps
+  });
+}
+async function buildEvmMultisignBodyTrueoBurn(args) {
+  assertTrueoChainId(args.chainId);
+  const executor = getAddress(args.executorAddress);
+  const market = getAddress(args.marketAddress);
+  const row = await fetchTrueoMarket({ marketAddress: market });
+  const amount = parseAmount(args.amountHuman, 18);
+  const steps = [];
+  const paymentKind = args.paymentKind === "usdc" ? "usdc" : "tyd";
+  if (paymentKind === "usdc") {
+    await pushApproveIfNeeded({
+      steps,
+      rpcUrl: args.rpcUrl,
+      token: getAddress(row.yesTokenAddress),
+      owner: executor,
+      spender: TRUEO_TRUTH_MARKET_ADAPTER,
+      amount
+    });
+    await pushApproveIfNeeded({
+      steps,
+      rpcUrl: args.rpcUrl,
+      token: getAddress(row.noTokenAddress),
+      owner: executor,
+      spender: TRUEO_TRUTH_MARKET_ADAPTER,
+      amount
+    });
+    steps.push({
+      kind: "adapter_burn",
+      to: TRUEO_TRUTH_MARKET_ADAPTER,
+      data: encodeTrueoAdapterBurn(market, amount),
+      value: 0n,
+      fallbackGas: TRUEO_MINT_FALLBACK_GAS
+    });
+  } else {
+    await pushApproveIfNeeded({
+      steps,
+      rpcUrl: args.rpcUrl,
+      token: getAddress(row.yesTokenAddress),
+      owner: executor,
+      spender: market,
+      amount
+    });
+    await pushApproveIfNeeded({
+      steps,
+      rpcUrl: args.rpcUrl,
+      token: getAddress(row.noTokenAddress),
+      owner: executor,
+      spender: market,
+      amount
+    });
+    steps.push({
+      kind: "burn",
+      to: market,
+      data: encodeTrueoBurn(amount),
+      value: 0n,
+      fallbackGas: TRUEO_MINT_FALLBACK_GAS
+    });
+  }
+  const purposeText = args.purposeText.trim() || buildTrueoPurposePrefill({ action: "burn", amountHuman: args.amountHuman, question: row.question });
+  return finalizeTrueo({
+    ...args,
+    executorAddress: executor,
+    purposeText,
+    purposeSuffix: `Trueo: burn YES+NO on ${row.question || market}.`,
+    steps
+  });
+}
+async function buildEvmMultisignBodyTrueoRedeem(args) {
+  assertTrueoChainId(args.chainId);
+  const executor = getAddress(args.executorAddress);
+  const market = getAddress(args.marketAddress);
+  const row = await fetchTrueoMarket({ marketAddress: market });
+  const amount = parseAmount(args.amountHuman, 18);
+  const steps = [];
+  const paymentKind = args.paymentKind === "usdc" ? "usdc" : "tyd";
+  const winning = row.yesTokenAddress;
+  if (paymentKind === "usdc") {
+    await pushApproveIfNeeded({
+      steps,
+      rpcUrl: args.rpcUrl,
+      token: getAddress(winning),
+      owner: executor,
+      spender: TRUEO_TRUTH_MARKET_ADAPTER,
+      amount
+    });
+    await pushApproveIfNeeded({
+      steps,
+      rpcUrl: args.rpcUrl,
+      token: getAddress(row.noTokenAddress),
+      owner: executor,
+      spender: TRUEO_TRUTH_MARKET_ADAPTER,
+      amount
+    });
+    steps.push({
+      kind: "adapter_redeem",
+      to: TRUEO_TRUTH_MARKET_ADAPTER,
+      data: encodeTrueoAdapterRedeem(market, amount),
+      value: 0n,
+      fallbackGas: TRUEO_MINT_FALLBACK_GAS
+    });
+  } else {
+    await pushApproveIfNeeded({
+      steps,
+      rpcUrl: args.rpcUrl,
+      token: getAddress(winning),
+      owner: executor,
+      spender: market,
+      amount
+    });
+    await pushApproveIfNeeded({
+      steps,
+      rpcUrl: args.rpcUrl,
+      token: getAddress(row.noTokenAddress),
+      owner: executor,
+      spender: market,
+      amount
+    });
+    steps.push({
+      kind: "redeem",
+      to: market,
+      data: encodeTrueoRedeem(amount),
+      value: 0n,
+      fallbackGas: TRUEO_MINT_FALLBACK_GAS
+    });
+  }
+  const purposeText = args.purposeText.trim() || buildTrueoPurposePrefill({ action: "redeem", amountHuman: args.amountHuman, question: row.question });
+  return finalizeTrueo({
+    ...args,
+    executorAddress: executor,
+    purposeText,
+    purposeSuffix: `Trueo: redeem on ${row.question || market}.`,
+    steps
+  });
+}
+function zeroForOneBuyOutcome(poolKey, tyd) {
+  return getAddress(poolKey.currency0) === getAddress(tyd);
+}
+async function loadBetMarketAndPool(args) {
+  const row = await fetchTrueoMarket({ marketAddress: args.marketAddress });
+  assertTrueoBetCanCreate(row);
+  const keys = await readTrueoPoolKeys({ rpcUrl: args.rpcUrl, marketAddress: getAddress(args.marketAddress) });
+  if (!keys) throw new Error("Could not read Trueo V2 pool keys. Confirm the market is Uniswap v4.");
+  return { row, poolKey: args.side === "no" ? keys.no : keys.yes };
+}
+async function buildEvmMultisignBodyTrueoSwap(args) {
+  assertTrueoChainId(args.chainId);
+  const executor = getAddress(args.executorAddress);
+  const { row, poolKey } = await loadBetMarketAndPool({
+    rpcUrl: args.rpcUrl,
+    marketAddress: args.marketAddress,
+    side: args.side
+  });
+  const amount = parseAmount(args.amountHuman, TRUEO_TYD_DECIMALS);
+  const amountOutMin = args.amountOutMinimumHuman?.trim() ? parseUnits(args.amountOutMinimumHuman.trim(), 18) : 0n;
+  const steps = [];
+  await pushApproveIfNeeded({
+    steps,
+    rpcUrl: args.rpcUrl,
+    token: TRUEO_TYD,
+    owner: executor,
+    spender: TRUEO_PERMIT2,
+    amount
+  });
+  steps.push({
+    kind: "permit2_approve",
+    to: TRUEO_PERMIT2,
+    data: encodePermit2Approve({
+      token: TRUEO_TYD,
+      spender: TRUEO_UNIVERSAL_ROUTER_ADAPTER,
+      amount,
+      expiration: trueoPermit2Expiration()
+    }),
+    value: 0n,
+    fallbackGas: TRUEO_APPROVE_FALLBACK_GAS
+  });
+  const encoded = encodeTrueoV4ExactInSwap({
+    poolKey,
+    zeroForOne: zeroForOneBuyOutcome(poolKey, TRUEO_TYD),
+    amountIn: amount,
+    amountOutMinimum: amountOutMin,
+    recipient: executor,
+    deadline: trueoSwapDeadline()
+  });
+  steps.push({
+    kind: "swap",
+    to: encoded.to,
+    data: encoded.data,
+    value: 0n,
+    fallbackGas: TRUEO_SWAP_FALLBACK_GAS,
+    routerSwap: true
+  });
+  const purposeText = args.purposeText.trim() || buildTrueoPurposePrefill({
+    action: "swap",
+    side: args.side,
+    amountHuman: args.amountHuman,
+    paymentSymbol: "TYD",
+    question: row.question
+  });
+  return finalizeTrueo({
+    ...args,
+    executorAddress: executor,
+    purposeText,
+    purposeSuffix: `Trueo: buy ${args.side === "no" ? "No" : "Yes"} ${args.amountHuman} TYD.`,
+    steps,
+    betExtra: buildTrueoBetExtraJson({
+      action: "swap",
+      marketAddress: row.address,
+      endOfTrading: row.endOfTrading
+    })
+  });
+}
+async function buildEvmMultisignBodyTrueoCreateOrder(args) {
+  assertTrueoChainId(args.chainId);
+  const executor = getAddress(args.executorAddress);
+  const { row, poolKey } = await loadBetMarketAndPool({
+    rpcUrl: args.rpcUrl,
+    marketAddress: args.marketAddress,
+    side: args.side
+  });
+  const amount = parseAmount(args.amountHuman, TRUEO_TYD_DECIMALS);
+  const steps = [];
+  await pushApproveIfNeeded({
+    steps,
+    rpcUrl: args.rpcUrl,
+    token: TRUEO_TYD,
+    owner: executor,
+    spender: TRUEO_PERMIT2,
+    amount
+  });
+  steps.push({
+    kind: "permit2_approve",
+    to: TRUEO_PERMIT2,
+    data: encodePermit2Approve({
+      token: TRUEO_TYD,
+      spender: TRUEO_ORDER_MANAGER,
+      amount,
+      expiration: trueoPermit2Expiration()
+    }),
+    value: 0n,
+    fallbackGas: TRUEO_APPROVE_FALLBACK_GAS
+  });
+  steps.push({
+    kind: "createOrder",
+    to: TRUEO_ORDER_MANAGER,
+    data: encodeTrueoCreateOrder({
+      poolKey,
+      amountIn: amount,
+      tickLower: args.tickLower,
+      tickUpper: args.tickUpper,
+      zeroForOne: zeroForOneBuyOutcome(poolKey, TRUEO_TYD),
+      enablePartialFill: args.enablePartialFill !== false
+    }),
+    value: 0n,
+    fallbackGas: TRUEO_ORDER_FALLBACK_GAS
+  });
+  const purposeText = args.purposeText.trim() || buildTrueoPurposePrefill({
+    action: "createOrder",
+    side: args.side,
+    amountHuman: args.amountHuman,
+    question: row.question
+  });
+  return finalizeTrueo({
+    ...args,
+    executorAddress: executor,
+    purposeText,
+    purposeSuffix: `Trueo: limit ${args.side === "no" ? "No" : "Yes"} ${args.amountHuman} TYD.`,
+    steps,
+    betExtra: buildTrueoBetExtraJson({
+      action: "createOrder",
+      marketAddress: row.address,
+      endOfTrading: row.endOfTrading
+    })
+  });
+}
+async function buildEvmMultisignBodyTrueoCancelOrder(args) {
+  assertTrueoChainId(args.chainId);
+  const executor = getAddress(args.executorAddress);
+  const row = await fetchTrueoMarket({ marketAddress: args.marketAddress });
+  const keys = await readTrueoPoolKeys({ rpcUrl: args.rpcUrl, marketAddress: getAddress(args.marketAddress) });
+  if (!keys) throw new Error("Could not read Trueo V2 pool keys.");
+  const poolKey = args.side === "no" ? keys.no : keys.yes;
+  const steps = [
+    {
+      kind: "cancelOrder",
+      to: TRUEO_ORDER_MANAGER,
+      data: encodeTrueoCancelOrder({ poolKey, orderId: args.orderId }),
+      value: 0n,
+      fallbackGas: TRUEO_ORDER_FALLBACK_GAS
+    }
+  ];
+  const purposeText = args.purposeText.trim() || buildTrueoPurposePrefill({ action: "cancelOrder", question: row.question });
+  return finalizeTrueo({
+    ...args,
+    executorAddress: executor,
+    purposeText,
+    purposeSuffix: `Trueo: cancel order ${args.orderId}.`,
+    steps
+  });
+}
+
+// src/protocols/evm/trueo/index.ts
+var trueoProtocolModule = {
+  id: TRUEO_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    const id = typeof ctx.chainId === "string" ? Number(ctx.chainId) : ctx.chainId;
+    return ctx.chainCategory === "evm" && isTrueoChainSupported(id);
+  },
+  isTokenSupported(token) {
+    return token.category === "evm" && (token.kind === "erc20" || token.kind === "ctmerc20");
+  },
+  actions: [
+    {
+      id: "trueo.wrap-tyd",
+      protocolId: TRUEO_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Mint TYD by depositing Base USDC into the Yearn ERC-4626 vault",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    },
+    {
+      id: "trueo.unwrap-tyd",
+      protocolId: TRUEO_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Redeem TYD shares back to Base USDC",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    },
+    {
+      id: "trueo.mint",
+      protocolId: TRUEO_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Mint YES+NO from TYD (or USDC via adapter)",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    },
+    {
+      id: "trueo.burn",
+      protocolId: TRUEO_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Burn equal YES+NO back to TYD",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    },
+    {
+      id: "trueo.redeem",
+      protocolId: TRUEO_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Redeem winning outcome tokens after resolution",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    },
+    {
+      id: "trueo.swap",
+      protocolId: TRUEO_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Buy Yes or No with TYD via UniversalRouterAdapter V4 swap",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    },
+    {
+      id: "trueo.create-order",
+      protocolId: TRUEO_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Create an on-chain OrderManager limit order",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    },
+    {
+      id: "trueo.cancel-order",
+      protocolId: TRUEO_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Cancel an on-chain OrderManager order",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    }
+  ]
+};
+registerProtocolModule(trueoProtocolModule);
+
+export { PREDICTION_MARKETS_PROTOCOL_ID, PREDICTION_MARKET_V1_KIND, TRUEO_API_ORIGIN, TRUEO_APPROVE_FALLBACK_GAS, TRUEO_BASE_CHAIN_ID, TRUEO_BET_ACTIONS, TRUEO_BET_CLOSE_BUFFER_SECONDS, TRUEO_BET_CLOSE_ERROR, TRUEO_BET_EXPIRED_ERROR, TRUEO_CHAIN_IDS, TRUEO_CHANCE_SERIES_LOOKBACK_SECONDS, TRUEO_CHANCE_SERIES_RESOLUTION, TRUEO_MARKET_API_PREFIX, TRUEO_MARKET_PAGE_SIZE, TRUEO_MINT_FALLBACK_GAS, TRUEO_NETWORK, TRUEO_ORDER_FALLBACK_GAS, TRUEO_ORDER_MANAGER, TRUEO_OUTCOME_TOKEN_DECIMALS, TRUEO_PERMIT2, TRUEO_PERMIT2_APPROVAL_SECONDS, TRUEO_PROTOCOL_ID, TRUEO_RECENT_MARKET_WINDOW_SECONDS, TRUEO_SANE_IMPLIED_PRICE_MAX, TRUEO_SWAP_FALLBACK_GAS, TRUEO_TRENDING_MAX_LIMIT, TRUEO_TRUE, TRUEO_TRUTH_MARKET_ADAPTER, TRUEO_TRUTH_MARKET_MANAGER, TRUEO_TYD, TRUEO_TYD_DECIMALS, TRUEO_TYD_VAULT_FALLBACK_GAS, TRUEO_UNIVERSAL_ROUTER_ADAPTER, TRUEO_USDC, TRUEO_V4_HOOK, UR_COMMAND_V4_SWAP, V4_ACTION_SETTLE, V4_ACTION_SWAP_EXACT_IN_SINGLE, V4_ACTION_TAKE, applyTrueoMarketSearchScope, assertTrueoBetCanCreate, assertTrueoBetCanExecute, assertTrueoBetStillOpen, assertTrueoChainId, buildEvmMultisignBodyTrueoBurn, buildEvmMultisignBodyTrueoCancelOrder, buildEvmMultisignBodyTrueoCreateOrder, buildEvmMultisignBodyTrueoMint, buildEvmMultisignBodyTrueoRedeem, buildEvmMultisignBodyTrueoSwap, buildEvmMultisignBodyTrueoUnwrapTyd, buildEvmMultisignBodyTrueoWrapTyd, buildPredictionMarketEnvelope, buildTrueoBetExtraJson, buildTrueoPurposePrefill, encodeErc20Approve, encodePermit2Approve, encodeTrueoAdapterBurn, encodeTrueoAdapterMint, encodeTrueoAdapterRedeem, encodeTrueoBurn, encodeTrueoCancelOrder, encodeTrueoCreateOrder, encodeTrueoMint, encodeTrueoRedeem, encodeTrueoTydDeposit, encodeTrueoTydRedeem, encodeTrueoUniversalRouterExecute, encodeTrueoV4ExactInInput, encodeTrueoV4ExactInSwap, extraJsonFromSignRequest, fetchTrueoCategories, fetchTrueoChanceSeries, fetchTrueoMarket, fetchTrueoOhlc, fetchTrueoOrderbook, fetchTrueoTransactions, fetchTrueoTrending, filterTrueoMarkets, getPredictionMarketSummary, isTrueoBetAction, isTrueoChainSupported, isTrueoCoreToken, isTrueoMarketLiveOrRecent, isTrueoMarketTradingOpen, isTrueoOutcomeTokenLabel, listMyPredictionMarketsSummary, listPredictionMarketsForHoldings, listTrueoMarketsPage, normalizeTrueoAddress, normalizeTrueoMarketRow, normalizeTrueoOhlcResolution, outcomeTokensFromMarkets, parseTrueoBetExtraJson, preferOpenTrueoTitleMatches, readTrueoPoolKeys, searchPredictionMarkets, searchPredictionMarketsSummary, searchTrueoMarkets, searchTrueoMarketsPage, suggestTrueoTokensToAdd, trueoAdapterMintAbi, trueoBetCreateBlockedReason, trueoBetExecuteBlockedReason, trueoCompactVolumeLabel, trueoErc20Abi, trueoExpiresAtIso, trueoExpiresAtLabel, trueoFetchCategoriesSummary, trueoFetchChanceSeriesSummary, trueoFetchMarketSummary, trueoFetchOrderbookSummary, trueoFetchTrendingSummary, trueoHoldingTokenAddressesFromRegistry, trueoImpliedPriceFromSqrtX96, trueoIsSaneImpliedPrice, trueoJsonFetch, trueoListUsesTrending, trueoMarketAbi, trueoMarketApiPath, trueoMarketStatusLabel, trueoMarketToPredictionRow, trueoMarketV2Abi, trueoMarketVotingOpen, trueoOrderManagerAbi, trueoOrderManagerStructAbi, trueoPercentLabel, trueoPermit2ApproveAbi, trueoPermit2Expiration, trueoProtocolModule, trueoQueryTokens, trueoResolutionCopy, trueoResolvedSide, trueoSanitizeBinaryPrices, trueoSearchMarketsSummary, trueoSearchScopeNote, trueoSwapDeadline, trueoTimeUntilTradingEndsLabel, trueoTradingDeadlineLabel, trueoTradingEndsCopy, trueoTydVaultAbi, trueoUniversalRouterAdapterAbi };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map