@stablecoin.xyz/swap-intent 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,1057 @@
+// ../../mcp/shared/intent-check.ts
+import { formatUnits, getAddress as getAddress2, toHex } from "viem";
+import { PublicKey as PublicKey3 } from "@solana/web3.js";
+import { ASSOCIATED_TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync } from "@solana/spl-token";
+
+// ../../engine/svm.js
+import { PublicKey } from "@solana/web3.js";
+import { getAddress } from "viem";
+var SETTLE_DISC = {
+  open: Buffer.from([228, 220, 155, 71, 199, 189, 60, 45]),
+  claim: Buffer.from([62, 198, 214, 193, 213, 159, 108, 210]),
+  refund: Buffer.from([2, 96, 183, 251, 63, 208, 46, 46])
+};
+var SETTLE_ORDER_DISC = Buffer.from([134, 173, 223, 185, 77, 86, 28, 51]);
+var ATTEST_DOMAIN = Buffer.from("BRALE_ORIGIN_SETTLE_V1");
+var pad32 = (evmAddr) => Buffer.concat([Buffer.alloc(12), Buffer.from(getAddress(evmAddr).slice(2), "hex")]);
+var evmFrom32 = (b32) => getAddress("0x" + Buffer.from(b32).subarray(12).toString("hex"));
+
+// ../../engine/order-ttl.js
+var MAX_ORDER_TTL_SECS = 24 * 60 * 60;
+
+// ../../registry.generated.js
+var REGISTRY = { "mainnet": { "tokens": { "SBC": { "base": { "address": "0xfdcC3dd6671eaB0709A4C0f3F53De9a333d80798", "decimals": 18 }, "solana": { "mint": "DBAzBUXaLj1qANCseUPZz4sp9F8d2sc78C4vKjhbTGMA", "decimals": 9 }, "radius": { "address": "0x33ad9e4BD16B69B5BFdED37D8B5D9fF9aba014Fb", "decimals": 6 }, "brale_value_type": "SBC", "par_usd": true }, "USDC": { "base": { "address": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", "decimals": 6 }, "solana": { "mint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", "decimals": 6 }, "par_usd": true }, "cfUSD": { "base": { "address": "0x131409B31bF446737dD04353D43DACada544b6fA", "decimals": 6 }, "solana": { "mint": "9Qh5igeYVb9ZC6s6BfNaffycTiNTqv9KhL432LdqyT4Y", "decimals": 9 }, "brale_value_type": "cfUSD", "par_usd": true }, "HSUSD": { "solana": { "mint": "4FVaHEubcqws8hKwJSiW8f8CmKGUyMsBxTKUytcGdRvd", "decimals": 9 }, "brale_value_type": "HSUSD", "par_usd": true }, "rUSD": { "base": { "address": "0xd899C2254C1F4B11FfF038571D6cb02aB8860eC8", "decimals": 6 }, "brale_value_type": "rUSD", "par_usd": true }, "USDGLO": { "base": { "address": "0x4F604735c1cF31399C6E711D5962b2B3E0225AD3", "decimals": 18 }, "brale_value_type": "USDGLO", "par_usd": true } } }, "testnet": { "tokens": { "SBC": { "base": { "address": "0xf9FB20B8E097904f0aB7d12e9DbeE88f2dcd0F16", "decimals": 6 }, "radius": { "address": "0x33ad9e4BD16B69B5BFdED37D8B5D9fF9aba014Fb", "decimals": 6 }, "solana": { "mint": "8vnThy8iZjjzxXg1dRagzqp6QZHVqfHT9swUBp5cYsuE", "decimals": 9 }, "brale_value_type": "SBC", "par_usd": true }, "USDC": { "base": { "address": "0x036CbD53842c5426634e7929541eC2318f3dCF7e", "decimals": 6 }, "solana": { "mint": "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU", "decimals": 6 }, "par_usd": true }, "cfUSD": { "base": { "address": "0x3E6975D4D85528d1E2cDEbD5FD440AB1C47b6939", "decimals": 6 }, "solana": { "mint": "6EarWgaa1PBoriuCWBSwPatFy1DTNnhXRsq8chE1f2Ja", "decimals": 9 }, "brale_value_type": "cfUSD", "par_usd": true }, "USDGLO": { "base": { "address": "0xE2B10292D34c64C30fc427427207AC285Bb324D1", "decimals": 18 }, "par_usd": true }, "USBC": { "base": { "address": "0x8976F63503366CbF293c144eceD857304e27691C", "decimals": 6 }, "solana": { "mint": "6vW9MMVXj9bi3ctJ9PXDevVgFyqyyL2TXznnMvh6uBBf", "decimals": 6 } }, "SBCX": { "base": { "address": "0xBc22a2a9F310A14ffEA77B87E3BEF0Ed6d912eD4", "decimals": 6 }, "solana": { "mint": "FitjzhLCnp4qezXnFGCWtQxgzps7y7DnsAszEH1WG9vi", "decimals": 6 } }, "OUSD": { "base": { "address": "0xC38D649aE6dFe9F689D4d35288d48fD55D4D2aDf", "decimals": 6 }, "solana": { "mint": "9i2S2wkqhQ2K6trHVA4aCSyPqqKmAagBC6GimhwWPYvn", "decimals": 6 } }, "MOCK_SBC": { "solana": { "mint": "DRTscPBHTYyUs2buH5tuuFtxJcY1Jdtag82KsPrsbBcr", "decimals": 9 } } } } };
+
+// ../../mcp/shared/addresses.generated.json
+var addresses_generated_default = {
+  mainnet: {
+    base: {
+      chainId: 8453,
+      escrow: "0x4F0c8045479DD9163977f3511c11a13D0dD666da",
+      rfqRouter: "0x8A62446bDbf0Df502a1C7fb2BBA31Fc69296d536",
+      permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
+      solver: "0x75770a6c6746D8B5B1C82c149B61B5bBc3dEDDe5"
+    },
+    radius: {
+      chainId: 723487,
+      escrow: "0xd6b99696C2A1363b30B47b850027d38fe177FC55"
+    },
+    solana: {
+      dstChainId: 900,
+      originSettler: "5MwMD5AbUDd2s5E4TSa3GvMKRUKQWxpKgH8LHWFXgqoY",
+      solver: "BvVi9qmmthHMwvbWLVwS9HefZ3fHVD3jAv5rygHJAkzG"
+    }
+  },
+  testnet: {
+    base: {
+      chainId: 84532,
+      escrow: "0xb5C3ac0a0e0D55af011f7BfE667EA99f936dA76c",
+      rfqRouter: "0xE223A90bb254F17e48120653678cD96dB877D349",
+      permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
+      solver: "0x75770a6c6746D8B5B1C82c149B61B5bBc3dEDDe5"
+    },
+    radius: {
+      chainId: 72344,
+      escrow: "0x7B90cd94e7cDA6c0391A8d9a51De53B9aa2E9ee3"
+    },
+    solana: {
+      dstChainId: 901,
+      originSettler: "5MwMD5AbUDd2s5E4TSa3GvMKRUKQWxpKgH8LHWFXgqoY",
+      solver: "BvVi9qmmthHMwvbWLVwS9HefZ3fHVD3jAv5rygHJAkzG",
+      sbcMint: "4VAdTvRcaDWCBU3kYpo8Xg8gtAqBCfCVu2jJ1r3PwU8j"
+    }
+  }
+};
+
+// ../../mcp/shared/sign-request.ts
+function loadManifest() {
+  return addresses_generated_default;
+}
+var INT_TYPE = /^u?int\d*$/;
+var ARRAY_TYPE = /^(.*)\[\d*\]$/;
+function hydrateValue(type, value, types) {
+  const arr = ARRAY_TYPE.exec(type);
+  if (arr) return Array.isArray(value) ? value.map((x) => hydrateValue(arr[1], x, types)) : value;
+  if (INT_TYPE.test(type)) return BigInt(value);
+  const fields = types[type];
+  if (fields && value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, hydrateValue(fields.find((f) => f.name === k)?.type ?? "", v, types)]));
+  }
+  return value;
+}
+function hydrateTypedData(td) {
+  const message = hydrateValue(td.primaryType, td.message, td.types);
+  const { EIP712Domain: _omit, ...types } = td.types;
+  return { domain: td.domain, types, primaryType: td.primaryType, message };
+}
+
+// ../../mcp/shared/sol-decode.ts
+import { ComputeBudgetProgram, PublicKey as PublicKey2, SystemProgram, VersionedTransaction } from "@solana/web3.js";
+import { TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID } from "@solana/spl-token";
+var TOKEN_PROGRAMS = /* @__PURE__ */ new Set([TOKEN_PROGRAM_ID.toBase58(), TOKEN_2022_PROGRAM_ID.toBase58()]);
+var SYSTEM = SystemProgram.programId.toBase58();
+var COMPUTE_BUDGET = ComputeBudgetProgram.programId.toBase58();
+var TRANSFER = 3;
+var TRANSFER_CHECKED = 12;
+var SYSTEM_TRANSFER = 2;
+var view = (d) => new DataView(d.buffer, d.byteOffset, d.byteLength);
+var u32 = (d, o) => view(d).getUint32(o, true);
+var u64 = (d, o) => view(d).getBigUint64(o, true);
+var i64 = (d, o) => view(d).getBigInt64(o, true);
+var hex = (d) => Array.from(d, (b) => b.toString(16).padStart(2, "0")).join("");
+var sameBytes = (a, b) => a.length === b.length && a.every((x, i) => x === b[i]);
+var fromBase64 = (s) => Uint8Array.from(atob(s), (c) => c.charCodeAt(0));
+function decodeIx(program, accounts, data, signers) {
+  const ix = { program, accounts, signers };
+  if (TOKEN_PROGRAMS.has(program) && data[0] === TRANSFER_CHECKED && data.length >= 10) {
+    ix.transfer = { program, source: accounts[0], mint: accounts[1], dest: accounts[2], authority: accounts[3], amount: u64(data, 1) };
+  } else if (TOKEN_PROGRAMS.has(program) && data[0] === TRANSFER && data.length >= 9) {
+    ix.transfer = { program, source: accounts[0], mint: null, dest: accounts[1], authority: accounts[2], amount: u64(data, 1) };
+  } else if (program === SYSTEM && data.length >= 12 && u32(data, 0) === SYSTEM_TRANSFER) {
+    ix.lamports = { from: accounts[0], to: accounts[1], amount: u64(data, 4) };
+  } else if (program === COMPUTE_BUDGET && data[0] === 2 && data.length >= 5) {
+    ix.computeBudget = { limit: u32(data, 1) };
+  } else if (program === COMPUTE_BUDGET && data[0] === 3 && data.length >= 9) {
+    ix.computeBudget = { microLamports: u64(data, 1) };
+  } else if (data.length >= 184 && sameBytes(data.subarray(0, 8), SETTLE_DISC.open)) {
+    ix.open = {
+      program,
+      user: accounts[0],
+      inputMint: accounts[1],
+      userAta: accounts[3],
+      tokenProgram: accounts[6],
+      solver: new PublicKey2(data.subarray(40, 72)).toBase58(),
+      inputAmount: u64(data, 72),
+      outputToken: "0x" + hex(data.subarray(80, 112)),
+      outputAmount: u64(data, 112) + (u64(data, 120) << 64n),
+      recipientEvm: evmFrom32(data.subarray(128, 160)),
+      dstChainId: Number(u64(data, 160)),
+      fillDeadline: i64(data, 168),
+      expires: i64(data, 176)
+    };
+  }
+  return ix;
+}
+async function decodeSolRequest(req, deps) {
+  const msg = VersionedTransaction.deserialize(fromBase64(req.txBase64)).message;
+  const lookups = "addressTableLookups" in msg ? msg.addressTableLookups : [];
+  const alts = lookups.length ? await deps.loadAlts(lookups.map((l) => l.accountKey), req.net) : [];
+  const keys = msg.getAccountKeys({ addressLookupTableAccounts: alts });
+  const nSig = msg.header.numRequiredSignatures;
+  const at = (i) => {
+    const k = keys.get(i);
+    if (!k) throw new Error("refused: transaction references an account that could not be resolved");
+    return k.toBase58();
+  };
+  return {
+    feePayer: at(0),
+    instructions: msg.compiledInstructions.map(
+      (ci) => decodeIx(at(ci.programIdIndex), ci.accountKeyIndexes.map(at), ci.data, ci.accountKeyIndexes.filter((i) => i < nSig).map(at))
+    )
+  };
+}
+
+// ../../mcp/shared/intent-check.ts
+var DEFAULT_LIMITS = { maxRedeemSlippageBps: 150, maxSolPriorityFeeLamports: 2e6 };
+var GAS_FLOOR_PCT = 97n;
+var isGasRoute = (req) => req.kind === "sol-tx" ? req.route === "gas-sol" : req.kind === "evm-permit";
+var gasQuoteQuery = (req, spend) => ({ chain: req.kind === "sol-tx" ? "solana" : "base", in: req.inSym, amount: formatUnits(spend.units, spend.decimals) });
+function gasSpend(p) {
+  const { req } = p;
+  if (!isGasRoute(req)) return void 0;
+  const decimals = token(req.net, req.inSym, sourceChain(req))?.decimals;
+  if (decimals === void 0) return void 0;
+  if (req.kind !== "sol-tx") return p.evm ? { units: p.evm.inputAmount, decimals } : void 0;
+  const me = p.self.sol;
+  const mine = me && p.sol ? userInstructions(p.sol, me) : [];
+  const pay = mine.length === 1 ? mine[0].transfer : void 0;
+  return pay ? { units: pay.amount, decimals } : void 0;
+}
+var spendMatchesDeclared = (s, uiAmount) => {
+  const spent = Number(formatUnits(s.units, s.decimals));
+  return Math.abs(spent - uiAmount) <= 1e-6 + uiAmount * 1e-9;
+};
+function gasFloorOf(quote) {
+  if (quote.fillable === false) throw new Error("gas top-up is not fillable right now");
+  try {
+    return BigInt(quote.outBaseUnits) * GAS_FLOOR_PCT / 100n;
+  } catch {
+    throw new Error("gas quote unavailable");
+  }
+}
+var MIN_DEADLINE_S = 60;
+var MAX_DEADLINE_AHEAD_S = 7200;
+var TTL_SKEW_S = 600;
+var DEFAULT_CU_PER_IX = 2e5;
+var MAX_CU = 14e5;
+var ZERO_ADDR = "0x0000000000000000000000000000000000000000";
+var scale = (amount, from, to) => to >= from ? amount * 10n ** BigInt(to - from) : amount / 10n ** BigInt(from - to);
+var lessBps = (amount, bps) => amount * BigInt(1e4 - bps) / 10000n;
+var nowS = (p) => BigInt(Math.floor(p.now / 1e3));
+function orderWindow(p, expires, fillDeadline) {
+  need(expires <= nowS(p) + BigInt(MAX_ORDER_TTL_SECS + TTL_SKEW_S), "deadline-too-far");
+  need(fillDeadline <= expires, "deadline-too-far");
+}
+var Refuse = class {
+  reason;
+  constructor(reason) {
+    this.reason = reason;
+  }
+};
+function need(cond, reason) {
+  if (!cond) throw new Refuse(reason);
+}
+var sameEvm = (a, b) => !!a && !!b && getAddress2(a) === getAddress2(b);
+function token(net, sym, chain) {
+  const tokens = REGISTRY[net]?.tokens ?? {};
+  const key = Object.keys(tokens).find((k) => k.toUpperCase() === sym.toUpperCase());
+  const t = key ? tokens[key]?.[chain] : void 0;
+  const sbcMint = loadManifest()[net]?.solana.sbcMint;
+  return t && chain === "solana" && key.toUpperCase() === "SBC" && sbcMint ? { ...t, mint: sbcMint } : t;
+}
+function userInstructions(s, me) {
+  const harmless = (ix) => ix.program === ASSOCIATED_TOKEN_PROGRAM_ID.toBase58() && ix.accounts[0] !== me || ix.lamports !== void 0 && ix.lamports.from !== me;
+  return s.instructions.filter((ix) => ix.signers.includes(me) && !harmless(ix));
+}
+var sourceChain = (req) => req.kind === "sol-tx" ? "solana" : req.chain;
+function ata(mint, owner, program) {
+  return getAssociatedTokenAddressSync(new PublicKey3(mint), new PublicKey3(owner), true, new PublicKey3(program)).toBase58();
+}
+function quotedOutOf(req) {
+  try {
+    return BigInt(String(req.submitBody.quotedOut));
+  } catch {
+    throw new Refuse("output-below-floor");
+  }
+}
+var limits = (p) => p.limits ?? DEFAULT_LIMITS;
+function evmChecks(p, e) {
+  const { req, self } = p;
+  const m = loadManifest()[req.net];
+  const chain = sourceChain(req);
+  const inTok = token(req.net, req.inSym, chain);
+  const chainId = chain === "radius" ? m.radius?.chainId : m.base.chainId;
+  need(e.chainId === chainId, "wrong-chain");
+  need(sameEvm(e.inputToken, inTok.address), "unknown-token");
+  const out = { units: e.inputAmount, destChain: chain, recipient: e.recipient, deadline: e.deadline, expires: e.expires };
+  if (req.kind === "evm-rfq") {
+    need(sameEvm(e.target, m.base.rfqRouter), "unknown-target");
+    need(sameEvm(e.spender, m.base.rfqRouter), "unknown-spender");
+    need(sameEvm(e.solver, m.base.solver), "unknown-solver");
+    const outTok = token(req.net, req.outSym, "base");
+    need(sameEvm(e.outputToken, outTok?.address), "unknown-token");
+    const par = scale(e.inputAmount, inTok.decimals, outTok.decimals);
+    need(e.minOutput >= (req.route === "base-redeem" ? lessBps(par, limits(p).maxRedeemSlippageBps) : par), "output-below-floor");
+    out.destChain = "base";
+    out.outUnits = e.minOutput;
+    out.outDecimals = outTok.decimals;
+  } else if (req.kind === "evm-permit") {
+    need(sameEvm(e.spender, m.base.solver), "unknown-spender");
+    need(p.minOut !== void 0, "gas-floor-missing");
+    need(quotedOutOf(req) >= p.minOut, "output-below-floor");
+  } else {
+    const escrow = chain === "radius" ? m.radius?.escrow : m.base.escrow;
+    need(sameEvm(e.target, escrow), "unknown-target");
+    need(sameEvm(e.destinationSettler, ZERO_ADDR), "unknown-target");
+    need(sameEvm(e.filler, m.base.solver), "unknown-solver");
+    let outDec;
+    let destChain;
+    if (e.recipientVm === "svm") {
+      need(e.destinationChainId === BigInt(m.solana.dstChainId), "wrong-chain");
+      const outT = token(req.net, req.outSym, "solana");
+      need(outT?.mint && e.outputToken === toHex(new PublicKey3(outT.mint).toBytes()), "unknown-token");
+      outDec = outT.decimals;
+      destChain = "solana";
+    } else {
+      const dst = e.destinationChainId === BigInt(m.base.chainId) ? "base" : e.destinationChainId === BigInt(m.radius?.chainId ?? -1) ? "radius" : null;
+      need(dst && dst !== chain, "wrong-chain");
+      const outT = token(req.net, req.outSym, dst);
+      need(outT?.address && String(e.outputToken).toLowerCase() === toHex(pad32(outT.address)).toLowerCase(), "unknown-token");
+      outDec = outT.decimals;
+      destChain = dst;
+    }
+    need(e.outputAmount >= scale(e.inputAmount, inTok.decimals, outDec), "output-below-floor");
+    orderWindow(p, e.expires, e.fillDeadline);
+    out.destChain = destChain;
+    out.outUnits = e.outputAmount;
+    out.outDecimals = outDec;
+  }
+  need(sameEvm(e.owner, self.evm), "owner-not-self");
+  need(e.recipientVm === "evm" ? sameEvm(e.recipient, self.evm) : !!self.sol && e.recipient === self.sol, "recipient-not-self");
+  need(e.deadline === void 0 || e.deadline >= nowS(p) + BigInt(MIN_DEADLINE_S), "deadline-too-close");
+  need(e.deadline === void 0 || e.deadline <= nowS(p) + BigInt(MAX_DEADLINE_AHEAD_S), "deadline-too-far");
+  return out;
+}
+function solChecks(p, s) {
+  const { req, self } = p;
+  need(req.kind === "sol-tx", "unexpected-instruction");
+  const m = loadManifest()[req.net];
+  const me = self.sol;
+  need(me, "owner-not-self");
+  const mine = userInstructions(s, me);
+  need(mine.length === 1, "unexpected-instruction");
+  const ix = mine[0];
+  const inMint = token(req.net, req.inSym, "solana").mint;
+  const inDec = token(req.net, req.inSym, "solana").decimals;
+  if (req.route === "xchain-sol-origin") {
+    need(ix.open, "unexpected-instruction");
+    const o = ix.open;
+    need(o.program === m.solana.originSettler, "unknown-target");
+    need(s.instructions.every((i) => i.program === m.solana.originSettler || i.program === COMPUTE_BUDGET), "unexpected-instruction");
+    const limit = s.instructions.find((i) => i.computeBudget?.limit !== void 0)?.computeBudget?.limit ?? Math.min(MAX_CU, DEFAULT_CU_PER_IX * s.instructions.filter((i) => i.program !== COMPUTE_BUDGET).length);
+    const price = s.instructions.find((i) => i.computeBudget?.microLamports !== void 0)?.computeBudget?.microLamports ?? 0n;
+    need(BigInt(limit) * price / 1000000n <= BigInt(limits(p).maxSolPriorityFeeLamports), "fee-too-high");
+    need(o.user === me, "owner-not-self");
+    need(o.userAta === ata(inMint, me, o.tokenProgram), "unexpected-instruction");
+    need(o.solver === m.solana.solver, "unknown-solver");
+    need(o.inputMint === inMint, "unknown-token");
+    const dst = o.dstChainId === m.base.chainId ? "base" : o.dstChainId === m.radius?.chainId ? "radius" : null;
+    need(dst, "wrong-chain");
+    const out = token(req.net, req.outSym, dst);
+    need(out?.address && o.outputToken.toLowerCase() === toHex(pad32(out.address)).toLowerCase(), "unknown-token");
+    need(sameEvm(o.recipientEvm, self.evm), "recipient-not-self");
+    need(o.outputAmount >= scale(o.inputAmount, inDec, out.decimals), "output-below-floor");
+    orderWindow(p, o.expires, o.fillDeadline);
+    return { units: o.inputAmount, outUnits: o.outputAmount, outDecimals: out.decimals, destChain: dst, recipient: o.recipientEvm, expires: o.expires };
+  }
+  need(s.feePayer !== me, "user-is-fee-payer");
+  need(ix.transfer && ix.transfer.authority === me && ix.transfer.mint, "unexpected-instruction");
+  const pay = ix.transfer;
+  need(pay.mint === inMint, "unknown-token");
+  need(pay.source === ata(inMint, me, pay.program), "unexpected-instruction");
+  need(pay.dest === ata(inMint, m.solana.solver, pay.program), "unknown-spender");
+  const res = { units: pay.amount, destChain: "solana", recipient: me };
+  if (req.route === "gas-sol") {
+    need(s.instructions.some((i) => i.lamports && i.lamports.to === me && i.lamports.amount > 0n), "recipient-not-self");
+    res.outUnits = s.instructions.reduce((a, i) => i.lamports && i.lamports.to === me ? a + i.lamports.amount : a, 0n);
+    res.outDecimals = 9;
+    need(p.minOut !== void 0, "gas-floor-missing");
+    need(res.outUnits >= p.minOut, "output-below-floor");
+  } else {
+    const outT = token(req.net, req.outSym, "solana");
+    need(outT?.mint, "unknown-token");
+    const par = scale(pay.amount, inDec, outT.decimals);
+    const floor = req.route === "sol-redeem" ? lessBps(par, limits(p).maxRedeemSlippageBps) : par;
+    const credits = s.instructions.filter((i) => i.transfer && i.transfer.mint === outT.mint && i.transfer.dest === ata(outT.mint, me, i.transfer.program));
+    need(credits.length > 0, "recipient-not-self");
+    const credited = credits.reduce((a, i) => a + i.transfer.amount, 0n);
+    need(credited >= floor, "output-below-floor");
+    res.outUnits = credited;
+    res.outDecimals = outT.decimals;
+  }
+  return res;
+}
+function checkIntent(p) {
+  try {
+    const { req } = p;
+    const inTok = token(req.net, req.inSym, sourceChain(req));
+    need(inTok && (inTok.address || inTok.mint), "unknown-token");
+    const checked = req.kind === "sol-tx" ? (need(p.sol, "unexpected-instruction"), solChecks(p, p.sol)) : (need(p.evm, "unexpected-instruction"), evmChecks(p, p.evm));
+    need(spendMatchesDeclared({ units: checked.units, decimals: inTok.decimals }, req.uiAmount), "amount-mismatch");
+    return { ok: true, decimals: inTok.decimals, ...checked };
+  } catch (e) {
+    if (e instanceof Refuse) return { ok: false, reason: e.reason };
+    throw e;
+  }
+}
+
+// ../../mcp/shared/evm-decode.ts
+import { decodeAbiParameters, decodeFunctionData, getAddress as getAddress4, hexToBytes } from "viem";
+import { PublicKey as PublicKey4 } from "@solana/web3.js";
+
+// ../../ui-app/src/core/evm.ts
+var PERMIT_TYPES = {
+  Permit: [
+    { name: "owner", type: "address" },
+    { name: "spender", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" }
+  ]
+};
+var RFQ_ORDER_TYPES = {
+  RfqOrder: [
+    { name: "user", type: "address" },
+    { name: "inputToken", type: "address" },
+    { name: "inputAmount", type: "uint256" },
+    { name: "outputToken", type: "address" },
+    { name: "minOutputAmount", type: "uint256" },
+    { name: "solver", type: "address" },
+    { name: "deadline", type: "uint256" },
+    { name: "nonce", type: "uint256" }
+  ]
+};
+function rfqDomain(router, chainId) {
+  return { name: "BraleRfqSwap", version: "1", chainId, verifyingContract: router };
+}
+function rfqOrderTypedData(router, chainId, order) {
+  return {
+    domain: rfqDomain(router, chainId),
+    types: RFQ_ORDER_TYPES,
+    primaryType: "RfqOrder",
+    message: order
+  };
+}
+var ERC20_ABI = [
+  { type: "function", name: "decimals", stateMutability: "view", inputs: [], outputs: [{ type: "uint8" }] },
+  { type: "function", name: "approve", stateMutability: "nonpayable", inputs: [{ type: "address" }, { type: "uint256" }], outputs: [{ type: "bool" }] },
+  { type: "function", name: "allowance", stateMutability: "view", inputs: [{ type: "address" }, { type: "address" }], outputs: [{ type: "uint256" }] },
+  { type: "function", name: "balanceOf", stateMutability: "view", inputs: [{ type: "address" }], outputs: [{ type: "uint256" }] }
+];
+var EVM_OPEN_ABI = [
+  {
+    type: "function",
+    name: "open",
+    stateMutability: "nonpayable",
+    inputs: [
+      {
+        name: "order",
+        type: "tuple",
+        components: [
+          { name: "settlementContract", type: "address" },
+          { name: "swapper", type: "address" },
+          { name: "nonce", type: "uint256" },
+          { name: "originChainId", type: "uint256" },
+          { name: "initiateDeadline", type: "uint256" },
+          { name: "fillDeadline", type: "uint256" },
+          { name: "orderDataType", type: "bytes32" },
+          { name: "orderData", type: "bytes" }
+        ]
+      },
+      { name: "signature", type: "bytes" },
+      { name: "fillerData", type: "bytes" }
+    ],
+    outputs: []
+  }
+];
+function rehydrateOrder(o) {
+  return {
+    settlementContract: o.settlementContract,
+    swapper: o.swapper,
+    nonce: BigInt(o.nonce),
+    originChainId: BigInt(o.originChainId),
+    initiateDeadline: BigInt(o.initiateDeadline),
+    fillDeadline: BigInt(o.fillDeadline),
+    orderDataType: o.orderDataType,
+    orderData: o.orderData
+  };
+}
+
+// ../../engine/evm.js
+import { keccak256, toHex as toHex2, encodeAbiParameters, getAddress as getAddress3 } from "viem";
+import { base, baseSepolia } from "viem/chains";
+var braleOrderDataType = {
+  type: "tuple",
+  components: [
+    { name: "inputToken", type: "address" },
+    { name: "inputAmount", type: "uint256" },
+    { name: "outputToken", type: "bytes32" },
+    { name: "outputAmount", type: "uint256" },
+    { name: "outputRecipient", type: "bytes32" },
+    { name: "destinationChainId", type: "uint256" },
+    { name: "expires", type: "uint256" },
+    { name: "destinationSettler", type: "address" },
+    { name: "filler", type: "address" }
+    // [L-2] swapper-signed filler; ANY_FILLER = open
+  ]
+};
+
+// ../../mcp/shared/evm-decode.ts
+function must(cond, msg) {
+  if (!cond) throw new Error(`refused: ${msg}`);
+}
+var addr = (v) => getAddress4(String(v));
+function permitFacts(p) {
+  must(p?.primaryType === "Permit", "permit typed data is not an EIP-2612 Permit");
+  return {
+    token: addr(p.domain.verifyingContract),
+    chainId: Number(p.domain.chainId),
+    owner: addr(p.message.owner),
+    spender: addr(p.message.spender),
+    value: BigInt(p.message.value),
+    deadline: BigInt(p.message.deadline)
+  };
+}
+function decodeRfq(req) {
+  const o = req.orderTypedData;
+  must(o?.primaryType === "RfqOrder", "order typed data is not an RfqOrder");
+  const m = o.message;
+  const p = permitFacts(req.permitTypedData);
+  const router = addr(o.domain.verifyingContract);
+  const inputToken = addr(m.inputToken), inputAmount = BigInt(m.inputAmount), deadline = BigInt(m.deadline), user = addr(m.user);
+  must(p.token === inputToken, "permit token is not the order input token");
+  must(p.value === inputAmount, "permit value is not the order input amount");
+  must(p.deadline === deadline, "permit deadline is not the order deadline");
+  must(p.owner === user, "permit owner is not the order user");
+  must(p.chainId === Number(o.domain.chainId), "permit and order are for different chains");
+  must(sameOrder(req.order, m), "submitted order differs from the signed order");
+  return {
+    chainId: Number(o.domain.chainId),
+    owner: user,
+    spender: p.spender,
+    target: router,
+    inputToken,
+    inputAmount,
+    recipient: user,
+    recipientVm: "evm",
+    solver: addr(m.solver),
+    outputToken: addr(m.outputToken),
+    deadline,
+    minOutput: BigInt(m.minOutputAmount)
+  };
+}
+function sameOrder(a, m) {
+  const keys = ["user", "inputToken", "inputAmount", "outputToken", "minOutputAmount", "solver", "deadline", "nonce"];
+  return keys.every((k) => String(a[k]).toLowerCase() === String(m[k]).toLowerCase());
+}
+function decodePermit(req) {
+  const p = permitFacts(req.permitTypedData);
+  must(String(req.submitBody.user).toLowerCase() === p.owner.toLowerCase(), "gas top-up is for a different wallet than the permit owner");
+  return { chainId: p.chainId, owner: p.owner, spender: p.spender, target: null, inputToken: p.token, inputAmount: p.value, recipient: p.owner, recipientVm: "evm", deadline: p.deadline };
+}
+function decodeTxs(req) {
+  must(req.txs.length === 2, "expected exactly 2 transactions (approve, open)");
+  for (const t of req.txs) must(BigInt(t.value) === 0n, "transactions must carry no native value");
+  const [approveTx, openTx] = req.txs;
+  const ap = decodeFunctionData({ abi: ERC20_ABI, data: approveTx.data });
+  must(ap.functionName === "approve", "first transaction is not an ERC-20 approve");
+  const op = decodeFunctionData({ abi: EVM_OPEN_ABI, data: openTx.data });
+  must(op.functionName === "open", "second transaction is not escrow open");
+  const order = op.args[0];
+  const escrow = addr(openTx.to);
+  const [od] = decodeAbiParameters([braleOrderDataType], order.orderData);
+  const [apSpender, apAmount] = ap.args;
+  must(addr(apSpender) === escrow, "approve spender is not the escrow being opened");
+  must(addr(approveTx.to) === addr(od.inputToken), "approve token is not the order input token");
+  must(apAmount === BigInt(od.inputAmount), "approve amount is not the order input amount");
+  must(addr(order.settlementContract) === escrow, "order settlementContract is not the escrow");
+  const net = loadManifest()[req.net];
+  const recipientBytes = hexToBytes(od.outputRecipient);
+  const toSolana = BigInt(od.destinationChainId) === BigInt(net.solana.dstChainId);
+  return {
+    chainId: Number(order.originChainId),
+    owner: addr(order.swapper),
+    spender: escrow,
+    target: escrow,
+    inputToken: addr(od.inputToken),
+    inputAmount: BigInt(od.inputAmount),
+    recipient: toSolana ? new PublicKey4(recipientBytes).toBase58() : evmFrom32(recipientBytes),
+    recipientVm: toSolana ? "svm" : "evm",
+    outputToken: od.outputToken,
+    destinationChainId: BigInt(od.destinationChainId),
+    deadline: BigInt(order.initiateDeadline),
+    outputAmount: BigInt(od.outputAmount),
+    filler: addr(od.filler),
+    destinationSettler: addr(od.destinationSettler),
+    expires: BigInt(od.expires),
+    fillDeadline: BigInt(order.fillDeadline)
+  };
+}
+function decodeEvmRequest(req) {
+  if (req.kind === "evm-rfq") return decodeRfq(req);
+  if (req.kind === "evm-permit") return decodePermit(req);
+  return decodeTxs(req);
+}
+
+// ../../mcp/worker/build.ts
+import { encodeFunctionData, getAddress as getAddress5, parseUnits } from "viem";
+
+// ../../ui-app/src/core/rfq.ts
+import { formatUnits as formatUnits2 } from "viem";
+var short = (a) => `${a.slice(0, 6)}\u2026${a.slice(-4)}`;
+function buildRfqOrder(p) {
+  const order = {
+    user: p.user,
+    inputToken: p.inputToken,
+    inputAmount: p.inputAmount,
+    outputToken: p.outputToken,
+    minOutputAmount: p.minOutputAmount,
+    solver: p.solver,
+    deadline: p.deadline,
+    nonce: p.nonce
+  };
+  const typedData = rfqOrderTypedData(p.router, p.chainId, order);
+  const confirmRows = rfqConfirmRows(order, p);
+  return { order, typedData, confirmRows };
+}
+function rfqConfirmRows(order, meta) {
+  const expires = new Date(Number(order.deadline) * 1e3);
+  return [
+    { label: "You pay", value: `${formatUnits2(order.inputAmount, meta.inputDecimals)} ${meta.inputSymbol}` },
+    {
+      label: "You receive at least",
+      value: `${formatUnits2(order.minOutputAmount, meta.outputDecimals)} ${meta.outputSymbol}`
+    },
+    { label: "Input token", value: short(order.inputToken) },
+    { label: "Output token", value: short(order.outputToken) },
+    { label: "Solver", value: short(order.solver) },
+    { label: "Your nonce", value: order.nonce.toString() },
+    { label: "Signature expires", value: expires.toISOString().replace("T", " ").slice(0, 16) + " UTC" }
+  ];
+}
+
+// ../../ui-app/src/core/solana.ts
+var B58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function b58decode(s) {
+  const map = {};
+  for (let i = 0; i < B58.length; i++) map[B58[i]] = i;
+  let bytes = [0];
+  for (const ch of s) {
+    if (!(ch in map)) throw new Error(`invalid base58 char '${ch}'`);
+    let carry = map[ch];
+    for (let j = 0; j < bytes.length; j++) {
+      carry += bytes[j] * 58;
+      bytes[j] = carry & 255;
+      carry >>= 8;
+    }
+    while (carry) {
+      bytes.push(carry & 255);
+      carry >>= 8;
+    }
+  }
+  for (const ch of s) {
+    if (ch === "1") bytes.push(0);
+    else break;
+  }
+  return Uint8Array.from(bytes.reverse());
+}
+function solToBytes32(addr2) {
+  const b = b58decode(addr2.trim());
+  if (b.length !== 32) throw new Error(`not a 32-byte Solana address (${b.length} bytes)`);
+  return "0x" + [...b].map((x) => x.toString(16).padStart(2, "0")).join("");
+}
+function isValidSolAddress(addr2) {
+  try {
+    solToBytes32(addr2);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ../../ui-app/src/core/engine.ts
+var BASE_PAR_OUT = ["SBC", "cfUSD"];
+var SOL_BUY_VAL = { SBC: "SBC", cfUSD: "CFUSD", HSUSD: "HSUSD" };
+var NATIVE_OF = { base: "ETH", solana: "SOL" };
+var isNativeSym = (s) => s === "ETH" || s === "SOL";
+var GAS_CHAINS = Object.keys(NATIVE_OF);
+function engineFor(p) {
+  const same2 = p.fromChain === p.toChain;
+  if (isNativeSym(p.output)) {
+    if (p.output !== NATIVE_OF[p.toChain]) return null;
+    if (same2) return "gasBuy";
+    return p.flow === "xchain_gas" && GAS_CHAINS.includes(p.fromChain) ? "xchainGas" : null;
+  }
+  if (p.output === "USDC" && same2) return p.fromChain === "solana" ? "solRedeem" : "baseRedeem";
+  if (p.input === "USDC" && same2) {
+    if (p.fromChain === "solana" && ["SBC", "cfUSD", "HSUSD"].includes(p.output)) return "solBuy";
+    if (p.fromChain === "base" && BASE_PAR_OUT.includes(p.output)) return "baseBuy";
+    return null;
+  }
+  if (same2 && p.input !== "USDC" && p.output !== "USDC") {
+    if (p.fromChain === "solana") return "solPar";
+    if (p.fromChain === "base" && BASE_PAR_OUT.includes(p.output)) return "basePar";
+    return null;
+  }
+  if (!same2 && p.fromChain === "base" && p.toChain === "solana" && ["SBC", "USDGLO", "USDC", "cfUSD"].includes(p.input))
+    return "intent";
+  if (!same2 && p.fromChain === "solana" && p.toChain === "base") return "solOrigin";
+  if (!same2 && p.fromChain === "base" && p.toChain === "radius") return "baseToRadius";
+  if (!same2 && p.fromChain === "radius" && p.toChain === "base") return "radiusToBase";
+  if (!same2 && p.fromChain === "radius" && p.toChain === "solana" && p.input === "SBC" && p.output === "SBC") return "radiusToSolana";
+  if (!same2 && p.fromChain === "solana" && p.toChain === "radius" && p.input === "SBC" && p.output === "SBC") return "solanaToRadius";
+  return null;
+}
+function xchainRecipientValid(engine, recipient) {
+  const v = (recipient || "").trim();
+  switch (engine) {
+    case "intent":
+    case "radiusToSolana":
+      return isValidSolAddress(v);
+    case "solOrigin":
+    case "baseToRadius":
+    case "radiusToBase":
+    case "solanaToRadius":
+      return isEvmAddress(v);
+    default:
+      return true;
+  }
+}
+function gasPairsFrom(caps) {
+  const flow = caps.flows?.gas_topup;
+  if (!flow?.enabled) return [];
+  const assets = caps.assets || {};
+  const allowedIn = new Set(flow.inputs || []);
+  const out = [];
+  for (const chain of ["base", "solana"]) {
+    if (!(flow.chains || []).includes(chain)) continue;
+    const native = NATIVE_OF[chain];
+    if (!native) continue;
+    if (!(flow.outputs || []).includes(native)) continue;
+    for (const [sym, a] of Object.entries(assets)) {
+      if (!allowedIn.has(sym)) continue;
+      if (!a?.enabled || !a?.input || !(a.chains || []).includes(chain)) continue;
+      out.push({ input: sym, fromChain: chain, output: native, toChain: chain, flow: "gas_topup" });
+    }
+  }
+  return out;
+}
+function bridgeStableFor(caps, input, from, to) {
+  const xg = caps.flows?.xchain_gas;
+  const gas = caps.flows?.gas_topup;
+  if (!xg?.enabled || !gas?.enabled) return null;
+  if (from === to || !GAS_CHAINS.includes(from) || !GAS_CHAINS.includes(to)) return null;
+  if (!(gas.chains || []).includes(to)) return null;
+  if (!(xg.corridors || []).some((c) => c.from === from && c.to === to)) return null;
+  if (!(xg.inputs || []).includes(input)) return null;
+  const assets = caps.assets || {};
+  const payable = new Set(gas.inputs || []);
+  const usable = (sym) => {
+    const a = assets[sym];
+    return !!a?.enabled && !!a?.output && (a.chains || []).includes(to) && payable.has(sym);
+  };
+  if (usable(input)) return input;
+  for (const sym of Object.keys(assets)) if (usable(sym)) return sym;
+  return null;
+}
+function xchainGasPairsFrom(caps) {
+  const xg = caps.flows?.xchain_gas;
+  if (!xg?.enabled) return [];
+  const assets = caps.assets || {};
+  const out = [];
+  for (const c of xg.corridors || []) {
+    const from = c.from;
+    const to = c.to;
+    if (from === to || !GAS_CHAINS.includes(from) || !GAS_CHAINS.includes(to)) continue;
+    const native = NATIVE_OF[to];
+    if (!native) continue;
+    if (!(xg.outputs || []).includes(native)) continue;
+    for (const sym of xg.inputs || []) {
+      const a = assets[sym];
+      if (!a?.enabled || !a?.input || !(a.chains || []).includes(from)) continue;
+      const via = bridgeStableFor(caps, sym, from, to);
+      if (!via) continue;
+      out.push({ input: sym, fromChain: from, output: native, toChain: to, flow: "xchain_gas", via });
+    }
+  }
+  return out;
+}
+var isEvmAddress = (v) => /^0x[0-9a-fA-F]{40}$/.test(v.trim());
+
+// ../../mcp/worker/routes.ts
+import { z } from "zod";
+var CHAIN = z.enum(["base", "solana", "radius"]);
+var ROUTE = {
+  inSym: z.string().min(1).max(16),
+  fromChain: CHAIN,
+  outSym: z.string().min(1).max(16),
+  toChain: CHAIN,
+  uiAmount: z.number().positive()
+};
+var same = (a, b) => a.toUpperCase() === b.toUpperCase();
+async function resolveEngine(ui, r) {
+  const caps = await ui.get("/api/capabilities");
+  const pairs = [...Array.isArray(caps.pairs) ? caps.pairs : [], ...gasPairsFrom(caps), ...xchainGasPairsFrom(caps)];
+  const pair = pairs.find((p) => same(p.input, r.inSym) && p.fromChain === r.fromChain && same(p.output, r.outSym) && p.toChain === r.toChain);
+  const engine = pair ? engineFor(pair) : null;
+  if (!pair || !engine) throw new Error(`route not enabled: ${r.inSym}@${r.fromChain} -> ${r.outSym}@${r.toChain}`);
+  return { engine, pair };
+}
+
+// ../../mcp/worker/build.ts
+var RFQ_TTL_S = 1800;
+var RAIL = {
+  intent: "evm-origin",
+  solOrigin: "sol-origin",
+  baseToRadius: "base->radius",
+  radiusToBase: "radius->base",
+  radiusToSolana: "radius->solana",
+  solanaToRadius: "solana->radius"
+};
+var eqAddr = (a, b) => a.toLowerCase() === b.toLowerCase();
+function jsonSafe(v) {
+  return JSON.parse(JSON.stringify(v, (_k, x) => typeof x === "bigint" ? x.toString() : x));
+}
+function orderJson(o) {
+  return jsonSafe({ user: o.user, inputToken: o.inputToken, inputAmount: o.inputAmount, outputToken: o.outputToken, minOutputAmount: o.minOutputAmount, solver: o.solver, deadline: o.deadline, nonce: o.nonce });
+}
+function registryToken(net, sym, chain) {
+  const tokens = REGISTRY[net]?.tokens ?? {};
+  const key = Object.keys(tokens).find((k) => k.toUpperCase() === sym.toUpperCase());
+  const t = key ? tokens[key]?.[chain] : void 0;
+  if (!t?.address) throw new Error(`${sym} has no ${chain} token in the ${net} registry`);
+  return t;
+}
+function evmUser(u) {
+  try {
+    return getAddress5(u);
+  } catch {
+    throw new Error("user must be a valid EVM (0x\u2026) address for this route");
+  }
+}
+function solUser(u) {
+  if (!isValidSolAddress(u)) throw new Error("user must be a valid Solana (base58) address for this route");
+  return u;
+}
+function permit(domain, token2, owner, spender, value, nonce, deadline) {
+  return jsonSafe({
+    domain: { name: domain.name, version: domain.version, chainId: domain.chainId, verifyingContract: token2 },
+    types: PERMIT_TYPES,
+    primaryType: "Permit",
+    message: { owner, spender, value, nonce, deadline }
+  });
+}
+function redeemInput(info, sym) {
+  const ri = info.redeemInputs || {};
+  return ri[sym] || ri[sym.toUpperCase()] || ri[sym === "cfUSD" ? "CFUSD" : sym];
+}
+async function baseInfo(d) {
+  const info = await d.ui.get("/api/base/info");
+  if (!eqAddr(String(info.router), loadManifest()[d.net].base.rfqRouter)) throw new Error("refused: /api/base/info router is not the RfqSwap in the address manifest");
+  return info;
+}
+async function baseRfq(d, a, engine) {
+  const user = evmUser(a.user);
+  const info = await baseInfo(d);
+  const router = getAddress5(info.router);
+  const amount = String(a.uiAmount);
+  let inToken, inDec, outToken, outDec, minOut, domain;
+  if (engine === "baseRedeem") {
+    const ri = redeemInput(info, a.inSym);
+    if (!ri?.addr || !ri.permitDomain) throw new Error(ri?.permitError || `${a.inSym} is not a configured Base redeem input`);
+    const q = await d.ui.get("/api/base/redeem/quote", { in: a.inSym, amount });
+    if (!q.minOutBase || !q.usdc) throw new Error("redeem quote is missing the signed floor; refusing to build");
+    [inToken, inDec, outToken, outDec, minOut, domain] = [getAddress5(ri.addr), Number(ri.dec), getAddress5(q.usdc), Number(q.usdcDec ?? 6), BigInt(q.minOutBase), ri.permitDomain];
+  } else {
+    const out = info.out?.[a.outSym];
+    if (!out?.addr) throw new Error(`${a.outSym} is not a configured Base output`);
+    if (a.uiAmount > Number(out.inventory ?? 0)) throw new Error(`solver ${a.outSym} inventory is ${Number(out.inventory ?? 0).toFixed(2)}; lower the amount`);
+    if (engine === "baseBuy") {
+      [inToken, inDec, domain] = [getAddress5(info.usdc), Number(info.usdcDec), { name: info.usdcName, version: info.usdcVersion, chainId: Number(info.chainId) }];
+    } else {
+      const ri = redeemInput(info, a.inSym);
+      if (!ri?.addr || !ri.permitDomain) throw new Error(ri?.permitError || `${a.inSym} is not a configured Base input`);
+      [inToken, inDec, domain] = [getAddress5(ri.addr), Number(ri.dec), ri.permitDomain];
+    }
+    [outToken, outDec] = [getAddress5(out.addr), Number(out.dec)];
+    minOut = parseUnits(amount, outDec);
+  }
+  const inputAmount = parseUnits(amount, inDec);
+  const deadline = BigInt(Math.floor((d.now?.() ?? Date.now()) / 1e3) + RFQ_TTL_S);
+  const built = buildRfqOrder({
+    user,
+    inputToken: inToken,
+    outputToken: outToken,
+    solver: getAddress5(info.solver),
+    router,
+    chainId: Number(info.chainId),
+    inputAmount,
+    minOutputAmount: minOut,
+    nonce: await d.chain.rfqNonce(router, user),
+    deadline,
+    inputSymbol: a.inSym,
+    outputSymbol: a.outSym,
+    inputDecimals: inDec,
+    outputDecimals: outDec
+  });
+  const order = orderJson(built.order);
+  const permitTypedData = permit(domain, inToken, user, router, inputAmount, await d.chain.permitNonce(inToken, user), deadline);
+  const route = engine === "baseBuy" ? "base-buy" : engine === "basePar" ? "base-par" : "base-redeem";
+  const submitBody = engine === "baseRedeem" ? { user, in: a.inSym, uiAmount: a.uiAmount } : { user, uiAmount: a.uiAmount, out: a.outSym, ...engine === "basePar" ? { in: a.inSym } : {} };
+  return {
+    kind: "evm-rfq",
+    chain: "base",
+    route,
+    net: d.net,
+    inSym: a.inSym,
+    outSym: a.outSym,
+    uiAmount: a.uiAmount,
+    user,
+    recipient: user,
+    orderTypedData: jsonSafe(built.typedData),
+    permitTypedData,
+    order,
+    submitPath: engine === "baseRedeem" ? "/api/base/redeem" : "/api/base/swap",
+    submitBody
+  };
+}
+async function baseGas(d, a) {
+  const user = evmUser(a.user);
+  const amount = String(a.uiAmount);
+  const quote = await d.ui.get("/api/gas/quote", { chain: "base", in: a.inSym, amount });
+  if (quote.fillable === false) throw new Error(quote.reason || "gas top-up is not fillable right now");
+  const info = await baseInfo(d);
+  const ri = redeemInput(info, a.inSym);
+  const isUsdc = a.inSym.toUpperCase() === "USDC";
+  const token2 = ri?.addr ? getAddress5(ri.addr) : isUsdc ? getAddress5(info.usdc) : null;
+  const domain = ri?.addr ? ri.permitDomain : isUsdc ? { name: info.usdcName, version: info.usdcVersion, chainId: Number(info.chainId) } : null;
+  if (!token2 || !domain?.name) throw new Error(ri?.permitError || `${a.inSym} permit domain unavailable; cannot sign safely`);
+  const dec = Number(ri?.dec ?? info.usdcDec);
+  if (quote.inDecimals != null && dec !== Number(quote.inDecimals)) throw new Error(`${a.inSym} decimals disagree (quote ${quote.inDecimals}, token info ${dec}); refusing to build`);
+  const value = parseUnits(amount, dec);
+  const deadline = BigInt(Math.floor((d.now?.() ?? Date.now()) / 1e3) + RFQ_TTL_S);
+  const spender = getAddress5(info.solver);
+  return {
+    kind: "evm-permit",
+    chain: "base",
+    route: "gas-base",
+    net: d.net,
+    inSym: a.inSym,
+    outSym: a.outSym,
+    uiAmount: a.uiAmount,
+    user,
+    recipient: user,
+    permitTypedData: permit(domain, token2, user, spender, value, await d.chain.permitNonce(token2, user), deadline),
+    submitPath: "/api/gas/buy",
+    submitBody: { user, in: a.inSym, amount, deadline: Number(deadline), quotedOut: quote.outBaseUnits, quotedAt: d.now?.() ?? Date.now() }
+  };
+}
+async function solSame(d, a, engine) {
+  const user = solUser(a.user);
+  const base2 = { kind: "sol-tx", net: d.net, inSym: a.inSym, outSym: a.outSym, uiAmount: a.uiAmount, user, recipient: user };
+  if (engine === "gasBuy") {
+    const amount = String(a.uiAmount);
+    const quote = await d.ui.get("/api/gas/quote", { chain: "solana", in: a.inSym, amount });
+    if (quote.fillable === false) throw new Error(quote.reason || "gas top-up is not fillable right now");
+    const b2 = await d.ui.post("/api/gas/build", { user, in: a.inSym, amount, quotedOut: quote.outBaseUnits, quotedAt: d.now?.() ?? Date.now() });
+    return { ...base2, route: "gas-sol", txBase64: b2.txB64, versioned: false, topupId: b2.topupId };
+  }
+  if (engine === "solRedeem") {
+    const b2 = await d.ui.post("/api/sol/redeem", { net: d.net, user, in: a.inSym, uiAmount: a.uiAmount });
+    return { ...base2, route: "sol-redeem", txBase64: b2.txB64, versioned: !!b2.versioned };
+  }
+  const body = engine === "solBuy" ? { net: d.net, user, uiAmount: a.uiAmount, out: SOL_BUY_VAL[a.outSym] || "SBC" } : { net: d.net, user, uiAmount: a.uiAmount, in: a.inSym, out: a.outSym };
+  const b = await d.ui.post("/api/sol/swap", body);
+  return { ...base2, route: engine === "solBuy" ? "sol-buy" : "sol-par", txBase64: b.txB64, versioned: !!b.versioned };
+}
+async function evmOrigin(d, a, engine) {
+  const user = evmUser(a.user);
+  const recipient = a.recipient;
+  const src = a.fromChain;
+  const dst = a.toChain;
+  const body = engine === "intent" ? { user, inSym: a.inSym, outSym: a.outSym, uiAmount: a.uiAmount, recipientSol: recipient } : dst === "solana" ? { user, src, dst, inSym: a.inSym, outSym: a.outSym, uiAmount: a.uiAmount, recipientSol: recipient } : { user, src, dst, inSym: a.inSym, outSym: a.outSym, uiAmount: a.uiAmount, recipient: getAddress5(recipient) };
+  const open = await d.ui.post("/api/xchain/evm-origin/open/build", body);
+  const rail = RAIL[engine];
+  if (engine !== "intent" && open.corridor !== rail) throw new Error("refused: the server built this order for a different route");
+  const m = loadManifest()[d.net];
+  const expectEscrow = src === "radius" ? m.radius?.escrow : m.base.escrow;
+  if (!expectEscrow || !eqAddr(String(open.escrow), expectEscrow)) throw new Error(`refused: escrow ${open.escrow} is not the ${src} SourceEscrow in the address manifest`);
+  const escrow = getAddress5(open.escrow);
+  const inAmt = BigInt(open.inputAmount);
+  const tok = registryToken(d.net, a.inSym, src);
+  if (!eqAddr(String(open.inputToken), tok.address)) throw new Error(`refused: input token ${open.inputToken} is not ${a.inSym} on ${src} per the registry`);
+  if (inAmt !== parseUnits(String(a.uiAmount), tok.decimals)) throw new Error(`refused: input amount ${open.inputAmount} does not equal ${a.uiAmount} ${a.inSym}`);
+  const order = rehydrateOrder(open.order);
+  if (!eqAddr(order.swapper, user)) throw new Error("refused: order swapper is not the user");
+  if (!eqAddr(order.settlementContract, escrow)) throw new Error("refused: order settlementContract is not the escrow");
+  const chainId = src === "radius" ? Number(open.chainId) : Number((await d.ui.get("/api/config")).chainId);
+  return {
+    kind: "evm-txs",
+    chain: src,
+    route: "xchain-evm-origin",
+    chainId,
+    net: d.net,
+    inSym: a.inSym,
+    outSym: a.outSym,
+    uiAmount: a.uiAmount,
+    user,
+    recipient,
+    orderId: open.orderId,
+    rail,
+    legacyGas: src === "radius",
+    txs: [
+      { to: getAddress5(open.inputToken), data: encodeFunctionData({ abi: ERC20_ABI, functionName: "approve", args: [escrow, inAmt] }), value: "0" },
+      { to: escrow, data: encodeFunctionData({ abi: EVM_OPEN_ABI, functionName: "open", args: [order, "0x", open.fillerData] }), value: "0" }
+    ]
+  };
+}
+async function solOrigin(d, a, engine) {
+  const user = solUser(a.user);
+  const recipient = getAddress5(a.recipient);
+  const toRadius = engine === "solanaToRadius";
+  const open = await d.ui.post("/api/xchain/sol-origin/open/build", { user, inSym: a.inSym, outSym: a.outSym, uiAmount: a.uiAmount, recipientEvm: recipient, ...toRadius ? { dst: "radius" } : {} });
+  if (toRadius && open.corridor !== "solana->radius") throw new Error("refused: the server built this order for a different route");
+  return {
+    kind: "sol-tx",
+    route: "xchain-sol-origin",
+    net: d.net,
+    inSym: a.inSym,
+    outSym: a.outSym,
+    uiAmount: a.uiAmount,
+    user,
+    recipient,
+    orderId: open.orderId,
+    rail: RAIL[engine],
+    txBase64: open.txB64,
+    versioned: false
+  };
+}
+async function buildSignRequest(d, a) {
+  const { engine } = await resolveEngine(d.ui, a);
+  const xchain = a.fromChain !== a.toChain;
+  if (engine === "xchainGas") throw new Error(`cross-chain gas runs as two swaps: a stable ${a.fromChain}->${a.toChain}, then gas on ${a.toChain}`);
+  if (xchain && !xchainRecipientValid(engine, a.recipient ?? "")) throw new Error(`a valid ${a.toChain} recipient address is required for this route`);
+  switch (engine) {
+    case "baseBuy":
+    case "basePar":
+    case "baseRedeem":
+      return baseRfq(d, a, engine);
+    case "solBuy":
+    case "solPar":
+    case "solRedeem":
+      return solSame(d, a, engine);
+    case "gasBuy":
+      return a.fromChain === "base" ? baseGas(d, a) : solSame(d, a, "gasBuy");
+    case "intent":
+    case "baseToRadius":
+    case "radiusToBase":
+    case "radiusToSolana":
+      return evmOrigin(d, a, engine);
+    case "solOrigin":
+    case "solanaToRadius":
+      return solOrigin(d, a, engine);
+  }
+  throw new Error(`route engine ${engine} is not supported over MCP`);
+}
+
+// ../../mcp/worker/order-rail.ts
+import { z as z2 } from "zod";
+var RAIL2 = z2.enum(["sol-origin", "evm-origin", "base->radius", "radius->base", "radius->solana", "solana->radius"]);
+async function findOrderOnRails(lookup) {
+  let first;
+  const failed = [];
+  for (const r of RAIL2.options) {
+    let res;
+    try {
+      res = await lookup(r);
+    } catch (e) {
+      if (/invalid orderId/.test(e.message)) throw e;
+      failed.push(`${r}: ${e.message}`);
+      continue;
+    }
+    if (res?.status !== "unknown") return res;
+    first ??= res;
+  }
+  if (failed.length) throw new Error(`not found on readable rails; unreadable: ${failed.join(" ; ")}`);
+  return first;
+}
+export {
+  COMPUTE_BUDGET,
+  DEFAULT_LIMITS,
+  GAS_FLOOR_PCT,
+  RAIL2 as RAIL,
+  Refuse,
+  buildSignRequest,
+  checkIntent,
+  decodeEvmRequest,
+  decodeSolRequest,
+  findOrderOnRails,
+  gasFloorOf,
+  gasQuoteQuery,
+  gasSpend,
+  hydrateTypedData,
+  isGasRoute,
+  loadManifest,
+  need,
+  token
+};