@ninsei-labs/sdk 0.39.0

package/engine/mock/chain.js

@@ -0,0 +1,98 @@
+// GENERATED FILE - a byte-for-byte copy of the engine module www/js/mock/chain.js for the SDK package.
+// Edit the source under www/js, then run: node tools/build-sdk-engine.mjs
+// tools/check-sdk-engine.mjs reddens on any drift, so a stale copy cannot ship silently.
+// Everything below this header is identical to the source.
+
+// Мок-чейн: escrow-контракт на EVM и Monero-нога.
+//
+// Здесь НЕТ реальных транзакций. Всё, что возвращается, помечено как mock, а хеши
+// детерминированы от id сделки - чтобы демо было воспроизводимо.
+// Точка подмены: когда появится контракт, эти функции заменяются на вызовы ethers.js,
+// а интерфейс (fund/lock/claim/refund/sweep) сохраняется.
+
+import { randomHex } from "../core/format.js";
+import * as node from "../monero/node.js";
+
+function hashOf(...parts) {
+  const payload = parts.join("|");
+  let hh = 0x811c9dc5;
+  for (let i = 0; i < payload.length; i++) {
+    hh ^= payload.charCodeAt(i);
+    hh = (hh * 0x01000193) >>> 0;
+  }
+  return "0x" + hh.toString(16).padStart(8, "0") + randomHex(28);
+}
+
+// CREATE2-адрес per-order escrow (litepaper §8: свой контракт на сделку, без admin).
+export function escrowAddress(swapId) {
+  return "0x" + hashOf("escrow", swapId).slice(2, 42);
+}
+
+// Адрес совместного Monero-выхода (S_a + S_b, V_a + V_b в реальном протоколе).
+export function moneroLockAddress(swapId) {
+  return "8" + hashOf("xmrlock", swapId).slice(2, 96);
+}
+
+export function fundEscrow({ swapId, ethAmountUsd, ethUsd }) {
+  return {
+    mock: true,
+    txHash: hashOf("fund", swapId),
+    escrow: escrowAddress(swapId),
+    ethAmount: ethUsd > 0 ? ethAmountUsd / ethUsd : 0,
+    valueUsd: ethAmountUsd,
+    gasUsd: 0.21,
+    // ИМЯ МЕТОДА НЕ ВЫДУМЫВАЕМ. Здесь стояло lockAndSwap(bytes32 quoteHash, bytes makerSig) - такого
+    // метода в контракте нет вовсе, но именно эта строка уезжала в запись сделки и показывалась на экране
+    // как "Escrow method". Демо-путь денег не двигает, поэтому честная подпись для него - эта, без
+    // выдуманной сигнатуры. Настоящее имя вызова живой путь записывает сам, из фактического вызова.
+    method: "simulated funding (no real transaction)",
+    confirmations: 1,
+  };
+}
+
+export function lockXmr({ swapId, xmrAmount }) {
+  return {
+    mock: true,
+    txid: hashOf("xmrtx", swapId),
+    address: moneroLockAddress(swapId),
+    amount: xmrAmount,
+    viewKeyVerified: true,
+    unlocked: "1 of 2 spend key shares revealed (DLEQ bound)",
+  };
+}
+
+export function sweepXmr({ swapId }) {
+  return { mock: true, txid: hashOf("sweep", swapId) };
+}
+
+export function refundEscrow({ swapId, by }) {
+  return { mock: true, txHash: hashOf("refund", swapId, by), by };
+}
+
+// Подтверждения Monero-ноды: 10 блоков по 2 минуты (litepaper §5.0).
+//
+// chainMode=mock - подтверждения идут по sim-времени (быстро, для показа потока).
+// chainMode=live - подтверждения считаются по реальному росту высоты mainnet-нода:
+//   сделка тогда честно длится ~20 минут независимо от скорости демки. Если нод
+//   недоступен или высота на момент лока не зафиксирована, откатываемся на sim-счётчик.
+export function confirmations(swap, simElapsedMs) {
+  const target = swap.timeline.confTarget;
+
+  if (swap.chainMode === "live") {
+    const lockHeight = swap.xmr && swap.xmr.lockHeight;
+    const snap = node.snapshot();
+    if (lockHeight && snap && typeof snap.height === "number" && snap.height >= lockHeight) {
+      return Math.max(0, Math.min(target, snap.height - lockHeight));
+    }
+    return swap.xmr ? 0 : 0;
+  }
+
+  const started = swap.timeline.lockAtSim;
+  if (started === null || simElapsedMs < started) return 0;
+  const blocks = Math.floor((simElapsedMs - started) / swap.timeline.blockSim);
+  return Math.max(0, Math.min(target, blocks));
+}
+
+export function explorerTx(hash) {
+  return "https://arbiscan.io/tx/" + hash;
+}

