@anywalletkit/protocol-swap2-omniston 0.0.0-stage → 0.2.2

package/dist/protocol.cjs

@@ -0,0 +1,2262 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/protocol.ts
+var protocol_exports = {};
+__export(protocol_exports, {
+  OmnistonSwap2Protocol: () => OmnistonSwap2Protocol
+});
+module.exports = __toCommonJS(protocol_exports);
+var import_single = require("@anywalletkit/protocol-swap2-core/swap2/single");
+
+// src/config.ts
+var import_util = require("@anywalletkit/protocol-swap2-core/util");
+var OMNISTON_EVM = /* @__PURE__ */ new Set([1, 56, 137, 196, 999, 4663, 8453, 9745, 42161, 43114]);
+var omniston = {
+  enabled: () => true,
+  integratorAddress: () => "",
+  integratorFeePips: () => "",
+  wsUrl: () => "wss://omni-ws.ston.fi",
+  /** Per-swap USD cap — the resolver quotes the corridor up to ~$1000. */
+  maxUsd: () => {
+    return 1e3;
+  },
+  supportsChain(chain) {
+    if ((0, import_util.namespace)(chain) === "ton") return true;
+    return (0, import_util.isEvm)(chain) && OMNISTON_EVM.has((0, import_util.evmRef)(chain));
+  },
+  // TON↔EVM and EVM↔EVM cross-chain (order settlement), TON↔TON same-chain
+  // (swap settlement — immediate DEX routes). Same-chain EVM is not an order
+  // corridor.
+  supports(from, to) {
+    if (!this.supportsChain(from) || !this.supportsChain(to)) return false;
+    const tonSide = (0, import_util.namespace)(from) === "ton" || (0, import_util.namespace)(to) === "ton";
+    return tonSide || from !== to;
+  }
+};
+
+// src/provider.ts
+var import_core3 = require("@ton/core");
+
+// src/activity.ts
+var import_core = require("@ton/core");
+var import_activity = require("@anywalletkit/protocol-swap2-core/activity");
+var OMNISTON_MODULE = "@anywalletkit/protocol-swap2-omniston";
+var STONFI_ROUTERS = [
+  "EQCS4UEa5UaJLzOyyKieqQOQ2P9M-7kXpkO5HnP3Bv250cN3",
+  "EQB3ncyBUTjZUA5EnFKR5_EnOMI9V1tTEAAPaiU71gc4TiUt"
+];
+var OMNISTON_ESCROWS = ["EQAbWJ3Y1HgIIvcMq1prG1anlDC0T3cZlAU7luPT6LmTpmrZ"];
+function raw(address) {
+  if (!address) return null;
+  try {
+    return import_core.Address.parse(address).toRawString();
+  } catch {
+    return null;
+  }
+}
+var ROUTER_RAW = new Set(STONFI_ROUTERS.map((a) => raw(a)));
+var ESCROW_RAW = new Set(OMNISTON_ESCROWS.map((a) => raw(a)));
+function counterparties(tx, own) {
+  const ownRaw = /* @__PURE__ */ new Set();
+  for (const a of own) {
+    const r = raw(a);
+    if (r) ownRaw.add(r);
+  }
+  const out = /* @__PURE__ */ new Set();
+  const add = (a) => {
+    const r = raw(a);
+    if (r && !ownRaw.has(r)) out.add(r);
+  };
+  add(tx.call?.to);
+  add(tx.to);
+  for (const t of tx.transfers) {
+    add(t.from);
+    add(t.to);
+  }
+  return [...out];
+}
+function describeOmnistonActivity(tx, ctx) {
+  if (!tx.chain.startsWith("ton:")) return null;
+  const parties = counterparties(tx, ctx.own);
+  const escrow = parties.find((p) => ESCROW_RAW.has(p));
+  if (escrow) {
+    return (0, import_activity.describeSwapLike)(tx, ctx, { protocol: OMNISTON_MODULE, subtitle: "Omniston \xB7 STON.fi", kind: "bridge", counterparty: tx.call?.to ?? tx.to ?? escrow });
+  }
+  const router = parties.find((p) => ROUTER_RAW.has(p));
+  if (router) {
+    return (0, import_activity.describeSwapLike)(tx, ctx, { protocol: OMNISTON_MODULE, subtitle: "STON.fi \xB7 TON", kind: "swap", counterparty: tx.call?.to ?? tx.to ?? router });
+  }
+  return null;
+}
+
+// src/provider.ts
+var import_buffer2 = require("buffer");
+var import_viem = require("viem");
+var import_swap2_assets = require("@anywalletkit/swap2-assets");
+
+// src/ton-swap.ts
+var import_buffer = require("buffer");
+var import_core2 = require("@ton/core");
+var TON_JETTON_TRANSFER_OP = 260734629;
+var PTON_V2_TON_TRANSFER_OP = 32736093;
+var STONFI_V2_SWAP_OP = 1717886506;
+var STONFI_V1_SWAP_OP = 630424929;
+var DEDUST_V1_NATIVE_SWAP_OP = 3926267997;
+var DEDUST_V1_JETTON_SWAP_OP = 3818968194;
+var DEDUST_V2_PAY_NATIVE_OP = 2779237368;
+var DEDUST_V2_PAY_JETTON_OP = 3418569033;
+var DEDUST_V2_SWAP_OP = 3292680207;
+var TON_SWAP_PROTOCOL_LAYOUTS = {
+  StonFiV1: "stonfi-v1",
+  StonFiV2: "stonfi-v2",
+  DeDust: "dedust-v1",
+  DeDustCPMMV2: "dedust-v2"
+};
+var TonSwapPayloadError = class extends Error {
+  constructor(reason, detail) {
+    super(`omniston: ton-swap-payload ${reason}${detail ? ` (${detail})` : ""}`);
+    this.reason = reason;
+    this.name = "TonSwapPayloadError";
+  }
+  reason;
+};
+var refuse = (reason, detail) => {
+  throw new TonSwapPayloadError(reason, detail);
+};
+function sameAddr(a, b) {
+  if (!a || !b) return false;
+  try {
+    return a.equals(import_core2.Address.parse(b));
+  } catch {
+    return false;
+  }
+}
+function end(s, where) {
+  if (s.remainingBits !== 0 || s.remainingRefs !== 0) refuse("unknown-layout", `${where}: ${s.remainingBits} bits / ${s.remainingRefs} refs left over`);
+}
+function eitherRef(s) {
+  return s.loadBit() ? s.loadRef().beginParse() : s;
+}
+function readAddress(s) {
+  const a = s.loadAddressAny();
+  if (a === null) return null;
+  if (!(a instanceof import_core2.Address)) refuse("unknown-layout", "external address");
+  return a;
+}
+function isTraderOrNone(a, trader) {
+  return a === null || sameAddr(a, trader);
+}
+function receiverOk(a, dest, trader) {
+  if (a === null) {
+    try {
+      return import_core2.Address.parse(dest).equals(import_core2.Address.parse(trader));
+    } catch {
+      return false;
+    }
+  }
+  return sameAddr(a, dest);
+}
+function referralOk(address, fee, integrator) {
+  if (address === null) return true;
+  if (fee === 0) return true;
+  return !!integrator && sameAddr(address, integrator);
+}
+function decodeStonFiV2(s, ctx) {
+  const hops = [];
+  let cur = s;
+  for (let depth = 0; cur; depth++) {
+    if (depth >= 4) refuse("unsupported-ton-route", "STON.fi v2 cross-swap deeper than 4 hops");
+    if (cur.loadUint(32) !== STONFI_V2_SWAP_OP) refuse("unknown-layout", `STON.fi v2 hop ${depth} is not swap#6664de2a`);
+    const askWallet = readAddress(cur);
+    const refund = readAddress(cur);
+    const excess = readAddress(cur);
+    cur.loadUintBig(64);
+    const body = cur.loadRef().beginParse();
+    end(cur, "STON.fi v2 swap");
+    const minOut = body.loadCoins();
+    const receiver = readAddress(body);
+    const fwdGas = body.loadCoins();
+    const custom = body.loadMaybeRef();
+    body.loadCoins();
+    const refundPayload = body.loadMaybeRef();
+    const refFee = body.loadUint(16);
+    const refAddress = readAddress(body);
+    end(body, "STON.fi v2 cross-swap body");
+    if (!askWallet) refuse("unknown-layout", "STON.fi v2 swap without an ask wallet");
+    if (!sameAddr(refund, ctx.trader)) refuse("refund-not-trader", `STON.fi v2 hop ${depth}`);
+    if (!sameAddr(excess, ctx.trader)) refuse("excess-not-trader", `STON.fi v2 hop ${depth}`);
+    if (refundPayload) refuse("unknown-layout", "STON.fi v2 refund payload");
+    if (!referralOk(refAddress, refFee, ctx.integratorAddress)) refuse("referral", `STON.fi v2 hop ${depth}`);
+    if (custom && fwdGas === 0n) refuse("unknown-layout", "STON.fi v2 custom payload without forward gas");
+    hops.push({ askWallet, minOut, receiver, next: custom ? custom.beginParse() : null });
+    cur = custom ? custom.beginParse() : null;
+  }
+  return hops;
+}
+function decodeDeDustV1(s) {
+  const pool = readAddress(s);
+  if (!pool) refuse("unknown-layout", "DeDust v1 swap without a pool");
+  if (s.loadUint(1) !== 0) refuse("unknown-layout", "DeDust v1 swap kind is not given_in");
+  const limit = s.loadCoins();
+  if (s.loadMaybeRef()) refuse("unsupported-ton-route", "DeDust v1 multi-hop (next step)");
+  const params = s.loadRef().beginParse();
+  end(s, "DeDust v1 swap step");
+  params.loadUint(32);
+  const recipient = readAddress(params);
+  const referral = readAddress(params);
+  params.loadMaybeRef();
+  params.loadMaybeRef();
+  end(params, "DeDust v1 swap params");
+  return { pool, limit, recipient, referral };
+}
+function decodeDeDustV2(payment, payout) {
+  if (payment.loadUint(32) !== DEDUST_V2_SWAP_OP) refuse("unknown-layout", "DeDust CPMM v2 payment payload is not swap#c442500f");
+  const minOut = payment.loadCoins();
+  payment.loadUint(40);
+  if (payment.loadMaybeRef()) refuse("unsupported-ton-route", "DeDust CPMM v2 multi-hop (next step)");
+  if (payment.loadBit()) refuse("referral", "DeDust CPMM v2 partner config");
+  if (payment.loadBit()) refuse("referral", "DeDust CPMM v2 referrer config");
+  end(payment, "DeDust CPMM v2 swap payload");
+  const options = () => {
+    const destination = readAddress(payout);
+    payout.loadCoins();
+    payout.loadMaybeRef();
+    payout.loadBit();
+    return destination;
+  };
+  const fulfill = options();
+  const reject = options();
+  const excessesTo = readAddress(payout);
+  end(payout, "DeDust CPMM v2 payout config");
+  return { minOut, fulfill, reject, excessesTo };
+}
+function checkTonSwapPayload(ctx) {
+  if (!/^(?:[0-9a-fA-F]{2})+$/.test(ctx.payloadHex)) refuse("malformed", "payload hex");
+  const roots = import_core2.Cell.fromBoc(import_buffer.Buffer.from(ctx.payloadHex, "hex"));
+  if (roots.length !== 1) refuse("malformed", "payload must have one root");
+  const steps = ctx.steps;
+  if (steps.length === 0) refuse("unsupported-ton-route", "no route steps");
+  const layouts = steps.map((step) => TON_SWAP_PROTOCOL_LAYOUTS[step.protocol] ?? refuse("unsupported-ton-route", `protocol ${step.protocol}`));
+  const layout = layouts[0];
+  if (layouts.some((l) => l !== layout)) refuse("unsupported-ton-route", `mixed protocols ${steps.map((s2) => s2.protocol).join("+")}`);
+  if (steps.length > 1 && layout !== "stonfi-v2") refuse("unsupported-ton-route", `${steps.length}-step ${steps[0].protocol} route`);
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    const wantIn = i === 0 ? ctx.inputJetton : steps[i - 1].outputJetton;
+    const wantOut = i === steps.length - 1 ? ctx.outputJetton : step.outputJetton;
+    if (step.inputJetton === void 0 || step.outputJetton === void 0) refuse("unsupported-ton-route", `step ${i} without assets`);
+    if (!sameJetton(step.inputJetton, wantIn ?? null) || !sameJetton(step.outputJetton, wantOut ?? null)) refuse("unsupported-ton-route", `step ${i} assets do not chain`);
+  }
+  const input = BigInt(ctx.inputUnits);
+  const quotedMin = BigInt(ctx.minOutputAmount);
+  const nativeInput = ctx.inputJetton === null;
+  const s = roots[0].beginParse();
+  const op = s.loadUint(32);
+  const legs = [];
+  const minOk = (minOut2) => {
+    if (minOut2 < quotedMin) refuse(minOut2 === 0n ? "min-out-zero" : "min-out-below-quote", `${minOut2} < ${quotedMin}`);
+  };
+  let transfer = null;
+  if (op === TON_JETTON_TRANSFER_OP) {
+    s.loadUintBig(64);
+    const amount = s.loadCoins();
+    const destination = readAddress(s);
+    const response = readAddress(s);
+    if (s.loadMaybeRef()) refuse("unknown-layout", "jetton transfer custom payload");
+    s.loadCoins();
+    const inline = !s.loadBit();
+    const forward = inline ? s : s.loadRef().beginParse();
+    if (amount !== input) refuse("amount-mismatch", "jetton transfer amount");
+    if (!destination) refuse("unknown-layout", "jetton transfer without a destination");
+    if (!sameAddr(response, ctx.trader)) refuse("excess-not-trader", "jetton transfer response destination");
+    transfer = { destination, forward, inline };
+  }
+  let minOut;
+  if (layout === "stonfi-v2") {
+    let hopsSlice;
+    let router;
+    let proxyTonWallet;
+    if (nativeInput) {
+      if (op !== PTON_V2_TON_TRANSFER_OP) refuse("unknown-layout", `native STON.fi v2 input op 0x${op.toString(16)}`);
+      s.loadUintBig(64);
+      const tonAmount = s.loadCoins();
+      const refund = readAddress(s);
+      hopsSlice = eitherRef(s);
+      end(s, "pTON v2 ton_transfer");
+      if (tonAmount !== input) refuse("amount-mismatch", "pTON v2 ton_amount");
+      if (!sameAddr(refund, ctx.trader)) refuse("refund-not-trader", "pTON v2 refund address");
+      router = null;
+      proxyTonWallet = ctx.targetAddress;
+    } else {
+      if (!transfer) refuse("unknown-layout", `jetton-input STON.fi v2 op 0x${op.toString(16)}`);
+      if (!transfer.inline) end(s, "jetton transfer");
+      hopsSlice = transfer.forward;
+      router = transfer.destination.toString();
+    }
+    const hops = decodeStonFiV2(hopsSlice, ctx);
+    if (hops.length !== steps.length) refuse("unsupported-ton-route", `${hops.length} STON.fi v2 hops for ${steps.length} quoted steps`);
+    hops.forEach((hop, i) => {
+      const last = i === hops.length - 1;
+      if (last) {
+        if (!receiverOk(hop.receiver, ctx.dest, ctx.trader) || hop.receiver === null) refuse("receiver-not-destination", `STON.fi v2 hop ${i}`);
+        if (hop.next) refuse("unknown-layout", "STON.fi v2 final hop carries a custom payload");
+      } else if (!hop.receiver) refuse("unknown-layout", `STON.fi v2 hop ${i} without a receiver`);
+      legs.push({
+        kind: "stonfi-router",
+        version: 2,
+        router: i === 0 ? router : hops[i - 1].receiver.toString(),
+        ...i === 0 && proxyTonWallet ? { proxyTonWallet } : {},
+        askWallet: hop.askWallet.toString(),
+        inputJetton: steps[i].inputJetton ?? null,
+        outputJetton: steps[i].outputJetton ?? null
+      });
+    });
+    minOut = hops[hops.length - 1].minOut;
+  } else if (layout === "stonfi-v1") {
+    if (!transfer) refuse("unknown-layout", `STON.fi v1 op 0x${op.toString(16)}`);
+    if (!transfer.inline) end(s, "jetton transfer");
+    const f = transfer.forward;
+    if (f.loadUint(32) !== STONFI_V1_SWAP_OP) refuse("unknown-layout", "STON.fi v1 forward payload is not swap#25938561");
+    const askWallet = readAddress(f);
+    minOut = f.loadCoins();
+    const to = readAddress(f);
+    const referral = f.loadBit() ? readAddress(f) : null;
+    end(f, "STON.fi v1 swap");
+    if (!askWallet) refuse("unknown-layout", "STON.fi v1 swap without an ask wallet");
+    if (!to || !sameAddr(to, ctx.dest)) refuse("receiver-not-destination", "STON.fi v1 to_address");
+    if (!referralOk(referral, null, ctx.integratorAddress)) refuse("referral", "STON.fi v1");
+    legs.push({
+      kind: "stonfi-router",
+      version: 1,
+      router: transfer.destination.toString(),
+      ...nativeInput ? { proxyTonWallet: ctx.targetAddress } : {},
+      askWallet: askWallet.toString(),
+      inputJetton: ctx.inputJetton,
+      outputJetton: ctx.outputJetton
+    });
+  } else if (layout === "dedust-v1") {
+    let swap;
+    if (nativeInput) {
+      if (op !== DEDUST_V1_NATIVE_SWAP_OP) refuse("unknown-layout", `native DeDust v1 input op 0x${op.toString(16)}`);
+      s.loadUintBig(64);
+      const amount = s.loadCoins();
+      if (amount !== input) refuse("amount-mismatch", "DeDust v1 native vault amount");
+      swap = decodeDeDustV1(s);
+    } else {
+      if (!transfer) refuse("unknown-layout", `jetton-input DeDust v1 op 0x${op.toString(16)}`);
+      if (!transfer.inline) end(s, "jetton transfer");
+      const f = transfer.forward;
+      if (f.loadUint(32) !== DEDUST_V1_JETTON_SWAP_OP) refuse("unknown-layout", "DeDust v1 forward payload is not swap#e3a0d482");
+      swap = decodeDeDustV1(f);
+    }
+    if (!receiverOk(swap.recipient, ctx.dest, ctx.trader)) refuse("receiver-not-destination", "DeDust v1 recipient");
+    if (!referralOk(swap.referral, null, ctx.integratorAddress)) refuse("referral", "DeDust v1");
+    minOut = swap.limit;
+    legs.push({ kind: "dedust-pool", version: 1, pool: swap.pool.toString(), inputJetton: ctx.inputJetton, outputJetton: ctx.outputJetton });
+  } else {
+    let swap;
+    let pool;
+    if (nativeInput) {
+      if (op !== DEDUST_V2_PAY_NATIVE_OP) refuse("unknown-layout", `native DeDust CPMM v2 input op 0x${op.toString(16)}`);
+      s.loadUintBig(64);
+      const amount = s.loadCoins();
+      const payment = s.loadRef().beginParse();
+      const payout = s.loadRef().beginParse();
+      end(s, "DeDust CPMM v2 pay_native");
+      if (amount !== input) refuse("amount-mismatch", "DeDust CPMM v2 pay_native amount");
+      swap = decodeDeDustV2(payment, payout);
+      pool = ctx.targetAddress;
+    } else {
+      if (!transfer) refuse("unknown-layout", `jetton-input DeDust CPMM v2 op 0x${op.toString(16)}`);
+      if (!transfer.inline) end(s, "jetton transfer");
+      const f = transfer.forward;
+      if (f.loadUint(32) !== DEDUST_V2_PAY_JETTON_OP) refuse("unknown-layout", "DeDust CPMM v2 forward payload is not pay_jetton#cbc33949");
+      const payment = f.loadRef().beginParse();
+      const payout = f.loadRef().beginParse();
+      end(f, "DeDust CPMM v2 pay_jetton");
+      swap = decodeDeDustV2(payment, payout);
+      pool = transfer.destination.toString();
+    }
+    if (!receiverOk(swap.fulfill, ctx.dest, ctx.trader)) refuse("receiver-not-destination", "DeDust CPMM v2 fulfill destination");
+    if (!isTraderOrNone(swap.reject, ctx.trader)) refuse("refund-not-trader", "DeDust CPMM v2 reject destination");
+    if (!isTraderOrNone(swap.excessesTo, ctx.trader)) refuse("excess-not-trader", "DeDust CPMM v2 excesses");
+    minOut = swap.minOut;
+    legs.push({ kind: "dedust-pool", version: 2, pool, inputJetton: ctx.inputJetton, outputJetton: ctx.outputJetton });
+  }
+  minOk(minOut);
+  return { layout, minOut, legs };
+}
+function sameJetton(a, b) {
+  if (a === null || b === null) return a === b;
+  try {
+    return import_core2.Address.parse(a).equals(import_core2.Address.parse(b));
+  } catch {
+    return false;
+  }
+}
+
+// src/provider.ts
+var EVM_CASE = {
+  1: "ethereum",
+  56: "bnb",
+  137: "polygon",
+  196: "xlayer",
+  999: "hyperevm",
+  4663: "robinhood",
+  8453: "base",
+  9745: "plasma",
+  42161: "arbitrum",
+  43114: "avalanche"
+};
+var TON_NS = "ton";
+var INTENT_PREFIX = "omn1";
+var QUOTE_SETTLE_MS = 3e3;
+var EXECUTION_SETTLE_MS = 600;
+var MIN_START_HEADROOM_MS = 12e3;
+var QUOTE_MAX_MS = 6500;
+var TRACK_SNAPSHOT_MS = 6e3;
+var DEFAULT_MAX_HTLC_EXECUTIONS = 1;
+var QUOTE_TTL_MS = 45e3;
+var CACHE_TTL_MS = 6 * 60 * 60 * 1e3;
+var LEGACY_INTENT_WINDOW_MS = 6 * 60 * 60 * 1e3;
+function inMemoryQuoteStore() {
+  const map = /* @__PURE__ */ new Map();
+  return {
+    save: (id, v) => void map.set(id, v),
+    load: (id) => map.get(id),
+    clear: (id) => void map.delete(id)
+  };
+}
+function inMemorySecretStore() {
+  const map = /* @__PURE__ */ new Map();
+  return {
+    save: (id, secrets) => void map.set(id, secrets),
+    load: (id) => map.get(id),
+    clear: (id) => void map.delete(id)
+  };
+}
+function evmRef2(caip2) {
+  if (!caip2.startsWith("eip155:")) return null;
+  const n = Number(caip2.slice("eip155:".length));
+  return Number.isInteger(n) ? n : null;
+}
+function isTon(caip2) {
+  return caip2.split(":")[0] === TON_NS;
+}
+function caipForChainCase($case) {
+  if ($case === "ton") return "ton:-239";
+  const entry = Object.entries(EVM_CASE).find(([, value]) => value === $case);
+  return entry ? `eip155:${entry[0]}` : null;
+}
+function toAssetId(caip2, asset, allowNative = false) {
+  if (!asset.contract) {
+    return allowNative && isTon(caip2) ? { chain: { $case: "ton", value: { kind: { $case: "native", value: {} } } } } : null;
+  }
+  if (isTon(caip2)) {
+    return { chain: { $case: "ton", value: { kind: { $case: "jetton", value: asset.contract } } } };
+  }
+  const ref = evmRef2(caip2);
+  const $case = ref === null ? void 0 : EVM_CASE[ref];
+  if (!$case) return null;
+  return { chain: { $case, value: { kind: { $case: "erc20", value: (0, import_viem.getAddress)(asset.contract) } } } };
+}
+function toChainAddress(caip2, address) {
+  if (isTon(caip2)) return { chain: { $case: "ton", value: address } };
+  const ref = evmRef2(caip2);
+  const $case = ref === null ? void 0 : EVM_CASE[ref];
+  if (!$case) return null;
+  return { chain: { $case, value: (0, import_viem.getAddress)(address) } };
+}
+function encodeIntent(quoteId, trader, dest, srcChain, kind = "order") {
+  return [INTENT_PREFIX, quoteId, trader, dest, srcChain, ...kind === "swap" ? ["swap"] : []].map(encodeURIComponent).join("|");
+}
+var QUOTE_ID = /^[0-9a-fA-F]{48,64}$/;
+function decodeIntent(intentId) {
+  try {
+    const parts = intentId.split("|");
+    if (parts.length !== 5 && parts.length !== 6 || parts[0] !== INTENT_PREFIX) return null;
+    const [, quoteId = "", trader = "", dest = "", srcChain = "", kindPart = ""] = parts.map(decodeURIComponent);
+    if (!QUOTE_ID.test(quoteId) || !trader || !dest || !srcChain) return null;
+    if (parts.length === 6 && kindPart !== "swap") return null;
+    return { quoteId, trader, dest, srcChain, kind: parts.length === 6 ? "swap" : "order" };
+  } catch {
+    return null;
+  }
+}
+function sameIntentAddress(a, b) {
+  if (a === b) return true;
+  const evm = /^0x[0-9a-fA-F]{40}$/;
+  if (evm.test(a) || evm.test(b)) return evm.test(a) && evm.test(b) && a.toLowerCase() === b.toLowerCase();
+  try {
+    return import_core3.Address.parse(a).equals(import_core3.Address.parse(b));
+  } catch {
+    return false;
+  }
+}
+function encodeTypedMessage(td) {
+  const paramFor = (typeName, name) => {
+    const isArray = typeName.endsWith("[]");
+    const base = isArray ? typeName.slice(0, -2) : typeName;
+    const fields = td.types[base];
+    if (!fields) return { type: typeName, ...name ? { name } : {} };
+    return {
+      type: isArray ? "tuple[]" : "tuple",
+      ...name ? { name } : {},
+      components: fields.map((f) => paramFor(f.type, f.name))
+    };
+  };
+  return (0, import_viem.hexToBytes)(
+    (0, import_viem.encodeAbiParameters)([paramFor(td.primaryType)], [td.message])
+  );
+}
+function generateSecret() {
+  return crypto.getRandomValues(new Uint8Array(32));
+}
+function hashlock(secret, hashingFunction) {
+  switch (hashingFunction) {
+    case "HASHING_FUNCTION_KECCAK256":
+      return (0, import_viem.keccak256)(secret, "bytes");
+    case "HASHING_FUNCTION_SHA256":
+      return (0, import_viem.sha256)(secret, "bytes");
+    default:
+      throw new Error(`omniston: unsupported HTLC hashing function ${String(hashingFunction)}`);
+  }
+}
+function sameAsset(a, b) {
+  const key = (asset) => {
+    const chain = asset.chain;
+    const value = chain.value;
+    const normalize = (text) => chain.$case === "ton" ? text : text.toLowerCase();
+    if (typeof value === "string") return `${chain.$case}:${normalize(value)}`;
+    const kind = value.kind;
+    return `${chain.$case}:${kind?.$case ?? ""}:${typeof kind?.value === "string" ? normalize(kind.value) : JSON.stringify(kind?.value ?? null)}`;
+  };
+  return key(a) === key(b);
+}
+function sameChainAddress(a, b) {
+  if (a === void 0 || b === void 0) return a === b;
+  if (a.chain.$case !== b.chain.$case) return false;
+  if (a.chain.$case !== "ton") return a.chain.value.toLowerCase() === b.chain.value.toLowerCase();
+  try {
+    return import_core3.Address.parse(a.chain.value).equals(import_core3.Address.parse(b.chain.value));
+  } catch {
+    return a.chain.value === b.chain.value;
+  }
+}
+function assetContract(asset) {
+  const value = asset.chain.value;
+  if (typeof value === "string") return null;
+  const kind = value.kind;
+  return kind && typeof kind.value === "string" ? kind.value : null;
+}
+function stepJetton(asset) {
+  if (!asset || asset.chain.$case !== "ton" || typeof asset.chain.value === "string") return void 0;
+  const kind = asset.chain.value.kind;
+  if (kind?.$case === "native") return null;
+  return kind?.$case === "jetton" && typeof kind.value === "string" ? kind.value : void 0;
+}
+function readBigEndian(bytes, offset, length) {
+  if (!Number.isInteger(offset) || !Number.isInteger(length) || length < 1 || offset < 0 || offset + length > bytes.length) {
+    throw new Error("omniston: truncated EVM order extension");
+  }
+  let value = 0n;
+  for (let index = offset; index < offset + length; index++) value = value << 8n | BigInt(bytes[index]);
+  return value;
+}
+function sliceEqual(a, b) {
+  return a.length === b.length && a.every((value, index) => value === b[index]);
+}
+function zeroBytes(bytes) {
+  return bytes.every((value) => value === 0);
+}
+function within(value, center, before, after) {
+  return value >= BigInt(center - before) && value <= BigInt(center + after);
+}
+var ORDER_FIELDS = [
+  ["salt", "uint256"],
+  ["maker", "address"],
+  ["receiver", "address"],
+  ["makerAsset", "address"],
+  ["takerAsset", "address"],
+  ["makingAmount", "uint256"],
+  ["takingAmount", "uint256"],
+  ["makerTraits", "uint256"]
+];
+function validUint256(value) {
+  try {
+    const n = BigInt(value);
+    return n >= 0n && n < 1n << 256n;
+  } catch {
+    return false;
+  }
+}
+function validEvmAddress(value) {
+  try {
+    (0, import_viem.getAddress)(String(value));
+    return true;
+  } catch {
+    return false;
+  }
+}
+var EVM_DEST_PROTOCOL_FEE_RECIPIENTS = /* @__PURE__ */ new Set(["0x076268146b4ec6d21fc49c27586cfa91b9079a00"]);
+async function validateEvmToTonOrderExtension(extension, expected) {
+  const evmDest = expected.dstChainId !== void 0;
+  if (evmDest && (!Number.isSafeInteger(expected.dstChainId) || expected.dstChainId <= 0)) throw new Error("omniston: invalid EVM destination chain id");
+  if (extension.length < 32) throw new Error("omniston: malformed EVM order extension");
+  const view = new DataView(extension.buffer, extension.byteOffset, extension.byteLength);
+  const fields = [];
+  let begin = 0;
+  const concatLength = extension.length - 32;
+  for (let index = 0; index < 8; index++) {
+    const end2 = view.getUint32(28 - index * 4, false);
+    if (end2 < begin || end2 > concatLength) throw new Error("omniston: malformed EVM order extension offsets");
+    fields.push(extension.slice(32 + begin, 32 + end2));
+    begin = end2;
+  }
+  for (const index of [0, 1, 4, 5, 6]) {
+    if (fields[index].length !== 0) throw new Error("omniston: unsupported EVM order extension field");
+  }
+  if (!sliceEqual(fields[2], fields[3])) {
+    throw new Error("omniston: making/taking amount getters use different programs");
+  }
+  let target;
+  for (const index of [2, 3, 7]) {
+    const field = fields[index];
+    if (field.length <= 20) throw new Error("omniston: incomplete EVM order extension program");
+    const address = (0, import_viem.getAddress)(`0x${bytesToHex(field.slice(0, 20))}`);
+    if (!expected.trustedTarget(address) || target !== void 0 && (0, import_viem.getAddress)(target) !== address) {
+      throw new Error("omniston: EVM order extension target is not independently trusted");
+    }
+    target = address;
+  }
+  const getter = fields[2];
+  let cursor = 20;
+  const gasBump = readBigEndian(getter, cursor, 3);
+  cursor += 3;
+  const gasPrice = readBigEndian(getter, cursor, 4);
+  cursor += 4;
+  const auctionStart = readBigEndian(getter, cursor, 4);
+  cursor += 4;
+  const duration = readBigEndian(getter, cursor, 3);
+  cursor += 3;
+  const initialRateBump = readBigEndian(getter, cursor, 3);
+  cursor += 3;
+  const pointCount = Number(readBigEndian(getter, cursor, 1));
+  cursor += 1;
+  if (pointCount !== 5) throw new Error("omniston: unsupported EVM auction profile");
+  const points = [];
+  for (let index = 0; index < pointCount; index++) {
+    points.push([readBigEndian(getter, cursor, 3), readBigEndian(getter, cursor + 3, 2)]);
+    cursor += 5;
+  }
+  const integratorFee = readBigEndian(getter, cursor, 2);
+  cursor += 2;
+  const integratorShare = readBigEndian(getter, cursor, 1);
+  cursor += 1;
+  const resolverFee = readBigEndian(getter, cursor, 2);
+  cursor += 2;
+  const whitelistDiscount = readBigEndian(getter, cursor, 1);
+  cursor += 1;
+  const getterWhitelistCount = Number(readBigEndian(getter, cursor, 1));
+  cursor += 1;
+  if (getterWhitelistCount !== 1 || cursor + getterWhitelistCount * 10 !== getter.length) {
+    throw new Error("omniston: malformed EVM amount-getter whitelist");
+  }
+  const getterResolver = readBigEndian(getter, cursor, 10);
+  const expectedPoints = [[800000n, 100n], [700000n, 100n], [600000n, 100n], [500000n, 100n], [400000n, 100n]];
+  const quoteResolverFee = expected.protocolFeePips % 10 === 0 ? BigInt(expected.protocolFeePips / 10) : -1n;
+  const resolverLow80 = BigInt((0, import_viem.getAddress)(expected.initialResolverAddress)) & (1n << 80n) - 1n;
+  if (gasBump !== 0n || gasPrice !== 0n || !within(auctionStart, expected.quoteTimestamp, 5, 5) || duration !== 1800n || initialRateBump !== 900000n || points.some((point, index) => point[0] !== expectedPoints[index][0] || point[1] !== expectedPoints[index][1]) || expected.integratorFeePips !== 0 || integratorFee !== 0n || integratorShare !== 100n || quoteResolverFee < 0n || resolverFee !== quoteResolverFee || whitelistDiscount !== 50n || getterResolver !== resolverLow80) {
+    throw new Error("omniston: EVM amount-getter terms do not match the pinned v1beta8 profile");
+  }
+  const post = fields[7];
+  cursor = 20;
+  const integratorRecipient = post.slice(cursor, cursor + 20);
+  cursor += 20;
+  const protocolRecipient = post.slice(cursor, cursor + 20);
+  cursor += 20;
+  const postIntegratorFee = readBigEndian(post, cursor, 2);
+  cursor += 2;
+  const postIntegratorShare = readBigEndian(post, cursor, 1);
+  cursor += 1;
+  const postResolverFee = readBigEndian(post, cursor, 2);
+  cursor += 2;
+  const postDiscount = readBigEndian(post, cursor, 1);
+  cursor += 1;
+  const allowedTime = readBigEndian(post, cursor, 4);
+  cursor += 4;
+  const whitelistCount = Number(readBigEndian(post, cursor, 1));
+  cursor += 1;
+  if (whitelistCount !== 1 || cursor + whitelistCount * 12 + 160 !== post.length) {
+    throw new Error("omniston: malformed EVM post-interaction whitelist");
+  }
+  const postResolver = readBigEndian(post, cursor, 10);
+  cursor += 10;
+  const resolverTimeDelta = readBigEndian(post, cursor, 2);
+  cursor += 2;
+  if (!zeroBytes(integratorRecipient) || !(zeroBytes(protocolRecipient) || evmDest && EVM_DEST_PROTOCOL_FEE_RECIPIENTS.has(`0x${bytesToHex(protocolRecipient)}`)) || postIntegratorFee !== 0n || postIntegratorShare !== 100n || postResolverFee !== quoteResolverFee || postDiscount !== 50n || !within(allowedTime, expected.quoteTimestamp, 60, 5) || postResolver !== resolverLow80 || resolverTimeDelta !== 0n) {
+    throw new Error("omniston: EVM post-interaction terms do not match the pinned v1beta8 profile");
+  }
+  const extra = Array.from({ length: 5 }, () => {
+    const value = readBigEndian(post, cursor, 32);
+    cursor += 32;
+    return value;
+  });
+  const hashlock2 = readBigEndian(expected.secretHash, 0, expected.secretHash.length);
+  const dstToken = evmDest ? BigInt((0, import_viem.getAddress)(expected.outputTokenAddress)) : BigInt((0, import_viem.getAddress)(expected.takerAsset));
+  const deposits = BigInt(expected.srcSecurityDepositUnits) << 128n | BigInt(expected.dstSecurityDepositUnits);
+  const timelocks = [1n, 120n, 240n, 300n, 1n, 120n, 180n, 0n].reduce((packed, value, index) => packed | value << BigInt(index * 32), 0n);
+  if (expected.secretHash.length !== 32 || extra[0] !== hashlock2 || extra[1] !== (evmDest ? BigInt(expected.dstChainId) : 0n) || extra[2] !== dstToken || extra[3] !== deposits || extra[4] !== timelocks) {
+    throw new Error("omniston: signed EVM HTLC terms do not match the validated order details");
+  }
+  const customData = extension.slice(32 + begin);
+  if (customData.length !== 131) throw new Error("omniston: malformed EVM order extension custom data");
+  if (evmDest) {
+    if (!zeroBytes(customData.slice(0, 66))) throw new Error("omniston: unexpected TON addresses in an EVM-destination order");
+  } else {
+    const { Address: Address3 } = await import("@ton/core");
+    const expectedTon = [expected.outputTokenAddress, expected.traderDstAddress].map((value) => Address3.parse(value));
+    for (let index = 0; index < expectedTon.length; index++) {
+      const offset = index * 33;
+      const workchain = customData[offset] === 255 ? -1 : customData[offset];
+      if (workchain !== expectedTon[index].workChain || !sliceEqual(customData.slice(offset + 1, offset + 33), expectedTon[index].hash)) {
+        throw new Error("omniston: signed EVM\u2192TON address does not match the validated request");
+      }
+    }
+  }
+  if (!zeroBytes(customData.slice(66, 99))) {
+    throw new Error("omniston: unexpected private TON disclosure address");
+  }
+  const quoteId = expected.quoteId.replace(/^0x/, "");
+  if (!QUOTE_ID.test(quoteId) || !sliceEqual(customData.slice(99), hexToBytes(quoteId.padStart(64, "0")))) {
+    throw new Error("omniston: EVM order extension custom data is not bound to the quote id");
+  }
+  if (expected.tradeStartDeadline < expected.quoteTimestamp) {
+    throw new Error("omniston: invalid EVM order quote deadline");
+  }
+}
+function validateEvmTypedOrder(td, expected) {
+  const value = td;
+  const order = value.types?.Order;
+  const exactSchema = Array.isArray(order) && order.length === ORDER_FIELDS.length && order.every((field, i) => field.name === ORDER_FIELDS[i][0] && field.type === ORDER_FIELDS[i][1]);
+  const message = value.message;
+  const salt = message?.salt;
+  const traits = validUint256(message?.makerTraits) ? BigInt(message.makerTraits) : -1n;
+  const flagMask = (1n << 56n) - 1n << 200n;
+  const baseFlags = 1n << 251n | 1n << 249n;
+  const flags = traits < 0n ? -1n : traits & flagMask;
+  const flagsOk = flags === baseFlags || flags === (baseFlags | 1n << 255n);
+  const allowedSender = traits & (1n << 80n) - 1n;
+  const expiration = traits >> 80n & (1n << 40n) - 1n;
+  const series = traits >> 160n & (1n << 40n) - 1n;
+  const extensionHash = BigInt((0, import_viem.keccak256)(expected.orderExtension));
+  const exactMessage = !!message && Object.keys(message).length === ORDER_FIELDS.length && ORDER_FIELDS.every(([name]) => Object.hasOwn(message, name));
+  if (value.domain?.name !== "1inch Limit Order Protocol" || value.domain.version !== "4" || typeof value.domain.verifyingContract !== "string" || (0, import_viem.getAddress)(value.domain.verifyingContract) !== (0, import_viem.getAddress)(expected.settlementContract) || Number(value.domain.chainId) !== expected.chainId || value.primaryType !== "Order" || !exactSchema || !message || !exactMessage || (0, import_viem.getAddress)(String(message.maker)) !== (0, import_viem.getAddress)(expected.owner) || (0, import_viem.getAddress)(String(message.receiver)) !== (0, import_viem.getAddress)(expected.receiver) || (0, import_viem.getAddress)(String(message.makerAsset)) !== (0, import_viem.getAddress)(expected.makerAsset) || !validUint256(salt) || (BigInt(salt) & (1n << 160n) - 1n) !== (extensionHash & (1n << 160n) - 1n) || // The order expires at the quote's trade-start deadline (±15 s of clock
+  // skew between the quote and the order builder), never later.
+  traits < 0n || !flagsOk || allowedSender !== 0n || series !== 0n || !within(expiration, expected.tradeStartDeadline, 15, 15) || expiration <= BigInt(expected.quoteTimestamp) || !validEvmAddress(message.takerAsset) || (0, import_viem.getAddress)(String(message.takerAsset)) === (0, import_viem.getAddress)(expected.makerAsset) || !validUint256(message.makingAmount) || BigInt(message.makingAmount) !== BigInt(expected.makingAmount) || !validUint256(message.takingAmount) || BigInt(message.takingAmount) !== BigInt(expected.takingAmount)) {
+    throw new Error("omniston: EVM order fields do not match the validated quote/request");
+  }
+}
+async function validateTonEscrowPayload(message, expected, validateForwardPayload) {
+  const { Address: Address3, Cell: Cell2 } = await import("@ton/core");
+  const boc = hexToBytes(message.payload);
+  let roots;
+  try {
+    roots = Cell2.fromBoc(import_buffer2.Buffer.from(boc));
+  } catch {
+    throw new Error("omniston: malformed TON escrow BoC");
+  }
+  if (roots.length !== 1) throw new Error("omniston: TON escrow must contain exactly one root cell");
+  const slice = roots[0].beginParse();
+  const op = slice.loadUint(32);
+  slice.loadUintBig(64);
+  const amount = slice.loadCoins();
+  const destination = slice.loadAddressAny();
+  const response = slice.loadAddressAny();
+  const customPayload = slice.loadMaybeRef();
+  const forwardAmount = slice.loadCoins();
+  const payloadByRef = slice.loadBit();
+  if (op !== 260734629 || amount !== BigInt(expected.inputUnits) || !(destination instanceof Address3) || !destination.equals(Address3.parse(expected.protocolAddress)) || response !== null && (!(response instanceof Address3) || !response.equals(Address3.parse(expected.ownerAddress))) || customPayload !== null || forwardAmount <= 0n || forwardAmount > BigInt(message.sendAmount) || !payloadByRef || slice.remainingBits !== 0 || slice.remainingRefs !== 1) {
+    throw new Error("omniston: TON jetton transfer does not match the validated quote/request");
+  }
+  const forwardPayload = slice.loadRef();
+  const verified = await validateForwardPayload({
+    payloadBocHex: message.payload,
+    forwardPayloadBocHex: import_buffer2.Buffer.from(forwardPayload.toBoc()).toString("hex"),
+    quoteId: expected.quoteId,
+    inputUnits: expected.inputUnits,
+    resolverSendsUnits: expected.resolverSendsUnits,
+    srcHtlcSecurityDepositUnits: expected.srcHtlcSecurityDepositUnits,
+    protocolAddress: expected.protocolAddress,
+    ownerAddress: expected.ownerAddress,
+    destinationChain: expected.destinationChain,
+    destinationAddress: expected.destinationAddress,
+    outputTokenAddress: expected.outputTokenAddress,
+    initialResolverAddress: expected.initialResolverAddress,
+    secretHashes: expected.hashes.map((hash) => hash.slice()),
+    ...expected.hashingFunction ? { hashingFunction: expected.hashingFunction } : {},
+    exclusivityTimeout: expected.exclusivityTimeout
+  });
+  if (!verified) throw new Error("omniston: TON escrow forward payload failed independent semantic validation");
+}
+function feeToken(asset) {
+  return asset.assetId || asset.contract || asset.symbol;
+}
+function chainCase(asset) {
+  return asset.chain.$case;
+}
+function bytesEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a[i] ^ b[i];
+  return diff === 0;
+}
+var ProtoReader = class {
+  constructor(bytes) {
+    this.bytes = bytes;
+  }
+  bytes;
+  pos = 0;
+  get done() {
+    return this.pos === this.bytes.length;
+  }
+  varint() {
+    let out = 0;
+    let shift = 0;
+    while (this.pos < this.bytes.length && shift <= 49) {
+      const byte = this.bytes[this.pos++];
+      out += (byte & 127) * 2 ** shift;
+      if ((byte & 128) === 0) {
+        if (!Number.isSafeInteger(out)) throw new Error("omniston: unsafe protobuf varint");
+        return out;
+      }
+      shift += 7;
+    }
+    throw new Error("omniston: malformed protobuf varint");
+  }
+  field() {
+    const tag = this.varint();
+    const number = Math.floor(tag / 8);
+    const wire = tag & 7;
+    if (number < 1) throw new Error("omniston: malformed protobuf field");
+    return { number, wire };
+  }
+  lengthDelimited() {
+    const length = this.varint();
+    const end2 = this.pos + length;
+    if (length < 0 || end2 > this.bytes.length) throw new Error("omniston: truncated protobuf payload");
+    const value = this.bytes.slice(this.pos, end2);
+    this.pos = end2;
+    return value;
+  }
+  skip(wire) {
+    if (wire === 0) {
+      this.varint();
+      return;
+    }
+    if (wire === 1) {
+      this.advance(8);
+      return;
+    }
+    if (wire === 2) {
+      this.lengthDelimited();
+      return;
+    }
+    if (wire === 5) {
+      this.advance(4);
+      return;
+    }
+    throw new Error("omniston: unsupported protobuf wire type");
+  }
+  advance(length) {
+    if (this.pos + length > this.bytes.length) throw new Error("omniston: truncated protobuf payload");
+    this.pos += length;
+  }
+};
+var utf8 = new TextDecoder("utf-8", { fatal: true });
+var PROTO_CASE_BY_FIELD = {
+  1: "arbitrum",
+  2: "avalanche",
+  3: "base",
+  4: "bnb",
+  5: "ethereum",
+  6: "polygon",
+  7: "robinhood",
+  8: "xlayer",
+  9: "arc",
+  10: "monad",
+  11: "plasma",
+  12: "hyperevm",
+  50: "ton",
+  60: "tron"
+};
+function decodeChainAddress(bytes) {
+  const reader = new ProtoReader(bytes);
+  let address;
+  while (!reader.done) {
+    const { number, wire } = reader.field();
+    const $case = PROTO_CASE_BY_FIELD[number];
+    if (!$case || wire !== 2 || address) throw new Error("omniston: malformed chain address in order details");
+    address = { chain: { $case, value: utf8.decode(reader.lengthDelimited()) } };
+  }
+  if (!address?.chain.value) throw new Error("omniston: empty chain address in order details");
+  return address;
+}
+function decodeAssetId(bytes) {
+  const reader = new ProtoReader(bytes);
+  let asset;
+  while (!reader.done) {
+    const { number, wire } = reader.field();
+    const $case = PROTO_CASE_BY_FIELD[number];
+    if (!$case || wire !== 2 || asset) throw new Error("omniston: malformed asset id in order details");
+    const kindReader = new ProtoReader(reader.lengthDelimited());
+    const kindField = kindReader.field();
+    if (kindField.wire !== 2 || kindField.number !== 1 && kindField.number !== 2) {
+      throw new Error("omniston: unsupported asset kind in order details");
+    }
+    const kindCase = kindField.number === 1 ? "native" : $case === "ton" ? "jetton" : $case === "tron" ? "trc20" : "erc20";
+    const value = kindField.number === 1 ? {} : utf8.decode(kindReader.lengthDelimited());
+    if (!kindReader.done || kindField.number === 2 && !value) throw new Error("omniston: malformed asset kind in order details");
+    asset = { chain: { $case, value: { kind: { $case: kindCase, value } } } };
+  }
+  if (!asset) throw new Error("omniston: empty asset id in order details");
+  return asset;
+}
+function validateSerializedOrderDetails(bytes, expected) {
+  if (!bytes?.length) throw new Error("omniston: EVM HTLC order payload has no serialized details");
+  const wrapper = new ProtoReader(bytes);
+  const outer = wrapper.field();
+  if (outer.number !== 1 || outer.wire !== 2) throw new Error("omniston: unsupported HTLC order-details version");
+  const detailsBytes = wrapper.lengthDelimited();
+  if (!wrapper.done) throw new Error("omniston: ambiguous HTLC order-details wrapper");
+  const reader = new ProtoReader(detailsBytes);
+  let quoteId;
+  let outputAsset;
+  let traderDstAddress;
+  const hashes = [];
+  while (!reader.done) {
+    const { number, wire } = reader.field();
+    if (wire !== 2) throw new Error("omniston: malformed HTLC order details");
+    const value = reader.lengthDelimited();
+    if (number === 1 && quoteId === void 0) quoteId = utf8.decode(value);
+    else if (number === 2 && outputAsset === void 0) outputAsset = decodeAssetId(value);
+    else if (number === 3 && traderDstAddress === void 0) traderDstAddress = decodeChainAddress(value);
+    else if (number === 5) hashes.push(value);
+    else throw new Error("omniston: duplicate or unexpected HTLC order-details field");
+  }
+  if (quoteId !== expected.quoteId || !outputAsset || !sameAsset(outputAsset, expected.outputAsset) || !traderDstAddress || !sameChainAddress(traderDstAddress, expected.traderDstAddress) || hashes.length !== expected.secretHashes.length || hashes.some((hash, i) => !bytesEqual(hash, expected.secretHashes[i]))) {
+    throw new Error("omniston: resolver order payload does not match the validated quote/request");
+  }
+}
+function isPositiveInteger(value) {
+  try {
+    return BigInt(value) > 0n;
+  } catch {
+    return false;
+  }
+}
+function isNonNegativeInteger(value) {
+  if (value === void 0) return true;
+  return /^[0-9]+$/.test(value);
+}
+function decimalToUnits(value, decimals) {
+  const match = value.match(/^(\d+)(?:\.(\d+))?$/);
+  if (!match || !Number.isInteger(decimals) || decimals < 0) return null;
+  const fraction = match[2] ?? "";
+  if (fraction.length > decimals) return null;
+  const units = BigInt(match[1]) * 10n ** BigInt(decimals) + BigInt((fraction + "0".repeat(decimals)).slice(0, decimals) || "0");
+  return units > 0n ? units : null;
+}
+function validDisclosurePhase(phase) {
+  return phase === "EXECUTION_PHASE_READY_FOR_PRIVATE_COMPLETION" || phase === "EXECUTION_PHASE_READY_FOR_PUBLIC_COMPLETION" || phase === "OUTPUT_LOCKED";
+}
+function bytesToHex(bytes) {
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function hexToBytes(hex) {
+  const clean = hex.replace(/^0x/, "");
+  if (!clean || !/^(?:[0-9a-fA-F]{2})+$/.test(clean)) {
+    throw new Error("omniston: malformed hex payload");
+  }
+  const out = new Uint8Array(clean.length / 2);
+  for (let i = 0; i < out.length; i++) out[i] = Number.parseInt(clean.slice(i * 2, i * 2 + 2), 16);
+  return out;
+}
+function hexToBase64(hex) {
+  const bytes = hexToBytes(hex);
+  let bin = "";
+  bytes.forEach((b) => bin += String.fromCharCode(b));
+  return btoa(bin);
+}
+function validOrderSettlement(q) {
+  if (q.settlementData?.$case !== "order") return false;
+  const v = q.settlementData.value;
+  return !!v.srcProtocolContractAddress && v.srcProtocolContractAddress.chain.$case === chainCase(q.inputAsset) && !!v.srcInitialResolverAddress && v.srcInitialResolverAddress.chain.$case === chainCase(q.inputAsset) && !!v.dstProtocolContractAddress && v.dstProtocolContractAddress.chain.$case === chainCase(q.outputAsset) && isPositiveInteger(v.srcHtlcSecurityDepositUnits ?? "") && isPositiveInteger(v.dstSecurityDepositUnits ?? "") && (v.htlcHashingFunction === "HASHING_FUNCTION_KECCAK256" || v.htlcHashingFunction === "HASHING_FUNCTION_SHA256") && Number.isSafeInteger(v.exclusivityTimeout) && v.exclusivityTimeout > 0 && isPositiveInteger(v.resolverSendsUnits) && BigInt(v.resolverSendsUnits) === BigInt(q.outputUnits) + BigInt(q.protocolFeeUnits || "0") + BigInt(q.integratorFeeUnits || "0");
+}
+function validSwapSettlement(q) {
+  if (q.settlementData?.$case !== "swap") return false;
+  const v = q.settlementData.value;
+  return Array.isArray(v.routes) && v.routes.length > 0 && v.routes.every((route) => Array.isArray(route?.steps) && route.steps.length > 0 && route.steps.every((step) => Array.isArray(step?.chunks) && step.chunks.length > 0 && step.chunks.every((chunk) => typeof chunk?.protocol === "string" && chunk.protocol.length > 0 && isPositiveInteger(chunk.inputUnits) && isPositiveInteger(chunk.outputUnits)))) && isPositiveInteger(v.minOutputAmount) && BigInt(v.minOutputAmount) <= BigInt(q.outputUnits) && (v.recommendedMinOutputAmount === void 0 || isPositiveInteger(v.recommendedMinOutputAmount) && BigInt(v.recommendedMinOutputAmount) <= BigInt(q.outputUnits)) && (q.gasBudget === void 0 || isPositiveInteger(q.gasBudget));
+}
+function swapProtocols(v) {
+  const names = /* @__PURE__ */ new Set();
+  for (const route of v.routes) for (const step of route.steps) for (const chunk of step.chunks) names.add(chunk.protocol);
+  return [...names];
+}
+function quoteRejection(q, update, acknowledgedRfqId, request, settlement) {
+  if (!q) return "empty quote";
+  if (!acknowledgedRfqId || update.rfqId !== acknowledgedRfqId || q.rfqId !== acknowledgedRfqId) return "quote for another RFQ";
+  if (!sameAsset(q.inputAsset, request.inputAsset) || !sameAsset(q.outputAsset, request.outputAsset)) return "quote assets differ from the request";
+  const requestedAmount = request.amount.$case === "inputUnits" ? request.amount.value : "";
+  if (q.inputUnits !== requestedAmount) return "quote input differs from the request";
+  if (!QUOTE_ID.test(q.quoteId)) return "malformed quote id";
+  if (!isPositiveInteger(q.inputUnits) || !isPositiveInteger(q.outputUnits)) return "non-positive quote amounts";
+  if (!isNonNegativeInteger(q.protocolFeeUnits) || !isNonNegativeInteger(q.integratorFeeUnits) || BigInt(q.protocolFeeUnits || "0") + BigInt(q.integratorFeeUnits || "0") > BigInt(q.outputUnits)) return "malformed quote fees";
+  if (!Number.isInteger(q.quoteTimestamp) || Math.abs(Math.floor(Date.now() / 1e3) - q.quoteTimestamp) > 120) return "quote timestamp out of range";
+  if (settlement === "order" ? !validOrderSettlement(q) : !validSwapSettlement(q)) return `incomplete ${settlement} settlement data`;
+  if (!sameChainAddress(q.integratorAddress, request.integratorAddress)) return "quote integrator differs from the request";
+  return null;
+}
+function awaitQuote(stream, request, signal, settleMs = QUOTE_SETTLE_MS, settlement = "order", outcome = { updates: 0 }) {
+  return new Promise((resolve) => {
+    let latest = null;
+    let done = false;
+    let sub = null;
+    let acknowledgedRfqId = null;
+    const onAbort = () => finish(null);
+    const finish = (value) => {
+      if (done) return;
+      done = true;
+      clearTimeout(settle);
+      clearTimeout(max);
+      signal?.removeEventListener("abort", onAbort);
+      try {
+        sub?.unsubscribe();
+      } catch {
+      }
+      resolve(value);
+    };
+    const settle = setTimeout(() => {
+      if (latest) finish(latest);
+    }, settleMs);
+    const max = setTimeout(() => finish(latest), QUOTE_MAX_MS);
+    sub = stream.subscribe({
+      next: (event) => {
+        if (event.$case === "ack") {
+          acknowledgedRfqId = event.value.rfqId || null;
+        } else if (event.$case === "quoteUpdated") {
+          const update = event;
+          outcome.updates += 1;
+          const rejection = quoteRejection(update.value, update, acknowledgedRfqId, request, settlement);
+          if (rejection) {
+            outcome.rejected = rejection;
+            latest = null;
+            return;
+          }
+          latest = update.value;
+        } else if (event.$case === "noQuote") {
+          const noQuote = event;
+          if (acknowledgedRfqId && noQuote.rfqId === acknowledgedRfqId) latest = null;
+        }
+      },
+      error: (err) => {
+        outcome.error = String(err?.message ?? err).slice(0, 200);
+        finish(null);
+      },
+      complete: () => finish(latest)
+    });
+    signal?.addEventListener("abort", onAbort, { once: true });
+    if (done) sub.unsubscribe();
+  });
+}
+function awaitSwapProgress(stream) {
+  return new Promise((resolve) => {
+    let done = false;
+    let latest = null;
+    let sub = null;
+    const finish = (value) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      try {
+        sub?.unsubscribe();
+      } catch {
+      }
+      resolve(value);
+    };
+    const timer = setTimeout(() => finish(latest), TRACK_SNAPSHOT_MS);
+    sub = stream.subscribe({
+      next: (event) => {
+        if (event.$case === "progress") {
+          latest = event.value;
+          if (["TRADE_STATUS_FULLY_FILLED", "TRADE_STATUS_PARTIALLY_FILLED", "TRADE_STATUS_CANCELLED", "TRADE_STATUS_FAILED"].includes(latest.status)) finish(latest);
+        } else if (event.$case === "awaitingTransfer" && latest === null) {
+          latest = "awaiting";
+        }
+      },
+      error: () => finish(null),
+      complete: () => finish(latest)
+    });
+    if (done) sub.unsubscribe();
+  });
+}
+var JETTON_TRANSFER_OP = 260734629;
+function parseSwapPayload(payloadHex) {
+  if (!/^(?:[0-9a-fA-F]{2})+$/.test(payloadHex)) throw new Error("omniston: malformed swap payload hex");
+  const roots = import_core3.Cell.fromBoc(import_buffer2.Buffer.from(payloadHex, "hex"));
+  if (roots.length !== 1) throw new Error("omniston: swap payload must have one root");
+  const s = roots[0].beginParse();
+  const op = s.loadUint(32);
+  if (op !== JETTON_TRANSFER_OP) return { op, jettonTransfer: null };
+  s.loadUintBig(64);
+  const amount = s.loadCoins();
+  const destination = s.loadAddress();
+  const responseDestination = s.loadMaybeAddress();
+  s.loadMaybeRef();
+  const forwardTon = s.loadCoins();
+  return {
+    op,
+    jettonTransfer: {
+      amount,
+      destination: destination.toString(),
+      responseDestination: responseDestination ? responseDestination.toString() : null,
+      forwardTon
+    }
+  };
+}
+function sameTonAddress(a, b) {
+  try {
+    return import_core3.Address.parse(a).equals(import_core3.Address.parse(b));
+  } catch {
+    return false;
+  }
+}
+function awaitOrder(stream) {
+  return new Promise((resolve) => {
+    let done = false;
+    let latest = null;
+    let sub = null;
+    const finish = (value) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      try {
+        sub?.unsubscribe();
+      } catch {
+      }
+      resolve(value);
+    };
+    const timer = setTimeout(() => finish(latest), TRACK_SNAPSHOT_MS);
+    sub = stream.subscribe({
+      next: (event) => {
+        if (event.$case === "order") {
+          latest = event.value;
+          if (["TRADE_STATUS_FULLY_FILLED", "TRADE_STATUS_CANCELLED", "TRADE_STATUS_FAILED"].includes(latest.status)) finish(latest);
+        }
+      },
+      error: () => finish(null),
+      complete: () => finish(latest)
+    });
+    if (done) sub.unsubscribe();
+  });
+}
+function mapOrderStatus(order) {
+  const depositReceived = order.executions.length > 0;
+  switch (order.status) {
+    case "TRADE_STATUS_FULLY_FILLED":
+      return { state: "completed", depositReceived: true };
+    case "TRADE_STATUS_PARTIALLY_FILLED":
+      return { state: "pending", depositReceived: true };
+    case "TRADE_STATUS_CANCELLED":
+    case "TRADE_STATUS_FAILED":
+      return { state: "pending", depositReceived };
+    default:
+      return { state: "pending", depositReceived };
+  }
+}
+function omnistonProvider(opts = {}) {
+  opts = Object.freeze({ ...opts });
+  const apiUrl = opts.apiUrl ?? "wss://omni-ws.ston.fi";
+  const parsedApiUrl = new URL(apiUrl);
+  if (parsedApiUrl.protocol !== "wss:" && parsedApiUrl.protocol !== "ws:") {
+    throw new Error("omniston: apiUrl must use ws or wss");
+  }
+  const maxUsdText = String(opts.maxUsd ?? 1e3);
+  if (!/^(?:0|[1-9]\d*)(?:\.\d+)?$/.test(maxUsdText) || Number(maxUsdText) <= 0 || !Number.isFinite(Number(maxUsdText))) {
+    throw new Error("omniston: maxUsd must be a positive plain decimal");
+  }
+  const hasIntegrator = opts.integratorAddress !== void 0;
+  const hasIntegratorPips = opts.integratorFeePips !== void 0;
+  if (hasIntegrator !== hasIntegratorPips) throw new Error("omniston: integratorAddress and integratorFeePips must be configured together");
+  if (hasIntegrator && (!opts.integratorAddress.trim() || !Number.isInteger(opts.integratorFeePips) || opts.integratorFeePips < 0 || opts.integratorFeePips > 1e6)) {
+    throw new Error("omniston: integrator fee config is invalid");
+  }
+  const trustedContracts = /* @__PURE__ */ new Map();
+  for (const [chain, addresses] of Object.entries(opts.trustedSettlementContracts ?? {})) {
+    const normalized = /* @__PURE__ */ new Set();
+    for (const address of addresses) {
+      try {
+        normalized.add(isTon(chain) ? address : (0, import_viem.getAddress)(address).toLowerCase());
+      } catch {
+        throw new Error(`omniston: invalid trusted settlement contract for ${chain}`);
+      }
+    }
+    if (normalized.size) trustedContracts.set(chain, normalized);
+  }
+  const isTrusted = (chain, address) => {
+    try {
+      return trustedContracts.get(chain)?.has(isTon(chain) ? address : (0, import_viem.getAddress)(address).toLowerCase()) ?? false;
+    } catch {
+      return false;
+    }
+  };
+  const trustedOrderProtocols = /* @__PURE__ */ new Map();
+  for (const [chain, addresses] of Object.entries(opts.trustedEvmOrderProtocols ?? {})) {
+    const normalized = /* @__PURE__ */ new Set();
+    for (const address of addresses) {
+      try {
+        if (evmRef2(chain) === null) throw new Error("not an EVM chain");
+        normalized.add((0, import_viem.getAddress)(address).toLowerCase());
+      } catch {
+        throw new Error(`omniston: invalid trusted EVM order protocol for ${chain}`);
+      }
+    }
+    if (normalized.size) trustedOrderProtocols.set(chain, normalized);
+  }
+  const isTrustedOrderProtocol = (chain, address) => {
+    try {
+      return trustedOrderProtocols.get(chain)?.has((0, import_viem.getAddress)(address).toLowerCase()) ?? false;
+    } catch {
+      return false;
+    }
+  };
+  const store = opts.secretStore ?? inMemorySecretStore();
+  const requestedMaxExecutions = opts.maxHtlcExecutions ?? DEFAULT_MAX_HTLC_EXECUTIONS;
+  if (!Number.isFinite(requestedMaxExecutions) || !Number.isInteger(requestedMaxExecutions) || requestedMaxExecutions < 1) {
+    throw new Error("omniston: maxHtlcExecutions must be a positive integer");
+  }
+  const maxExecutions = Math.min(16, requestedMaxExecutions);
+  const maxTonExecutionNano = opts.maxTonExecutionNano ?? "2000000000";
+  if (!isPositiveInteger(maxTonExecutionNano)) {
+    throw new Error("omniston: maxTonExecutionNano must be a positive integer");
+  }
+  const quoteSettleMs = opts.quoteSettleMs ?? QUOTE_SETTLE_MS;
+  if (!Number.isInteger(quoteSettleMs) || quoteSettleMs < 0 || quoteSettleMs >= QUOTE_MAX_MS) {
+    throw new Error(`omniston: quoteSettleMs must be an integer in [0, ${QUOTE_MAX_MS})`);
+  }
+  const injectedClient = opts.client ?? null;
+  let client = injectedClient;
+  let clientPromise = null;
+  let clientGeneration = 0;
+  async function getClient() {
+    if (client) return client;
+    if (clientPromise) return clientPromise;
+    const generation = clientGeneration;
+    clientPromise = (async () => {
+      const sdk = await import("@ston-fi/omniston-sdk");
+      const webSocketTransport = new sdk.WebSocketTransport(apiUrl);
+      const connect = webSocketTransport.connect.bind(webSocketTransport);
+      webSocketTransport.connect = () => {
+        const pending = connect();
+        const socket = webSocketTransport.webSocket;
+        socket?.addEventListener("error", () => {
+        });
+        return pending;
+      };
+      webSocketTransport.reconnect = () => webSocketTransport.connect();
+      const messages = webSocketTransport.messagesSubject;
+      if (messages) {
+        const deliver = messages.next.bind(messages);
+        messages.next = (m) => {
+          setTimeout(() => deliver(m), 0);
+        };
+      }
+      const transport = new sdk.AutoReconnectTransport({ transport: webSocketTransport });
+      const created = new sdk.Omniston({ apiUrl, transport });
+      if (generation !== clientGeneration) {
+        if (created.close) created.close();
+        else created.transport?.close();
+        throw new Error("omniston: provider closed while client was being created");
+      }
+      client = created;
+      return created;
+    })();
+    try {
+      return await clientPromise;
+    } finally {
+      clientPromise = null;
+    }
+  }
+  const quotes = opts.quoteStore ?? inMemoryQuoteStore();
+  async function saveBuilt(quoteId, entry) {
+    await quotes.save(quoteId, JSON.stringify(entry));
+  }
+  async function loadBuilt(quoteId) {
+    const raw2 = await quotes.load(quoteId);
+    if (!raw2) return void 0;
+    try {
+      const e = JSON.parse(raw2);
+      if (!Number.isFinite(e.at) || Date.now() - e.at > CACHE_TTL_MS) {
+        await quotes.clear(quoteId);
+        return void 0;
+      }
+      return e;
+    } catch {
+      await quotes.clear(quoteId);
+      return void 0;
+    }
+  }
+  function bindIntent(decoded, entry) {
+    const owner = entry.evmOrder?.owner;
+    const bound = entry.bound;
+    if (bound) {
+      if (bound.kind !== decoded.kind) return { ok: false, reason: "mismatch", field: "kind" };
+      if (bound.srcChain !== decoded.srcChain) return { ok: false, reason: "mismatch", field: "srcChain" };
+      if (!sameIntentAddress(bound.trader, decoded.trader)) return { ok: false, reason: "mismatch", field: "trader" };
+      if (!sameIntentAddress(bound.dest, decoded.dest)) return { ok: false, reason: "mismatch", field: "dest" };
+      if (owner !== void 0 && !sameIntentAddress(owner, bound.trader)) return { ok: false, reason: "mismatch", field: "owner" };
+      return { ok: true, legacy: false, ref: { quoteId: decoded.quoteId, trader: owner ?? bound.trader, dest: bound.dest, srcChain: bound.srcChain, kind: bound.kind } };
+    }
+    if (!Number.isFinite(entry.at) || Date.now() - entry.at > LEGACY_INTENT_WINDOW_MS) return { ok: false, reason: "legacy-expired" };
+    if (owner !== void 0 && !sameIntentAddress(owner, decoded.trader)) return { ok: false, reason: "mismatch", field: "owner" };
+    return { ok: true, legacy: true, ref: { ...decoded, trader: owner ?? decoded.trader } };
+  }
+  const traceFor = (quoteId) => (event, details) => {
+    try {
+      opts.trace?.(event, { quoteId, ...details });
+    } catch {
+    }
+  };
+  function requireBinding(decoded, entry, where) {
+    const trace = traceFor(decoded.quoteId);
+    const bound = bindIntent(decoded, entry);
+    if (!bound.ok) {
+      if (bound.reason === "legacy-expired") {
+        trace("legacy-intent-expired", { where });
+        throw new Error("omniston: quote expired \u2014 request a fresh quote");
+      }
+      trace("intent-mismatch", { where, field: bound.field });
+      throw new Error(`omniston: intent id does not match the quote it was issued for (${bound.field})`);
+    }
+    if (bound.legacy) trace("legacy-intent", { where });
+    return bound.ref;
+  }
+  const bindKey = (quoteId) => `${quoteId}#bind`;
+  const disclosedKey = (quoteId) => `${quoteId}#disclosed`;
+  function orderBinding(ref, q) {
+    return (0, import_viem.sha256)(new TextEncoder().encode(JSON.stringify([
+      ref.quoteId,
+      ref.trader ?? null,
+      ref.dest ?? null,
+      ref.srcChain ?? null,
+      q.inputUnits,
+      q.outputUnits,
+      JSON.stringify(q.inputAsset),
+      JSON.stringify(q.outputAsset)
+    ]))).slice(2);
+  }
+  async function clearSecrets(quoteId) {
+    await store.clear(quoteId);
+    await store.clear(bindKey(quoteId));
+    await store.clear(disclosedKey(quoteId));
+  }
+  async function secretsFor(ref, q, count) {
+    const quoteId = ref.quoteId;
+    const binding = orderBinding(ref, q);
+    const existing = await store.load(quoteId);
+    if (existing && existing.length > 0) {
+      const [boundTo] = await store.load(bindKey(quoteId)) ?? [];
+      const disclosed = (await store.load(disclosedKey(quoteId)) ?? []).length > 0;
+      if (boundTo !== binding || disclosed) {
+        traceFor(quoteId)("secret-reuse-refused", { disclosed, bound: boundTo !== void 0 });
+        throw new Error("omniston: this quote id already belongs to another order \u2014 request a fresh quote");
+      }
+      if (existing.length !== count || !existing.every((s) => /^[0-9a-fA-F]{64}$/.test(s))) {
+        throw new Error("omniston: stored HTLC secrets for this quote do not fit the order \u2014 request a fresh quote");
+      }
+      traceFor(quoteId)("secret-reused", { count });
+      return { secrets: existing.map(hexToBytes), created: false };
+    }
+    const secrets = Array.from({ length: count }, generateSecret);
+    await store.save(bindKey(quoteId), [binding]);
+    await store.save(quoteId, secrets.map(bytesToHex));
+    return { secrets, created: true };
+  }
+  async function quoteIdInUse(quoteId) {
+    const existing = await store.load(quoteId);
+    return !!existing && existing.length > 0;
+  }
+  const SWAP_SLIPPAGE_PIPS_DEFAULT = 5e3;
+  const sameChainTonReady = () => typeof opts.validateTonJettonWallet === "function" && typeof opts.validateTonSwapTarget === "function";
+  const tonSourceReady = (from, to) => omniston.supports(from, to) && trustedContracts.has(from) && trustedContracts.has(to) && typeof opts.validateTonJettonWallet === "function" && typeof opts.validateTonEscrowPayload === "function" && typeof opts.validateEvmOutputPosition === "function";
+  const evmSourceReady = (from, to) => omniston.supports(from, to) && trustedOrderProtocols.has(from) && trustedContracts.has(from) && trustedContracts.has(to) && typeof opts.validateEvmInputPosition === "function" && typeof opts.validateTonOutputPosition === "function";
+  const evmToEvmReady = (from, to) => omniston.supports(from, to) && trustedOrderProtocols.has(from) && trustedContracts.has(from) && trustedContracts.has(to) && typeof opts.validateEvmInputPosition === "function" && typeof opts.validateEvmOutputPosition === "function";
+  async function getSwapQuote(params, signal) {
+    if (!omniston.supports(params.sourceChain, params.destChain) || !trustedContracts.has(params.sourceChain) || !sameChainTonReady()) return null;
+    const source = (0, import_swap2_assets.ccAsset)(params.sourceChain, params.sourceToken);
+    const dest = (0, import_swap2_assets.ccAssetByToken)(params.destChain, params.destToken);
+    if (!source || !dest || source.symbol === dest.symbol) return null;
+    const inputAsset = toAssetId(params.sourceChain, source, true);
+    const outputAsset = toAssetId(params.destChain, dest, true);
+    if (!inputAsset || !outputAsset || sameAsset(inputAsset, outputAsset) || !isPositiveInteger(params.amountIn)) return null;
+    const trader = params.refundAddress ?? "";
+    if (!trader && !params.dry) return null;
+    const slippagePips = params.slippageBps !== void 0 ? Math.round(params.slippageBps * 100) : SWAP_SLIPPAGE_PIPS_DEFAULT;
+    if (!Number.isInteger(slippagePips) || slippagePips < 0 || slippagePips > 5e5) return null;
+    const omni = await getClient();
+    const settle = params.dry === false ? Math.min(quoteSettleMs, EXECUTION_SETTLE_MS) : quoteSettleMs;
+    const outcome = { updates: 0 };
+    const rfq = async (pips) => {
+      const request = {
+        inputAsset,
+        outputAsset,
+        amount: { $case: "inputUnits", value: params.amountIn },
+        // One route → one outgoing message: a TON account sends exactly one.
+        settlementParams: [{ params: { $case: "swap", value: { maxPriceSlippagePips: pips, maxRoutes: 1 } } }]
+      };
+      if (hasIntegrator) {
+        const address = opts.integratorAddress ? toChainAddress(params.destChain, opts.integratorAddress) : null;
+        if (!address) return null;
+        request.integratorAddress = address;
+        request.integratorFeePips = opts.integratorFeePips;
+      }
+      for (let attempt = 0; attempt < 2; attempt++) {
+        if (attempt > 0) await new Promise((resolve) => setTimeout(resolve, 300));
+        const quote = await awaitQuote(omni.requestForQuote(request), request, signal, settle, "swap", outcome);
+        if (quote && quote.settlementData.$case === "swap") return quote;
+        if (signal?.aborted) return null;
+      }
+      return null;
+    };
+    let q = await rfq(slippagePips);
+    if (!q) {
+      if (!signal?.aborted) {
+        params.onRefusal?.(`omniston: ${outcome.error ? `RFQ failed: ${outcome.error}` : outcome.rejected ? `swap quote rejected: ${outcome.rejected}` : "no TON DEX route quoted this pair/amount"}`);
+      }
+      return null;
+    }
+    let swap = q.settlementData.$case === "swap" ? q.settlementData.value : null;
+    if (!swap) return null;
+    const absoluteFloor = params.minAmountOut !== void 0 && isPositiveInteger(params.minAmountOut) ? BigInt(params.minAmountOut) : 0n;
+    const requiredMin = (outputUnits) => {
+      const out = BigInt(outputUnits);
+      const slippageFloor = params.slippageBps !== void 0 ? (out * BigInt(1e4 - params.slippageBps) + 9999n) / 10000n : 0n;
+      return absoluteFloor > slippageFloor ? absoluteFloor : slippageFloor;
+    };
+    for (let attempt = 0; attempt < 2 && BigInt(swap.minOutputAmount) < requiredMin(q.outputUnits); attempt++) {
+      const out = BigInt(q.outputUnits);
+      const floor = requiredMin(q.outputUnits);
+      if (out < floor) return null;
+      const tightened = Number((out - floor) * 1000000n / out);
+      const again = await rfq(Math.max(0, Math.min(tightened, slippagePips)));
+      const againSwap = again?.settlementData.$case === "swap" ? again.settlementData.value : null;
+      if (!again || !againSwap) return null;
+      q = again;
+      swap = againSwap;
+    }
+    if (BigInt(swap.minOutputAmount) < requiredMin(q.outputUnits)) return null;
+    if (q.gasBudget !== void 0 && BigInt(q.gasBudget) > BigInt(maxTonExecutionNano)) return null;
+    const minOut = swap.minOutputAmount;
+    await saveBuilt(q.quoteId, { quote: q, at: Date.now(), bound: { trader, dest: params.destAddress, srcChain: params.sourceChain, kind: "swap" } });
+    const feeUnits = Number(q.protocolFeeUnits || "0") + Number(q.integratorFeeUnits || "0");
+    const stableOut = /^(USDT|USDC|USD₮|jUSDT)$/.test(dest.symbol);
+    const feeUsd = stableOut ? feeUnits / 10 ** dest.decimals : 0;
+    return {
+      provider: "omniston",
+      intentId: encodeIntent(q.quoteId, trader, params.destAddress, params.sourceChain, "swap"),
+      depositAddress: "",
+      // swap settlement — the built message pays the DEX directly
+      depositMemo: null,
+      sourceAmount: q.inputUnits,
+      destAmount: q.outputUnits,
+      minDestAmount: minOut,
+      feeUsd: Number.isFinite(feeUsd) ? feeUsd : 0,
+      fees: [
+        ...q.protocolFeeUnits && q.protocolFeeUnits !== "0" ? [{ type: "protocol", amount: q.protocolFeeUnits, token: feeToken(dest), included: true }] : [],
+        ...q.integratorFeeUnits && q.integratorFeeUnits !== "0" ? [{ type: "affiliate", amount: q.integratorFeeUnits, token: feeToken(dest), included: true }] : []
+      ],
+      etaSeconds: 30,
+      reliability: 0.9,
+      validUntilMs: Date.now() + QUOTE_TTL_MS,
+      // gasBudget = TON the message carries on top of the input; gasEstimate =
+      // what the route is expected to burn. Consumers show both so the user
+      // sees the 1.1 GRAM leaving for a 1 GRAM swap — and the refund.
+      providerData: {
+        settlement: "swap",
+        protocols: swapProtocols(swap).join(","),
+        ...q.gasBudget ? { gasBudget: q.gasBudget } : {},
+        ...q.estimatedGasConsumption ? { gasEstimate: q.estimatedGasConsumption } : {}
+      }
+    };
+  }
+  async function buildSwapDeposit(ref, q, swap) {
+    if (!ref.trader) throw new Error("omniston: quote was requested without a refund/source address");
+    if (!isTon(ref.srcChain) || q.inputAsset.chain.$case !== "ton" || q.outputAsset.chain.$case !== "ton") {
+      throw new Error("omniston: swap quote is not a TON same-chain swap");
+    }
+    if (!sameChainTonReady()) throw new Error("omniston: TON same-chain swaps need independent jetton-wallet and swap-target validators");
+    const owner = { chain: { $case: "ton", value: ref.trader } };
+    const receiver = { chain: { $case: "ton", value: ref.dest } };
+    const omni = await getClient();
+    if (typeof omni.tonBuildSwap !== "function") throw new Error("omniston: client does not support swap settlement (tonBuildSwap)");
+    const tx = await omni.tonBuildSwap({
+      quoteId: ref.quoteId,
+      transferSrcAddress: owner,
+      refundSrcAddress: owner,
+      gasExcessAddress: owner,
+      traderDstAddress: receiver,
+      // Build at the slippage the quote was requested with: its
+      // minOutputAmount is the minimum this module reported to the router.
+      useRecommendedSlippage: false
+    });
+    const [message, ...rest] = tx.messages;
+    if (!message || rest.length > 0) throw new Error(`omniston: expected exactly one swap message, got ${tx.messages.length}`);
+    if (message.jettonWalletStateInit) throw new Error("omniston: deploying a resolver-provided jetton wallet is not supported");
+    if (!isPositiveInteger(message.sendAmount)) throw new Error("omniston: malformed swap message value");
+    const sendAmount = BigInt(message.sendAmount);
+    const gasCap = BigInt(maxTonExecutionNano);
+    const gasBudget = q.gasBudget && isPositiveInteger(q.gasBudget) ? BigInt(q.gasBudget) : gasCap;
+    const protocols = swapProtocols(swap);
+    const inputJetton = assetContract(q.inputAsset);
+    const payload = parseSwapPayload(message.payload);
+    const routeSteps = swap.routes.length === 1 ? swap.routes[0].steps : [];
+    const singleV1 = routeSteps.length === 1 && routeSteps[0].chunks.length === 1 && routeSteps[0].chunks[0].protocol === "StonFiV1";
+    const ptonV1Native = !inputJetton && !!payload.jettonTransfer && singleV1;
+    if (inputJetton) {
+      const transfer = payload.jettonTransfer;
+      if (!transfer) throw new Error("omniston: jetton-input swap message is not a jetton transfer");
+      if (sendAmount > gasCap || sendAmount > gasBudget) throw new Error(`omniston: swap message attaches more TON than the quoted gas budget (${sendAmount} > ${gasBudget} nanoTON, cap ${gasCap}, ${protocols.join("+")})`);
+      if (transfer.amount !== BigInt(q.inputUnits)) throw new Error("omniston: swap message moves a different amount than quoted");
+      if (!transfer.responseDestination || !sameTonAddress(transfer.responseDestination, ref.trader)) {
+        throw new Error("omniston: swap message returns excess to a wallet other than the trader");
+      }
+      if (transfer.forwardTon >= sendAmount) throw new Error("omniston: swap message forwards more TON than it carries");
+      const walletValid = await opts.validateTonJettonWallet({
+        ownerAddress: ref.trader,
+        jettonMasterAddress: inputJetton,
+        walletAddress: message.targetAddress
+      });
+      if (!walletValid) throw new Error("omniston: TON jetton wallet was not independently validated");
+      const targetValid = await opts.validateTonSwapTarget({ address: transfer.destination, protocols });
+      if (!targetValid) throw new Error("omniston: swap destination is not a recognized DEX contract for the quoted protocol");
+    } else if (ptonV1Native) {
+      const transfer = payload.jettonTransfer;
+      const input = BigInt(q.inputUnits);
+      if (transfer.amount !== input) throw new Error("omniston: swap message moves a different amount than quoted");
+      if (sendAmount < input) throw new Error("omniston: swap message carries less than the quoted input");
+      const gas = sendAmount - input;
+      if (gas > gasCap || gas > gasBudget) throw new Error(`omniston: swap message attaches more TON than the quoted gas budget (${gas} > ${gasBudget} nanoTON, cap ${gasCap}, ${protocols.join("+")})`);
+      if (transfer.forwardTon > gas) throw new Error("omniston: swap message forwards more TON than its gas");
+      if (!transfer.responseDestination || !sameTonAddress(transfer.responseDestination, ref.trader)) {
+        throw new Error("omniston: swap message returns excess to a wallet other than the trader");
+      }
+      if (typeof opts.validateTonSwapLeg !== "function") throw new Error("omniston: STON.fi v1 native input needs the validateTonSwapLeg validator (pTON v1 wallet ownership)");
+      const targetValid = await opts.validateTonSwapTarget({ address: message.targetAddress, protocols });
+      if (!targetValid) throw new Error("omniston: swap target is not a recognized DEX contract for the quoted protocol");
+      const routerValid = await opts.validateTonSwapTarget({ address: transfer.destination, protocols });
+      if (!routerValid) throw new Error("omniston: swap destination is not a recognized DEX contract for the quoted protocol");
+    } else {
+      if (payload.jettonTransfer) {
+        throw new Error(`omniston: native-input swap message must not be a jetton transfer (route ${protocols.join("+") || "?"}, target ${message.targetAddress}, transfer ${payload.jettonTransfer.amount} to ${payload.jettonTransfer.destination}, forwardTon ${payload.jettonTransfer.forwardTon}, value ${sendAmount})`);
+      }
+      const input = BigInt(q.inputUnits);
+      if (sendAmount < input) throw new Error("omniston: swap message carries less than the quoted input");
+      const gas = sendAmount - input;
+      if (gas > gasCap || gas > gasBudget) throw new Error(`omniston: swap message attaches more TON than the quoted gas budget (${gas} > ${gasBudget} nanoTON, cap ${gasCap}, ${protocols.join("+")})`);
+      const targetValid = await opts.validateTonSwapTarget({ address: message.targetAddress, protocols });
+      if (!targetValid) throw new Error("omniston: swap target is not a recognized DEX contract for the quoted protocol");
+    }
+    const mode = ptonV1Native ? "enforce" : opts.tonSwapPayloadCheck ?? "enforce";
+    const trace = traceFor(ref.quoteId);
+    const payloadRefusal = (reason, detail) => {
+      trace("ton-swap-payload", { reason, detail, mode, protocols: protocols.join("+") });
+      if (mode === "enforce") throw new Error(`omniston: ton-swap-payload ${reason} \u2014 ${detail}`);
+    };
+    let checked = null;
+    try {
+      checked = checkTonSwapPayload({
+        payloadHex: message.payload,
+        targetAddress: message.targetAddress,
+        sendAmount,
+        trader: ref.trader,
+        dest: ref.dest,
+        inputUnits: q.inputUnits,
+        minOutputAmount: swap.minOutputAmount,
+        inputJetton,
+        outputJetton: assetContract(q.outputAsset),
+        steps: swap.routes.length === 1 ? routeSteps.map((step) => {
+          if (step.chunks.length !== 1) return { protocol: `split(${step.chunks.map((c) => c.protocol).join("|")})`, inputJetton: void 0, outputJetton: void 0 };
+          return { protocol: step.chunks[0].protocol, inputJetton: stepJetton(step.inputAsset), outputJetton: stepJetton(step.outputAsset) };
+        }) : [{ protocol: `${swap.routes.length}-routes`, inputJetton: void 0, outputJetton: void 0 }],
+        integratorAddress: q.integratorAddress?.chain.$case === "ton" ? q.integratorAddress.chain.value : null
+      });
+    } catch (error) {
+      if (error instanceof TonSwapPayloadError) payloadRefusal(error.reason, error.message);
+      else payloadRefusal("malformed", error instanceof Error ? error.message : String(error));
+    }
+    if (checked) {
+      if (typeof opts.validateTonSwapLeg !== "function") {
+        trace("ton-swap-payload", { reason: "legs-unverified", detail: "no validateTonSwapLeg hook", mode, legs: checked.legs.length });
+      } else {
+        for (const leg of checked.legs) {
+          let ok = false;
+          try {
+            ok = await opts.validateTonSwapLeg(leg);
+          } catch {
+            ok = false;
+          }
+          if (!ok) {
+            payloadRefusal("leg-unverified", `${leg.kind} v${leg.version} ${leg.kind === "dedust-pool" ? `pool ${leg.pool}` : `ask wallet ${leg.askWallet}`}`);
+            break;
+          }
+        }
+      }
+    }
+    return {
+      chain: ref.srcChain,
+      to: message.targetAddress,
+      value: message.sendAmount,
+      // nanotons: gas only (jetton input) or input + gas (native)
+      bodyBoc: hexToBase64(message.payload)
+    };
+  }
+  async function trackSwap(decoded, sourceTxHash) {
+    if (!sourceTxHash) return { state: "pending" };
+    const omni = await getClient();
+    if (typeof omni.swapTrack !== "function") return { state: "pending" };
+    const progress = await awaitSwapProgress(
+      omni.swapTrack({ quoteId: decoded.quoteId, traderAddress: { chain: { $case: "ton", value: decoded.trader } }, outgoingTxQuery: sourceTxHash })
+    );
+    if (!progress || progress === "awaiting") return { state: "pending" };
+    switch (progress.status) {
+      case "TRADE_STATUS_FULLY_FILLED":
+        await quotes.clear(decoded.quoteId);
+        return { state: "completed", depositReceived: true, ...progress.outgoingTxHash ? { destTxHash: progress.outgoingTxHash } : {} };
+      case "TRADE_STATUS_PARTIALLY_FILLED":
+        await quotes.clear(decoded.quoteId);
+        return { state: "completed", depositReceived: true, ...progress.outgoingTxHash ? { destTxHash: progress.outgoingTxHash } : {} };
+      case "TRADE_STATUS_CANCELLED":
+      case "TRADE_STATUS_FAILED":
+        await quotes.clear(decoded.quoteId);
+        return { state: "failed", depositReceived: true };
+      default:
+        return { state: "pending", depositReceived: true };
+    }
+  }
+  async function buildEvmOrder(ref, q, settlement, bound) {
+    const srcChain = ref.srcChain;
+    const chainId = evmRef2(srcChain);
+    const srcCase = q.inputAsset.chain.$case;
+    if (chainId === null || EVM_CASE[chainId] !== srcCase) throw new Error("omniston: source chain does not match the EVM quote");
+    const destCase = q.outputAsset.chain.$case;
+    const destChain = caipForChainCase(destCase);
+    const tonDest = destCase === "ton";
+    if (!destChain || destChain === srcChain) throw new Error("omniston: EVM-source order has no supported destination chain");
+    if (!trustedOrderProtocols.has(srcChain) || typeof opts.validateEvmInputPosition !== "function" || typeof (tonDest ? opts.validateTonOutputPosition : opts.validateEvmOutputPosition) !== "function") {
+      throw new Error(`omniston: EVM\u2192${tonDest ? "TON" : "EVM"} needs a trusted order protocol and both position validators`);
+    }
+    let owner;
+    try {
+      owner = (0, import_viem.getAddress)(ref.trader);
+    } catch {
+      throw new Error("omniston: trader is not an EVM address");
+    }
+    let dest;
+    if (tonDest) {
+      try {
+        import_core3.Address.parse(ref.dest);
+      } catch {
+        throw new Error("omniston: destination is not a TON address");
+      }
+      dest = ref.dest;
+    } else {
+      try {
+        dest = (0, import_viem.getAddress)(ref.dest);
+      } catch {
+        throw new Error("omniston: destination is not an EVM address");
+      }
+    }
+    const traderDst = { chain: { $case: destCase, value: dest } };
+    const protocol = settlement.srcProtocolContractAddress;
+    const resolver = settlement.srcInitialResolverAddress;
+    const factory = settlement.dstProtocolContractAddress;
+    const inputToken = assetContract(q.inputAsset);
+    const outputToken = assetContract(q.outputAsset);
+    const destChainId = tonDest ? null : evmRef2(destChain);
+    if (protocol.chain.$case !== srcCase || !isTrustedOrderProtocol(srcChain, protocol.chain.value) || resolver?.chain.$case !== srcCase || !validEvmAddress(resolver.chain.value) || factory?.chain.$case !== destCase || !isTrusted(destChain, factory.chain.value) || !inputToken || !outputToken || !Number.isSafeInteger(settlement.protocolFeePips) || !tonDest && (destChainId === null || !validEvmAddress(outputToken) || !isPositiveInteger(settlement.dstSecurityDepositUnits ?? ""))) throw new Error("omniston: incomplete EVM order settlement binding in quote");
+    const { secrets, created } = await secretsFor(ref, q, 1);
+    const hashes = secrets.map((secret) => hashlock(secret, settlement.htlcHashingFunction));
+    const forget = async () => {
+      if (created) await clearSecrets(ref.quoteId);
+    };
+    const omni = await getClient();
+    let payload;
+    try {
+      payload = await omni.evmBuildOrderPayload({
+        quoteId: ref.quoteId,
+        ownerSrcAddress: { chain: { $case: srcCase, value: owner } },
+        traderDstAddress: traderDst,
+        htlcSecrets: { secretMode: { $case: "provided", value: { hashes } } }
+      });
+    } catch (error) {
+      await forget();
+      throw error;
+    }
+    let td;
+    try {
+      try {
+        td = JSON.parse(payload.typedData);
+      } catch {
+        throw new Error("omniston: malformed EVM order typed data");
+      }
+      validateSerializedOrderDetails(payload.serializedOrderDetails, {
+        quoteId: ref.quoteId,
+        outputAsset: q.outputAsset,
+        traderDstAddress: traderDst,
+        secretHashes: hashes
+      });
+      validateEvmTypedOrder(td, {
+        chainId,
+        settlementContract: protocol.chain.value,
+        owner,
+        receiver: resolver.chain.value,
+        makerAsset: inputToken,
+        makingAmount: q.inputUnits,
+        takingAmount: settlement.resolverSendsUnits,
+        orderExtension: payload.orderExtension,
+        quoteTimestamp: q.quoteTimestamp,
+        tradeStartDeadline: settlement.tradeStartDeadline
+      });
+      await validateEvmToTonOrderExtension(payload.orderExtension, {
+        quoteId: ref.quoteId,
+        quoteTimestamp: q.quoteTimestamp,
+        tradeStartDeadline: settlement.tradeStartDeadline,
+        protocolFeePips: settlement.protocolFeePips,
+        integratorFeePips: settlement.integratorFeePips ?? 0,
+        initialResolverAddress: resolver.chain.value,
+        outputTokenAddress: outputToken,
+        traderDstAddress: dest,
+        takerAsset: String(td.message.takerAsset),
+        srcSecurityDepositUnits: settlement.srcHtlcSecurityDepositUnits ?? "",
+        // TON destination: the TON deposit is bound in the TON position, not in
+        // the EVM deposits word (live: 0 for every TON-destination order). EVM
+        // destination: the word carries the quote's destination deposit and
+        // ExtraDataArgs name the destination chain and token (live 2026-10-20).
+        dstSecurityDepositUnits: tonDest ? "0" : settlement.dstSecurityDepositUnits,
+        ...tonDest ? {} : { dstChainId: destChainId },
+        secretHash: hashes[0],
+        trustedTarget: (address) => isTrusted(srcChain, address)
+      });
+    } catch (error) {
+      await forget();
+      throw error;
+    }
+    const extensionTarget = (0, import_viem.getAddress)(`0x${bytesToHex(payload.orderExtension.slice(32 + new DataView(payload.orderExtension.buffer, payload.orderExtension.byteOffset).getUint32(4, false), 32 + new DataView(payload.orderExtension.buffer, payload.orderExtension.byteOffset).getUint32(4, false) + 20))}`);
+    const typedData = JSON.stringify({ ...td, domain: { ...td.domain, chainId } });
+    await saveBuilt(ref.quoteId, {
+      quote: q,
+      at: Date.now(),
+      ...bound ? { bound } : {},
+      evmOrder: {
+        typedData,
+        orderExtension: bytesToHex(payload.orderExtension),
+        serializedOrderDetails: bytesToHex(payload.serializedOrderDetails ?? new Uint8Array()),
+        owner,
+        chainCase: srcCase,
+        factory: extensionTarget
+      }
+    });
+    const orderProtocol = (0, import_viem.getAddress)(protocol.chain.value);
+    return { chain: srcChain, to: orderProtocol, value: "0", chainId, approvalAddress: orderProtocol, typedData };
+  }
+  return {
+    name: "omniston",
+    describeActivity: describeOmnistonActivity,
+    enabled: () => (opts.enabled ?? true) && trustedContracts.size > 0,
+    // Capability discovery comes from the provider itself, so it can run alone
+    // or inside the optional aggregator without a central capability table.
+    supportsChain: (chain) => omniston.supportsChain(chain),
+    supportsChainPair: (fromChain, toChain) => omniston.supports(fromChain, toChain),
+    // TON↔TON swap settlement is same-chain by definition.
+    supportsSameChain: true,
+    supportsRoute(from, to) {
+      if (isTon(from.chain) && isTon(to.chain)) {
+        return omniston.supports(from.chain, to.chain) && trustedContracts.has(from.chain) && sameChainTonReady();
+      }
+      if (isTon(from.chain) && !isTon(to.chain)) return tonSourceReady(from.chain, to.chain);
+      if (!isTon(from.chain) && isTon(to.chain)) return evmSourceReady(from.chain, to.chain);
+      return evmToEvmReady(from.chain, to.chain);
+    },
+    async getQuote(params, signal) {
+      if (params.flex) return null;
+      if (isTon(params.sourceChain) && isTon(params.destChain)) return await getSwapQuote(params, signal);
+      const refuse2 = (reason) => {
+        params.onRefusal?.(`omniston: ${reason}`);
+        return null;
+      };
+      const evmSource = !isTon(params.sourceChain);
+      const tonDest = isTon(params.destChain);
+      if (!omniston.supports(params.sourceChain, params.destChain)) return refuse2("route is not an Omniston order corridor");
+      if (!trustedContracts.has(params.sourceChain) || !trustedContracts.has(params.destChain)) {
+        return refuse2(`no trusted settlement contract configured for ${trustedContracts.has(params.sourceChain) ? params.destChain : params.sourceChain}`);
+      }
+      if (evmSource) {
+        if (!trustedOrderProtocols.has(params.sourceChain)) return refuse2(`no trusted EVM order protocol configured for ${params.sourceChain}`);
+        if (typeof opts.validateEvmInputPosition !== "function" || typeof (tonDest ? opts.validateTonOutputPosition : opts.validateEvmOutputPosition) !== "function") {
+          return refuse2(tonDest ? "EVM\u2192TON needs the EVM input-position and TON output-position validators" : "EVM\u2192EVM needs the EVM input-position and EVM output-position validators");
+        }
+        if (params.dry === false) {
+          if (tonDest) {
+            try {
+              import_core3.Address.parse(params.destAddress);
+            } catch {
+              return refuse2("destination is not a TON address");
+            }
+          } else if (!validEvmAddress(params.destAddress)) return refuse2("destination is not an EVM address");
+        }
+      } else if (typeof opts.validateTonJettonWallet !== "function" || typeof opts.validateTonEscrowPayload !== "function" || typeof opts.validateEvmOutputPosition !== "function") return refuse2("TON\u2192EVM needs the jetton-wallet, escrow-payload and EVM output-position validators");
+      const source = (0, import_swap2_assets.ccAsset)(params.sourceChain, params.sourceToken);
+      const dest = (0, import_swap2_assets.ccAssetByToken)(params.destChain, params.destToken);
+      if (!source || !dest) return refuse2("asset is not in the catalog");
+      const inputAsset = toAssetId(params.sourceChain, source);
+      const outputAsset = toAssetId(params.destChain, dest);
+      if (!inputAsset || !outputAsset) {
+        return refuse2(`cross-chain orders are token corridors only (no ${!inputAsset ? source.symbol : dest.symbol} native leg)`);
+      }
+      const maxUnits = decimalToUnits(maxUsdText, source.decimals);
+      if (!maxUnits || !isPositiveInteger(params.amountIn)) return refuse2("invalid amount");
+      if (BigInt(params.amountIn) > maxUnits) return refuse2(`amount above the ${maxUsdText} USD per-swap cap`);
+      const trader = params.refundAddress ?? "";
+      if (!trader && !params.dry) return refuse2(`execution quote needs the trader's ${evmSource ? "EVM" : "TON"} address (refundAddress)`);
+      if (evmSource && trader && !validEvmAddress(trader)) return refuse2("refundAddress is not an EVM address");
+      const request = {
+        inputAsset,
+        outputAsset,
+        amount: { $case: "inputUnits", value: params.amountIn },
+        settlementParams: [{ params: { $case: "order", value: {} } }]
+      };
+      const integrator = opts.integratorAddress ?? "";
+      if (hasIntegrator) {
+        const pips = opts.integratorFeePips;
+        const address = integrator ? toChainAddress(params.destChain, integrator) : null;
+        if (!address) return refuse2("integrator address is not valid on the destination chain");
+        request.integratorAddress = address;
+        request.integratorFeePips = pips;
+      }
+      const omni = await getClient();
+      const rfq = { updates: 0 };
+      const q = await awaitQuote(
+        omni.requestForQuote(request),
+        request,
+        signal,
+        params.dry === false ? Math.min(quoteSettleMs, EXECUTION_SETTLE_MS) : quoteSettleMs,
+        "order",
+        rfq
+      );
+      if (!q) {
+        if (signal?.aborted) return null;
+        return refuse2(
+          rfq.error ? `RFQ failed: ${rfq.error}` : rfq.rejected ? `resolver quote rejected: ${rfq.rejected}` : "no resolver quoted this route/amount"
+        );
+      }
+      const orderData = q.settlementData.$case === "order" ? q.settlementData.value : null;
+      if (!orderData) return refuse2("resolver answered without order settlement");
+      const srcContract = orderData.srcProtocolContractAddress.chain.value;
+      if (evmSource ? !isTrustedOrderProtocol(params.sourceChain, srcContract) : !isTrusted(params.sourceChain, srcContract)) {
+        return refuse2(evmSource ? `untrusted ${params.sourceChain} order protocol ${srcContract}` : `untrusted TON settlement contract ${srcContract}`);
+      }
+      if (!orderData.dstProtocolContractAddress || !isTrusted(params.destChain, orderData.dstProtocolContractAddress.chain.value)) {
+        return refuse2(`untrusted ${params.destChain} settlement contract ${orderData.dstProtocolContractAddress?.chain.value ?? "(none)"}`);
+      }
+      const deadlineMs = orderData.tradeStartDeadline * 1e3;
+      if (!Number.isFinite(deadlineMs) || deadlineMs <= Date.now()) return refuse2("quote trade-start deadline already passed");
+      if (params.dry === false && deadlineMs - Date.now() < MIN_START_HEADROOM_MS) return refuse2("quote trade-start deadline too close to execute");
+      const inputScaled = BigInt(q.inputUnits) * 10n ** BigInt(dest.decimals);
+      const outputScaled = BigInt(q.outputUnits) * 10n ** BigInt(source.decimals);
+      if (outputScaled * 2n < inputScaled || outputScaled > inputScaled * 2n) return refuse2("quoted output is outside 0.5x\u20132x of the input");
+      if (await quoteIdInUse(q.quoteId)) return refuse2("the platform reused a quote id that already belongs to an order");
+      await saveBuilt(q.quoteId, { quote: q, at: Date.now(), bound: { trader, dest: params.destAddress, srcChain: params.sourceChain, kind: "order" } });
+      const feeUnits = Number(q.protocolFeeUnits || "0") + Number(q.integratorFeeUnits || "0");
+      const feeUsd = feeUnits / 10 ** dest.decimals;
+      return {
+        provider: "omniston",
+        intentId: encodeIntent(q.quoteId, trader, params.destAddress, params.sourceChain),
+        depositAddress: "",
+        // order settlement — no static deposit address
+        depositMemo: null,
+        sourceAmount: q.inputUnits,
+        destAmount: q.outputUnits,
+        minDestAmount: q.outputUnits,
+        // HTLC fills at the quoted amount or refunds
+        feeUsd: Number.isFinite(feeUsd) ? feeUsd : 0,
+        fees: [
+          ...q.protocolFeeUnits && q.protocolFeeUnits !== "0" ? [{ type: "protocol", amount: q.protocolFeeUnits, token: feeToken(dest), included: true }] : [],
+          ...q.integratorFeeUnits && q.integratorFeeUnits !== "0" ? [{ type: "affiliate", amount: q.integratorFeeUnits, token: feeToken(dest), included: true }] : []
+        ],
+        etaSeconds: 240,
+        reliability: 0.9,
+        validUntilMs: Math.min(Date.now() + QUOTE_TTL_MS, deadlineMs)
+      };
+    },
+    /**
+     * TON-source only: generate the HTLC secret, persist it, build the escrow
+     * transfer. The returned tx carries the payload as a serialized CELL
+     * (`bodyBoc`, base64) — sending it as a text comment would strand the swap.
+     */
+    async buildDeposit(quote) {
+      if (!Number.isFinite(quote.validUntilMs) || quote.validUntilMs <= Date.now()) {
+        throw new Error("omniston: quote expired \u2014 request a fresh quote");
+      }
+      const decoded = decodeIntent(quote.intentId);
+      if (!decoded) throw new Error("omniston: malformed intent id");
+      const cached = await loadBuilt(decoded.quoteId);
+      if (!cached) throw new Error("omniston: quote expired \u2014 request a fresh quote");
+      const ref = requireBinding(decoded, cached, "buildDeposit");
+      const q = cached.quote;
+      if (q.settlementData.$case === "swap") return await buildSwapDeposit(ref, q, q.settlementData.value);
+      if (q.settlementData.$case !== "order" || q.settlementData.value.tradeStartDeadline * 1e3 <= Date.now()) {
+        throw new Error("omniston: quote trade deadline expired \u2014 request a fresh quote");
+      }
+      if (!ref.trader) throw new Error("omniston: quote was requested without a refund/source address");
+      const srcCase = q.inputAsset.chain.$case;
+      if (srcCase !== "ton") return await buildEvmOrder(ref, q, q.settlementData.value, cached.bound);
+      const srcChain = ref.srcChain;
+      if (!isTon(srcChain)) throw new Error("omniston: source chain does not match TON quote");
+      const destCase = q.outputAsset.chain.$case;
+      const traderDst = destCase === "ton" ? null : { chain: { $case: destCase, value: (0, import_viem.getAddress)(ref.dest) } };
+      if (!traderDst) throw new Error("omniston: TON-destination orders are not supported");
+      const settlement = q.settlementData;
+      const hashingFunction = settlement.$case === "order" ? settlement.value.htlcHashingFunction : void 0;
+      const { secrets, created } = await secretsFor(ref, q, maxExecutions);
+      const hashes = secrets.map((s) => hashlock(s, hashingFunction));
+      const forget = async () => {
+        if (created) await clearSecrets(ref.quoteId);
+      };
+      const owner = { chain: { $case: "ton", value: ref.trader } };
+      const omni = await getClient();
+      let tx;
+      try {
+        tx = await omni.tonBuildEscrowTransfer({
+          quoteId: ref.quoteId,
+          ownerSrcAddress: owner,
+          transferSrcAddress: owner,
+          refundSrcAddress: owner,
+          gasExcessAddress: owner,
+          traderDstAddress: traderDst,
+          htlcSecrets: { secretMode: { $case: "provided", value: { hashes } } }
+        });
+      } catch (error) {
+        await forget();
+        throw error;
+      }
+      const [message, ...rest] = tx.messages;
+      if (!message || rest.length > 0) {
+        await forget();
+        throw new Error(`omniston: expected exactly one escrow message, got ${tx.messages.length}`);
+      }
+      if (!isPositiveInteger(message.sendAmount) || BigInt(message.sendAmount) > BigInt(maxTonExecutionNano)) {
+        await forget();
+        throw new Error("omniston: resolver TON execution value exceeds the configured safety cap");
+      }
+      const expectedProtocol = q.settlementData.value.srcProtocolContractAddress;
+      const initialResolver = q.settlementData.value.srcInitialResolverAddress;
+      const jettonMaster = assetContract(q.inputAsset);
+      if (expectedProtocol.chain.$case !== "ton" || initialResolver?.chain.$case !== "ton" || !jettonMaster) {
+        await forget();
+        throw new Error("omniston: incomplete TON settlement binding in quote");
+      }
+      if (message.jettonWalletStateInit) {
+        await forget();
+        throw new Error("omniston: deploying a resolver-provided jetton wallet is not supported");
+      }
+      let walletValid = false;
+      try {
+        walletValid = opts.validateTonJettonWallet ? await opts.validateTonJettonWallet({
+          ownerAddress: ref.trader,
+          jettonMasterAddress: jettonMaster,
+          walletAddress: message.targetAddress
+        }) : false;
+      } catch (error) {
+        await forget();
+        throw error;
+      }
+      if (!walletValid) {
+        await forget();
+        throw new Error("omniston: TON jetton wallet was not independently validated");
+      }
+      try {
+        if (!opts.validateTonEscrowPayload) {
+          throw new Error("omniston: TON source requires an independent escrow-payload validator");
+        }
+        await validateTonEscrowPayload(message, {
+          quoteId: ref.quoteId,
+          inputUnits: q.inputUnits,
+          resolverSendsUnits: q.settlementData.value.resolverSendsUnits,
+          srcHtlcSecurityDepositUnits: q.settlementData.value.srcHtlcSecurityDepositUnits ?? "",
+          protocolAddress: expectedProtocol.chain.value,
+          ownerAddress: ref.trader,
+          destinationChain: q.outputAsset.chain.$case,
+          destinationAddress: ref.dest,
+          outputTokenAddress: assetContract(q.outputAsset) ?? "",
+          initialResolverAddress: initialResolver.chain.value,
+          hashes,
+          ...hashingFunction ? { hashingFunction } : {},
+          exclusivityTimeout: q.settlementData.value.exclusivityTimeout ?? 0
+        }, opts.validateTonEscrowPayload);
+      } catch (error) {
+        await forget();
+        throw error;
+      }
+      return {
+        chain: srcChain,
+        to: message.targetAddress,
+        value: message.sendAmount,
+        // nanotons (gas + forward), NOT the jetton amount
+        bodyBoc: hexToBase64(message.payload)
+      };
+    },
+    /**
+     * Snapshot the order and use ready phases only to discover candidate EVM
+     * escrows. Disclosure follows only after independent finalized on-chain
+     * validation; transient failures are retried on the next poll.
+     */
+    async trackIntent(ref) {
+      const decoded = decodeIntent(ref.intentId);
+      if (!decoded) throw new Error("omniston: malformed intent id");
+      if (decoded.kind === "swap") return await trackSwap(decoded, ref.sourceTxHash ?? null);
+      const trace = traceFor(decoded.quoteId);
+      const stored = await loadBuilt(decoded.quoteId);
+      let cached;
+      let bound = decoded;
+      if (stored) {
+        const result = bindIntent(decoded, stored);
+        if (!result.ok && result.reason === "mismatch") {
+          trace("intent-mismatch", { where: "trackIntent", field: result.field });
+          throw new Error(`omniston: intent id does not match the quote it was issued for (${result.field})`);
+        }
+        if (result.ok) {
+          if (result.legacy) trace("legacy-intent", { where: "trackIntent" });
+          cached = stored;
+          bound = result.ref;
+        } else {
+          trace("legacy-intent-expired", { where: "trackIntent" });
+        }
+      }
+      const omni = await getClient();
+      const order = await awaitOrder(
+        omni.orderTrack({
+          quoteId: decoded.quoteId,
+          traderAddress: toChainAddress(bound.srcChain, bound.trader) ?? { chain: { $case: "ton", value: bound.trader } }
+        })
+      );
+      if (!order) return { state: "pending" };
+      const secretsHex = await store.load(decoded.quoteId);
+      if (!secretsHex || cached?.quote.settlementData.$case !== "order") trace("disclosure-skipped", { gate: "context", secrets: !!secretsHex, cached: !!cached, feedStatus: order.status });
+      if (secretsHex && cached?.quote.settlementData.$case === "order") {
+        const q = cached.quote;
+        const settlement = q.settlementData.value;
+        const indices = order.executions.map((execution) => execution.index);
+        const validIndices = indices.every((index) => Number.isSafeInteger(index) && index >= 0 && index < secretsHex.length) && new Set(indices).size === indices.length;
+        const outputTokenAddress = assetContract(q.outputAsset);
+        const outputChain = q.outputAsset.chain.$case;
+        const outputCaip = caipForChainCase(outputChain);
+        const factory = settlement.dstProtocolContractAddress;
+        const evmSource = q.inputAsset.chain.$case !== "ton";
+        const tonDest = outputChain === "ton";
+        const inputChain = q.inputAsset.chain.$case;
+        const inputCaip = caipForChainCase(inputChain);
+        const inputTokenAddress = assetContract(q.inputAsset);
+        const evmOrder = cached.evmOrder;
+        await Promise.all(
+          order.executions.map(async (execution) => {
+            const i = execution.index;
+            const secret = validIndices ? secretsHex[i] : void 0;
+            const phase = execution.outputPositionPhase;
+            const position = execution.outputPositionAddress;
+            const inputPosition = execution.inputPositionAddress;
+            if (!secret || !validDisclosurePhase(phase) || !position || position.chain.$case !== outputChain || !position.chain.value || !factory || factory.chain.$case !== outputChain || !outputTokenAddress || !outputCaip) {
+              trace("disclosure-skipped", { gate: "position", index: i, phase, positionChain: position?.chain.$case, outputChain });
+              return;
+            }
+            if (evmSource ? !evmOrder || !inputCaip || !inputTokenAddress || !inputPosition || inputPosition.chain.$case !== inputChain || !inputPosition.chain.value || !settlement.srcInitialResolverAddress || typeof opts.validateEvmInputPosition !== "function" || typeof (tonDest ? opts.validateTonOutputPosition : opts.validateEvmOutputPosition) !== "function" : typeof opts.validateEvmOutputPosition !== "function") {
+              trace("disclosure-skipped", { gate: "context-fields", index: i, evmSource, evmOrder: !!evmOrder, inputPositionChain: inputPosition?.chain.$case });
+              return;
+            }
+            const secretBytes = hexToBytes(secret);
+            const expectedHash = hashlock(secretBytes, settlement.htlcHashingFunction);
+            if (!execution.secretHash || !bytesEqual(execution.secretHash, expectedHash) || execution.inputUnits !== q.inputUnits || execution.outputUnits !== q.outputUnits || execution.resolverSendsUnits !== settlement.resolverSendsUnits) {
+              trace("disclosure-skipped", { gate: "terms", index: i, hashMatches: !!execution.secretHash && bytesEqual(execution.secretHash, expectedHash), inputUnits: [execution.inputUnits, q.inputUnits], outputUnits: [execution.outputUnits, q.outputUnits], resolverSendsUnits: [execution.resolverSendsUnits, settlement.resolverSendsUnits] });
+              return;
+            }
+            let verified = false;
+            try {
+              const evmOutput = () => opts.validateEvmOutputPosition({
+                chain: outputCaip,
+                positionAddress: position.chain.value,
+                factoryAddress: factory.chain.value,
+                quoteTimestamp: q.quoteTimestamp,
+                executionIndex: i,
+                recipientAddress: bound.dest,
+                outputTokenAddress,
+                inputUnits: execution.inputUnits,
+                outputUnits: execution.outputUnits,
+                resolverSendsUnits: execution.resolverSendsUnits,
+                srcHtlcSecurityDepositUnits: settlement.srcHtlcSecurityDepositUnits ?? "",
+                dstSecurityDepositUnits: settlement.dstSecurityDepositUnits ?? "",
+                protocolFeeUnits: q.protocolFeeUnits ?? "0",
+                integratorFeeUnits: q.integratorFeeUnits ?? "0",
+                ...q.integratorAddress?.chain.value ? { integratorAddress: q.integratorAddress.chain.value } : {},
+                ...settlement.protocolFeeRecipientAddress?.chain.value ? { protocolFeeRecipientAddress: settlement.protocolFeeRecipientAddress.chain.value } : {},
+                secretHash: expectedHash
+              });
+              verified = evmSource ? await opts.validateEvmInputPosition({
+                chain: inputCaip,
+                positionAddress: inputPosition.chain.value,
+                factoryAddress: evmOrder.factory,
+                orderProtocolAddress: settlement.srcProtocolContractAddress.chain.value,
+                ownerAddress: evmOrder.owner,
+                resolverAddress: settlement.srcInitialResolverAddress.chain.value,
+                inputTokenAddress,
+                inputUnits: execution.inputUnits,
+                resolverSendsUnits: execution.resolverSendsUnits,
+                srcHtlcSecurityDepositUnits: settlement.srcHtlcSecurityDepositUnits ?? "",
+                quoteTimestamp: q.quoteTimestamp,
+                secretHash: expectedHash,
+                ...tonDest ? {} : {
+                  destinationChainId: evmRef2(outputCaip),
+                  destinationTokenAddress: outputTokenAddress,
+                  dstSecurityDepositUnits: settlement.dstSecurityDepositUnits ?? ""
+                }
+              }) && (tonDest ? await opts.validateTonOutputPosition({
+                positionAddress: position.chain.value,
+                protocolAddress: factory.chain.value,
+                outputJettonMasterAddress: outputTokenAddress,
+                recipientAddress: bound.dest,
+                quoteId: decoded.quoteId,
+                quoteTimestamp: q.quoteTimestamp,
+                inputUnits: execution.inputUnits,
+                outputUnits: execution.outputUnits,
+                resolverSendsUnits: execution.resolverSendsUnits,
+                dstSecurityDepositUnits: settlement.dstSecurityDepositUnits ?? "",
+                secretHash: expectedHash
+              }) : await evmOutput()) : await evmOutput();
+            } catch (error) {
+              verified = false;
+              trace("validator-threw", { index: i, error: error instanceof Error ? error.message : String(error) });
+            }
+            if (!verified) {
+              trace("validator-refused", { index: i, evmSource, tonDest });
+              return;
+            }
+            await omni.orderDiscloseHtlcSecret({ quoteId: decoded.quoteId, executionIndex: i, secret: secretBytes }).then(async () => {
+              trace("secret-disclosed", { index: i });
+              await store.save(disclosedKey(decoded.quoteId), ["1"]);
+            }, (error) => trace("disclose-failed", { index: i, error: error instanceof Error ? error.message : String(error) }));
+          })
+        );
+      }
+      const status = mapOrderStatus(order);
+      const delivered = order.executions[0]?.outputPositionAddress;
+      const outCase = cached?.quote.outputAsset.chain.$case;
+      const outCaip = outCase ? caipForChainCase(outCase) : null;
+      const outToken = cached ? assetContract(cached.quote.outputAsset) : null;
+      if (status.state === "completed" && opts.locateEvmDelivery && outCase && outCase !== "ton" && outCaip && outToken && order.executions.length === 1 && delivered?.chain.$case === outCase && delivered.chain.value) {
+        const hash = await opts.locateEvmDelivery({
+          chain: outCaip,
+          positionAddress: delivered.chain.value,
+          recipientAddress: bound.dest,
+          tokenAddress: outToken,
+          minUnits: order.executions[0].outputUnits
+        }).catch(() => null);
+        if (hash) status.destTxHash = hash;
+      }
+      if (status.state === "completed" && !status.destTxHash && opts.locateTonDelivery && outCase === "ton" && outToken && order.executions.length === 1 && delivered?.chain.$case === "ton" && delivered.chain.value) {
+        const hash = await opts.locateTonDelivery({
+          positionAddress: delivered.chain.value,
+          recipientAddress: bound.dest,
+          jettonMasterAddress: outToken,
+          minUnits: order.executions[0].outputUnits
+        }).catch(() => null);
+        if (hash) status.destTxHash = hash;
+      }
+      if (status.state === "completed") {
+        await clearSecrets(decoded.quoteId);
+        await quotes.clear(decoded.quoteId);
+      }
+      return status;
+    },
+    /** EVM→TON: hand the wallet's EIP-712 signature over the validated order to Omniston. */
+    async registerSignedOrder(intentId, signature) {
+      const ref = decodeIntent(intentId);
+      if (!ref) throw new Error("omniston: malformed intent id");
+      const cached = await loadBuilt(ref.quoteId);
+      const order = cached?.evmOrder;
+      if (!order) throw new Error("omniston: no signed-order context for this quote \u2014 build the order again");
+      requireBinding(ref, cached, "registerSignedOrder");
+      if (!/^0x[0-9a-fA-F]{130}$/.test(signature)) throw new Error("omniston: malformed order signature");
+      const td = JSON.parse(order.typedData);
+      const omni = await getClient();
+      await omni.orderRegisterSignedOrder({
+        quoteId: ref.quoteId,
+        ownerSrcAddress: { chain: { $case: order.chainCase, value: order.owner } },
+        signedOrder: { order: { $case: "evmV1", value: {
+          encodedOrder: encodeTypedMessage(td),
+          signature: hexToBytes(signature),
+          orderExtension: hexToBytes(order.orderExtension)
+        } } },
+        ...order.serializedOrderDetails ? { serializedOrderDetails: hexToBytes(order.serializedOrderDetails) } : {}
+      });
+    },
+    close() {
+      clientGeneration += 1;
+      if (client && (client !== injectedClient || opts.closeInjectedClient)) {
+        if (client.close) client.close();
+        else client.transport?.close();
+      }
+      client = null;
+    }
+  };
+}
+
+// src/protocol.ts
+var OmnistonSwap2Protocol = class extends import_single.SingleProviderSwap2 {
+  provider;
+  constructor(account, config) {
+    super(account, config);
+    this.provider = omnistonProvider(config);
+  }
+  chainSupported(caip2) {
+    return omniston.supportsChain(caip2);
+  }
+  pairSupported(fromChain, toChain) {
+    return this.provider.supportsRoute({ chain: fromChain, token: "" }, { chain: toChain, token: "" });
+  }
+};
+//# sourceMappingURL=protocol.cjs.map