teleton 0.8.3 → 0.8.4

package/dist/chunk-FUNF6H4W.js

@@ -1,251 +0,0 @@
-import {
-  COINGECKO_API_URL,
-  tonapiFetch
-} from "./chunk-VFA7QMCZ.js";
-import {
-  fetchWithTimeout
-} from "./chunk-XQUHC3JZ.js";
-import {
-  TELETON_ROOT
-} from "./chunk-EYWNOHMJ.js";
-import {
-  createLogger
-} from "./chunk-NQ6FZKCE.js";
-
-// src/ton/endpoint.ts
-var ENDPOINT_CACHE_TTL_MS = 6e4;
-var ORBS_HOST = "ton.access.orbs.network";
-var ORBS_TOPOLOGY_URL = `https://${ORBS_HOST}/mngr/nodes?npm_version=2.3.3`;
-var TONCENTER_URL = `https://toncenter.com/api/v2/jsonRPC`;
-var _cache = null;
-var _toncenterApiKey;
-function setToncenterApiKey(key) {
-  _toncenterApiKey = key;
-}
-function getToncenterApiKey() {
-  return _toncenterApiKey;
-}
-async function discoverOrbsEndpoint() {
-  const res = await fetch(ORBS_TOPOLOGY_URL, { signal: AbortSignal.timeout(5e3) });
-  const nodes = await res.json();
-  const healthy = nodes.filter(
-    (n) => n.Healthy === "1" && n.Weight > 0 && n.Mngr?.health?.["v2-mainnet"]
-  );
-  if (healthy.length === 0) throw new Error("no healthy orbs nodes");
-  const totalWeight = healthy.reduce((sum, n) => sum + n.Weight, 0);
-  let r = Math.floor(Math.random() * totalWeight);
-  let chosen = healthy[0];
-  for (const node of healthy) {
-    r -= node.Weight;
-    if (r < 0) {
-      chosen = node;
-      break;
-    }
-  }
-  return `https://${ORBS_HOST}/${chosen.NodeId}/1/mainnet/toncenter-api-v2/jsonRPC`;
-}
-async function getCachedHttpEndpoint() {
-  if (_cache && Date.now() - _cache.ts < ENDPOINT_CACHE_TTL_MS) {
-    return _cache.url;
-  }
-  let url;
-  if (_toncenterApiKey) {
-    try {
-      const testUrl = `https://toncenter.com/api/v2/getAddressInformation?address=EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c`;
-      const res = await fetch(testUrl, {
-        headers: { "X-API-Key": _toncenterApiKey },
-        signal: AbortSignal.timeout(5e3)
-      });
-      if (!res.ok) throw new Error(`TonCenter ${res.status}`);
-      url = TONCENTER_URL;
-    } catch {
-      try {
-        url = await discoverOrbsEndpoint();
-      } catch {
-        url = TONCENTER_URL;
-      }
-    }
-  } else {
-    try {
-      url = await discoverOrbsEndpoint();
-    } catch {
-      url = TONCENTER_URL;
-    }
-  }
-  _cache = { url, ts: Date.now() };
-  return url;
-}
-function invalidateEndpointCache() {
-  _cache = null;
-}
-
-// src/ton/wallet-service.ts
-import { mnemonicNew, mnemonicToPrivateKey, mnemonicValidate } from "@ton/crypto";
-import { WalletContractV5R1, TonClient, fromNano } from "@ton/ton";
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
-import { join, dirname } from "path";
-var log = createLogger("TON");
-var WALLET_FILE = join(TELETON_ROOT, "wallet.json");
-var _walletCache;
-var _keyPairCache = null;
-var _tonClientCache = null;
-async function generateWallet() {
-  const mnemonic = await mnemonicNew(24);
-  const keyPair = await mnemonicToPrivateKey(mnemonic);
-  const wallet = WalletContractV5R1.create({
-    workchain: 0,
-    publicKey: keyPair.publicKey
-  });
-  const address = wallet.address.toString({ bounceable: true, testOnly: false });
-  return {
-    version: "w5r1",
-    address,
-    publicKey: keyPair.publicKey.toString("hex"),
-    mnemonic,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-function saveWallet(wallet) {
-  const dir = dirname(WALLET_FILE);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-  writeFileSync(WALLET_FILE, JSON.stringify(wallet, null, 2), { encoding: "utf-8", mode: 384 });
-  _walletCache = void 0;
-  _keyPairCache = null;
-}
-function loadWallet() {
-  if (_walletCache !== void 0) return _walletCache;
-  if (!existsSync(WALLET_FILE)) {
-    _walletCache = null;
-    return null;
-  }
-  try {
-    const content = readFileSync(WALLET_FILE, "utf-8");
-    const parsed = JSON.parse(content);
-    if (!parsed.mnemonic || !Array.isArray(parsed.mnemonic) || parsed.mnemonic.length !== 24) {
-      throw new Error("Invalid wallet.json: mnemonic must be a 24-word array");
-    }
-    _walletCache = parsed;
-    return _walletCache;
-  } catch (error) {
-    log.error({ err: error }, "Failed to load wallet");
-    _walletCache = null;
-    return null;
-  }
-}
-function walletExists() {
-  return existsSync(WALLET_FILE);
-}
-async function importWallet(mnemonic) {
-  const valid = await mnemonicValidate(mnemonic);
-  if (!valid) {
-    throw new Error("Invalid mnemonic: words do not form a valid TON seed phrase");
-  }
-  const keyPair = await mnemonicToPrivateKey(mnemonic);
-  const wallet = WalletContractV5R1.create({
-    workchain: 0,
-    publicKey: keyPair.publicKey
-  });
-  const address = wallet.address.toString({ bounceable: true, testOnly: false });
-  return {
-    version: "w5r1",
-    address,
-    publicKey: keyPair.publicKey.toString("hex"),
-    mnemonic,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-function getWalletAddress() {
-  const wallet = loadWallet();
-  return wallet?.address || null;
-}
-async function getCachedTonClient() {
-  const endpoint = await getCachedHttpEndpoint();
-  if (_tonClientCache && _tonClientCache.endpoint === endpoint) {
-    return _tonClientCache.client;
-  }
-  const apiKey = getToncenterApiKey();
-  const client = new TonClient({ endpoint, ...apiKey && { apiKey } });
-  _tonClientCache = { client, endpoint };
-  return client;
-}
-function invalidateTonClientCache() {
-  _tonClientCache = null;
-  invalidateEndpointCache();
-}
-async function getKeyPair() {
-  if (_keyPairCache) return _keyPairCache;
-  const wallet = loadWallet();
-  if (!wallet) return null;
-  _keyPairCache = await mnemonicToPrivateKey(wallet.mnemonic);
-  return _keyPairCache;
-}
-async function getWalletBalance(address) {
-  try {
-    const client = await getCachedTonClient();
-    const { Address } = await import("@ton/core");
-    const addressObj = Address.parse(address);
-    const balance = await client.getBalance(addressObj);
-    const balanceFormatted = fromNano(balance);
-    return {
-      balance: balanceFormatted,
-      balanceNano: balance.toString()
-    };
-  } catch (error) {
-    log.error({ err: error }, "Failed to get balance");
-    return null;
-  }
-}
-var TON_PRICE_CACHE_TTL_MS = 3e4;
-var _tonPriceCache = null;
-async function getTonPrice() {
-  if (_tonPriceCache && Date.now() - _tonPriceCache.timestamp < TON_PRICE_CACHE_TTL_MS) {
-    return { ..._tonPriceCache };
-  }
-  try {
-    const response = await tonapiFetch(`/rates?tokens=ton&currencies=usd`);
-    if (response.ok) {
-      const data = await response.json();
-      const price = data?.rates?.TON?.prices?.USD;
-      if (typeof price === "number" && price > 0) {
-        _tonPriceCache = { usd: price, source: "TonAPI", timestamp: Date.now() };
-        return _tonPriceCache;
-      }
-    }
-  } catch {
-  }
-  try {
-    const response = await fetchWithTimeout(
-      `${COINGECKO_API_URL}/simple/price?ids=the-open-network&vs_currencies=usd`
-    );
-    if (!response.ok) {
-      throw new Error(`CoinGecko API error: ${response.status}`);
-    }
-    const data = await response.json();
-    const price = data["the-open-network"]?.usd;
-    if (typeof price === "number" && price > 0) {
-      _tonPriceCache = { usd: price, source: "CoinGecko", timestamp: Date.now() };
-      return _tonPriceCache;
-    }
-  } catch (error) {
-    log.error({ err: error }, "Failed to get TON price");
-  }
-  return null;
-}
-
-export {
-  setToncenterApiKey,
-  invalidateEndpointCache,
-  generateWallet,
-  saveWallet,
-  loadWallet,
-  walletExists,
-  importWallet,
-  getWalletAddress,
-  getCachedTonClient,
-  invalidateTonClientCache,
-  getKeyPair,
-  getWalletBalance,
-  getTonPrice
-};