package/engine/monero/address.js

@@ -0,0 +1,265 @@
+// GENERATED FILE - a byte-for-byte copy of the engine module www/js/monero/address.js for the SDK package.
+// Edit the source under www/js, then run: node tools/build-sdk-engine.mjs
+// tools/check-sdk-engine.mjs reddens on any drift, so a stale copy cannot ship silently.
+// Everything below this header is identical to the source.
+
+// Проверка и сборка Monero-адресов: формат + настоящий checksum + префиксы всех сетей.
+//
+// Важная деталь, на которой легко ошибиться: у Monero СВОЙ base58 - блочный
+// (8 байт кодируются 11 символами, остаток идёт в конце). Он НЕ совместим с обычным
+// биткойн-base58: там ведущий символ '1' означает нулевой байт, а у Monero блок кодируется
+// как ЧИСЛО, и '1' может быть просто цифрой внутри числа. Поэтому ни bs58.decode, ни
+// bs58.encode здесь не годятся - base58 реализован ниже численно (см. base58ToBlock).
+//
+// Зачем это нужно в демке: без проверки checksum опечатка в адресе получения
+// выглядит валидной, а в atomic-свопе ошибка в адресе означает потерянные деньги.
+//
+// Префиксы сетей (из src/cryptonote_config.h, официальные значения):
+//   mainnet: 18 обычный, 19 с payment id, 42 суб-адрес
+//   stagenet: 24 / 25 / 36
+//   testnet: 53 / 54 / 63
+// Вендоренная monero-js умеет ТОЛЬКО mainnet (у неё в address.js жёстко 18/19/42),
+// поэтому здесь свой энкодер: библиотека даёт публичные ключи, а строку адреса собираем мы.
+
+const BLOCK_CHARS = 11;
+
+// encoded bytes -> chars (из monero-js/src/base58.js, ENC_BLOCK_BYTE_LENS)
+const CHARS_BY_BYTES = { 1: 2, 2: 3, 3: 5, 4: 6, 5: 7, 6: 9, 7: 10, 8: 11 };
+const BYTES_BY_CHARS = { 2: 1, 3: 2, 5: 3, 6: 4, 7: 5, 9: 6, 10: 7, 11: 8 };
+
+const PREFIXES = {
+  18: { network: "mainnet", kind: "primary" },
+  19: { network: "mainnet", kind: "integrated" },
+  42: { network: "mainnet", kind: "subaddress" },
+  24: { network: "stagenet", kind: "primary" },
+  25: { network: "stagenet", kind: "integrated" },
+  36: { network: "stagenet", kind: "subaddress" },
+  53: { network: "testnet", kind: "primary" },
+  54: { network: "testnet", kind: "integrated" },
+  63: { network: "testnet", kind: "subaddress" },
+};
+
+// обратная таблица: сеть + вид -> байт префикса (для сборки адреса)
+export const PREFIX_BY_NETWORK = {
+  mainnet: { primary: 18, integrated: 19, subaddress: 42 },
+  stagenet: { primary: 24, integrated: 25, subaddress: 36 },
+  testnet: { primary: 53, integrated: 54, subaddress: 63 },
+};
+
+export function prefixFor(network, kind = "primary") {
+  const byKind = PREFIX_BY_NETWORK[network];
+  if (!byKind) throw new Error("Unknown network: " + network);
+  const prefix = byKind[kind];
+  if (prefix === undefined) throw new Error("Unknown address kind: " + kind);
+  return prefix;
+}
+
+// Синхронная проверка формата (для UI до загрузки библиотеки).
+export function formatCheck(addr) {
+  const a = String(addr || "").trim();
+  if (![95, 106].includes(a.length)) return false;
+  if (!/^[1-9A-HJ-NP-Za-km-z]+$/.test(a)) return false;
+  // первая буква адреса определяется префиксом сети: 4/8 mainnet, 5/7 stagenet, 9/A/B testnet
+  return ["4", "5", "7", "8", "9", "A", "B"].includes(a[0]);
+}
+
+// Первая буква адреса прямо следует из префикса: 4/8 - mainnet, 5/7 - stagenet, 9/A/B - testnet
+export function networkFromShape(addr) {
+  const a = String(addr || "").trim();
+  if (!formatCheck(a)) return null;
+  if (a[0] === "4" || a[0] === "8") return "mainnet";
+  if (a[0] === "5" || a[0] === "7") return "stagenet";
+  if (["9", "A", "B"].includes(a[0])) return "testnet";
+  return null;
+}
+
+export function isStagenetShaped(addr) {
+  return networkFromShape(addr) === "stagenet";
+}
+
+let lib = null;
+let libFailed = false;
+
+async function loadLib() {
+  if (lib) return lib;
+  if (libFailed) return null;
+  try {
+    const mod = await import("../../assets/vendors/monero/monero-js-browser.js?v=05c682ea");
+    lib = mod.default || mod;
+    return lib;
+  } catch {
+    libFailed = true;
+    return null;
+  }
+}
+
+// Алфавит Monero-base58 (тот же, что у Bitcoin, но правила кодирования другие).
+const B58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+const B58_VALUES = (() => {
+  const m = new Map();
+  [...B58_ALPHABET].forEach((c, i) => m.set(c, BigInt(i)));
+  return m;
+})();
+
+// Блок байтов -> base58-строка (числом: никакого «ведущий '1' = нулевой байт»).
+function blockToBase58(block) {
+  let num = 0n;
+  for (const b of block) num = (num << 8n) | BigInt(b);
+  let s = "";
+  while (num > 0n) {
+    s = B58_ALPHABET[Number(num % 58n)] + s;
+    num /= 58n;
+  }
+  return s;
+}
+
+// base58-строка блока -> ровно `bytes` байтов, выравнивание по ПРАВОМУ краю.
+//
+// Почему не bs58 из npm: его декодер трактует каждый ведущий символ '1' как нулевой БАЙТ
+// (биткойн-семантика). В Monero блок кодируется как число, и '1' может быть просто цифрой
+// внутри числа - тогда bs58 выдаёт лишний нулевой байт, payload разъезжается, и checksum
+// ложно не сходится. На этом ловились: 18 адресов из 120 (15%) проверялись как «с опечаткой».
+function base58ToBlock(str, bytes) {
+  let num = 0n;
+  for (const ch of str) {
+    const v = B58_VALUES.get(ch);
+    if (v === undefined) throw new Error("Invalid Monero base58 character: " + ch);
+    num = num * 58n + v;
+  }
+  const out = new Uint8Array(bytes);
+  for (let i = bytes - 1; i >= 0; i--) {
+    out[i] = Number(num & 0xffn);
+    num >>= 8n;
+  }
+  if (num !== 0n) throw new Error("Base58 block does not fit in " + bytes + " bytes");
+  return out;
+}
+
+// Блочный Monero-base58: строка -> байты.
+//
+// Порядок блоков важен: Monero сначала кодирует полные 8-байтовые блоки (по 11 символов),
+// а НЕПОЛНЫЙ остаток идёт В КОНЦЕ и занимает меньше символов (см. monero-js/src/base58.js:
+// сначала tot_block_cnt блоков, затем last_block_enc_len). Поэтому остаток берём с конца строки.
+export function decodeMoneroBase58(str) {
+  const s = String(str);
+  const L = s.length;
+  const rem = L % BLOCK_CHARS;
+  const lastChars = rem === 0 ? BLOCK_CHARS : rem;
+  const lastBytes = BYTES_BY_CHARS[lastChars];
+  if (!lastBytes) throw new Error("Invalid Monero base58 length");
+
+  const chunks = [];
+  const headLen = L - lastChars;
+  for (let i = 0; i < headLen; i += BLOCK_CHARS) chunks.push(base58ToBlock(s.slice(i, i + BLOCK_CHARS), 8));
+  chunks.push(base58ToBlock(s.slice(headLen), lastBytes));
+
+  const out = new Uint8Array(chunks.reduce((n, c) => n + c.length, 0));
+  let offset = 0;
+  for (const c of chunks) { out.set(c, offset); offset += c.length; }
+  return out;
+}
+
+// Блочный Monero-base58: байты -> строка (обратная к decode выше).
+// Полные 8-байтовые блоки кодируются по 11 символов (слева дополняются '1'), остаток - в конце.
+export function encodeMoneroBase58(bytes) {
+  const arr = Array.from(bytes);
+  const L = arr.length;
+  const rem = L % 8;
+  const lastBytes = rem === 0 ? 8 : rem;
+  const headLen = L - lastBytes;
+
+  let out = "";
+  for (let i = 0; i < headLen; i += 8) {
+    const s = blockToBase58(arr.slice(i, i + 8));
+    out += "1".repeat(Math.max(0, CHARS_BY_BYTES[8] - s.length)) + s;
+  }
+  const t = blockToBase58(arr.slice(headLen));
+  out += "1".repeat(Math.max(0, CHARS_BY_BYTES[lastBytes] - t.length)) + t;
+  return out;
+}
+
+// Полезная нагрузка адреса (без checksum): префикс + публичный spend + публичный view [+ payment id]
+export function addressPayload({ network, kind = "primary", spendPub, viewPub, paymentId }) {
+  const prefix = prefixFor(network, kind);
+  const spend = hexToBytes(spendPub, 32, "public spend key");
+  const view = hexToBytes(viewPub, 32, "public view key");
+  const out = [prefix, ...spend, ...view];
+  if (kind === "integrated") {
+    const pid = hexToBytes(paymentId, 8, "payment id");
+    out.push(...pid);
+  }
+  return Uint8Array.from(out);
+}
+
+function hexToBytes(hex, expectedBytes, label) {
+  const s = String(hex || "").trim();
+  if (!new RegExp("^[0-9a-fA-F]{" + expectedBytes * 2 + "}$").test(s)) {
+    throw new Error("Bad " + label + ": expected " + expectedBytes * 2 + " hex characters");
+  }
+  const out = new Uint8Array(expectedBytes);
+  for (let i = 0; i < expectedBytes; i++) out[i] = parseInt(s.slice(i * 2, i * 2 + 2), 16);
+  return out;
+}
+
+// Сборка адреса из публичных ключей: deps = { keccak256 } (в браузере - из бандла monero-js).
+// bs58 здесь не нужен: base58 у Monero блочный и числовой, см. комментарий у base58ToBlock.
+export function addressFromKeys({ network, kind = "primary", spendPub, viewPub, paymentId }, deps) {
+  if (!deps?.keccak256) throw new Error("addressFromKeys needs { keccak256 }");
+  const payload = addressPayload({ network, kind, spendPub, viewPub, paymentId });
+  const digest = Uint8Array.from(deps.keccak256(deps.Buffer ? deps.Buffer.from(payload) : payload));
+  const full = new Uint8Array(payload.length + 4);
+  full.set(payload, 0);
+  full.set(digest.slice(0, 4), payload.length);
+  return encodeMoneroBase58(full);
+}
+
+// Полная проверка: формат + блочный декод + keccak256-checksum + сеть.
+// expectNetwork (необязательно): если задан, адрес чужой сети считается ошибкой -
+// в свапе на stagenet mainnet-адрес это потерянные деньги, а не придирка.
+export async function checkAddress(addr, opts = {}) {
+  const a = String(addr || "").trim();
+  if (!formatCheck(a)) {
+    return { ok: false, reason: "Not a Monero address (expected 95 or 106 base58 characters)" };
+  }
+  const shape = networkFromShape(a);
+  if (opts.expectNetwork && shape && shape !== opts.expectNetwork) {
+    return { ok: false, reason: `This is a ${shape} address, but the swap runs on ${opts.expectNetwork}` };
+  }
+  const l = await loadLib();
+  if (!l) {
+    return { ok: true, verified: false, network: shape, reason: "Format looks valid (checksum check unavailable: monero-js bundle is not built)" };
+  }
+  try {
+    const bytes = decodeMoneroBase58(a);
+    const payloadLen = bytes.length - 4;
+    if (payloadLen < 65) throw new Error("Address is too short");
+    const payload = bytes.slice(0, payloadLen);
+    const checksum = bytes.slice(payloadLen);
+    // keccak256 из бандла требует Buffer: Uint8Array он не принимает
+    const digest = Uint8Array.from(l.keccak256(l.Buffer.from(payload)));
+    const match = checksum.length === 4 && checksum.every((b, i) => b === digest[i]);
+    if (!match) {
+      // Мок-адреса демки (wallet.js, режим mock) намеренно без checksum: они помечены в UI как
+      // фиктивные. Если такой адрес попадёт сюда, «опечатка» - не единственная версия, и текст
+      // должен это говорить, иначе отладка уходит не туда.
+      return { ok: false, reason: "Checksum mismatch: the address has a typo, is corrupted, or is a demo mock address (mock addresses have no checksum)" };
+    }
+
+    const prefix = payload[0];
+    const meta = PREFIXES[prefix] || { network: "unknown", kind: "unknown" };
+    if (meta.network === "unknown") return { ok: false, reason: `Unsupported address prefix ${prefix}` };
+    if (opts.expectNetwork && meta.network !== opts.expectNetwork) {
+      return { ok: false, reason: `This is a ${meta.network} address, but the swap runs on ${opts.expectNetwork}` };
+    }
+    return { ok: true, verified: true, network: meta.network, kind: meta.kind, bytes: bytes.length };
+  } catch (e) {
+    return { ok: false, reason: "Address decode failed: " + e.message };
+  }
+}
+
+// Хелпер для кода, который уже загрузил бандл: собрать адрес нужной сети из ключей кошелька.
+export async function addressForNetwork({ network, kind = "primary", spendPub, viewPub }) {
+  const l = await loadLib();
+  if (!l) throw new Error("monero-js bundle is not available");
+  return addressFromKeys({ network, kind, spendPub, viewPub }, { keccak256: l.keccak256, Buffer: l.Buffer });
+}

