@continuumdao/ctm-mpc-defi 0.2.49 → 0.2.50

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

@@ -0,0 +1,2308 @@
+'use strict';
+
+var viem = require('viem');
+var continuumNodeSdk = require('@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 = viem.getAddress("0xb13CF163d916917d9cD6E836905cA5f12a1dEF4B");
+var TRUEO_TRUE = viem.getAddress("0x21CFCFc3d8F98fC728f48341D10Ad8283F6EB7AB");
+var TRUEO_USDC = viem.getAddress("0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913");
+var TRUEO_TRUTH_MARKET_MANAGER = viem.getAddress("0x61A98Bef11867c69489B91f340fE545eEfc695d7");
+var TRUEO_ORDER_MANAGER = viem.getAddress("0x1cdB1C43eB64e99780EA9d3C7162C23432C59a1A");
+var TRUEO_UNIVERSAL_ROUTER_ADAPTER = viem.getAddress("0x0A1AFc2121B4441127a02DEF72928F61f564034a");
+var TRUEO_TRUTH_MARKET_ADAPTER = viem.getAddress("0x6E08d24AEf78F6d1a97503F64E84fDF65f8125E1");
+var TRUEO_V4_HOOK = viem.getAddress("0x3E83479B2276EcFb7C7181F67b5d092d3511e0C4");
+var TRUEO_PERMIT2 = viem.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 = viem.getAddress(address);
+    return n === TRUEO_TYD || n === TRUEO_TRUE;
+  } catch {
+    return false;
+  }
+}
+function normalizeTrueoAddress(address) {
+  return viem.getAddress(address);
+}
+var trueoErc20Abi = viem.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 = viem.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 = viem.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 = viem.parseAbi([
+  "function mint(address truthMarket, uint256 assetAmount)",
+  "function burn(address truthMarket, uint256 amount)",
+  "function redeem(address truthMarket, uint256 amount)"
+]);
+var trueoTydVaultAbi = viem.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 = viem.parseAbi([
+  "function execute(bytes commands, bytes[] inputs, uint256 deadline) payable"
+]);
+var trueoPermit2ApproveAbi = viem.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 = viem.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 = viem.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 viem.encodeFunctionData({
+    abi: trueoErc20Abi,
+    functionName: "approve",
+    args: [viem.getAddress(spender), amount]
+  });
+}
+function encodePermit2Approve(args) {
+  return viem.encodeFunctionData({
+    abi: trueoPermit2ApproveAbi,
+    functionName: "approve",
+    args: [viem.getAddress(args.token), viem.getAddress(args.spender), args.amount, args.expiration]
+  });
+}
+function encodeTrueoTydDeposit(assets, receiver) {
+  return viem.encodeFunctionData({
+    abi: trueoTydVaultAbi,
+    functionName: "deposit",
+    args: [assets, viem.getAddress(receiver)]
+  });
+}
+function encodeTrueoTydRedeem(shares, receiver, owner) {
+  return viem.encodeFunctionData({
+    abi: trueoTydVaultAbi,
+    functionName: "redeem",
+    args: [shares, viem.getAddress(receiver), viem.getAddress(owner)]
+  });
+}
+function encodeTrueoMint(paymentTokenAmount) {
+  return viem.encodeFunctionData({
+    abi: trueoMarketAbi,
+    functionName: "mint",
+    args: [paymentTokenAmount]
+  });
+}
+function encodeTrueoBurn(amount) {
+  return viem.encodeFunctionData({
+    abi: trueoMarketAbi,
+    functionName: "burn",
+    args: [amount]
+  });
+}
+function encodeTrueoRedeem(amount) {
+  return viem.encodeFunctionData({
+    abi: trueoMarketAbi,
+    functionName: "redeem",
+    args: [amount]
+  });
+}
+function encodeTrueoAdapterMint(market, assetAmount) {
+  return viem.encodeFunctionData({
+    abi: trueoAdapterMintAbi,
+    functionName: "mint",
+    args: [viem.getAddress(market), assetAmount]
+  });
+}
+function encodeTrueoAdapterBurn(market, amount) {
+  return viem.encodeFunctionData({
+    abi: trueoAdapterMintAbi,
+    functionName: "burn",
+    args: [viem.getAddress(market), amount]
+  });
+}
+function encodeTrueoAdapterRedeem(market, amount) {
+  return viem.encodeFunctionData({
+    abi: trueoAdapterMintAbi,
+    functionName: "redeem",
+    args: [viem.getAddress(market), amount]
+  });
+}
+function encodeTrueoV4ExactInInput(args) {
+  const poolKey = {
+    currency0: viem.getAddress(args.poolKey.currency0),
+    currency1: viem.getAddress(args.poolKey.currency1),
+    fee: args.poolKey.fee,
+    tickSpacing: args.poolKey.tickSpacing,
+    hooks: viem.getAddress(args.poolKey.hooks)
+  };
+  const settleCurrency = args.zeroForOne ? poolKey.currency0 : poolKey.currency1;
+  const takeCurrency = args.zeroForOne ? poolKey.currency1 : poolKey.currency0;
+  const swapParams = viem.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 = viem.encodeAbiParameters(
+    [
+      { name: "currency", type: "address" },
+      { name: "amount", type: "uint256" },
+      { name: "payerIsUser", type: "bool" }
+    ],
+    [settleCurrency, args.amountIn, true]
+  );
+  const takeParams = viem.encodeAbiParameters(
+    [
+      { name: "currency", type: "address" },
+      { name: "recipient", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    [takeCurrency, viem.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 viem.encodeAbiParameters(
+    [
+      { name: "actions", type: "bytes" },
+      { name: "params", type: "bytes[]" }
+    ],
+    [actions, [swapParams, settleParams, takeParams]]
+  );
+}
+function encodeTrueoUniversalRouterExecute(args) {
+  return viem.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 viem.encodeFunctionData({
+    abi: trueoOrderManagerStructAbi,
+    functionName: "createOrder",
+    args: [
+      {
+        poolKey: {
+          currency0: viem.getAddress(args.poolKey.currency0),
+          currency1: viem.getAddress(args.poolKey.currency1),
+          fee: args.poolKey.fee,
+          tickSpacing: args.poolKey.tickSpacing,
+          hooks: viem.getAddress(args.poolKey.hooks)
+        },
+        amountIn: args.amountIn,
+        tickLower: args.tickLower,
+        tickUpper: args.tickUpper,
+        zeroForOne: args.zeroForOne,
+        enablePartialFill: args.enablePartialFill
+      }
+    ]
+  });
+}
+function encodeTrueoCancelOrder(args) {
+  return viem.encodeFunctionData({
+    abi: trueoOrderManagerStructAbi,
+    functionName: "cancelOrder",
+    args: [
+      {
+        poolKey: {
+          currency0: viem.getAddress(args.poolKey.currency0),
+          currency1: viem.getAddress(args.poolKey.currency1),
+          fee: args.poolKey.fee,
+          tickSpacing: args.poolKey.tickSpacing,
+          hooks: viem.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 = viem.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 = viem.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: viem.getAddress(marketAddress) });
+  assertTrueoBetCanExecute(row);
+  return row;
+}
+function buildTrueoBetExtraJson(args) {
+  return {
+    protocolId: "trueo",
+    trueoAction: args.action,
+    marketAddress: viem.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 viem.http(url, opts);
+}
+
+// src/protocols/evm/trueo/orderbook.ts
+function publicClient(rpcUrl, chainId) {
+  const chain = viem.defineChain({
+    id: chainId,
+    name: "Base",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpcUrl] } }
+  });
+  return viem.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: viem.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: viem.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/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"]).map((v) => v.trim().toLowerCase()).filter(Boolean);
+  if (venues.length && !venues.includes("trueo")) {
+    return {
+      markets: [],
+      notes: "No supported venues in the filter. v1 adapter is trueo (Base).",
+      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 page = await listTrueoMarketsPage({
+    query: args.query,
+    category: args.category,
+    offset,
+    includeAll,
+    trending: args.trending,
+    excludeAddresses: args.excludeAddresses
+  });
+  const markets = page.markets.map(trueoMarketToPredictionRow).slice(0, args.limit ?? TRUEO_MARKET_PAGE_SIZE).map((row, i) => ({ ...row, index: indexBase + i + 1 }));
+  const nextIndexBase = indexBase + markets.length;
+  const scope = trueoSearchScopeNote(includeAll);
+  const q = args.query?.trim() ?? "";
+  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 the catalog. Do not list trending unless the operator asked. ${scope}`
+    };
+  }
+  const more = page.hasMore ? `More: search_prediction_markets with offset=${page.nextOffset}, trending=false, indexBase=${nextIndexBase}, excludeAddresses from this page's venueMarketIds.` : "End of results.";
+  return {
+    markets,
+    hasMore: page.hasMore,
+    nextOffset: page.nextOffset,
+    nextIndexBase,
+    includeAll,
+    notes: `${scope} ${more} Pick #N then get_prediction_market.`
+  };
+}
+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 !== "trueo") {
+    throw new Error(`Venue "${venue}" is not supported. v1 adapter is trueo.`);
+  }
+  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"
+]);
+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 = continuumNodeSdk.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 continuumNodeSdk.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 = viem.defineChain({
+    id: chainId,
+    name: "Destination",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpcUrl] } }
+  });
+  const publicClient2 = viem.createPublicClient({ chain: ch, transport: defiEvmTransport(rpcUrl) });
+  const feeParams = await continuumNodeSdk.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 = viem.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 ? continuumNodeSdk.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 = viem.parseGwei(continuumNodeSdk.gweiToDecimalString(Number(chainDetail.gasPrice)));
+        if (configured > gasPriceWei) gasPriceWei = configured;
+      }
+      serialized = viem.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 = continuumNodeSdk.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 ? viem.parseGwei(continuumNodeSdk.gweiToDecimalString(effectivePriorityFeeGwei)) : viem.parseGwei("1");
+      let maxFeePerGas = viem.parseGwei(continuumNodeSdk.gweiToDecimalString(maxFeePerGasGwei));
+      if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+        maxPriorityFeePerGas = maxPriorityFeePerGas * BigInt(100 + gasFeeMultiplier) / 100n;
+        maxFeePerGas = maxFeePerGas * BigInt(100 + gasFeeMultiplier) / 100n;
+      }
+      ({ maxFeePerGas, maxPriorityFeePerGas } = continuumNodeSdk.alignEip1559FeesWithLatestBase(
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        latestBaseFeeWei
+      ));
+      serialized = viem.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 ? continuumNodeSdk.proposalTxParamsToFeeSnapshot(proposalTxParams) : {};
+    }
+    const h = viem.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 = viem.defineChain({
+    id: TRUEO_BASE_CHAIN_ID,
+    name: "Base",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpcUrl] } }
+  });
+  return viem.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 = viem.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 (viem.getAddress(underlying) !== TRUEO_USDC) {
+    throw new Error("TYD vault underlying is not Base USDC.");
+  }
+}
+async function buildEvmMultisignBodyTrueoWrapTyd(args) {
+  assertTrueoChainId(args.chainId);
+  const executor = viem.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 = viem.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 = viem.getAddress(args.executorAddress);
+  const market = viem.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 = viem.getAddress(args.executorAddress);
+  const market = viem.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: viem.getAddress(row.yesTokenAddress),
+      owner: executor,
+      spender: TRUEO_TRUTH_MARKET_ADAPTER,
+      amount
+    });
+    await pushApproveIfNeeded({
+      steps,
+      rpcUrl: args.rpcUrl,
+      token: viem.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: viem.getAddress(row.yesTokenAddress),
+      owner: executor,
+      spender: market,
+      amount
+    });
+    await pushApproveIfNeeded({
+      steps,
+      rpcUrl: args.rpcUrl,
+      token: viem.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 = viem.getAddress(args.executorAddress);
+  const market = viem.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: viem.getAddress(winning),
+      owner: executor,
+      spender: TRUEO_TRUTH_MARKET_ADAPTER,
+      amount
+    });
+    await pushApproveIfNeeded({
+      steps,
+      rpcUrl: args.rpcUrl,
+      token: viem.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: viem.getAddress(winning),
+      owner: executor,
+      spender: market,
+      amount
+    });
+    await pushApproveIfNeeded({
+      steps,
+      rpcUrl: args.rpcUrl,
+      token: viem.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 viem.getAddress(poolKey.currency0) === viem.getAddress(tyd);
+}
+async function loadBetMarketAndPool(args) {
+  const row = await fetchTrueoMarket({ marketAddress: args.marketAddress });
+  assertTrueoBetCanCreate(row);
+  const keys = await readTrueoPoolKeys({ rpcUrl: args.rpcUrl, marketAddress: viem.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 = viem.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() ? viem.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 = viem.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 = viem.getAddress(args.executorAddress);
+  const row = await fetchTrueoMarket({ marketAddress: args.marketAddress });
+  const keys = await readTrueoPoolKeys({ rpcUrl: args.rpcUrl, marketAddress: viem.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);
+
+exports.PREDICTION_MARKETS_PROTOCOL_ID = PREDICTION_MARKETS_PROTOCOL_ID;
+exports.PREDICTION_MARKET_V1_KIND = PREDICTION_MARKET_V1_KIND;
+exports.TRUEO_API_ORIGIN = TRUEO_API_ORIGIN;
+exports.TRUEO_APPROVE_FALLBACK_GAS = TRUEO_APPROVE_FALLBACK_GAS;
+exports.TRUEO_BASE_CHAIN_ID = TRUEO_BASE_CHAIN_ID;
+exports.TRUEO_BET_ACTIONS = TRUEO_BET_ACTIONS;
+exports.TRUEO_BET_CLOSE_BUFFER_SECONDS = TRUEO_BET_CLOSE_BUFFER_SECONDS;
+exports.TRUEO_BET_CLOSE_ERROR = TRUEO_BET_CLOSE_ERROR;
+exports.TRUEO_BET_EXPIRED_ERROR = TRUEO_BET_EXPIRED_ERROR;
+exports.TRUEO_CHAIN_IDS = TRUEO_CHAIN_IDS;
+exports.TRUEO_CHANCE_SERIES_LOOKBACK_SECONDS = TRUEO_CHANCE_SERIES_LOOKBACK_SECONDS;
+exports.TRUEO_CHANCE_SERIES_RESOLUTION = TRUEO_CHANCE_SERIES_RESOLUTION;
+exports.TRUEO_MARKET_API_PREFIX = TRUEO_MARKET_API_PREFIX;
+exports.TRUEO_MARKET_PAGE_SIZE = TRUEO_MARKET_PAGE_SIZE;
+exports.TRUEO_MINT_FALLBACK_GAS = TRUEO_MINT_FALLBACK_GAS;
+exports.TRUEO_NETWORK = TRUEO_NETWORK;
+exports.TRUEO_ORDER_FALLBACK_GAS = TRUEO_ORDER_FALLBACK_GAS;
+exports.TRUEO_ORDER_MANAGER = TRUEO_ORDER_MANAGER;
+exports.TRUEO_OUTCOME_TOKEN_DECIMALS = TRUEO_OUTCOME_TOKEN_DECIMALS;
+exports.TRUEO_PERMIT2 = TRUEO_PERMIT2;
+exports.TRUEO_PERMIT2_APPROVAL_SECONDS = TRUEO_PERMIT2_APPROVAL_SECONDS;
+exports.TRUEO_PROTOCOL_ID = TRUEO_PROTOCOL_ID;
+exports.TRUEO_RECENT_MARKET_WINDOW_SECONDS = TRUEO_RECENT_MARKET_WINDOW_SECONDS;
+exports.TRUEO_SANE_IMPLIED_PRICE_MAX = TRUEO_SANE_IMPLIED_PRICE_MAX;
+exports.TRUEO_SWAP_FALLBACK_GAS = TRUEO_SWAP_FALLBACK_GAS;
+exports.TRUEO_TRENDING_MAX_LIMIT = TRUEO_TRENDING_MAX_LIMIT;
+exports.TRUEO_TRUE = TRUEO_TRUE;
+exports.TRUEO_TRUTH_MARKET_ADAPTER = TRUEO_TRUTH_MARKET_ADAPTER;
+exports.TRUEO_TRUTH_MARKET_MANAGER = TRUEO_TRUTH_MARKET_MANAGER;
+exports.TRUEO_TYD = TRUEO_TYD;
+exports.TRUEO_TYD_DECIMALS = TRUEO_TYD_DECIMALS;
+exports.TRUEO_TYD_VAULT_FALLBACK_GAS = TRUEO_TYD_VAULT_FALLBACK_GAS;
+exports.TRUEO_UNIVERSAL_ROUTER_ADAPTER = TRUEO_UNIVERSAL_ROUTER_ADAPTER;
+exports.TRUEO_USDC = TRUEO_USDC;
+exports.TRUEO_V4_HOOK = TRUEO_V4_HOOK;
+exports.UR_COMMAND_V4_SWAP = UR_COMMAND_V4_SWAP;
+exports.V4_ACTION_SETTLE = V4_ACTION_SETTLE;
+exports.V4_ACTION_SWAP_EXACT_IN_SINGLE = V4_ACTION_SWAP_EXACT_IN_SINGLE;
+exports.V4_ACTION_TAKE = V4_ACTION_TAKE;
+exports.applyTrueoMarketSearchScope = applyTrueoMarketSearchScope;
+exports.assertTrueoBetCanCreate = assertTrueoBetCanCreate;
+exports.assertTrueoBetCanExecute = assertTrueoBetCanExecute;
+exports.assertTrueoBetStillOpen = assertTrueoBetStillOpen;
+exports.assertTrueoChainId = assertTrueoChainId;
+exports.buildEvmMultisignBodyTrueoBurn = buildEvmMultisignBodyTrueoBurn;
+exports.buildEvmMultisignBodyTrueoCancelOrder = buildEvmMultisignBodyTrueoCancelOrder;
+exports.buildEvmMultisignBodyTrueoCreateOrder = buildEvmMultisignBodyTrueoCreateOrder;
+exports.buildEvmMultisignBodyTrueoMint = buildEvmMultisignBodyTrueoMint;
+exports.buildEvmMultisignBodyTrueoRedeem = buildEvmMultisignBodyTrueoRedeem;
+exports.buildEvmMultisignBodyTrueoSwap = buildEvmMultisignBodyTrueoSwap;
+exports.buildEvmMultisignBodyTrueoUnwrapTyd = buildEvmMultisignBodyTrueoUnwrapTyd;
+exports.buildEvmMultisignBodyTrueoWrapTyd = buildEvmMultisignBodyTrueoWrapTyd;
+exports.buildPredictionMarketEnvelope = buildPredictionMarketEnvelope;
+exports.buildTrueoBetExtraJson = buildTrueoBetExtraJson;
+exports.buildTrueoPurposePrefill = buildTrueoPurposePrefill;
+exports.encodeErc20Approve = encodeErc20Approve;
+exports.encodePermit2Approve = encodePermit2Approve;
+exports.encodeTrueoAdapterBurn = encodeTrueoAdapterBurn;
+exports.encodeTrueoAdapterMint = encodeTrueoAdapterMint;
+exports.encodeTrueoAdapterRedeem = encodeTrueoAdapterRedeem;
+exports.encodeTrueoBurn = encodeTrueoBurn;
+exports.encodeTrueoCancelOrder = encodeTrueoCancelOrder;
+exports.encodeTrueoCreateOrder = encodeTrueoCreateOrder;
+exports.encodeTrueoMint = encodeTrueoMint;
+exports.encodeTrueoRedeem = encodeTrueoRedeem;
+exports.encodeTrueoTydDeposit = encodeTrueoTydDeposit;
+exports.encodeTrueoTydRedeem = encodeTrueoTydRedeem;
+exports.encodeTrueoUniversalRouterExecute = encodeTrueoUniversalRouterExecute;
+exports.encodeTrueoV4ExactInInput = encodeTrueoV4ExactInInput;
+exports.encodeTrueoV4ExactInSwap = encodeTrueoV4ExactInSwap;
+exports.extraJsonFromSignRequest = extraJsonFromSignRequest;
+exports.fetchTrueoCategories = fetchTrueoCategories;
+exports.fetchTrueoChanceSeries = fetchTrueoChanceSeries;
+exports.fetchTrueoMarket = fetchTrueoMarket;
+exports.fetchTrueoOhlc = fetchTrueoOhlc;
+exports.fetchTrueoOrderbook = fetchTrueoOrderbook;
+exports.fetchTrueoTransactions = fetchTrueoTransactions;
+exports.fetchTrueoTrending = fetchTrueoTrending;
+exports.filterTrueoMarkets = filterTrueoMarkets;
+exports.getPredictionMarketSummary = getPredictionMarketSummary;
+exports.isTrueoBetAction = isTrueoBetAction;
+exports.isTrueoChainSupported = isTrueoChainSupported;
+exports.isTrueoCoreToken = isTrueoCoreToken;
+exports.isTrueoMarketLiveOrRecent = isTrueoMarketLiveOrRecent;
+exports.isTrueoMarketTradingOpen = isTrueoMarketTradingOpen;
+exports.isTrueoOutcomeTokenLabel = isTrueoOutcomeTokenLabel;
+exports.listMyPredictionMarketsSummary = listMyPredictionMarketsSummary;
+exports.listPredictionMarketsForHoldings = listPredictionMarketsForHoldings;
+exports.listTrueoMarketsPage = listTrueoMarketsPage;
+exports.normalizeTrueoAddress = normalizeTrueoAddress;
+exports.normalizeTrueoMarketRow = normalizeTrueoMarketRow;
+exports.normalizeTrueoOhlcResolution = normalizeTrueoOhlcResolution;
+exports.outcomeTokensFromMarkets = outcomeTokensFromMarkets;
+exports.parseTrueoBetExtraJson = parseTrueoBetExtraJson;
+exports.preferOpenTrueoTitleMatches = preferOpenTrueoTitleMatches;
+exports.readTrueoPoolKeys = readTrueoPoolKeys;
+exports.searchPredictionMarkets = searchPredictionMarkets;
+exports.searchPredictionMarketsSummary = searchPredictionMarketsSummary;
+exports.searchTrueoMarkets = searchTrueoMarkets;
+exports.searchTrueoMarketsPage = searchTrueoMarketsPage;
+exports.suggestTrueoTokensToAdd = suggestTrueoTokensToAdd;
+exports.trueoAdapterMintAbi = trueoAdapterMintAbi;
+exports.trueoBetCreateBlockedReason = trueoBetCreateBlockedReason;
+exports.trueoBetExecuteBlockedReason = trueoBetExecuteBlockedReason;
+exports.trueoCompactVolumeLabel = trueoCompactVolumeLabel;
+exports.trueoErc20Abi = trueoErc20Abi;
+exports.trueoExpiresAtIso = trueoExpiresAtIso;
+exports.trueoExpiresAtLabel = trueoExpiresAtLabel;
+exports.trueoFetchCategoriesSummary = trueoFetchCategoriesSummary;
+exports.trueoFetchChanceSeriesSummary = trueoFetchChanceSeriesSummary;
+exports.trueoFetchMarketSummary = trueoFetchMarketSummary;
+exports.trueoFetchOrderbookSummary = trueoFetchOrderbookSummary;
+exports.trueoFetchTrendingSummary = trueoFetchTrendingSummary;
+exports.trueoHoldingTokenAddressesFromRegistry = trueoHoldingTokenAddressesFromRegistry;
+exports.trueoImpliedPriceFromSqrtX96 = trueoImpliedPriceFromSqrtX96;
+exports.trueoIsSaneImpliedPrice = trueoIsSaneImpliedPrice;
+exports.trueoJsonFetch = trueoJsonFetch;
+exports.trueoListUsesTrending = trueoListUsesTrending;
+exports.trueoMarketAbi = trueoMarketAbi;
+exports.trueoMarketApiPath = trueoMarketApiPath;
+exports.trueoMarketStatusLabel = trueoMarketStatusLabel;
+exports.trueoMarketToPredictionRow = trueoMarketToPredictionRow;
+exports.trueoMarketV2Abi = trueoMarketV2Abi;
+exports.trueoMarketVotingOpen = trueoMarketVotingOpen;
+exports.trueoOrderManagerAbi = trueoOrderManagerAbi;
+exports.trueoOrderManagerStructAbi = trueoOrderManagerStructAbi;
+exports.trueoPercentLabel = trueoPercentLabel;
+exports.trueoPermit2ApproveAbi = trueoPermit2ApproveAbi;
+exports.trueoPermit2Expiration = trueoPermit2Expiration;
+exports.trueoProtocolModule = trueoProtocolModule;
+exports.trueoQueryTokens = trueoQueryTokens;
+exports.trueoResolutionCopy = trueoResolutionCopy;
+exports.trueoResolvedSide = trueoResolvedSide;
+exports.trueoSanitizeBinaryPrices = trueoSanitizeBinaryPrices;
+exports.trueoSearchMarketsSummary = trueoSearchMarketsSummary;
+exports.trueoSearchScopeNote = trueoSearchScopeNote;
+exports.trueoSwapDeadline = trueoSwapDeadline;
+exports.trueoTimeUntilTradingEndsLabel = trueoTimeUntilTradingEndsLabel;
+exports.trueoTradingDeadlineLabel = trueoTradingDeadlineLabel;
+exports.trueoTradingEndsCopy = trueoTradingEndsCopy;
+exports.trueoTydVaultAbi = trueoTydVaultAbi;
+exports.trueoUniversalRouterAdapterAbi = trueoUniversalRouterAdapterAbi;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map