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

package/dist/validators.js

@@ -0,0 +1,1065 @@
+// src/validators/evm-output.ts
+import {
+  decodeAbiParameters,
+  decodeFunctionResult,
+  encodeFunctionData,
+  getAddress,
+  isAddress,
+  keccak256,
+  stringToHex
+} from "viem";
+var ESCROW_FACTORY_ABI = [
+  {
+    type: "function",
+    name: "createDstEscrow",
+    stateMutability: "payable",
+    inputs: [
+      {
+        name: "dstImmutables",
+        type: "tuple",
+        components: [
+          { name: "orderHash", type: "bytes32" },
+          { name: "hashlock", type: "bytes32" },
+          { name: "maker", type: "uint256" },
+          { name: "taker", type: "uint256" },
+          { name: "token", type: "uint256" },
+          { name: "amount", type: "uint256" },
+          { name: "safetyDeposit", type: "uint256" },
+          { name: "timelocks", type: "uint256" },
+          { name: "parameters", type: "bytes" }
+        ]
+      },
+      { name: "srcCancellationTimestamp", type: "uint256" }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "addressOfEscrowDst",
+    stateMutability: "view",
+    inputs: [
+      {
+        name: "immutables",
+        type: "tuple",
+        components: [
+          { name: "orderHash", type: "bytes32" },
+          { name: "hashlock", type: "bytes32" },
+          { name: "maker", type: "uint256" },
+          { name: "taker", type: "uint256" },
+          { name: "token", type: "uint256" },
+          { name: "amount", type: "uint256" },
+          { name: "safetyDeposit", type: "uint256" },
+          { name: "timelocks", type: "uint256" },
+          { name: "parameters", type: "bytes" }
+        ]
+      }
+    ],
+    outputs: [{ name: "escrow", type: "address" }]
+  }
+];
+var FACTORY_ABI = [{
+  type: "function",
+  name: "FACTORY",
+  stateMutability: "view",
+  inputs: [],
+  outputs: [{ type: "address" }]
+}];
+var BALANCE_OF_ABI = [{
+  type: "function",
+  name: "balanceOf",
+  stateMutability: "view",
+  inputs: [{ name: "account", type: "address" }],
+  outputs: [{ type: "uint256" }]
+}];
+var DST_ESCROW_CREATED_TOPIC = keccak256(stringToHex("DstEscrowCreated(address,bytes32,uint256)"));
+var UINT32_MASK = (1n << 32n) - 1n;
+var DEPLOYED_AT_OFFSET = 224n;
+var DEPLOYED_AT_MASK = UINT32_MASK << DEPLOYED_AT_OFFSET;
+var ADDRESS_MASK = (1n << 160n) - 1n;
+var DST_STAGES = [1n, 120n, 180n];
+var DST_STAGE_WORD = 4;
+var DST_CANCELLATION_STAGE = 2;
+var DISCLOSURE_MARGIN_SECONDS = 45n;
+var FEE_PARAMETERS = [{ type: "uint256" }, { type: "uint256" }, { type: "uint256" }, { type: "uint256" }];
+var FEE_PARAMETERS_HEX_LENGTH = 2 + 128 * 2;
+var DEFAULT_RPC_URLS = {
+  "eip155:1": ["https://ethereum-rpc.publicnode.com"],
+  "eip155:56": ["https://bsc-rpc.publicnode.com"],
+  "eip155:137": ["https://polygon-bor-rpc.publicnode.com"],
+  "eip155:4663": ["https://rpc.mainnet.chain.robinhood.com"],
+  "eip155:8453": ["https://base-rpc.publicnode.com"],
+  "eip155:42161": ["https://arbitrum-one-rpc.publicnode.com"],
+  "eip155:43114": ["https://avalanche-c-chain-rpc.publicnode.com"],
+  "eip155:196": ["https://rpc.xlayer.tech"],
+  "eip155:999": ["https://rpc.hyperliquid.xyz/evm"],
+  "eip155:9745": ["https://rpc.plasma.to"]
+};
+var OMNISTON_EVM_LOOKBACK_BLOCKS = {
+  "eip155:1": 3000n,
+  "eip155:56": 40000n,
+  "eip155:137": 20000n,
+  "eip155:4663": 100000n,
+  "eip155:8453": 20000n,
+  "eip155:42161": 100000n,
+  "eip155:43114": 20000n,
+  // ~1 s blocks (measured 2026-10-20): ~11 h, past the 6 h quote horizon.
+  "eip155:196": 40000n,
+  "eip155:999": 40000n,
+  "eip155:9745": 40000n
+};
+var OMNISTON_EVM_MIN_CONFIRMATIONS = {
+  "eip155:1": 2n,
+  "eip155:56": 5n,
+  "eip155:137": 20n,
+  "eip155:4663": 20n,
+  "eip155:8453": 20n,
+  "eip155:42161": 20n,
+  "eip155:43114": 5n,
+  "eip155:196": 20n,
+  // sequencer rollup
+  "eip155:999": 5n,
+  // HyperBFT, fast finality
+  "eip155:9745": 5n
+  // PlasmaBFT, fast finality
+};
+function quantity(value) {
+  return `0x${value.toString(16)}`;
+}
+function uintAddress(value) {
+  return getAddress(`0x${(value & ADDRESS_MASK).toString(16).padStart(40, "0")}`);
+}
+function bytesHex(bytes) {
+  return `0x${Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+}
+function stage(timelocks, index) {
+  return timelocks >> BigInt(index * 32) & UINT32_MASK;
+}
+function decodeFeeParameters(parameters) {
+  if (parameters.length !== FEE_PARAMETERS_HEX_LENGTH) return null;
+  try {
+    const [protocolFee, integratorFee, protocolFeeRecipient, integratorFeeRecipient] = decodeAbiParameters(FEE_PARAMETERS, parameters);
+    return { protocolFee, integratorFee, protocolFeeRecipient, integratorFeeRecipient };
+  } catch {
+    return null;
+  }
+}
+async function omnistonEvmRpcRequest(chain, method, params, rpcUrls) {
+  const urls = [...rpcUrls?.[chain] ?? [], ...DEFAULT_RPC_URLS[chain] ?? []].filter((url) => !!url);
+  if (!urls.length) throw new Error(`omniston: no RPC configured for ${chain}`);
+  let lastError;
+  for (const url of urls) {
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
+        signal: AbortSignal.timeout(1e4)
+      });
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      const body = await response.json();
+      if (body.error !== void 0 || body.result === void 0) throw new Error("invalid JSON-RPC response");
+      return body.result;
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error(`omniston: RPC failed for ${chain}`);
+}
+async function ethCall(request, chain, to, data) {
+  return await request(chain, "eth_call", [{ to, data }, "latest"]);
+}
+function locateImmutables(input, secretHash) {
+  const data = input.slice(2).toLowerCase();
+  const needle = secretHash.slice(2).toLowerCase();
+  const at = data.indexOf(needle);
+  if (at < 72 || (at - 8) % 64 !== 0 || data.length < at + 64 * 8) return null;
+  const start = at - 64;
+  const word = (i) => BigInt(`0x${data.slice(at + 64 * i, at + 64 * (i + 1))}`);
+  try {
+    const offset = word(7);
+    if (offset % 32n !== 0n || offset < 288n || offset > 4096n) return null;
+    const lengthAt = start + Number(offset) * 2;
+    if (data.length < lengthAt + 64) return null;
+    const length = BigInt(`0x${data.slice(lengthAt, lengthAt + 64)}`);
+    if (length > 1024n || data.length < lengthAt + 64 + Number(length) * 2) return null;
+    return {
+      orderHash: `0x${data.slice(start, at)}`,
+      hashlock: `0x${needle}`,
+      maker: word(1),
+      taker: word(2),
+      token: word(3),
+      amount: word(4),
+      safetyDeposit: word(5),
+      timelocks: word(6),
+      parameters: `0x${data.slice(lengthAt + 64, lengthAt + 64 + Number(length) * 2)}`
+    };
+  } catch {
+    return null;
+  }
+}
+function createOmnistonEvmOutputValidator(options = {}) {
+  const refuse = (reason, details) => {
+    try {
+      options.onRefusal?.(reason, details);
+    } catch {
+    }
+    return false;
+  };
+  const request = options.request ?? ((chain, method, params) => omnistonEvmRpcRequest(chain, method, params, options.rpcUrls));
+  const now = options.now ?? Date.now;
+  return async (input) => {
+    try {
+      if (!OMNISTON_EVM_LOOKBACK_BLOCKS[input.chain] || input.executionIndex !== 0 || !isAddress(input.positionAddress) || !isAddress(input.factoryAddress) || !isAddress(input.recipientAddress) || !isAddress(input.outputTokenAddress) || !Number.isInteger(input.quoteTimestamp) || input.quoteTimestamp * 1e3 > now() + 12e4 || now() - input.quoteTimestamp * 1e3 > 6 * 60 * 60 * 1e3) return refuse("input-shape");
+      const position = getAddress(input.positionAddress);
+      const factory = getAddress(input.factoryAddress);
+      const recipient = getAddress(input.recipientAddress);
+      const token = getAddress(input.outputTokenAddress);
+      const secretHash = bytesHex(input.secretHash);
+      const outputUnits = BigInt(input.outputUnits);
+      const resolverSendsUnits = BigInt(input.resolverSendsUnits);
+      const protocolFeeUnits = BigInt(input.protocolFeeUnits);
+      const integratorFeeUnits = BigInt(input.integratorFeeUnits);
+      const dstDeposit = BigInt(input.dstSecurityDepositUnits);
+      if (BigInt(input.inputUnits) <= 0n || outputUnits <= 0n || dstDeposit <= 0n || resolverSendsUnits !== outputUnits + protocolFeeUnits + integratorFeeUnits || input.secretHash.length !== 32) return refuse("quote-amounts", { outputUnits: String(outputUnits), resolverSendsUnits: String(resolverSendsUnits), protocolFeeUnits: String(protocolFeeUnits), integratorFeeUnits: String(integratorFeeUnits) });
+      if (protocolFeeUnits < 0n || integratorFeeUnits < 0n) return refuse("quote-amounts", { protocolFeeUnits: String(protocolFeeUnits), integratorFeeUnits: String(integratorFeeUnits) });
+      if (protocolFeeUnits > 0n && (!input.protocolFeeRecipientAddress || !isAddress(input.protocolFeeRecipientAddress))) {
+        return refuse("quote-missing-protocol-fee-recipient", { protocolFeeUnits: String(protocolFeeUnits) });
+      }
+      if (integratorFeeUnits > 0n && (!input.integratorAddress || !isAddress(input.integratorAddress))) {
+        return refuse("quote-missing-integrator-address", { integratorFeeUnits: String(integratorFeeUnits) });
+      }
+      const latest = BigInt(await request(input.chain, "eth_blockNumber", []));
+      const minConfirmations = OMNISTON_EVM_MIN_CONFIRMATIONS[input.chain] ?? 20n;
+      const newestFinal = latest >= minConfirmations ? latest - minConfirmations : 0n;
+      const oldest = newestFinal > OMNISTON_EVM_LOOKBACK_BLOCKS[input.chain] ? newestFinal - OMNISTON_EVM_LOOKBACK_BLOCKS[input.chain] : 0n;
+      let matchingLog;
+      for (let to = newestFinal; to >= oldest && !matchingLog; ) {
+        const from = to - oldest > 4999n ? to - 4999n : oldest;
+        const logs = await request(input.chain, "eth_getLogs", [{
+          address: factory,
+          topics: [DST_ESCROW_CREATED_TOPIC],
+          fromBlock: quantity(from),
+          toBlock: quantity(to)
+        }]);
+        matchingLog = logs.find((log) => {
+          try {
+            const [escrow, hashlock] = decodeAbiParameters(
+              [{ type: "address" }, { type: "bytes32" }, { type: "uint256" }],
+              log.data
+            );
+            return getAddress(escrow) === position && hashlock.toLowerCase() === secretHash.toLowerCase();
+          } catch {
+            return false;
+          }
+        });
+        if (from === oldest) break;
+        to = from - 1n;
+      }
+      if (!matchingLog) return refuse("no-escrow-event", { factory, lookback: String(OMNISTON_EVM_LOOKBACK_BLOCKS[input.chain]) });
+      const [transaction, receipt, block, code] = await Promise.all([
+        request(input.chain, "eth_getTransactionByHash", [matchingLog.transactionHash]),
+        request(input.chain, "eth_getTransactionReceipt", [matchingLog.transactionHash]),
+        request(input.chain, "eth_getBlockByNumber", [matchingLog.blockNumber, false]),
+        request(input.chain, "eth_getCode", [position, "latest"])
+      ]);
+      if (!transaction || !receipt || !block || !code || code === "0x" || receipt.status !== "0x1" || BigInt(receipt.blockNumber) !== BigInt(matchingLog.blockNumber) || latest - BigInt(receipt.blockNumber) < minConfirmations || BigInt(block.timestamp) + 120n < BigInt(input.quoteTimestamp)) return refuse("receipt-or-confirmations", { receiptStatus: receipt?.status, receiptBlock: receipt?.blockNumber, logBlock: matchingLog.blockNumber, latest: String(latest), minConfirmations: String(minConfirmations), codeLength: code ? code.length : 0, blockTimestamp: block?.timestamp });
+      const immutables = locateImmutables(transaction.input, secretHash);
+      if (!immutables) return refuse("immutables-not-found", { transaction: matchingLog.transactionHash });
+      const stamped = { ...immutables, timelocks: immutables.timelocks & ~DEPLOYED_AT_MASK | BigInt(block.timestamp) << DEPLOYED_AT_OFFSET };
+      const derived = decodeFunctionResult({
+        abi: ESCROW_FACTORY_ABI,
+        functionName: "addressOfEscrowDst",
+        data: await ethCall(request, input.chain, factory, encodeFunctionData({ abi: ESCROW_FACTORY_ABI, functionName: "addressOfEscrowDst", args: [stamped] }))
+      });
+      if (getAddress(derived) !== position) return refuse("derived-address", { derived, position });
+      if (!(uintAddress(immutables.maker) === recipient && uintAddress(immutables.token) === token && immutables.amount === resolverSendsUnits && immutables.safetyDeposit === dstDeposit)) return refuse("escrow-terms", { maker: uintAddress(immutables.maker), recipient, token: uintAddress(immutables.token), expectedToken: token, amount: String(immutables.amount), resolverSendsUnits: String(resolverSendsUnits), safetyDeposit: String(immutables.safetyDeposit), dstDeposit: String(dstDeposit) });
+      const fees = decodeFeeParameters(immutables.parameters);
+      if (!fees || fees.protocolFeeRecipient > ADDRESS_MASK || fees.integratorFeeRecipient > ADDRESS_MASK) {
+        return refuse("fee-parameters-shape", { parametersLength: (immutables.parameters.length - 2) / 2 });
+      }
+      if (fees.protocolFee !== protocolFeeUnits || fees.integratorFee !== integratorFeeUnits || immutables.amount - fees.protocolFee - fees.integratorFee !== outputUnits) {
+        return refuse("fee-amounts", { protocolFee: String(fees.protocolFee), protocolFeeUnits: String(protocolFeeUnits), integratorFee: String(fees.integratorFee), integratorFeeUnits: String(integratorFeeUnits), amount: String(immutables.amount), outputUnits: String(outputUnits) });
+      }
+      if (fees.protocolFee > 0n && uintAddress(fees.protocolFeeRecipient) !== getAddress(input.protocolFeeRecipientAddress)) {
+        return refuse("protocol-fee-recipient", { escrow: uintAddress(fees.protocolFeeRecipient), quote: getAddress(input.protocolFeeRecipientAddress) });
+      }
+      if (fees.integratorFee > 0n && uintAddress(fees.integratorFeeRecipient) !== getAddress(input.integratorAddress)) {
+        return refuse("integrator-fee-recipient", { escrow: uintAddress(fees.integratorFeeRecipient), quote: getAddress(input.integratorAddress) });
+      }
+      if (DST_STAGES.some((expected, index) => stage(immutables.timelocks, DST_STAGE_WORD + index) !== expected)) {
+        return refuse("dst-timelocks", { stages: DST_STAGES.map((_, index) => String(stage(immutables.timelocks, DST_STAGE_WORD + index))) });
+      }
+      const deployedAt = BigInt(block.timestamp);
+      const nowSeconds = BigInt(Math.floor(now() / 1e3));
+      if (nowSeconds + DISCLOSURE_MARGIN_SECONDS >= deployedAt + DST_STAGES[DST_CANCELLATION_STAGE]) {
+        return refuse("dst-cancellation-window", { now: String(nowSeconds), deployedAt: String(deployedAt), cancellationAt: String(deployedAt + DST_STAGES[DST_CANCELLATION_STAGE]), marginSeconds: String(DISCLOSURE_MARGIN_SECONDS) });
+      }
+      const [reportedFactory, tokenBalance, nativeBalance] = await Promise.all([
+        ethCall(request, input.chain, position, encodeFunctionData({ abi: FACTORY_ABI, functionName: "FACTORY" })).then((data) => decodeFunctionResult({ abi: FACTORY_ABI, functionName: "FACTORY", data })),
+        ethCall(request, input.chain, token, encodeFunctionData({ abi: BALANCE_OF_ABI, functionName: "balanceOf", args: [position] })).then((data) => decodeFunctionResult({ abi: BALANCE_OF_ABI, functionName: "balanceOf", data })),
+        request(input.chain, "eth_getBalance", [position, "latest"])
+      ]);
+      const ok = getAddress(reportedFactory) === factory && tokenBalance >= resolverSendsUnits && BigInt(nativeBalance) >= dstDeposit;
+      return ok || refuse("escrow-state", { reportedFactory, factory, tokenBalance: String(tokenBalance), resolverSendsUnits: String(resolverSendsUnits), nativeBalance: String(BigInt(nativeBalance)), dstDeposit: String(dstDeposit) });
+    } catch (error) {
+      return refuse("error", { message: error instanceof Error ? error.message : String(error) });
+    }
+  };
+}
+var TRANSFER_TOPIC = keccak256(stringToHex("Transfer(address,address,uint256)"));
+var topicAddress = (address) => `0x${getAddress(address).slice(2).toLowerCase().padStart(64, "0")}`;
+function createOmnistonEvmDeliveryLocator(options = {}) {
+  const request = options.request ?? ((chain, method, params) => omnistonEvmRpcRequest(chain, method, params, options.rpcUrls));
+  return async (input) => {
+    try {
+      const lookback = OMNISTON_EVM_LOOKBACK_BLOCKS[input.chain];
+      if (!lookback || !isAddress(input.positionAddress) || !isAddress(input.recipientAddress) || !isAddress(input.tokenAddress)) return null;
+      const min = BigInt(input.minUnits);
+      const latest = BigInt(await request(input.chain, "eth_blockNumber", []));
+      const oldest = latest > lookback ? latest - lookback : 0n;
+      for (let to = latest; to >= oldest; ) {
+        const from = to - oldest > 4999n ? to - 4999n : oldest;
+        const logs = await request(input.chain, "eth_getLogs", [{
+          address: getAddress(input.tokenAddress),
+          topics: [TRANSFER_TOPIC, topicAddress(input.positionAddress), topicAddress(input.recipientAddress)],
+          fromBlock: quantity(from),
+          toBlock: quantity(to)
+        }]);
+        const hit = [...logs].reverse().find((log) => {
+          try {
+            return getAddress(log.address) === getAddress(input.tokenAddress) && BigInt(log.data) >= min;
+          } catch {
+            return false;
+          }
+        });
+        if (hit) return hit.transactionHash;
+        if (from === oldest) break;
+        to = from - 1n;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  };
+}
+
+// src/validators/evm-input.ts
+import {
+  decodeEventLog,
+  decodeFunctionResult as decodeFunctionResult2,
+  encodeFunctionData as encodeFunctionData2,
+  getAddress as getAddress2,
+  isAddress as isAddress2,
+  keccak256 as keccak2562,
+  stringToHex as stringToHex2
+} from "viem";
+var IMMUTABLES = [
+  { name: "orderHash", type: "bytes32" },
+  { name: "hashlock", type: "bytes32" },
+  { name: "maker", type: "uint256" },
+  { name: "taker", type: "uint256" },
+  { name: "token", type: "uint256" },
+  { name: "amount", type: "uint256" },
+  { name: "safetyDeposit", type: "uint256" },
+  { name: "timelocks", type: "uint256" },
+  { name: "parameters", type: "bytes" }
+];
+var DST_COMPLEMENT = [
+  { name: "maker", type: "uint256" },
+  { name: "amount", type: "uint256" },
+  { name: "token", type: "uint256" },
+  { name: "safetyDeposit", type: "uint256" },
+  { name: "chainId", type: "uint256" },
+  { name: "parameters", type: "bytes" }
+];
+var FACTORY_ABI2 = [
+  {
+    type: "event",
+    name: "SrcEscrowCreated",
+    inputs: [
+      { name: "srcImmutables", type: "tuple", components: IMMUTABLES, indexed: false },
+      { name: "dstImmutablesComplement", type: "tuple", components: DST_COMPLEMENT, indexed: false }
+    ]
+  },
+  {
+    type: "function",
+    name: "addressOfEscrowSrc",
+    stateMutability: "view",
+    inputs: [{ name: "immutables", type: "tuple", components: IMMUTABLES }],
+    outputs: [{ name: "escrow", type: "address" }]
+  },
+  { type: "function", name: "FACTORY", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] },
+  { type: "function", name: "balanceOf", stateMutability: "view", inputs: [{ name: "account", type: "address" }], outputs: [{ type: "uint256" }] }
+];
+var SRC_ESCROW_CREATED_TOPIC = keccak2562(stringToHex2(
+  "SrcEscrowCreated((bytes32,bytes32,uint256,uint256,uint256,uint256,uint256,uint256,bytes),(uint256,uint256,uint256,uint256,uint256,bytes))"
+));
+var SRC_STAGES = [1n, 120n, 240n, 300n, 1n, 120n, 180n];
+var SRC_CANCELLATION_STAGE = 2;
+var DISCLOSURE_MARGIN_SECONDS2 = 45n;
+var UINT32_MASK2 = (1n << 32n) - 1n;
+var ADDRESS_MASK2 = (1n << 160n) - 1n;
+function quantity2(value) {
+  return `0x${value.toString(16)}`;
+}
+function uintAddress2(value) {
+  return getAddress2(`0x${(value & ADDRESS_MASK2).toString(16).padStart(40, "0")}`);
+}
+function bytesHex2(bytes) {
+  return `0x${Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+}
+function stage2(timelocks, index) {
+  return timelocks >> BigInt(index * 32) & UINT32_MASK2;
+}
+async function ethCall2(request, chain, to, data) {
+  return await request(chain, "eth_call", [{ to, data }, "latest"]);
+}
+function createOmnistonEvmInputValidator(options = {}) {
+  const refuse = (reason, details) => {
+    try {
+      options.onRefusal?.(reason, details);
+    } catch {
+    }
+    return false;
+  };
+  const request = options.request ?? ((chain, method, params) => omnistonEvmRpcRequest(chain, method, params, options.rpcUrls));
+  const now = options.now ?? Date.now;
+  return async (input) => {
+    try {
+      if (!OMNISTON_EVM_LOOKBACK_BLOCKS[input.chain] || !isAddress2(input.positionAddress) || !isAddress2(input.factoryAddress) || !isAddress2(input.orderProtocolAddress) || !isAddress2(input.ownerAddress) || !isAddress2(input.resolverAddress) || !isAddress2(input.inputTokenAddress) || !Number.isInteger(input.quoteTimestamp) || input.quoteTimestamp * 1e3 > now() + 12e4 || now() - input.quoteTimestamp * 1e3 > 6 * 60 * 60 * 1e3 || input.secretHash.length !== 32) return refuse("input-shape");
+      const position = getAddress2(input.positionAddress);
+      const factory = getAddress2(input.factoryAddress);
+      const owner = getAddress2(input.ownerAddress);
+      const resolver = getAddress2(input.resolverAddress);
+      const token = getAddress2(input.inputTokenAddress);
+      const secretHash = bytesHex2(input.secretHash).toLowerCase();
+      const inputUnits = BigInt(input.inputUnits);
+      const resolverSendsUnits = BigInt(input.resolverSendsUnits);
+      const safetyDeposit = BigInt(input.srcHtlcSecurityDepositUnits);
+      if (inputUnits <= 0n || resolverSendsUnits <= 0n || safetyDeposit <= 0n) return refuse("non-positive-amounts");
+      const latest = BigInt(await request(input.chain, "eth_blockNumber", []));
+      const minConfirmations = OMNISTON_EVM_MIN_CONFIRMATIONS[input.chain] ?? 20n;
+      const newestFinal = latest >= minConfirmations ? latest - minConfirmations : 0n;
+      const lookback = OMNISTON_EVM_LOOKBACK_BLOCKS[input.chain];
+      const oldest = newestFinal > lookback ? newestFinal - lookback : 0n;
+      let match;
+      for (let to = newestFinal; to >= oldest && !match; ) {
+        const from = to - oldest > 4999n ? to - 4999n : oldest;
+        const logs = await request(input.chain, "eth_getLogs", [{
+          address: factory,
+          topics: [SRC_ESCROW_CREATED_TOPIC],
+          fromBlock: quantity2(from),
+          toBlock: quantity2(to)
+        }]);
+        for (const log2 of logs) {
+          if (getAddress2(log2.address) !== factory) continue;
+          try {
+            const decoded = decodeEventLog({ abi: FACTORY_ABI2, eventName: "SrcEscrowCreated", data: log2.data, topics: log2.topics });
+            if (decoded.args.srcImmutables.hashlock.toLowerCase() === secretHash) {
+              match = { log: log2, immutables: decoded.args.srcImmutables, complement: decoded.args.dstImmutablesComplement };
+              break;
+            }
+          } catch {
+          }
+        }
+        if (from === oldest) break;
+        to = from - 1n;
+      }
+      if (!match) return refuse("no-fill-event", { factory, lookback: String(OMNISTON_EVM_LOOKBACK_BLOCKS[input.chain]) });
+      const { immutables, complement, log } = match;
+      const deployedAt = stage2(immutables.timelocks, 7);
+      if (uintAddress2(immutables.maker) !== owner || uintAddress2(immutables.taker) !== resolver || uintAddress2(immutables.token) !== token || immutables.amount !== inputUnits || immutables.safetyDeposit !== safetyDeposit || immutables.parameters !== "0x" || SRC_STAGES.some((expected, index) => stage2(immutables.timelocks, index) !== expected) || deployedAt < BigInt(input.quoteTimestamp) - 120n || deployedAt > BigInt(input.quoteTimestamp) + 900n || // EVM destination: the complement is the destination escrow's amount, enforced by its CREATE2
+      // derivation — exact. TON destination: Omniston records a larger figure here (live 2026-10-20,
+      // both orders: 1.089 × resolverSendsUnits — 4 485 039 for 4 118 665, 791 340 for 726 690); the
+      // delivered amount is proven on the TON position itself (validateTonOutputPosition), so this
+      // only has to be no smaller than the promise. Strict equality blocked every EVM → TON disclosure.
+      (input.destinationChainId !== void 0 ? complement.amount !== resolverSendsUnits : complement.amount < resolverSendsUnits)) return refuse("refused");
+      if (input.destinationChainId !== void 0 && (complement.chainId !== BigInt(input.destinationChainId) || !input.destinationTokenAddress || !isAddress2(input.destinationTokenAddress) || uintAddress2(complement.token) !== getAddress2(input.destinationTokenAddress) || complement.safetyDeposit !== BigInt(input.dstSecurityDepositUnits ?? "-1"))) return refuse("complement-destination");
+      const derived = decodeFunctionResult2({
+        abi: FACTORY_ABI2,
+        functionName: "addressOfEscrowSrc",
+        data: await ethCall2(request, input.chain, factory, encodeFunctionData2({ abi: FACTORY_ABI2, functionName: "addressOfEscrowSrc", args: [immutables] }))
+      });
+      if (getAddress2(derived) !== position) return refuse("derived-address", { derived, position });
+      const [receipt, block, code] = await Promise.all([
+        request(input.chain, "eth_getTransactionReceipt", [log.transactionHash]),
+        request(input.chain, "eth_getBlockByNumber", [log.blockNumber, false]),
+        request(input.chain, "eth_getCode", [position, "latest"])
+      ]);
+      if (!receipt || !block || !code || code === "0x" || receipt.status !== "0x1" || BigInt(receipt.blockNumber) !== BigInt(log.blockNumber) || latest - BigInt(receipt.blockNumber) < minConfirmations || BigInt(block.timestamp) !== deployedAt) return refuse("receipt-or-confirmations", { receiptStatus: receipt?.status, receiptBlock: receipt?.blockNumber, logBlock: log.blockNumber, latest: String(latest), minConfirmations: String(minConfirmations), codeLength: code ? code.length : 0, blockTimestamp: block?.timestamp, deployedAt: String(deployedAt) });
+      const nowSeconds = BigInt(Math.floor(now() / 1e3));
+      if (nowSeconds + DISCLOSURE_MARGIN_SECONDS2 >= deployedAt + SRC_STAGES[SRC_CANCELLATION_STAGE]) return refuse("receipt-or-confirmations", { receiptStatus: receipt?.status, receiptBlock: receipt?.blockNumber, logBlock: log.blockNumber, latest: String(latest), minConfirmations: String(minConfirmations), codeLength: code ? code.length : 0, blockTimestamp: block?.timestamp, deployedAt: String(deployedAt) });
+      const [reportedFactory, tokenBalance, nativeBalance] = await Promise.all([
+        ethCall2(request, input.chain, position, encodeFunctionData2({ abi: FACTORY_ABI2, functionName: "FACTORY" })).then((data) => decodeFunctionResult2({ abi: FACTORY_ABI2, functionName: "FACTORY", data })),
+        ethCall2(request, input.chain, token, encodeFunctionData2({ abi: FACTORY_ABI2, functionName: "balanceOf", args: [position] })).then((data) => decodeFunctionResult2({ abi: FACTORY_ABI2, functionName: "balanceOf", data })),
+        request(input.chain, "eth_getBalance", [position, "latest"])
+      ]);
+      const ok = getAddress2(reportedFactory) === factory && tokenBalance >= inputUnits && BigInt(nativeBalance) >= safetyDeposit;
+      return ok || refuse("escrow-state", { reportedFactory, factory, tokenBalance: String(tokenBalance), inputUnits: String(inputUnits), nativeBalance: String(BigInt(nativeBalance)), safetyDeposit: String(safetyDeposit) });
+    } catch (error) {
+      return refuse("error", { message: error instanceof Error ? error.message : String(error) });
+    }
+  };
+}
+
+// src/validators/ton.ts
+import { Buffer } from "buffer";
+import { Address, Cell } from "@ton/core";
+var JETTON_TRANSFER_OP = 260734629;
+var ESCROW_CREATE_OP = 3232100569;
+var ESCROW_CONFIG_OP = 4073126499;
+var ESCROW_EXECUTION_KECCAK_OP = 3369382952;
+var MAX_FORWARD_NANO = 2000000000n;
+var DEFAULT_OMNISTON_TON_CODE_HASHES = {
+  escrow: ["9e77cb9e8fd7406d4e85e5f57378eb51e51b862424cf988306c783d50ade697a"],
+  execution: ["f6edbc76e6fbcd6bac573cb942401a3d9198ee9605f9403b0f5c8081259210e5"],
+  authorityKeys: ["ed210da12aa96ea42de4f2f61dc172bbaa3da86051a1b2a6f342f69a777d2770"],
+  /** EVM→TON output position: the contract the factory deploys for the
+   *  resolver's jetton lock (observed on every resolver-created position,
+   *  2026-10-15/16), and the escrow code cell it carries in its state. */
+  position: ["e4d5115a321ade7b827e38fb522c20d2f2cd46e4c6b0b5f7dd8b6b096792d77b"],
+  outputEscrow: ["d30423575384773abaad8d3c6f763898afa3d57a5693005904b7c61e95cee630"]
+};
+var POSITION_DEPLOY_OP = "0xf240cd30";
+var POSITION_STAGES = { publicWithdrawalAfterWithdrawal: 119n, cancellationAfterWithdrawal: 179n };
+var OUTPUT_DISCLOSURE_MARGIN_SECONDS = 45;
+var MAX_OMNISTON_EXCLUSIVITY_SECONDS = 3600;
+var DEFAULT_OMNISTON_TON_SWAP_INTERFACES = [
+  "stonfi_router",
+  "stonfi_router_v2",
+  "stonfi_pool",
+  "stonfi_pool_v2",
+  "dedust_vault",
+  "dedust_v2_cpmm",
+  "dedust_pool"
+];
+var DEFAULT_OMNISTON_TON_PROXY_TON_MASTERS = [
+  "EQCM3B12QK1e4yZSf8GtBRT0aLMNyEsBc_DhVfRRtOEffLez",
+  // pTON v1
+  "EQBnGWMCf3-FZZq1W4IWcWiGAc3PHuZ0_H-7sad2oY00o83S"
+  // pTON v2
+];
+function cellFromApi(value) {
+  const roots = Cell.fromBoc(Buffer.from(value, /^b5ee9c/i.test(value) ? "hex" : "base64"));
+  if (roots.length !== 1) throw new Error("omniston TON validator: account cell must have one root");
+  return roots[0];
+}
+var lastStateRefusal = null;
+function validateOutputPositionState(data, input, expected) {
+  if (!/^[0-9a-fA-F]{48,64}$/.test(input.quoteId) || input.secretHash.length !== 32) {
+    lastStateRefusal = "state#1: if (!/^[0-9a-fA-F]{48,64}$/.test(input.quoteId) || input.secretHash.length !== 32) return null;";
+    return null;
+  }
+  if (!/^\d+$/.test(input.resolverSendsUnits) || !/^\d+$/.test(input.outputUnits) || !/^\d+$/.test(input.dstSecurityDepositUnits)) {
+    lastStateRefusal = "state#2: if (!/^\\d+$/.test(input.resolverSendsUnits) || !/^\\d+$/.test(input.outputUnits) || !/^\\d+$/.test(inp";
+    return null;
+  }
+  if (data.refs.length !== 3) {
+    lastStateRefusal = "state#3: if (data.refs.length !== 3) return null;";
+    return null;
+  }
+  const root = data.beginParse();
+  root.loadUint(8);
+  if (!sameHex(root.loadBuffer(32), input.quoteId.padStart(64, "0"))) {
+    lastStateRefusal = 'state#4: if (!sameHex(root.loadBuffer(32), input.quoteId.padStart(64, "0"))) return null;';
+    return null;
+  }
+  if (!sameAddress(root.loadAddressAny(), input.protocolAddress)) {
+    lastStateRefusal = "state#5: if (!sameAddress(root.loadAddressAny(), input.protocolAddress)) return null;";
+    return null;
+  }
+  if (!sameAddress(root.loadAddressAny(), expected.jettonWallet)) {
+    lastStateRefusal = "state#6: if (!sameAddress(root.loadAddressAny(), expected.jettonWallet)) return null;";
+    return null;
+  }
+  if (root.remainingBits !== 5 && root.remainingBits !== 29 || root.remainingRefs !== 3) {
+    lastStateRefusal = `state#7: root tail ${root.remainingBits} bits / ${root.remainingRefs} refs`;
+    return null;
+  }
+  const parties = data.refs[0];
+  if (parties.refs.length !== 2) {
+    lastStateRefusal = "state#8: if (parties.refs.length !== 2) return null;";
+    return null;
+  }
+  const partySlice = parties.beginParse();
+  if (!(partySlice.loadAddressAny() instanceof Address)) {
+    lastStateRefusal = "state#9: if (!(partySlice.loadAddressAny() instanceof Address)) return null; // owner (resolver) \u2014 any";
+    return null;
+  }
+  if (!sameAddress(partySlice.loadAddressAny(), input.outputJettonMasterAddress)) {
+    lastStateRefusal = "state#10: if (!sameAddress(partySlice.loadAddressAny(), input.outputJettonMasterAddress)) return null;";
+    return null;
+  }
+  if (partySlice.remainingBits !== 6) {
+    lastStateRefusal = "state#11: if (partySlice.remainingBits !== 6) return null;";
+    return null;
+  }
+  const lock = data.refs[1];
+  if (lock.refs.length !== 2) {
+    lastStateRefusal = "state#12: if (lock.refs.length !== 2) return null;";
+    return null;
+  }
+  const lockSlice = lock.beginParse();
+  if (!Buffer.from(lockSlice.loadBuffer(32)).equals(Buffer.from(input.secretHash))) {
+    lastStateRefusal = "state#13: if (!Buffer.from(lockSlice.loadBuffer(32)).equals(Buffer.from(input.secretHash))) return null;";
+    return null;
+  }
+  if (lockSlice.loadCoins() < BigInt(input.resolverSendsUnits)) {
+    lastStateRefusal = "state#14: if (lockSlice.loadCoins() < BigInt(input.resolverSendsUnits)) return null;";
+    return null;
+  }
+  const withdrawalAt = lockSlice.loadUintBig(64);
+  const publicWithdrawalAt = lockSlice.loadUintBig(64);
+  const cancellationAt = lockSlice.loadUintBig(64);
+  if (lockSlice.remainingBits !== 0) {
+    lastStateRefusal = "state#15: if (lockSlice.remainingBits !== 0) return null; // its two refs are the terms and authority cells be";
+    return null;
+  }
+  if (publicWithdrawalAt - withdrawalAt !== POSITION_STAGES.publicWithdrawalAfterWithdrawal) {
+    lastStateRefusal = "state#16: if (publicWithdrawalAt - withdrawalAt !== POSITION_STAGES.publicWithdrawalAfterWithdrawal) return nu";
+    return null;
+  }
+  if (cancellationAt - withdrawalAt !== POSITION_STAGES.cancellationAfterWithdrawal) {
+    lastStateRefusal = "state#17: if (cancellationAt - withdrawalAt !== POSITION_STAGES.cancellationAfterWithdrawal) return null;";
+    return null;
+  }
+  if (withdrawalAt < BigInt(input.quoteTimestamp) - 120n || withdrawalAt > BigInt(input.quoteTimestamp) + 900n) {
+    lastStateRefusal = "state#18: if (withdrawalAt < BigInt(input.quoteTimestamp) - 120n || withdrawalAt > BigInt(input.quoteTimestamp";
+    return null;
+  }
+  if (BigInt(expected.nowSeconds + OUTPUT_DISCLOSURE_MARGIN_SECONDS) >= cancellationAt) {
+    lastStateRefusal = "state#19: if (BigInt(expected.nowSeconds + OUTPUT_DISCLOSURE_MARGIN_SECONDS) >= cancellationAt) return null;";
+    return null;
+  }
+  const terms = lock.refs[0].beginParse();
+  if (!sameAddress(terms.loadAddressAny(), input.recipientAddress)) {
+    lastStateRefusal = "state#20: if (!sameAddress(terms.loadAddressAny(), input.recipientAddress)) return null;";
+    return null;
+  }
+  if (!(terms.loadAddressAny() instanceof Address)) {
+    lastStateRefusal = "state#21: if (!(terms.loadAddressAny() instanceof Address)) return null; // resolver \u2014 any";
+    return null;
+  }
+  if (terms.loadCoins() !== BigInt(input.dstSecurityDepositUnits) || !exactCellEnd(terms)) {
+    lastStateRefusal = "state#22: if (terms.loadCoins() !== BigInt(input.dstSecurityDepositUnits) || !exactCellEnd(terms)) return null";
+    return null;
+  }
+  const authority = lock.refs[1].beginParse();
+  if (!authority.loadBit() || !expected.trusted.authorityKeys.has(Buffer.from(authority.loadBuffer(32)).toString("hex"))) {
+    lastStateRefusal = "state#23: if (!authority.loadBit() || !expected.trusted.authorityKeys.has(Buffer.from(authority.loadBuffer(32)";
+    return null;
+  }
+  const authorityAddress = authority.loadAddressAny();
+  if (authorityAddress !== null && !sameAddress(authorityAddress, input.recipientAddress) || !exactCellEnd(authority)) {
+    lastStateRefusal = "state#24: if ((authorityAddress !== null && !sameAddress(authorityAddress, input.recipientAddress)) || !exactC";
+    return null;
+  }
+  if (!expected.trusted.outputEscrow.has(data.refs[2].hash().toString("hex"))) {
+    lastStateRefusal = 'state#25: if (!expected.trusted.outputEscrow.has(data.refs[2]!.hash().toString("hex"))) return null;';
+    return null;
+  }
+  return { withdrawalAt };
+}
+function oneRoot(hex, label) {
+  if (!/^(?:[0-9a-fA-F]{2})+$/.test(hex)) throw new Error(`omniston TON validator: malformed ${label} hex`);
+  const roots = Cell.fromBoc(Buffer.from(hex, "hex"));
+  if (roots.length !== 1) throw new Error(`omniston TON validator: ${label} must have one root`);
+  return roots[0];
+}
+function sameAddress(actual, expected) {
+  try {
+    return actual instanceof Address && actual.equals(Address.parse(expected));
+  } catch {
+    return false;
+  }
+}
+function sameHex(actual, expected) {
+  const clean = expected.replace(/^0x/, "").toLowerCase();
+  return clean.length === actual.length * 2 && Buffer.from(actual).toString("hex") === clean;
+}
+function exactCellEnd(slice) {
+  return slice.remainingBits === 0 && slice.remainingRefs === 0;
+}
+function destinationChainId(chain) {
+  const ids = {
+    ethereum: 1n,
+    bnb: 56n,
+    polygon: 137n,
+    robinhood: 4663n,
+    base: 8453n,
+    arbitrum: 42161n,
+    avalanche: 43114n,
+    xlayer: 196n,
+    hyperevm: 999n,
+    plasma: 9745n
+  };
+  return ids[chain] ?? null;
+}
+function validatePayload(input, trusted) {
+  const exclusivityTimeout = input.exclusivityTimeout;
+  if (typeof exclusivityTimeout !== "number" || !Number.isSafeInteger(exclusivityTimeout) || exclusivityTimeout < 1 || exclusivityTimeout > MAX_OMNISTON_EXCLUSIVITY_SECONDS) return false;
+  if (!/^\d+$/.test(input.inputUnits) || !/^\d+$/.test(input.resolverSendsUnits) || !/^\d+$/.test(input.srcHtlcSecurityDepositUnits) || !/^[0-9a-fA-F]{48,64}$/.test(input.quoteId) || input.secretHashes.length !== 1 || input.secretHashes[0]?.length !== 32 || input.hashingFunction !== "HASHING_FUNCTION_KECCAK256") return false;
+  const payload = oneRoot(input.payloadBocHex, "payload");
+  const outer = payload.beginParse();
+  if (outer.loadUint(32) !== JETTON_TRANSFER_OP) return false;
+  outer.loadUintBig(64);
+  if (outer.loadCoins() !== BigInt(input.inputUnits)) return false;
+  if (!sameAddress(outer.loadAddressAny(), input.protocolAddress)) return false;
+  if (!sameAddress(outer.loadAddressAny(), input.ownerAddress)) return false;
+  if (outer.loadMaybeRef() !== null) return false;
+  const forwardNano = outer.loadCoins();
+  if (forwardNano <= 0n || forwardNano > MAX_FORWARD_NANO || !outer.loadBit()) return false;
+  if (outer.remainingBits !== 0 || outer.remainingRefs !== 1) return false;
+  const embeddedForward = outer.loadRef();
+  const forward = oneRoot(input.forwardPayloadBocHex, "forward payload");
+  if (!embeddedForward.hash().equals(forward.hash())) return false;
+  const root = forward.beginParse();
+  if (root.loadUint(32) !== ESCROW_CREATE_OP || !sameHex(root.loadBuffer(32), input.quoteId.padStart(64, "0"))) return false;
+  if (root.loadBit() || !sameAddress(root.loadAddressAny(), input.ownerAddress)) return false;
+  const escrowForwardNano = root.loadCoins();
+  if (escrowForwardNano <= 0n || escrowForwardNano > MAX_FORWARD_NANO || root.loadBit()) return false;
+  if (root.remainingBits !== 0 || root.remainingRefs !== 4) return false;
+  const [config, escrowCode, auxiliary, flags] = [root.loadRef(), root.loadRef(), root.loadRef(), root.loadRef()];
+  if (!trusted.escrow.has(escrowCode.hash().toString("hex"))) return false;
+  const configSlice = config.beginParse();
+  if (configSlice.loadUint(32) !== ESCROW_CONFIG_OP || !sameAddress(configSlice.loadAddressAny(), input.initialResolverAddress)) return false;
+  if (!configSlice.loadBit() || !trusted.authorityKeys.has(Buffer.from(configSlice.loadBuffer(32)).toString("hex"))) return false;
+  if (configSlice.loadUintBig(64) !== BigInt(exclusivityTimeout)) return false;
+  if (configSlice.loadUintBig(64) !== 0n) return false;
+  if (configSlice.remainingRefs !== 2) return false;
+  const state = configSlice.loadRef();
+  if (!configSlice.loadBit()) return false;
+  const destination = configSlice.loadRef();
+  if (configSlice.loadUint(16) !== 0 || !exactCellEnd(configSlice)) return false;
+  if (state.bits.length !== 0 || state.refs.length !== 2) return false;
+  if (!trusted.execution.has(state.refs[0].hash().toString("hex"))) return false;
+  const execution = state.refs[1].beginParse();
+  if (execution.loadUint(32) !== ESCROW_EXECUTION_KECCAK_OP || !Buffer.from(execution.loadBuffer(32)).equals(Buffer.from(input.secretHashes[0])) || !sameAddress(execution.loadAddressAny(), input.initialResolverAddress)) return false;
+  if ([1n, 120n, 240n, 300n].some((expected) => execution.loadUintBig(64) !== expected)) return false;
+  if (execution.remainingBits !== 0 || execution.remainingRefs !== 1) return false;
+  const ownerData = execution.loadRef().beginParse();
+  if (!sameAddress(ownerData.loadAddressAny(), input.ownerAddress) || ownerData.loadBit()) return false;
+  if (ownerData.loadCoins() !== BigInt(input.srcHtlcSecurityDepositUnits) || !exactCellEnd(ownerData)) return false;
+  const destinationSlice = destination.beginParse();
+  const chainId = destinationChainId(input.destinationChain);
+  if (chainId === null || destinationSlice.loadUintBig(64) !== chainId) return false;
+  if (!sameHex(destinationSlice.loadBuffer(20), input.outputTokenAddress)) return false;
+  if (!sameHex(destinationSlice.loadBuffer(20), input.destinationAddress)) return false;
+  if (destinationSlice.loadCoins() !== BigInt(input.resolverSendsUnits) || !exactCellEnd(destinationSlice)) return false;
+  if (auxiliary.bits.length !== 537 || auxiliary.refs.length !== 1) return false;
+  if (flags.bits.length !== 98 || flags.refs.length !== 0) return false;
+  return true;
+}
+function createOmnistonTonValidators(options = {}) {
+  const now = options.now ?? Date.now;
+  const swapInterfaces = new Set(options.swapTargetInterfaces ?? DEFAULT_OMNISTON_TON_SWAP_INTERFACES);
+  const proxyTonMasters = new Set(
+    (options.proxyTonMasters ?? DEFAULT_OMNISTON_TON_PROXY_TON_MASTERS).map((value) => Address.parse(value).toRawString())
+  );
+  const request = options.fetch ?? fetch;
+  const base = (options.tonApiUrl ?? "https://tonapi.io").replace(/\/$/, "");
+  const headers = options.tonApiKey ? { Authorization: `Bearer ${options.tonApiKey}` } : void 0;
+  const get = (path) => request(`${base}${path}`, { ...headers ? { headers } : {}, signal: AbortSignal.timeout(5e3) });
+  const getRetry = async (path) => {
+    for (let attempt = 0; ; attempt++) {
+      const response = await get(path);
+      if (response.status !== 429 || attempt >= 3) return response;
+      await new Promise((resolve) => setTimeout(resolve, 1100 * (attempt + 1)));
+    }
+  };
+  const runGet = async (address, method, args = []) => {
+    const query = args.length ? `?${args.map((arg) => `args=${encodeURIComponent(arg)}`).join("&")}` : "";
+    const response = await getRetry(`/v2/blockchain/accounts/${encodeURIComponent(address)}/methods/${method}${query}`);
+    if (!response.ok) return null;
+    const body = await response.json();
+    return body.success === true && (body.exit_code ?? 0) === 0 && Array.isArray(body.stack) ? body.stack : null;
+  };
+  const stackCell = (entry) => entry && (entry.type === "cell" || entry.type === "slice") && entry.cell ? cellFromApi(entry.cell) : null;
+  const derivedWallet = async (master, owner) => {
+    const cell = stackCell((await runGet(master, "get_wallet_address", [Address.parse(owner).toRawString()]))?.[0]);
+    return cell ? cell.beginParse().loadAddress() : null;
+  };
+  const walletData = async (wallet) => {
+    const stack = await runGet(wallet, "get_wallet_data");
+    const owner = stackCell(stack?.[1]);
+    const master = stackCell(stack?.[2]);
+    return owner && master ? { owner: owner.beginParse().loadAddress(), master: master.beginParse().loadAddress() } : null;
+  };
+  const accountHas = async (address, iface) => {
+    const response = await getRetry(`/v2/accounts/${encodeURIComponent(address)}`);
+    if (!response.ok) return false;
+    const body = await response.json();
+    return !!body.address && sameAddress(Address.parse(body.address), address) && body.is_wallet !== true && (body.interfaces ?? []).includes(iface);
+  };
+  const samePair = (pool, leg) => {
+    const key = (value) => value === null ? "native" : Address.parse(value).toRawString();
+    const a = pool.map(key).sort();
+    const b = leg.map(key).sort();
+    return a.length === 2 && a[0] === b[0] && a[1] === b[1] && a[0] !== a[1];
+  };
+  const readAccount = async (address) => {
+    const response = await get(`/v2/accounts/${encodeURIComponent(address)}`);
+    if (!response.ok) return null;
+    const body = await response.json();
+    if (!body.address || !sameAddress(Address.parse(body.address), address)) return null;
+    return { interfaces: body.interfaces ?? [], isWallet: body.is_wallet === true };
+  };
+  const isDexContract = (account) => !account.isWallet && account.interfaces.some((name) => swapInterfaces.has(name));
+  const trusted = {
+    escrow: new Set((options.escrowCodeHashes ?? DEFAULT_OMNISTON_TON_CODE_HASHES.escrow).map((value) => value.toLowerCase())),
+    execution: new Set((options.executionCodeHashes ?? DEFAULT_OMNISTON_TON_CODE_HASHES.execution).map((value) => value.toLowerCase())),
+    authorityKeys: new Set((options.authorityKeys ?? DEFAULT_OMNISTON_TON_CODE_HASHES.authorityKeys).map((value) => value.toLowerCase())),
+    position: new Set((options.positionCodeHashes ?? DEFAULT_OMNISTON_TON_CODE_HASHES.position).map((value) => value.toLowerCase())),
+    outputEscrow: new Set((options.outputEscrowCodeHashes ?? DEFAULT_OMNISTON_TON_CODE_HASHES.outputEscrow).map((value) => value.toLowerCase()))
+  };
+  const jettonWalletOf = async (ownerAddress, jettonMasterAddress) => {
+    const response = await get(`/v2/accounts/${encodeURIComponent(ownerAddress)}/jettons/${encodeURIComponent(jettonMasterAddress)}`);
+    if (!response.ok) return null;
+    const body = await response.json();
+    const wallet = body.wallet_address?.address;
+    if (!wallet || body.jetton?.address !== void 0 && !sameAddress(Address.parse(body.jetton.address), jettonMasterAddress)) return null;
+    return Address.parse(wallet).toString();
+  };
+  return {
+    async validateTonJettonWallet({ ownerAddress, jettonMasterAddress, walletAddress }) {
+      try {
+        const url = `${base}/v2/accounts/${encodeURIComponent(ownerAddress)}/jettons/${encodeURIComponent(jettonMasterAddress)}`;
+        const response = await request(url, {
+          ...headers ? { headers } : {},
+          signal: AbortSignal.timeout(5e3)
+        });
+        if (!response.ok) return false;
+        const body = await response.json();
+        if (!sameAddress(body.wallet_address?.address ? Address.parse(body.wallet_address.address) : null, walletAddress)) return false;
+        return body.jetton?.address === void 0 || sameAddress(Address.parse(body.jetton.address), jettonMasterAddress);
+      } catch {
+        return false;
+      }
+    },
+    validateTonEscrowPayload(input) {
+      try {
+        return validatePayload(input, trusted);
+      } catch {
+        return false;
+      }
+    },
+    /**
+     * EVM→TON: the position the tracking feed named must be (1) an active
+     * contract with the pinned position code, (2) carrying state that binds
+     * this quote, hashlock, recipient, output jetton, amount, deposit and the
+     * pinned timelocks — still inside the completion window — with jetton
+     * custody at the factory's own wallet, and (3) deployed by the trusted
+     * factory itself (its deploy message is only sent after the factory's
+     * jetton wallet notified it of the resolver's transfer). Nothing here
+     * trusts the feed beyond the address it suggested.
+     */
+    async validateTonOutputPosition(input) {
+      const refuse = (reason, details) => {
+        try {
+          options.onRefusal?.(reason, details);
+        } catch {
+        }
+        return false;
+      };
+      lastStateRefusal = null;
+      try {
+        Address.parse(input.positionAddress);
+        Address.parse(input.recipientAddress);
+        const nowSeconds = Math.floor(now() / 1e3);
+        if (!Number.isInteger(input.quoteTimestamp) || input.quoteTimestamp > nowSeconds + 120 || nowSeconds - input.quoteTimestamp > 6 * 60 * 60) return refuse("quote-age");
+        const accountResponse = await get(`/v2/blockchain/accounts/${encodeURIComponent(input.positionAddress)}`);
+        if (!accountResponse.ok) return refuse("account-fetch", { status: accountResponse.status });
+        const account = await accountResponse.json();
+        if (!account.address || !sameAddress(Address.parse(account.address), input.positionAddress) || account.status !== "active" || !account.code || !account.data) return refuse("account-state", { status: account.status, hasCode: !!account.code, hasData: !!account.data });
+        if (!trusted.position.has(cellFromApi(account.code).hash().toString("hex"))) return refuse("position-code-hash", { hash: cellFromApi(account.code).hash().toString("hex") });
+        const jettonWallet = await jettonWalletOf(input.protocolAddress, input.outputJettonMasterAddress);
+        if (!jettonWallet) return refuse("jetton-wallet");
+        const state = validateOutputPositionState(cellFromApi(account.data), input, { jettonWallet, trusted, nowSeconds });
+        if (!state) return refuse("state", { check: lastStateRefusal });
+        const txResponse = await get(`/v2/blockchain/accounts/${encodeURIComponent(input.positionAddress)}/transactions?limit=25`);
+        if (!txResponse.ok) return refuse("transactions-fetch", { status: txResponse.status });
+        const body = await txResponse.json();
+        const deployedByFactory = (body.transactions ?? []).some((tx) => tx.success === true && tx.aborted !== true && tx.in_msg?.op_code?.toLowerCase() === POSITION_DEPLOY_OP && !!tx.in_msg.source?.address && sameAddress(Address.parse(tx.in_msg.source.address), input.protocolAddress) && typeof tx.utime === "number" && Math.abs(Number(state.withdrawalAt) - 1 - tx.utime) <= 5);
+        return deployedByFactory || refuse("deploy-transaction", { transactions: (body.transactions ?? []).length });
+      } catch (error) {
+        return refuse("error", { message: error instanceof Error ? error.message : String(error) });
+      }
+    },
+    /**
+     * Scan F11: one chain fact a decoded TON swap body depends on.
+     *  - STON.fi hop: the router carries the STON.fi router interface of its
+     *    version; for native input the pTON wallet the message pays is a
+     *    proxy-TON wallet OWNED BY that router; the hop's ask wallet is the
+     *    router's own wallet of the hop's output (of a proxy-TON master for
+     *    native output), as the output's master derives it.
+     *  - DeDust pool: the pool carries the DeDust pool interface of its version
+     *    and trades exactly the hop's pair.
+     */
+    async validateTonSwapLeg(leg) {
+      try {
+        if (leg.kind === "stonfi-router") {
+          let router = leg.router ? Address.parse(leg.router) : null;
+          if (leg.proxyTonWallet) {
+            const data = await walletData(leg.proxyTonWallet);
+            if (!data || !proxyTonMasters.has(data.master.toRawString())) return false;
+            if (router && !router.equals(data.owner)) return false;
+            router = data.owner;
+          }
+          if (!router) return false;
+          if (!await accountHas(router.toString(), leg.version === 1 ? "stonfi_router" : "stonfi_router_v2")) return false;
+          const masters = leg.outputJetton ? [leg.outputJetton] : [...proxyTonMasters];
+          for (const master of masters) {
+            const wallet = await derivedWallet(master, router.toString());
+            if (wallet && wallet.equals(Address.parse(leg.askWallet))) return true;
+          }
+          return false;
+        }
+        if (leg.version === 1) {
+          if (!await accountHas(leg.pool, "dedust_pool")) return false;
+          const stack2 = await runGet(leg.pool, "get_assets");
+          const assets2 = [stackCell(stack2?.[0]), stackCell(stack2?.[1])].map((cell) => {
+            if (!cell) return void 0;
+            const slice = cell.beginParse();
+            const tag = slice.loadUint(4);
+            if (tag === 0) return null;
+            if (tag !== 1) return void 0;
+            return new Address(slice.loadInt(8), slice.loadBuffer(32)).toString();
+          });
+          if (assets2.some((asset) => asset === void 0)) return false;
+          return samePair(assets2, [leg.inputJetton, leg.outputJetton]);
+        }
+        if (!await accountHas(leg.pool, "dedust_v2_cpmm")) return false;
+        const stack = await runGet(leg.pool, "get_pool_data");
+        const assets = [stackCell(stack?.[3]), stackCell(stack?.[4])].map((cell) => {
+          if (!cell) return void 0;
+          const address = cell.beginParse().loadAddressAny();
+          if (address === null) return null;
+          return address instanceof Address ? address.toString() : void 0;
+        });
+        if (assets.some((asset) => asset === void 0)) return false;
+        return samePair(assets, [leg.inputJetton, leg.outputJetton]);
+      } catch {
+        return false;
+      }
+    },
+    /** The contract a swap pays into must carry a recognised DEX code
+     *  interface on the indexer — an EOA, an unknown contract or a fresh
+     *  resolver-deployed proxy is refused. */
+    async validateTonSwapTarget({ address }) {
+      try {
+        Address.parse(address);
+        const account = await readAccount(address);
+        if (!account || account.isWallet) return false;
+        if (isDexContract(account)) return true;
+        if (!account.interfaces.includes("jetton_wallet")) return false;
+        const data = await get(`/v2/blockchain/accounts/${encodeURIComponent(address)}/methods/get_wallet_data`);
+        if (!data.ok) return false;
+        const body = await data.json();
+        const owner = body.decoded?.owner;
+        const master = body.decoded?.jetton;
+        if (!body.success || !owner || !master || !proxyTonMasters.has(Address.parse(master).toRawString())) return false;
+        const ownerAccount = await readAccount(owner);
+        return ownerAccount !== null && isDexContract(ownerAccount);
+      } catch {
+        return false;
+      }
+    }
+  };
+}
+function createOmnistonTonDeliveryLocator(options = {}) {
+  const request = options.fetch ?? fetch;
+  const base = (options.tonApiUrl ?? "https://tonapi.io").replace(/\/$/, "");
+  const headers = options.tonApiKey ? { Authorization: `Bearer ${options.tonApiKey}` } : void 0;
+  const limit = Math.min(100, Math.max(1, Math.floor(options.limit ?? 20)));
+  return async (input) => {
+    try {
+      const recipient = Address.parse(input.recipientAddress);
+      const master = Address.parse(input.jettonMasterAddress);
+      const position = input.positionAddress ? Address.parse(input.positionAddress) : null;
+      const min = BigInt(input.minUnits);
+      if (min <= 0n) return null;
+      const since = Number.isFinite(input.afterTimestamp) ? `&start_date=${Math.max(0, Math.floor(input.afterTimestamp))}` : "";
+      const until = Number.isFinite(input.beforeTimestamp) ? `&end_date=${Math.max(0, Math.floor(input.beforeTimestamp))}` : "";
+      const url = `${base}/v2/accounts/${encodeURIComponent(recipient.toString())}/events?limit=${limit}${since}${until}`;
+      const response = await request(url, { ...headers ? { headers } : {}, signal: AbortSignal.timeout(8e3) });
+      if (!response.ok) return null;
+      const body = await response.json();
+      const events = [...body.events ?? []];
+      if (input.afterTimestamp !== void 0) events.sort((a, b) => (a.timestamp ?? 0) - (b.timestamp ?? 0));
+      for (const event of events) {
+        if (!event.event_id || event.in_progress === true) continue;
+        if (input.afterTimestamp !== void 0 && typeof event.timestamp === "number" && event.timestamp < input.afterTimestamp) continue;
+        if (input.beforeTimestamp !== void 0 && typeof event.timestamp === "number" && event.timestamp > input.beforeTimestamp) continue;
+        for (const action of event.actions ?? []) {
+          if (action.type !== "JettonTransfer" || action.status !== "ok") continue;
+          const t = action.JettonTransfer;
+          if (!t?.jetton?.address || !t.recipient?.address || t.amount === void 0) continue;
+          if (!sameAddress(Address.parse(t.jetton.address), master.toString())) continue;
+          if (!sameAddress(Address.parse(t.recipient.address), recipient.toString())) continue;
+          if (position && (!t.sender?.address || !sameAddress(Address.parse(t.sender.address), position.toString()))) continue;
+          let amount;
+          try {
+            amount = BigInt(t.amount);
+          } catch {
+            continue;
+          }
+          if (amount < min) continue;
+          return event.event_id.toLowerCase();
+        }
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  };
+}
+
+// src/validators/settlement.ts
+var AUDITED_OMNISTON_SETTLEMENT_CONTRACTS = {
+  "ton:-239": ["EQAbWJ3Y1HgIIvcMq1prG1anlDC0T3cZlAU7luPT6LmTpmrZ"],
+  "eip155:1": ["0xafCF681272AF10959736f45616eeCBC22D7095E2"],
+  "eip155:56": ["0xafCF681272AF10959736f45616eeCBC22D7095E2"],
+  "eip155:137": ["0x41A392062A4307a6961d48e30FF20bF6823715B8"],
+  "eip155:4663": ["0xafCF681272AF10959736f45616eeCBC22D7095E2"],
+  "eip155:8453": ["0xACa3E2F9b61a44892926bC6c3e104192E7D1c3cd"],
+  "eip155:42161": ["0xafCF681272AF10959736f45616eeCBC22D7095E2"],
+  "eip155:43114": ["0xafCF681272AF10959736f45616eeCBC22D7095E2"],
+  // 2026-10-20: one factory address on X Layer, HyperEVM and Plasma. Runtime
+  // bytecode equals Ethereum's 0xafCF… byte for byte except the immutable slots
+  // (escrow implementations, its order protocol, domain hash); it references
+  // the order protocol trusted below on the same chain.
+  "eip155:196": ["0xd602079AFa5c38F550510a2a988CbFa698Fa0189"],
+  "eip155:999": ["0xd602079AFa5c38F550510a2a988CbFa698Fa0189"],
+  "eip155:9745": ["0xd602079AFa5c38F550510a2a988CbFa698Fa0189"]
+};
+var AUDITED_OMNISTON_EVM_ORDER_PROTOCOLS = {
+  "eip155:1": ["0xb5810aCfD45D85Eaa938bF90a5857295513DA7E9"],
+  "eip155:56": ["0xb5810aCfD45D85Eaa938bF90a5857295513DA7E9"],
+  "eip155:137": ["0xafCF681272AF10959736f45616eeCBC22D7095E2"],
+  "eip155:8453": ["0xe7405fAcDEDB2512e91F2886BDff13231343aF5E"],
+  "eip155:42161": ["0xb5810aCfD45D85Eaa938bF90a5857295513DA7E9"],
+  "eip155:43114": ["0xb5810aCfD45D85Eaa938bF90a5857295513DA7E9"],
+  // 2026-10-20: bytecode equals Ethereum's 0xb581… except immutables (wrapped
+  // native, own address, chain id 196 / 9745 / 999 at the chain-id slot).
+  "eip155:196": ["0xb5810aCfD45D85Eaa938bF90a5857295513DA7E9"],
+  "eip155:9745": ["0xb5810aCfD45D85Eaa938bF90a5857295513DA7E9"],
+  "eip155:999": ["0xD84778bbeEC5D2a8d17c6424249C438EC0b1ABE3"]
+};
+export {
+  AUDITED_OMNISTON_EVM_ORDER_PROTOCOLS,
+  AUDITED_OMNISTON_SETTLEMENT_CONTRACTS,
+  DEFAULT_OMNISTON_TON_CODE_HASHES,
+  DEFAULT_OMNISTON_TON_PROXY_TON_MASTERS,
+  DEFAULT_OMNISTON_TON_SWAP_INTERFACES,
+  MAX_OMNISTON_EXCLUSIVITY_SECONDS,
+  OMNISTON_EVM_LOOKBACK_BLOCKS,
+  OMNISTON_EVM_MIN_CONFIRMATIONS,
+  SRC_ESCROW_CREATED_TOPIC,
+  createOmnistonEvmDeliveryLocator,
+  createOmnistonEvmInputValidator,
+  createOmnistonEvmOutputValidator,
+  createOmnistonTonDeliveryLocator,
+  createOmnistonTonValidators,
+  omnistonEvmRpcRequest
+};
+//# sourceMappingURL=validators.js.map