package/engine/monero/halvesSweep.js

@@ -0,0 +1,68 @@
+// GENERATED FILE - a byte-for-byte copy of the engine module www/js/monero/halvesSweep.js for the SDK package.
+// Edit the source under www/js, then run: node tools/build-sdk-engine.mjs
+// tools/check-sdk-engine.mjs reddens on any drift, so a stale copy cannot ship silently.
+// Everything below this header is identical to the source.
+
+// КЛЮЧИ ДЛЯ ВЫВОДА ИЗ ФАЙЛА ПОЛОВИН. Вынесено отдельным модулем, потому что это ОДНА логика на два
+// потребителя: страница вывода (sweep.js) и проверка (tools/check-sweep-halves.mjs). Пока код жил прямо на
+// странице, проверить его можно было только в браузере, а вторая копия в проверке неизбежно разошлась бы с
+// первой - и заметил бы это не тот, кто ошибся.
+//
+// ПОЧЕМУ ЭТО ГЛАВНАЯ ФУНКЦИЯ ВСЕГО ВЫВОДА. Контракт убеждается лишь в том, что ХЕШ раскрытой половины совпал
+// с обязательством. Связь «раскрытая половина и точка в адресе» проверить он не может: ed25519 в EVM нет.
+// Значит её проверяем мы, и ДО всякой синхронизации: (s_a + s_b)*G обязана совпасть с публичным ключом траты
+// ордера. Не совпало - не метём и говорим прямо.
+//
+// Секреты здесь не создаются: обе половины уже есть у стороны (своя - в файле, чужая - раскрыта в цепи).
+export function spendKeysFromRevealedHalf({
+  halves, ownSpendHalf, ownViewHalf, otherSpendPoint, otherViewHalf, revealedHalf,
+}) {
+  if (!halves) throw new Error("нужна математика половин");
+  for (const [name, v] of Object.entries({ ownSpendHalf, ownViewHalf, otherSpendPoint, otherViewHalf, revealedHalf })) {
+    if (v === undefined || v === null || v === "") throw new Error("не задано: " + name);
+  }
+  const sum = halves.combineHalves(BigInt(ownSpendHalf), BigInt(revealedHalf));
+  const sumPub = halves.publicHalves(sum).ed;
+  // Ожидаемый ключ траты собирается ИЗ СВОЕЙ ПОЛОВИНЫ И ЧУЖОЙ ТОЧКИ - то есть из того, что было в ордере.
+  // ПОЛОВИНА ИЗ ФАЙЛА ПРИХОДИТ СТРОКОЙ, И ЭТО НАДО УЧЕСТЬ КАЖДЫЙ РАЗ. Строкой она была и в сумме, и здесь -
+  // здесь забыли, и вывод XMR падал на живом стенде с «invalid field element: expected bigint, got string»
+  // уже ПОСЛЕ чтения раскрытой половины из цепи: до этой строки дело доходило, а дальше нет.
+  const expected = halves.combinePublic(halves.publicHalves(BigInt(ownSpendHalf)).ed, otherSpendPoint);
+  const norm = (h) => String(h).replace(/^0x/i, "").toLowerCase();
+  if (norm(sumPub) !== norm(expected)) {
+    throw new Error(
+      "раскрытая половина не соответствует адресу: (s_a + s_b)*G != ключ траты ордера. " +
+        "Половина из другого ордера или подменена - метать нельзя"
+    );
+  }
+  // Полный ключ ПРОСМОТРА - тоже сумма: своей половины из файла и половины контрагента. Тратить он не даёт,
+  // а без него кошелёк не найдёт наши XMR в цепи: ключи просмотра и траты в Monero независимы.
+  const viewSum = halves.combineHalves(BigInt(ownViewHalf), BigInt(otherViewHalf));
+  // ПОРЯДОК БАЙТ - ЭТО ФОРМАТ, А НЕ КОСМЕТИКА, И ЗДЕСЬ ОН БЫЛ НЕВЕРЕН ДО 28.09.2026.
+  // Прежняя редакция писала скаляр обычной записью числа: старший байт первым. Библиотека ждёт ЗАПИСЬ
+  // MONERO - младшим байтом вперёд, как скаляр лежит в памяти.
+  //
+  // ЗАМЕР 28.09.2026, ОБЕ СБОРКИ monero-ts 0.11.16 (нативная в узле и вендорная в браузере), ОДНИ И ТЕ ЖЕ
+  // ключи: своя же строка (createWalletKeys().getPrivateSpendKey()) принимается КАК ЕСТЬ и публичный ключ
+  // совпадает, а развёрнутая отвергается словами "failed to verify secret spend key". Обе сборки ведут себя
+  // ОДИНАКОВО - значит расхождение было нашим, а не библиотеки: прежняя запись числа давала развёрнутый
+  // порядок, и обе точки входа чинили это обходным путём (страница вывода - reversedKey, инструмент узла -
+  // flip). Обходные пути оставлены КАК СЕТЬ для чужого файла, но срабатывать не должны, и срабатывание
+  // видно в журнале.
+  //
+  // ПРЕФИКСА 0x ЗДЕСЬ НЕТ И БЫТЬ НЕ ДОЛЖНО: библиотека выдаёт ключ 64 hex без префикса и такой принимает,
+  // а вид "0x"+64 hex отвергает на разборе - "failed to parse secret spend key".
+  const be32 = (v) => BigInt(v).toString(16).padStart(64, "0");  // обычная запись числа, старший байт первым
+  const le32 = (v) => be32(v).match(/../g).reverse().join("");   // запись Monero: младший байт первым
+  return { privateSpendKey: le32(sum), privateViewKey: le32(viewSum) };
+}
+
+// ОБРАТНЫЙ ПЕРЕХОД - ТОЖЕ ОДНА ФУНКЦИЯ НА ВСЕХ. Кто читает выданный ключ как ЧИСЛО, обязан развернуть порядок:
+// обычная запись числа (BigInt("0x" + ключ)) прочтёт запись Monero задом наперёд и даст другой скаляр - молча,
+// без всякой ошибки. Ровно на этом мы уже стояли: и проверка, и инструмент пары разбирали ключ напрямую, и
+// после исправления порядка байт оба обязаны были бы покраснеть - если бы их не поправили вместе с модулем.
+export function scalarFromMoneroHex(h) {
+  const hex = String(h).replace(/^0x/i, "");
+  if (!/^[0-9a-f]{64}$/.test(hex)) throw new Error("ключ не в записи Monero: ожидались 64 hex");
+  return BigInt("0x" + hex.match(/../g).reverse().join(""));
+}

package/engine/monero/node.js

@@ -0,0 +1,110 @@
+// GENERATED FILE - a byte-for-byte copy of the engine module www/js/monero/node.js for the SDK package.
+// Edit the source under www/js, then run: node tools/build-sdk-engine.mjs
+// tools/check-sdk-engine.mjs reddens on any drift, so a stale copy cannot ship silently.
+// Everything below this header is identical to the source.
+
+// Живой Monero-нод: единственная реальная внешняя зависимость демки.
+//
+// Адрес ноды - константа MONERO.node в www/js/core/config.js: наш прокси
+// https://xmr.arrakisswap.trade (конфиг .hermes/deploy/arrakis-xmr-rpc.conf).
+// Никаких параметров и переопределений у демки нет: адрес один и виден в коде.
+// Используем ноду для двух честных вещей:
+//   1) статус сети в шапке: реальная высота, nettype, доступность нода;
+//   2) режим "live chain": подтверждения Monero считаются по реальному росту высоты,
+//      а не по таймеру (медленно - блок ~2 минуты, зато по-настоящему).
+//
+// Балансы, outputs и ключи через этот RPC не запрашиваются: для этого нужен кошелёк
+// (wallet2 в WASM + view-ключ), это следующий шаг, а не то, что делает демка.
+
+import { MONERO } from "../core/config.js";
+
+const RPC = MONERO.node;
+const TIMEOUT_MS = 8000;
+const CACHE_MS = 15_000;
+
+let cache = { at: 0, data: null, error: null };
+let inflight = null;
+
+async function rpc(method, params = {}, path = "/json_rpc") {
+  const ctl = new AbortController();
+  const timer = setTimeout(() => ctl.abort(), TIMEOUT_MS);
+  try {
+    const res = await fetch(RPC + path, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ jsonrpc: "2.0", id: "arrakis-demo", method, params }),
+      signal: ctl.signal,
+    });
+    if (!res.ok) throw new Error("HTTP " + res.status);
+    const json = await res.json();
+    if (json.error) throw new Error(json.error.message || "RPC error");
+    return json.result;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export function snapshot() {
+  return cache.data;
+}
+
+export function lastError() {
+  return cache.error;
+}
+
+// Высота сети на момент вызова (из кеша, если он свежий).
+export async function height() {
+  const info = await getInfo();
+  return info ? info.height : null;
+}
+
+export async function getInfo({ force = false } = {}) {
+  const fresh = cache.data && Date.now() - cache.at < CACHE_MS;
+  if (fresh && !force) return cache.data;
+  if (inflight) return inflight;
+
+  inflight = rpc("get_info")
+    .then((info) => {
+      cache = { at: Date.now(), data: normalize(info), error: null };
+      return cache.data;
+    })
+    .catch((e) => {
+      cache = { at: Date.now(), data: null, error: e.message };
+      return null;
+    })
+    .finally(() => {
+      inflight = null;
+    });
+  return inflight;
+}
+
+function normalize(info) {
+  return {
+    height: info.height,
+    nettype: info.nettype || (info.mainnet ? "mainnet" : info.stagenet ? "stagenet" : "testnet"),
+    offline: !!info.offline,
+    busySyncing: !!info.busy_syncing,
+    version: info.version,
+    target: info.target,
+    txPoolSize: info.tx_pool_size,
+    outgoing: info.outgoing_connections_count,
+    incoming: info.incoming_connections_count,
+    databaseSizeGb: info.database_size ? Math.round(info.database_size / 1024 ** 3) : null,
+    fetchedAt: Date.now(),
+  };
+}
+
+// Опрос раз в 30 секунд, пока страница открыта: шапка показывает живую высоту.
+let poller = null;
+export function startPolling(onUpdate, intervalMs = 30_000) {
+  if (poller) clearInterval(poller);
+  const tick = async () => {
+    const info = await getInfo({ force: true });
+    if (onUpdate) onUpdate(info, lastError());
+  };
+  tick();
+  poller = setInterval(tick, intervalMs);
+  return () => clearInterval(poller);
+}
+
+export const nodeUrl = RPC;