/* global React, PageHeader, useLang, useT, fmtNumber, decodeTonswapLiquidity, TonswapProtocol */ (() => { const { useEffect, useRef, useState } = React; const TONSWAP_SITE = 'https://test.tonswap.org/'; const MANIFEST = TONSWAP_SITE + 'release-manifest.json'; // The published SCCP screen disables transfers in both directions for this release and web build. const SCCP_DISABLED_RELEASE = { id: 'testnet-ovh-20261104-639a09ce4da1', hash: '2e36913c48cb23358b281d2fad70ff816126147be2c9d874e5789d77ad5db5fb', webEntry: 'index-D1RCMYtW.js', }; const INDEXER = 'https://ti.soramitsu.io/api/indexer/v1'; const TON_ACCOUNTS = 'https://testnet.tonapi.io/v2/accounts'; const TON_BLOCKCHAIN = 'https://testnet.tonapi.io/v2/blockchain'; const TON_TRACES = 'https://testnet.tonapi.io/v2/traces/'; const EXPLORER = 'https://testnet.tonscan.org'; // Public address used in the official Tonswap testnet walkthrough. const EXAMPLE_WALLET = '0:3e94dfc963398c6bbbcdb0e640bbc9024dce1ddbb793605e87cdade07184479e'; // Public wallet from the November testnet swap trace. const BALANCE_EXAMPLE = '0:b4872d375a401a48ecccfb1a5d989d92471a5d8b3b46368a88dfdb5979135f94'; const CREATOR_EXAMPLE = '0:4169fa9e547a8e199e70c2bd6de5eca79a0b495365f50ab9e1fb6da7ad7da9c4'; const WATCH_STORAGE = 'sm.tonswap.testnet.watchlist'; const RAW_ADDRESS = /^(?:-1|0):[a-f0-9]{64}$/i; const FRIENDLY_ADDRESS = /^[a-z0-9+/_-]{48}$/i; const SWAP_LIMIT = 50; const CREATOR_PAGE_SIZE = 25; const WALLET_HISTORY_CACHE_MS = 30_000; const WALLET_HISTORY_CACHE_SIZE = 32; const WALLET_CREDIT_CACHE_MS = 5 * 60_000; // SVGs from the official testnet token selector (TokenIcon-DmDoxS8q.js). const TOKEN_ICONS = { GRAM: "data:image/svg+xml,%3csvg%20xmlns='http://www.w3.org/2000/svg'%20width='80'%20height='80'%20fill='none'%20viewBox='0%200%2080%2080'%3e%3crect%20width='80'%20height='80'%20fill='%2330A1F5'%20rx='40'%20/%3e%3crect%20width='79.2'%20height='79.2'%20x='.4'%20y='.4'%20stroke='%23000'%20stroke-opacity='.06'%20stroke-width='.8'%20rx='39.6'%20/%3e%3cpath%20fill='%23fff'%20d='M48.328%2021.4H31.673c-2.218%200-3.327%200-4.33.31a7%207%200%200%200-2.423%201.323c-.804.676-1.404%201.61-2.603%203.475l-5.294%208.236c-.793%201.233-1.19%201.849-1.297%202.498a3.2%203.2%200%200%200%20.183%201.698c.243.61.76%201.13%201.797%202.165L37.38%2060.778c.918.918%201.377%201.377%201.906%201.549.465.151.966.151%201.432%200%20.529-.172.988-.631%201.905-1.549l19.673-19.673c1.037-1.036%201.555-1.554%201.798-2.165a3.2%203.2%200%200%200%20.182-1.698c-.107-.649-.504-1.265-1.296-2.498l-5.294-8.236c-1.2-1.866-1.8-2.799-2.603-3.475a7%207%200%200%200-2.423-1.323c-1.003-.31-2.112-.31-4.33-.31'%20/%3e%3cpath%20fill='%2330A1F5'%20d='M45.173%2027.897c.27-.731%201.304-.731%201.575%200l1.87%205.054c.112.303.352.542.655.655l5.054%201.87c.731.27.731%201.305%200%201.575l-5.054%201.87a1.1%201.1%200%200%200-.655.655l-1.87%205.054c-.27.731-1.305.731-1.575%200l-1.87-5.054a1.1%201.1%200%200%200-.656-.655l-5.053-1.87c-.732-.27-.732-1.305%200-1.575l5.053-1.87c.304-.113.543-.352.656-.655z'%20/%3e%3c/svg%3e", T3: "data:image/svg+xml,%3csvg%20width='48'%20height='48'%20viewBox='0%200%2048%2048'%20fill='none'%20xmlns='http://www.w3.org/2000/svg'%3e%3ccircle%20cx='24'%20cy='24'%20r='24'%20fill='%232458EB'/%3e%3cpath%20d='M10.5%2016.5H25M17.75%2016.5V33'%20stroke='white'%20stroke-width='4.2'%20stroke-linecap='round'%20stroke-linejoin='round'/%3e%3cpath%20d='M29.5%2016.5H38.5L33.4%2022.6C36.6%2022.6%2039%2024.7%2039%2027.8C39%2031%2036.4%2033.5%2033%2033.5C31%2033.5%2029.4%2032.8%2028.2%2031.6'%20stroke='white'%20stroke-width='4.2'%20stroke-linecap='round'%20stroke-linejoin='round'/%3e%3c/svg%3e", TS: "data:image/svg+xml,%3csvg%20width='48'%20height='48'%20viewBox='0%200%2048%2048'%20fill='none'%20xmlns='http://www.w3.org/2000/svg'%3e%3cpath%20d='M1.09669e-06%2024C5.17322e-07%2037.2545%2010.7449%2048%2023.9994%2048C37.2538%2048%2048%2037.2558%2048%2024C48%2010.7442%2037.2551%20-4.69673e-07%2024.0006%20-1.04904e-06C10.7462%20-1.62842e-06%201.67607e-06%2010.7455%201.09669e-06%2024Z'%20fill='%230098EA'/%3e%3cpath%20d='M32.0124%2013.9779C32.0124%2013.9779%2015.1708%2010.9095%2011.354%2012.0268C7.53725%2013.1447%205.30214%2017.396%206.38027%2021.4842C7.4584%2025.5725%2011.4561%2027.9994%2015.2723%2026.8808C19.089%2025.7629%2032.0124%2013.9779%2032.0124%2013.9779ZM15.823%2033.3699C15.823%2033.3699%2032.5657%2037.0331%2036.416%2036.051C40.2651%2035.0702%2042.6321%2030.9008%2041.6806%2026.7775C40.7292%2022.6548%2036.8084%2020.0888%2032.9586%2021.0709C29.1089%2022.0517%2015.8236%2033.3693%2015.8236%2033.3693L15.823%2033.3699Z'%20fill='white'/%3e%3c/svg%3e", USDT: "data:image/svg+xml,%3c?xml%20version='1.0'%20encoding='UTF-8'?%3e%3csvg%20id='Layer_2'%20data-name='Layer%202'%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20800%20800'%3e%3cdefs%3e%3cstyle%3e%20.cls-1%20{%20fill:%20%23009393;%20}%20.cls-1,%20.cls-2%20{%20stroke-width:%200px;%20}%20.cls-2%20{%20fill:%20%23fff;%20fill-rule:%20evenodd;%20}%20%3c/style%3e%3c/defs%3e%3cg%20id='Layer_1-2'%20data-name='Layer%201'%3e%3cg%3e%3ccircle%20class='cls-1'%20cx='400'%20cy='400'%20r='400'/%3e%3cpath%20class='cls-2'%20d='M400.49,428.59c68.79,0,126.28-11.63,140.33-27.17-11.93-13.18-55.08-23.56-109.88-26.4v32.83c-9.81.51-20.01.76-30.46.76s-20.65-.25-30.48-.76v-32.83c-54.78,2.84-97.95,13.22-109.88,26.4,14.07,15.54,71.57,27.17,140.36,27.17ZM522.71,274.06v45.21h-91.77v31.35c64.46,3.35,112.83,17.13,113.19,33.62v34.38c-.36,16.49-48.73,30.24-113.19,33.6v76.94h-60.93v-76.94c-64.46-3.35-112.81-17.11-113.17-33.6v-34.38c.36-16.49,48.71-30.27,113.17-33.62v-31.35h-91.77v-45.21h244.48ZM242.15,202.11h322.16c7.7,0,14.79,4.05,18.63,10.63l93.85,161.16c4.86,8.36,3.42,18.91-3.52,25.68l-258.34,252.18c-8.38,8.17-21.84,8.17-30.2,0L126.71,399.92c-7.09-6.94-8.43-17.79-3.2-26.19l100.33-161.49c3.91-6.28,10.85-10.12,18.32-10.12Z'/%3e%3c/g%3e%3c/g%3e%3c/svg%3e", USDC: "data:image/svg+xml,%3csvg%20width='96'%20height='96'%20viewBox='0%200%2096%2096'%20fill='none'%20xmlns='http://www.w3.org/2000/svg'%3e%3cpath%20d='M48%2095C73.9574%2095%2095%2073.9574%2095%2048C95%2022.0426%2073.9574%201%2048%201C22.0426%201%201%2022.0426%201%2048C1%2073.9574%2022.0426%2095%2048%2095Z'%20fill='%230B53BF'/%3e%3cpath%20d='M56.4609%2013.7778V19.8291C68.5341%2023.4716%2077.3759%2034.6928%2077.3759%2047.9997C77.3759%2061.3066%2068.5341%2072.5278%2056.4609%2076.1703V82.2216C71.8534%2078.4616%2083.2509%2064.5672%2083.2509%2047.9997C83.2509%2031.4322%2071.8534%2017.5378%2056.4609%2013.7778Z'%20fill='white'/%3e%3cpath%20d='M18.625%2047.9997C18.625%2034.6928%2027.4669%2023.4716%2039.54%2019.8291V13.7778C24.1475%2017.5378%2012.75%2031.4322%2012.75%2047.9997C12.75%2064.5672%2024.1475%2078.4616%2039.54%2082.2216V76.1703C27.4669%2072.5572%2018.625%2061.3066%2018.625%2047.9997Z'%20fill='white'/%3e%3cpath%20d='M60.6319%2054.5506C60.6319%2042.5362%2041.8025%2047.4713%2041.8025%2040.8325C41.8025%2038.4531%2043.7119%2036.9256%2047.3544%2036.9256C51.7019%2036.9256%2053.2%2039.0406%2053.67%2041.89H59.6625C59.1279%2036.5426%2056.0588%2033.1662%2050.9382%2032.1604V27.4375H45.0632V31.9918C39.4534%2032.7062%2035.9275%2035.973%2035.9275%2040.8325C35.9275%2052.9056%2054.7863%2048.3819%2054.7863%2054.9031C54.7863%2057.3706%2052.4069%2059.0156%2048.3825%2059.0156C43.1244%2059.0156%2041.3913%2056.695%2040.745%2053.4931H34.8994C35.2781%2059.3502%2038.8897%2063.0159%2045.0632%2063.9307V68.5625H50.9382V63.9923C56.9633%2063.2139%2060.6319%2059.7089%2060.6319%2054.5506Z'%20fill='white'/%3e%3c/svg%3e", }; const PROTOCOL_CONTRACTS = { perps: ['PerpsEngine', '2d3904daaf43529a87f9594d753641ffff880f1c75ce11d8505576d326883069'], launchpad: ['SaleFactory', 'ca26175c1c8b216b8b8dc1e7c12dce20a5d72978c3a867716ebb9db0dc169844'], t3: ['T3Hub', 'b2fb1bebba68bfd5444424f914f22e2a4d6ac0cf0a69c1803106ea25ef0b67cb'], options: ['OptionVault', '2db5e0199689f4561850c048a523fc526b28a615869de3ec64c8977cdbf53a77'], orders: ['SpotOrderFactory', '42ba761d87b32874205d59bee2ab4603cbb899e19b2a26efb2eb4601d90dec11'], }; const SPOT_ORDER_HASH = '48973db561a87f955d55a1e1b20ddc2a52148e9aad7f3bf3e2478761b7b6e442'; const OPTION_FACTORY_HASH = 'a62a03a709068f957ec7657056e52dc5cb0cf4bba8cc9b315d152bc07377b162'; const FAUCET_HASH = 'df7838b72e21688cff6cbbcb3376f0cce0a71878adb6d990cc6796b7a884b6c5'; async function readResponse(url, signal, body) { const options = body === undefined ? {} : { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body), }; const response = await fetch(url, { ...options, credentials: 'omit', signal: AbortSignal.any([signal, AbortSignal.timeout(15000)]), }); if (!response.ok) throw Object.assign(new Error('Tonswap request failed'), { status: response.status }); return response; } async function readJson(url, signal, body) { return (await readResponse(url, signal, body)).json(); } function releaseTokens(manifest) { if (manifest.schema !== 'tonswap-release-v1' || manifest.network !== 'ton:testnet' || manifest.globalId !== -3 || !Array.isArray(manifest.tokens)) { throw new Error('Unexpected Tonswap release manifest'); } return manifest.tokens; } const validDecimals = value => Number.isInteger(value) && value >= 0 && value <= 30; function marketCatalog(manifest) { const tokens = new Map(releaseTokens(manifest).map(token => [token.symbol, token.decimals])); if (!Array.isArray(manifest.spotMarkets)) throw new Error('Unexpected Tonswap markets'); if (!validDecimals(tokens.get('T3'))) throw new Error('T3 precision is unavailable'); const treasury = manifest.contracts?.Treasury?.address; return manifest.spotMarkets.map(({ symbol, pool, xDecimals, feePips }) => { if (!RAW_ADDRESS.test(pool) || !/^[A-Z0-9]{1,12}$/.test(symbol) || !validDecimals(xDecimals) || tokens.get(symbol) !== xDecimals || !Number.isInteger(feePips) || feePips < 0 || feePips > 1_000_000) { throw new Error('Unexpected Tonswap market configuration'); } return { symbol, pool, xDecimals, t3Decimals: tokens.get('T3'), feePips, treasury }; }); } function poolReserves({ exit_code, stack }) { // Current DLMM get_pool_info returns 14 items, with reserveT and reserveX at 8 and 9. const value = item => item?.[0] === 'num' && typeof item[1] === 'string' && /^\d+$/.test(item[1]); if (exit_code !== 0 || stack?.length !== 14 || stack[0]?.[0] !== 'cell' || !value(stack[8]) || !value(stack[9])) { throw new Error('Unexpected DLMM reserve response'); } return { t3: BigInt(stack[8][1]), asset: BigInt(stack[9][1]) }; } function formatTokenAmount(raw, decimals, locale) { const digits = String(raw).padStart(decimals + 1, '0'); const split = digits.length - decimals; const whole = BigInt(digits.slice(0, split)); const fraction = digits.slice(split).replace(/0+$/, ''); const format = new Intl.NumberFormat(locale); const decimalMark = format.formatToParts(1.1).find(part => part.type === 'decimal').value; const digitFormat = new Intl.NumberFormat(locale, { useGrouping: false }); return format.format(whole) + (fraction ? decimalMark + fraction.replace(/\d/g, digit => digitFormat.format(digit)) : ''); } function transactionHash(hash) { if (typeof hash !== 'string') return null; if (/^[a-f0-9]{64}$/i.test(hash)) return hash.toLowerCase(); if (!/^[a-z0-9+/_-]{43}=?$/i.test(hash)) return null; const bytes = atob(hash.replace(/-/g, '+').replace(/_/g, '/')); return Array.from(bytes, byte => byte.charCodeAt(0).toString(16).padStart(2, '0')).join(''); } function TonTokenIcon({ symbol = '?', showLogo = true }) { const icon = showLogo && Object.hasOwn(TOKEN_ICONS, symbol) ? TOKEN_ICONS[symbol] : null; return ; } function PoolCard({ market, reserves, onActivity }) { const { t, locale } = useLang(); const funded = reserves && (reserves.asset > 0n || reserves.t3 > 0n); const state = reserves ? (funded ? 'liquid' : 'noLiquidity') : 'unavailable'; const percent = fmtNumber(market.feePips / 1_000_000, locale, { style: 'percent', maximumFractionDigits: 4 }); return (

{market.symbol} / T3

{t('tonswap.' + state)}

{t('tonswap.reserves')}

{market.symbol}
{reserves ? formatTokenAmount(reserves.asset, market.xDecimals, locale) : '—'}
T3
{reserves ? formatTokenAmount(reserves.t3, market.t3Decimals, locale) : '—'}
); } function TonAddressLink({ address, label }) { return ( {label && {label}} {address.slice(0, 8)}…{address.slice(-4)} ); } function ActivityRow({ row, market, dateFormat }) { const { t, locale } = useLang(); const action = { 1: 'deposit', 2: 'withdrawal', 3: 'eviction' }[row.kind]; const date = new Date(row.utime * 1000); return (
  • {t('tonswap.activity.' + action)}
    {row.asset !== 0n && {formatTokenAmount(row.asset, market.xDecimals, locale)} {market.symbol}} {row.t3 !== 0n && {formatTokenAmount(row.t3, market.t3Decimals, locale)} T3} {row.asset === 0n && row.t3 === 0n && —}
    {row.payer && row.payer !== row.owner && ( {t('tonswap.activity.payer')} )}
    {t('tonswap.viewTx')}
    • ); } function PoolActivity({ market, onClose }) { const { t, locale } = useLang(); const dialog = useRef(null); const [request, setRequest] = useState({ cursor: null }); const [data, setData] = useState({ rows: [], loading: true }); const dateFormat = new Intl.DateTimeFormat(locale, { dateStyle: 'medium', timeStyle: 'short' }); useEffect(() => { const element = dialog.current; element.showModal(); return () => element.close(); }, []); useEffect(() => { const controller = new AbortController(); const { signal } = controller; const anchor = request.cursor; const query = new URLSearchParams(anchor ? { cursor_lt: anchor.lt, cursor_hash: anchor.hash } : { page: '1' }); const url = INDEXER + '/accounts/' + encodeURIComponent(market.pool) + '/txs?' + query; async function load() { try { const page = await readJson(url, signal); if (page.network !== 'testnet' || !Array.isArray(page.txs) || !Number.isInteger(page.page_size) || page.page_size < 1) { throw new Error('Unexpected Tonswap account history'); } const decoded = decodeTonswapLiquidity(page.txs); const rows = decoded.rows.map(row => ({ ...row, hash: transactionHash(row.hash) })) .filter(row => row.hash && Number.isSafeInteger(row.utime) && row.utime > 0 && row.utime < 253402300800); const last = page.txs.at(-1); const more = page.txs.length >= page.page_size && (anchor || (page.total_pages ?? page.total_pages_min) > 1 || page.history_complete !== true); const next = more && typeof last?.lt === 'string' && /^\d+$/.test(last.lt) && transactionHash(last.hash) && (!anchor || last.lt !== anchor.lt) ? { lt: last.lt, hash: last.hash } : null; const incomplete = decoded.incomplete || rows.length !== decoded.rows.length || page.history_complete !== true || (more && !next); if (signal.aborted) return; setData(previous => { // Soramitsu's cursor includes the boundary transaction. const all = anchor ? previous.rows.concat(rows) : rows; const unique = new Map(all.map(row => [row.hash + ':' + row.key, row])); return { rows: [...unique.values()], next, incomplete: incomplete || Boolean(anchor && previous.incomplete) }; }); } catch { if (!signal.aborted) setData(previous => ({ ...previous, loading: false, error: true })); } } load(); return () => controller.abort(); }, [market.pool, request]); function loadPage(cursor) { setData(previous => ({ ...previous, loading: true, error: false })); setRequest({ cursor }); } function close() { dialog.current.close(); onClose(); } return ( { event.preventDefault(); close(); }} onClick={event => { if (event.target === event.currentTarget) close(); }}>

    {t('tonswap.activity.title')} · {market.symbol} / T3

    {t('tonswap.testnet')}
    {data.loading &&

    {t('pool.activity.loading')}

    } {data.error &&

    {t('tonswap.activity.error')}

    } {!data.loading && data.incomplete &&

    {t('tonswap.activity.incomplete')}

    } {!data.loading && !data.error && !data.rows.length && (

    {t(data.incomplete || data.next ? 'tonswap.activity.emptyPage' : 'tonswap.activity.empty')}

    )} {data.rows.length > 0 && (
      {data.rows.map(row => )}
    )} {data.rows.some(row => row.kind !== 1) &&

    {t('tonswap.activity.withdrawalNote')}

    } {data.next && !data.error && ( )}
    ); } function TonswapPools() { const { t, locale } = useLang(); const [revision, setRevision] = useState(0); const [data, setData] = useState({ loading: true, rows: [] }); const [activeMarket, setActiveMarket] = useState(null); useEffect(() => { const controller = new AbortController(); const { signal } = controller; async function load() { try { const markets = marketCatalog(await readJson(MANIFEST, signal)); const responses = await Promise.allSettled(markets.map(async market => poolReserves( await readJson(INDEXER + '/runGetMethod', signal, { address: market.pool, method: 'get_pool_info', stack: [] }), ))); if (signal.aborted) return; const rows = markets.map((market, index) => { const response = responses[index]; return { market, reserves: response.status === 'fulfilled' ? response.value : null }; }); setData({ rows, checkedAt: Date.now() }); } catch { if (!signal.aborted) setData({ error: true, rows: [] }); } } load(); return () => controller.abort(); }, [revision]); function refresh() { setData(current => ({ ...current, loading: true, error: false })); setRevision(current => current + 1); } return (

    {t('tonswap.poolHeading')}

    {t('tonswap.poolDescription')}

    {data.checkedAt && {t('tonswap.updated').replace('{time}', new Intl.DateTimeFormat(locale, { timeStyle: 'short' }).format(data.checkedAt))}}
    {data.loading &&

    {t('tonswap.loadingPools')}

    } {data.error &&

    {t('tonswap.poolError')}

    } {!data.loading && !data.error && !data.rows.length &&

    {t('tonswap.noPools')}

    }
    {data.rows.map(({ market, reserves }) => ( setActiveMarket(market)}/> ))}
    {activeMarket && setActiveMarket(null)}/>} {!data.loading && data.rows.some(row => !row.reserves) &&

    {t('tonswap.poolPartial')}

    }
    ); } function WalletHistory({ history }) { const { t, locale } = useLang(); const statusTags = { success: 'ok', failed: 'err', pending: 'warn' }; const dateFormat = new Intl.DateTimeFormat(locale, { dateStyle: 'medium', timeStyle: 'short' }); return ( <> {!history.history_complete &&

    {t('tonswap.coverage')}

    } {history.swaps.length === 0 ?

    {t('tonswap.noSwaps')}

    : (
    {t('tonswap.swapCount').replace('{shown}', fmtNumber(history.swaps.length, locale)).replace('{total}', fmtNumber(history.total_swaps, locale))}
      {history.swaps.map(swap => { const hash = transactionHash(swap.hash); const timestamp = Number(swap.utime) * 1000; const date = new Date(timestamp); const validDate = timestamp > 0 && Number.isFinite(date.getTime()); const status = Object.hasOwn(statusTags, swap.status) ? swap.status : null; return (
    1. {swap.payToken || '—'} {swap.receiveToken || '—'} {t(status ? 'tonswap.' + status : 'tonswap.unavailable')} {hash && {t('tonswap.viewTx')} }
      2. ); })}
    )} ); } function TonswapWallet() { const t = useT(); const [address, setAddress] = useState(''); const [result, setResult] = useState({}); const request = useRef(null); useEffect(() => () => request.current?.abort(), []); async function lookup(value) { request.current?.abort(); const wallet = value.trim(); if (!RAW_ADDRESS.test(wallet) && !FRIENDLY_ADDRESS.test(wallet)) { setResult({ error: 'tonswap.invalidAddress' }); return; } const controller = new AbortController(); request.current = controller; setResult({ loading: true }); try { const data = await readJson(INDEXER + '/accounts/' + encodeURIComponent(wallet) + '/swaps?limit=' + SWAP_LIMIT, controller.signal); if (data.network !== 'testnet' || !Array.isArray(data.swaps) || !Number.isInteger(data.total_swaps)) { throw new Error('Unexpected wallet swap history'); } if (!controller.signal.aborted) setResult({ history: data }); } catch (error) { if (!controller.signal.aborted) setResult({ error: error.status === 400 ? 'tonswap.invalidAddress' : 'tonswap.walletError' }); } } return (

    {t('tonswap.walletSwaps')}

    {t('tonswap.walletHint')}

    { event.preventDefault(); lookup(address); }}>
    setAddress(event.target.value)} maxLength={96} placeholder="0:… / kQ…" spellCheck={false} autoComplete="off" autoCapitalize="off" aria-invalid={result.error === 'tonswap.invalidAddress' || undefined} aria-describedby={result.error ? 'tonswap-wallet-error' : undefined}/>
    {result.error && }

    {t('tonswap.walletScope')}

    {result.loading &&

    {t('tonswap.loadingSwaps')}

    } {result.history && }
    ); } function canonicalTonAddress(value) { const address = value.trim(); if (RAW_ADDRESS.test(address)) return address.toLowerCase(); if (!FRIENDLY_ADDRESS.test(address)) return null; const bytes = Uint8Array.from(atob(address.replace(/-/g, '+').replace(/_/g, '/')), char => char.charCodeAt(0)); const tag = bytes[0] & 0x7f; if (bytes.length !== 36 || (tag !== 0x11 && tag !== 0x51) || (bytes[1] !== 0 && bytes[1] !== 255)) return null; let checksum = 0; for (const byte of bytes.subarray(0, 34)) { checksum ^= byte << 8; for (let bit = 0; bit < 8; bit++) checksum = ((checksum << 1) ^ ((checksum & 0x8000) ? 0x1021 : 0)) & 0xffff; } if (checksum !== (bytes[34] << 8 | bytes[35])) return null; const hash = Array.from(bytes.subarray(2, 34), byte => byte.toString(16).padStart(2, '0')).join(''); return (bytes[1] === 0 ? '0:' : '-1:') + hash; } function watchedWallets() { try { const items = JSON.parse(localStorage.getItem(WATCH_STORAGE)); if (Array.isArray(items)) return items.filter(item => item && RAW_ADDRESS.test(item.address) && typeof item.label === 'string'); } catch {} return []; } async function readTonPortfolio(address, signal) { const url = TON_ACCOUNTS + '/' + encodeURIComponent(address); const [account, assets, manifest] = await Promise.allSettled([ readJson(url, signal), readJson(url + '/jettons', signal), readJson(MANIFEST, signal).then(releaseTokens), ]); const native = account.status === 'fulfilled' && account.value?.address === address && Number.isSafeInteger(account.value.balance) && account.value.balance >= 0 ? BigInt(account.value.balance) : null; if (assets.status !== 'fulfilled' || !Array.isArray(assets.value?.balances) || manifest.status !== 'fulfilled') { return { native, holdings: null, incomplete: true }; } const current = new Map(manifest.value.filter(token => RAW_ADDRESS.test(token?.root)) .map(token => [token.root.toLowerCase(), token])); const holdings = new Map(); let incomplete = native === null; for (const entry of assets.value.balances) { const address = entry?.jetton?.address; const raw = entry?.balance; if (typeof address !== 'string' || !RAW_ADDRESS.test(address) || typeof raw !== 'string' || !/^\d{1,78}$/.test(raw)) { incomplete = true; continue; } const amount = BigInt(raw); if (amount === 0n) continue; const root = address.toLowerCase(); const official = current.get(root); const metadata = official || entry.jetton; const symbol = typeof metadata.symbol === 'string' ? metadata.symbol.trim().slice(0, 24) : ''; const decimals = validDecimals(metadata.decimals) ? metadata.decimals : null; incomplete ||= decimals === null; holdings.set(root, { root, symbol: symbol || 'Jetton', amount, decimals, current: Boolean(official) }); } const rows = [...holdings.values()].sort((left, right) => Number(right.current) - Number(left.current)); return { native, holdings: rows, incomplete }; } function TonWatchlist({ entries, active, onOpen }) { const t = useT(); return ( ); } function TonPortfolioBalances({ result, onRefresh }) { const { t, locale } = useLang(); const assets = [{ symbol: 'GRAM', amount: result.native, decimals: 9 }, ...(result.holdings || [])]; return ( <>

    {t('tonswap.portfolio.assets')}

    {assets.map(asset => ( ))}
    {t('tonswap.portfolio.asset')} {t('s.balance')}
    {asset.symbol} {asset.current && {t('tonswap.portfolio.current')}}
    {asset.root ? : {t('tonswap.portfolio.native')}}
    		{asset.amount === null || asset.decimals === null ? '—' : formatTokenAmount(asset.amount, asset.decimals, locale)}
    {result.holdings === null &&

    {t('tonswap.portfolio.noTokenData')}

    } {result.holdings?.length === 0 &&

    {t('tonswap.portfolio.noTokens')}

    } ); } function TonWalletPanels({ result, cache, onRefresh }) { const t = useT(); const [pane, setPane] = useState('assets'); const [activityOpened, setActivityOpened] = useState(false); const panes = ['assets', 'activity']; function selectPane(next) { setPane(next); if (next === 'activity') setActivityOpened(true); } function handleTabKey(event) { const index = panes.indexOf(pane); const move = { ArrowLeft: 1 - index, ArrowRight: 1 - index, Home: 0, End: panes.length - 1 }; const next = move[event.key]; if (!Number.isInteger(next)) return; event.preventDefault(); event.currentTarget.querySelectorAll('[role="tab"]')[next].focus(); selectPane(panes[next]); } return ( <>
    {panes.map(id => ( ))}
    ); } function TonswapPortfolio() { const t = useT(); const [address, setAddress] = useState(''); const [alias, setAlias] = useState(''); const [watchlist, setWatchlist] = useState(watchedWallets); const [saveError, setSaveError] = useState(false); const [result, setResult] = useState({}); const request = useRef(null); const historyCache = useRef(new Map()); const watched = watchlist.find(entry => entry.address === result.address); useEffect(() => { const sync = event => { if (event.key === WATCH_STORAGE || event.key === null) setWatchlist(watchedWallets()); }; window.addEventListener('storage', sync); return () => { window.removeEventListener('storage', sync); request.current?.abort(); }; }, []); async function lookup(value) { request.current?.abort(); setAlias(''); setSaveError(false); const wallet = canonicalTonAddress(value); if (!wallet) { setResult({ invalid: true }); return; } const controller = new AbortController(); request.current = controller; setResult({ address: wallet, loading: true }); try { const balances = await readTonPortfolio(wallet, controller.signal); if (!controller.signal.aborted) setResult({ address: wallet, balances }); } catch { if (!controller.signal.aborted) setResult({ address: wallet, balances: { native: null, holdings: null, incomplete: true } }); } } function openWallet(wallet) { setAddress(wallet); lookup(wallet); } function toggleFollow() { const items = watchedWallets(); const next = items.some(item => item.address === result.address) ? items.filter(item => item.address !== result.address) : [...items, { address: result.address, label: alias.trim() }]; try { localStorage.setItem(WATCH_STORAGE, JSON.stringify(next)); setWatchlist(next); setSaveError(false); } catch { setSaveError(true); } } return (

    {t('tonswap.portfolio.title')}

    {t('tonswap.portfolio.hint')}

    { event.preventDefault(); lookup(address); }}>
    setAddress(event.target.value)} maxLength={96} placeholder="0:… / kQ…" spellCheck={false} autoComplete="off" autoCapitalize="off" aria-invalid={result.invalid || undefined} aria-describedby={result.invalid ? 'tonswap-portfolio-invalid' : undefined}/>
    {result.invalid && }
    {result.address && (

    {watched?.label || t('tonswap.portfolio.addressTitle')}

    {!watched && }
    {saveError &&

    {t('tonswap.portfolio.saveError')}

    }
    lookup(result.address)}/>
    )}
    ); } async function readT3Summary(release, signal) { const getter = method => readJson(INDEXER + '/runGetMethod', signal, { address: release.address, method, stack: [] }); const [economy, ledger] = await Promise.all([getter('get_hub_state'), getter('get_jetton_ledger')]); const { amounts, supply } = TonswapProtocol.t3Backing(economy); const roots = TonswapProtocol.t3ReserveMasters(ledger); const reserves = amounts.map((amount, slot) => { const token = release.tokens.find(item => canonicalTonAddress(item.root) === roots[slot]); if (token && /^[A-Z0-9]{1,12}$/.test(token.symbol) && validDecimals(token.decimals)) { return { symbol: token.symbol, decimals: token.decimals, amount }; } if (amount > 0n) throw new Error('Unknown T3 reserve'); return null; }); if (!['USDT', 'USDC'].every(symbol => reserves.some(token => token?.symbol === symbol))) { throw new Error('Missing T3 reserve metadata'); } return { reserves, supply }; } async function readTonAccountPage(address, cursor, signal, limit = 50) { const query = new URLSearchParams({ limit: String(limit) }); if (cursor) query.set('before_lt', String(cursor.lt)); const url = TON_BLOCKCHAIN + '/accounts/' + encodeURIComponent(address) + '/transactions?' + query; const { transactions } = await readJson(url, signal); if (!Array.isArray(transactions) || transactions.some(tx => tx?.account?.address !== address)) { throw new Error('Unexpected TON history'); } let previous = cursor?.previous; let incomplete = transactions.length === 0; for (const [index, tx] of transactions.entries()) { if (index > 0 && !previous) incomplete = true; if (previous && (previous.lt !== tx.lt || previous.hash !== transactionHash(tx.hash))) incomplete = true; const hash = transactionHash(tx.prev_trans_hash); previous = hash && Number.isSafeInteger(tx.prev_trans_lt) && tx.prev_trans_lt > 0 && tx.prev_trans_lt < tx.lt ? { lt: tx.prev_trans_lt, hash } : null; } const last = transactions.at(-1); const next = previous && Number.isSafeInteger(last.lt) && (!cursor || last.lt < cursor.lt) ? { lt: last.lt, previous } : null; const reachedDeployment = last?.orig_status === 'nonexist' && !last.prev_trans_lt; return { transactions, next, incomplete: incomplete || (!next && !reachedDeployment) }; } function walletActivitySources(manifest) { const pools = marketCatalog(manifest).map(market => ({ address: market.pool.toLowerCase(), market, rows: [], })); const faucet = manifest.contracts?.TestnetFaucet; const tokens = new Map(releaseTokens(manifest) .filter(token => RAW_ADDRESS.test(token?.root) && validDecimals(token.decimals)) .map(token => [token.symbol, token.decimals])); return [...pools, { address: faucet?.codeHash === FAUCET_HASH && RAW_ADDRESS.test(faucet.address) ? faucet.address.toLowerCase() : null, tokens, rows: [], }]; } async function readWalletHistoryData(cache, key, fresh, signal, read, maxAge = WALLET_HISTORY_CACHE_MS) { const entry = cache.get(key); if (!fresh && entry?.expiresAt > Date.now()) return entry.value; let value; try { value = await read(); } catch (error) { if (error.status !== 429 || signal.aborted) throw error; const wait = AbortSignal.any([signal, AbortSignal.timeout(4500)]); await new Promise(resolve => wait.addEventListener('abort', resolve, { once: true })); signal.throwIfAborted(); value = await read(); } if (!signal.aborted && value && !value.incomplete) { cache.delete(key); if (cache.size >= WALLET_HISTORY_CACHE_SIZE) cache.delete(cache.keys().next().value); cache.set(key, { value, expiresAt: Date.now() + maxAge }); } return value; } async function readWalletActivity(source, wallet, cache, fresh, signal) { if (!source.address) throw new Error('Unsupported wallet activity source'); const key = 'page:' + source.address + ':' + (source.next ? source.next.lt + ':' + source.next.previous.hash : 'head'); // The same contract pages serve every wallet. Refresh still checks the chain head. const { transactions, next, incomplete } = await readWalletHistoryData(cache, key, fresh, signal, () => readTonAccountPage(source.address, source.next, signal)); let rows; let partial = incomplete; if (source.market) { const decoded = TonswapProtocol.walletPoolEvents(transactions, source.address, wallet, decodeTonswapLiquidity); rows = decoded.rows.map(row => ({ ...row, market: source.market })); partial ||= decoded.incomplete; } else { rows = []; for (const tx of transactions) { if (signal.aborted) break; try { const grant = TonswapProtocol.faucetGrant(tx, source.address, wallet); if (!grant) continue; const hash = transactionHash(grant.claimHash); const decimals = source.tokens.get(grant.symbol); if (!hash || !validDecimals(decimals)) throw new Error('Unknown faucet token'); const credit = await readWalletHistoryData(cache, 'credit:' + wallet + ':' + hash, false, signal, async () => { const trace = await readJson(TON_TRACES + hash, signal); return TonswapProtocol.faucetCredit(trace, grant, source.address, wallet); }, WALLET_CREDIT_CACHE_MS); if (credit) rows.push({ ...credit, decimals }); } catch { partial = true; } } } const merged = new Map(source.rows.map(row => [row.hash + ':' + row.index, row])); for (const row of rows) { const hash = transactionHash(row.hash); if (!hash || !validTonTime(row.utime)) { partial = true; continue; } merged.set(hash + ':' + row.index, { ...row, hash }); } return { ...source, rows: [...merged.values()], next, incomplete: source.incomplete || partial, failed: false }; } function useWalletActivity(wallet, cache) { const [request, setRequest] = useState({ sources: null }); const [data, setData] = useState({ loading: true, sources: [] }); useEffect(() => { const controller = new AbortController(); const { signal } = controller; async function load() { try { const sources = request.sources || walletActivitySources(await readJson(MANIFEST, signal)); const results = await Promise.allSettled(sources.map(source => !request.sources || source.next || source.failed ? readWalletActivity(source, wallet, cache, request.fresh, signal) : source)); if (!signal.aborted) setData({ sources: results.map((result, i) => result.status === 'fulfilled' ? result.value : { ...sources[i], failed: true }), }); } catch { if (!signal.aborted) setData(previous => ({ ...previous, loading: false, error: true })); } } load(); return () => controller.abort(); }, [wallet, cache, request]); function read(sources = null, fresh = false) { setData(previous => ({ ...previous, loading: true, error: false, sources: sources || [] })); setRequest({ sources, fresh }); } const refresh = () => read(null, true); const error = data.error || (data.sources.length > 0 && data.sources.every(source => source.failed)); return { ...data, refresh, retry: refresh, loadMore: () => read(data.sources), error, incomplete: !error && data.sources.some(source => source.incomplete || source.failed), next: data.sources.some(source => source.next), }; } function TonWalletHistoryAmount({ symbol, amount, decimals, credit }) { const { locale } = useLang(); return {credit && '+'}{formatTokenAmount(amount, decimals, locale)}{' '} {symbol} ; } function TonWalletHistoryTable({ rows, wallet }) { const { t, locale } = useLang(); const dateFormat = new Intl.DateTimeFormat(locale, { dateStyle: 'medium' }); const timeFormat = new Intl.DateTimeFormat(locale, { timeStyle: 'short' }); return ( {rows.map(row => { const date = new Date(row.utime * 1000); const { market } = row; const amount = (side, raw) => ; const isOwner = row.owner === wallet; const counterparty = row.payer && row.owner !== row.payer ? (isOwner ? row.payer : row.owner) : null; return ( ); })}
    {t('s.date')} {t('s.detail2')}
    {t('tonswap.walletHistory.action.' + row.kind)}
    {row.kind === 'swap' ? <> {amount(row.side, row.amountIn)} → {amount(1 - row.side, row.amountOut)} : market ? <> {row.t3 > 0n && amount(0, row.t3)} {row.asset > 0n && amount(1, row.asset)} {market.symbol} / T3 : }
    {counterparty &&
    {t(isOwner ? 'tonswap.activity.payer' : 'tonswap.activity.owner')}
    }
    ); } function TonWalletHistory({ wallet, cache }) { const t = useT(); const history = useWalletActivity(wallet, cache); const [filter, setFilter] = useState('all'); const rows = history.sources.flatMap(source => source.rows) .sort((a, b) => b.utime - a.utime || a.hash.localeCompare(b.hash)); const categories = { all: rows, swap: rows.filter(row => row.kind === 'swap'), liquidity: rows.filter(row => row.market && row.kind !== 'swap'), faucet: rows.filter(row => row.kind === 'faucet'), }; const grants = new Map(); if (filter === 'faucet') { for (const row of categories.faucet) { grants.set(row.symbol, { ...row, amount: row.amount + (grants.get(row.symbol)?.amount ?? 0n) }); } } return (

    {t('tonswap.walletHistory.scope')}

    {grants.size > 0 && (
    {t('tonswap.walletHistory.received')} {[...grants.values()].map(row => )}
    )} }/>
    ); } async function readTonProtocolHistory(kind, { address, factory }, cursor, signal) { const page = await readTonAccountPage(address, cursor, signal); const { transactions } = page; const decoded = kind === 't3' ? TonswapProtocol.t3Events(transactions, address) : TonswapProtocol.optionEvents(transactions, address, factory); return { rows: decoded.rows, next: page.next, incomplete: page.incomplete || decoded.incomplete }; } async function readSpotOrders({ address }, cursor, signal) { const page = await readTonAccountPage(address, cursor, signal, 20); const { orders, incomplete } = TonswapProtocol.spotOrderRequests(page.transactions, address, canonicalTonAddress); if (!orders.length) return { rows: [], next: page.next, incomplete: incomplete || page.incomplete }; const { accounts } = await readJson(TON_BLOCKCHAIN + '/accounts/_bulk', signal, { account_ids: orders.map(order => order.order) }); if (!Array.isArray(accounts)) throw new Error('Unexpected order accounts'); const byAddress = new Map(accounts.map(account => [account.address, account])); const hashes = new Map(); const results = await Promise.allSettled(orders.map(async order => { const account = byAddress.get(order.order); if (account?.status !== 'active' || !Number.isSafeInteger(account.last_transaction_lt) || account.last_transaction_lt <= order.lt) { throw new Error('Order state unavailable'); } if (!hashes.has(account.code)) hashes.set(account.code, TonswapProtocol.spotOrderCodeHash(account.code)); if (await hashes.get(account.code) !== SPOT_ORDER_HASH) throw new Error('Unexpected order code'); return { ...order, ...TonswapProtocol.spotOrderState(account.data, address, order) }; })); const rows = results.flatMap(result => result.status === 'fulfilled' ? [result.value] : []); return { rows, next: page.next, incomplete: page.incomplete || incomplete || rows.length !== orders.length }; } async function readProtocolHistory(kind, release, cursor, signal) { if (kind === 'orders') return readSpotOrders(release, cursor, signal); if (kind === 't3' || kind === 'options') return readTonProtocolHistory(kind, release, cursor, signal); const query = new URLSearchParams(cursor ? { cursor_lt: cursor.lt, cursor_hash: cursor.hash } : { page: '1' }); const url = INDEXER + '/accounts/' + encodeURIComponent(release.address) + '/txs?' + query; const page = await readJson(url, signal); if (page.network !== 'testnet' || !Array.isArray(page.txs) || !Number.isInteger(page.page_size) || page.page_size < 1) throw new Error('Unexpected contract history'); const decoded = TonswapProtocol.contractEvents(page.txs, kind, release.address, canonicalTonAddress); const more = page.txs.length >= page.page_size && (cursor || (page.total_pages ?? page.total_pages_min) > 1 || page.history_complete !== true); const last = page.txs.at(-1); const next = more && /^\d+$/.test(last?.lt) && transactionHash(last.hash) && last.lt !== cursor?.lt ? { lt: last.lt, hash: last.hash } : null; return { ...decoded, next, incomplete: page.history_complete !== true || decoded.incomplete || Boolean(more && !next) }; } function optionCatalog(manifest) { const factory = canonicalTonAddress(manifest.contracts?.OptionFactory?.address); if (!factory || manifest.contracts.OptionFactory.codeHash !== OPTION_FACTORY_HASH || !Array.isArray(manifest.options)) { throw new Error('Unexpected options catalog'); } const series = []; const templates = []; for (const { kind, symbol, comparisonSymbol, option, seriesId, expiry } of manifest.options) { if (!['shout', 'outperformance'].includes(kind) || !/^[A-Z0-9]{1,12}$/.test(symbol) || (kind === 'outperformance' && !/^[A-Z0-9]{1,12}$/.test(comparisonSymbol))) { throw new Error('Unexpected option market'); } const market = symbol + ' / ' + (kind === 'shout' ? 'T3' : comparisonSymbol); if (option == null && seriesId == null && expiry == null) { templates.push({ kind, market }); continue; } const address = canonicalTonAddress(option); const end = Number(expiry); if (!address || typeof seriesId !== 'string' || !/^[1-9]\d{0,19}$/.test(seriesId) || BigInt(seriesId) > 0xffffffffffffffffn || !Number.isInteger(end) || end <= 0 || end > 0xffffffff || series.some(item => item.seriesId === seriesId)) { throw new Error('Unexpected option series'); } series.push({ kind, symbol, market, address, seriesId, expiry: end }); } return { factory, series, templates }; } async function readOptionSeries(series, factory, signal) { const getter = (address, method, stack = []) => readJson(INDEXER + '/runGetMethod', signal, { address, method, stack }); const [terms, capacity] = await Promise.allSettled([ getter(factory, 'series_info', [['num', series.seriesId]]).then(TonswapProtocol.optionSeriesTerms), getter(series.address, 'get_capacity').then(TonswapProtocol.optionCapacity), ]); const verified = terms.status === 'fulfilled' && terms.value.address === series.address && terms.value.kind === series.kind && terms.value.expiry === series.expiry; return { ...series, verified, capacity: verified && capacity.status === 'fulfilled' ? capacity.value : null }; } function useProtocolHistory(kind) { const [request, setRequest] = useState({ cursor: null, release: null }); const [data, setData] = useState({ rows: [], loading: true, summaryLoading: kind === 't3' }); useEffect(() => { const controller = new AbortController(); const { signal } = controller; const { cursor } = request; async function load() { let summaryStarted = false; try { let release = request.release; if (!release) { const manifest = await readJson(MANIFEST, signal); const tokens = releaseTokens(manifest); const [name, codeHash] = PROTOCOL_CONTRACTS[kind]; const contract = manifest.contracts?.[name]; const address = canonicalTonAddress(contract?.address); if (!address || contract.codeHash !== codeHash) throw new Error('Unsupported Tonswap contract version'); const markets = kind === 'perps' ? manifest.perpsMarkets.map(({ marketId, pool, symbol }) => { if (!Number.isInteger(marketId) || marketId < 0 || marketId > 0xffffffff || !RAW_ADDRESS.test(pool) || !/^[A-Z0-9]{1,12}$/.test(symbol)) { throw new Error('Unexpected Perps market'); } return { marketId, pool, symbol }; }) : []; release = { address, tokens, markets, minterCode: manifest.templates?.JettonV21Minter, ...(kind === 'options' ? optionCatalog(manifest) : {}), ...(kind === 'orders' ? { spotMarkets: marketCatalog(manifest) } : {}), }; if (kind === 'orders' && manifest.templates?.SpotOrder !== SPOT_ORDER_HASH) throw new Error('Unsupported order template'); if (signal.aborted) return; setData(previous => ({ ...previous, release })); } if (kind === 't3' && !cursor) { summaryStarted = true; readT3Summary(release, signal).then( summary => { if (!signal.aborted) setData(previous => ({ ...previous, summary, summaryLoading: false })); }, () => { if (!signal.aborted) setData(previous => ({ ...previous, summaryError: true, summaryLoading: false })); }, ); } const seriesRequest = request.release ? release.series : Promise.all( (release.series || []).map(series => readOptionSeries(series, release.factory, signal)) ).then(series => { if (kind === 'options' && !signal.aborted) setData(previous => ({ ...previous, release: { ...release, series } })); return series; }); const [decoded, markets, series] = await Promise.all([ readProtocolHistory(kind, release, cursor, signal), request.release ? release.markets : Promise.all(release.markets.map(async market => { try { const result = await readJson(INDEXER + '/runGetMethod', signal, { address: release.address, method: 'get_market', stack: [['num', String(market.marketId)]], }); return { ...market, stats: TonswapProtocol.perpsMarket(result, market.pool) }; } catch { return market; } })), seriesRequest, ]); const rows = decoded.rows.map(row => ({ ...row, hash: transactionHash(row.hash) })) .filter(row => row.hash && validTonTime(row.utime)); const incomplete = decoded.incomplete || rows.length !== decoded.rows.length; if (signal.aborted) return; setData(previous => { const all = cursor ? previous.rows.concat(rows) : rows; const unique = new Map(all.map(row => [row.order || row.hash + ':' + row.index, row])); return { ...previous, loading: false, error: false, release: { ...release, markets, series }, rows: [...unique.values()], next: decoded.next, incomplete: incomplete || Boolean(cursor && previous.incomplete), }; }); } catch { if (!signal.aborted) setData(previous => ({ ...previous, loading: false, error: true, ...(!summaryStarted && !cursor && kind === 't3' ? { summaryLoading: false, summaryError: true } : {}), })); } } load(); return () => controller.abort(); }, [kind, request]); function read(cursor = null) { setData(previous => ({ ...previous, loading: true, error: false, ...(!cursor && kind === 't3' ? { summaryLoading: true, summaryError: false } : {}), })); setRequest({ cursor, release: cursor ? data.release : null }); } return { ...data, refresh: () => read(), retry: () => read(request.cursor), loadMore: () => read(data.next) }; } function validTonTime(value) { return Number.isSafeInteger(value) && value > 0 && value < 253402300800; } function TonTxLink({ hash, label = 'tonswap.viewTx', accessibleLabel }) { const t = useT(); return {t(label)} ; } function TonEventDate({ seconds }) { const { locale } = useLang(); const date = new Date(seconds * 1000); return ; } function ProtocolToolbar({ kind, history, contractLabel = 'tonswap.viewContract' }) { const t = useT(); return (

    {t('tonswap.' + kind + '.title')}

    {t('tonswap.' + kind + '.description')}

    {history.release && }
    ); } function ProtocolActivity({ history, rows, empty, children, renderRows }) { const t = useT(); return (
    {history.loading &&

    {t('tonswap.protocol.loading')}

    } {history.error &&

    {t('tonswap.protocol.error')}

    } {history.incomplete &&

    {t('tonswap.protocol.partial')}

    } {!history.loading && !history.error && !rows.length &&
    {t(history.incomplete || history.next ? 'tonswap.protocol.emptyPage' : empty)}
    } {!!rows.length && (renderRows ? renderRows(rows) :
      {rows.map(row =>
    1. {children(row)}
      2. )}
    )} {history.next && !history.error && }
    ); } function PerpsView() { const { t, locale } = useLang(); const history = useProtocolHistory('perps'); const [filter, setFilter] = useState(null); const actions = ['open', 'close', 'liquidate']; const markets = history.release?.markets || []; const marketLabel = id => markets.find(market => market.marketId === id)?.symbol; const rows = history.rows.filter(row => !filter || row.kind === filter); const complete = history.release && !history.loading && !history.error && !history.incomplete && !history.next; const amount = value => formatTokenAmount(value < 0n ? -value : value, 9, locale); return (
    {markets.map(market =>
    {t('tonswap.perps.market')}

    {market.symbol} / T3

    {t('tonswap.perps.longOi')}
    {market.stats ? amount(market.stats.long) + ' T3' : '—'}
    {t('tonswap.perps.shortOi')}
    {market.stats ? amount(market.stats.short) + ' T3' : '—'}
    {t('tonswap.perps.cap')}
    {market.stats ? amount(market.stats.cap) + ' T3' : '—'}
    {t('tonswap.perps.leverage')}
    {market.stats ? fmtNumber(market.stats.leverage, locale) + '×' : '—'}
    )}
    {actions.map(action => { const count = history.rows.filter(row => row.kind === action).length; return ; })}

    {t('tonswap.activity.title')}

    {row => <>
    {t(row.kind === 'close' && row.size !== 0n ? 'tonswap.perps.partialClose' : 'tonswap.perps.' + row.kind)}
    {marketLabel(row.marketId) ? marketLabel(row.marketId) + ' / T3' : '#' + row.marketId} {row.size === 0n ? t('tonswap.perps.noPosition') : t('tonswap.perps.position').replace('{size}', amount(row.size)) .replace('{side}', t(row.size > 0n ? 'tonswap.perps.long' : 'tonswap.perps.short'))}
    {t('tonswap.activity.owner')}
    {t('tonswap.protocol.details')} {row.fill > 0n && {t('tonswap.perps.fill')} {amount(row.fill)} T3} {t('tonswap.perps.margin')} {row.margin < 0n ? '−' : row.margin > 0n ? '+' : ''}{amount(row.margin)} T3 {t('tonswap.fee')} {amount(row.fee)} T3
    }
    ); } async function creatorPage(creator, release, cursor, signal) { if (!/^[a-f0-9]{64}$/.test(release.minterCode)) throw new Error('Missing Launchpad minter template'); const params = new URLSearchParams({ limit: String(CREATOR_PAGE_SIZE) }); if (cursor) params.set('before_lt', cursor); const { transactions } = await readJson(TON_BLOCKCHAIN + '/accounts/' + encodeURIComponent(creator) + '/transactions?' + params, signal); if (!Array.isArray(transactions)) throw new Error('Unexpected wallet history'); const published = new Map(release.tokens.map(token => [canonicalTonAddress(token.root), token.symbol])); const rows = []; let incomplete = false; for (const tx of transactions) { if (!Array.isArray(tx.out_msgs)) { incomplete = true; continue; } if (!tx.success || tx.aborted) continue; for (const message of tx.out_msgs) { if (message.op_code !== '0x642b7d07' || !message.init || message.bounced) continue; const token = canonicalTonAddress(message.destination?.address); const hash = transactionHash(message.hash); if (!token || !hash) continue; try { const encoded = encodeURIComponent(token); const deployment = await readJson(TON_BLOCKCHAIN + '/messages/' + hash + '/transaction', signal); if (!deployment.success || deployment.aborted || deployment.end_status !== 'active' || !['nonexist', 'uninit'].includes(deployment.orig_status) || canonicalTonAddress(deployment.account?.address) !== token || canonicalTonAddress(deployment.in_msg?.source?.address) !== creator || transactionHash(deployment.in_msg?.hash) !== hash || deployment.in_msg?.op_code !== '0x642b7d07' || !deployment.in_msg?.init || !validTonTime(deployment.utime)) continue; const txHash = transactionHash(deployment.hash); if (!txHash) throw new Error('Missing deployment hash'); const init = await TonswapProtocol.stateInitHashes(deployment.in_msg.init.boc); if (!init || init.code !== release.minterCode || init.root !== token.split(':')[1]) continue; const info = published.has(token) ? null : await readJson('https://testnet.tonapi.io/v2/jettons/' + encoded, signal).catch(() => null); const metadata = info?.metadata; const name = [published.get(token), metadata?.symbol, metadata?.name].find(value => typeof value === 'string' && value.trim()); rows.push({ token, name: name?.trim().slice(0, 80), hash: txHash, utime: deployment.utime, releaseToken: published.has(token) }); } catch { if (signal.aborted) throw new Error('Token lookup cancelled'); incomplete = true; } } } const last = transactions.at(-1)?.lt; const next = transactions.length === CREATOR_PAGE_SIZE && Number.isSafeInteger(last) && last > 0 && String(last) !== cursor ? String(last) : null; return { rows, next, incomplete: incomplete || (transactions.length === CREATOR_PAGE_SIZE && !next) }; } function CreatorTokens({ release }) { const t = useT(); const request = useRef(null); const [input, setInput] = useState(''); const [data, setData] = useState({ rows: [] }); useEffect(() => () => request.current?.abort(), []); async function lookup(value, cursor = null) { request.current?.abort(); const creator = canonicalTonAddress(value); if (!creator) { setData({ rows: [], invalid: true }); return; } const controller = new AbortController(); request.current = controller; const { signal } = controller; setData(previous => ({ creator, rows: cursor ? previous.rows : [], loading: true })); try { const page = await creatorPage(creator, release, cursor, signal); if (!signal.aborted) setData(previous => ({ ...page, creator, incomplete: page.incomplete || Boolean(cursor && previous.incomplete), rows: [...new Map(previous.rows.concat(page.rows).map(row => [row.token, row])).values()], })); } catch { if (!signal.aborted) setData(previous => ({ ...previous, loading: false, error: true, cursor })); } } return (

    {t('tonswap.launchpad.tokens')}

    {t('tonswap.launchpad.tokenScope')}

    { event.preventDefault(); lookup(input); }}>
    setInput(event.target.value)} maxLength={96} placeholder="0:… / kQ…" spellCheck={false} autoComplete="off" autoCapitalize="off" aria-invalid={data.invalid || undefined}/>
    {data.invalid &&

    {t('tonswap.invalidAddress')}

    }
    {data.creator && lookup(data.creator, data.cursor), loadMore: () => lookup(data.creator, data.next) }} rows={data.rows} empty="tonswap.launchpad.emptyTokens"> {row => <>
    {row.releaseToken && {t('tonswap.launchpad.releaseToken')}}
    {t('tonswap.launchpad.creator')}
    }     }
    ); } function LaunchpadView() { const { t, locale } = useLang(); const history = useProtocolHistory('launchpad'); const tokenLabel = root => history.release?.tokens.find(token => canonicalTonAddress(token.root) === root)?.symbol; return (

    {t('tonswap.launchpad.sales')}

    {t('tonswap.launchpad.salesScope')}

    {row => <>
    {t('tonswap.launchpad.' + row.kind)}
    {t('tonswap.launchpad.token')}
    {t('tonswap.launchpad.creator')}
    {t('tonswap.protocol.details')} {t('tonswap.launchpad.supply')} {formatTokenAmount(row.supply, row.decimals, locale)} {t('tonswap.launchpad.hardCap')} {formatTokenAmount(row.hardCap, 9, locale)} T3 {t('tonswap.launchpad.starts')} {t('tonswap.launchpad.ends')}
    }
    ); } function T3View() { const { t, locale } = useLang(); const history = useProtocolHistory('t3'); const [filter, setFilter] = useState('all'); const rows = history.rows.filter(row => filter === 'all' || row.kind === filter); const summary = history.summary; const summaryLabel = token => token === 'T3' ? t('tonswap.t3.supply') : t('tonswap.t3.reserve').replace('{token}', token); const reserveTokens = ['USDT', 'USDC', ...(summary?.reserves.filter(token => token?.amount > 0n && token.symbol !== 'USDT' && token.symbol !== 'USDC').map(token => token.symbol) || [])]; const balanceCards = reserveTokens.map(symbol => ({ symbol, balance: summary?.reserves.find(token => token?.symbol === symbol) })); balanceCards.push({ symbol: 'T3', balance: summary && { amount: summary.supply, decimals: 9 } }); function amountText(amount, decimals, symbol) { return formatTokenAmount(amount, decimals, locale) + ' ' + symbol; } return (
    {balanceCards.map(({ symbol, balance }) =>

    {summaryLabel(symbol)}

    {balance ? amountText(balance.amount, balance.decimals, symbol) : '—'}
    )}
    {history.summaryError &&

    {t('tonswap.t3.summaryError')}

    }

    {t('tonswap.activity.title')}

    {t('tonswap.t3.activityNote')}

    {['all', 'mint', 'redeem'].map(action => )}
    {row => <>
    {t(row.paired ? 'tonswap.t3.pairedMint' : 'tonswap.t3.' + row.kind)}
    {amountText(row.amount, 9, 'T3')} {row.reserves?.map((amount, slot) => { const token = summary?.reserves[slot]; return amount > 0n && token && {amountText(amount, token.decimals, token.symbol)}; })}
    {t('tonswap.t3.wallet')} {row.recipient !== row.owner && {t('tonswap.t3.recipient')} }
    }
    ); } function OptionsView() { const { t, locale } = useLang(); const history = useProtocolHistory('options'); const [filter, setFilter] = useState('all'); const [selection, setSelection] = useState('all'); const series = history.release?.series || []; const templates = history.release?.templates || []; const selected = series.some(item => item.seriesId === selection) ? selection : 'all'; const visible = history.rows.filter(row => selected === 'all' || row.seriesId === selected); const rows = visible.filter(row => filter === 'all' || row.kind === filter); const complete = !history.loading && !history.error && !history.incomplete && !history.next; const seriesLabel = id => t('tonswap.options.seriesId').replace('{id}', id); const seriesTitle = item => t('tonswap.options.' + item.kind) + ' · ' + item.market; function countLabel(kind, items) { const count = items.filter(row => row.kind === kind).length; if (!complete && count === 0) return '—'; return (complete ? '' : '≥ ') + fmtNumber(count, locale); } return (
    {series.length > 0 &&
    {series.map(item => { const activity = history.rows.filter(row => row.seriesId === item.seriesId); const status = item.verified === false ? 'unverified' : item.expiry * 1000 <= Date.now() ? 'expired' : 'unexpired'; return (
    {seriesLabel(item.seriesId)}

    {seriesTitle(item)}

    {t('tonswap.options.' + status)}
    {t('tonswap.options.expiry')}
    {t('tonswap.options.positions')}
    {item.capacity ? fmtNumber(item.capacity.count, locale) + ' / ' + fmtNumber(item.capacity.limit, locale) : '—'}
    {t('tonswap.options.buyFilter')}
    {countLabel('buy', activity)}
    {t('tonswap.options.exerciseFilter')}
    {countLabel('exercise', activity)}
    ); })}
    } {history.release && series.length === 0 &&

    {t('tonswap.options.noSeries')}

    } {templates.length > 0 &&

    {t('tonswap.options.templates')} · {templates.map(seriesTitle).join(' · ')}

    }

    {t('tonswap.activity.title')}

    {t('tonswap.options.activityNote')}

    {series.length > 1 && }
    {['all', 'buy', 'exercise'].map(action => )}
    {row => <>
    {t('tonswap.options.' + row.kind)}
    {seriesLabel(row.seriesId)} {row.position !== '0' && {t('tonswap.options.positionId').replace('{id}', row.position)}}
    {formatTokenAmount(row.amount, 9, locale)} T3 {row.kind !== 'fund' && {t(row.kind === 'buy' ? 'tonswap.options.premium' : 'tonswap.options.payout')}}
    {t('tonswap.t3.wallet')}
    }
    ); } function SpotOrdersView() { const { t, locale } = useLang(); const history = useProtocolHistory('orders'); const [filter, setFilter] = useState('all'); const now = Date.now() / 1000; const orders = history.rows.map(row => { const status = row.state === 3 ? [null, 'filled', 'cancelled', 'expired'][row.closeReason] : row.state === 2 ? 'executing' : row.expiresAt <= now ? 'awaitingClose' : 'open'; return { ...row, status, isOpen: status === 'open' || status === 'executing' }; }); const rows = orders.filter(row => filter === 'all' || (filter === 'open' ? row.isOpen : row.executed > 0)); const tokens = new Map((history.release?.tokens || []).map(token => [canonicalTonAddress(token.root), token])); const markets = new Map((history.release?.spotMarkets || []).map(market => [market.pool, market])); const complete = !history.loading && !history.error && !history.incomplete && !history.next; const counts = { all: orders.length, open: orders.filter(row => row.isOpen).length, executed: orders.filter(row => row.executed > 0).length }; const statusColors = { open: 'info', executing: 'warn', filled: 'ok', awaitingClose: 'warn' }; return (

    {t('tonswap.orders.list')}

    {t('tonswap.orders.progressNote')}

    {['all', 'open', 'executed'].map(action => )}
    {row => { const token = tokens.get(row.inputMaster); const market = markets.get(row.pool); const output = token?.symbol === 'T3' ? market?.symbol : token?.symbol === market?.symbol ? 'T3' : null; const amount = token && validDecimals(token.decimals) ? formatTokenAmount(row.amount, token.decimals, locale) + ' ' + token.symbol : null; const sold = amount ? formatTokenAmount(row.sold, token.decimals, locale) + ' ' + token.symbol : null; return <>
    {t(row.slices === 1 ? 'tonswap.orders.limit' : 'tonswap.orders.twap')}
    {t('tonswap.orders.status.' + row.status)}
    {row.cancelRequested && row.isOpen && {t('tonswap.orders.cancelRequested')}} {row.status === 'open' && !row.inputWallet && {t('tonswap.orders.waitingWallet')}}
    {token && output ? {token.symbol} → {output} : } {amount && {t('tonswap.orders.input')} {amount}}
    {t('tonswap.orders.progress')} {fmtNumber(row.executed, locale)} / {fmtNumber(row.slices, locale)} {row.executed > 0 && sold && {t('tonswap.orders.sold')} {sold}} {row.lastExecutedAt > 0 && {t('tonswap.orders.lastSlice')} }
    {t('tonswap.t3.wallet')} {t('tonswap.orders.expiry')}
    ; }}
    ); } function TonswapSwaps({ visible }) { const t = useT(); const [orders, setOrders] = useState(() => new URLSearchParams(window.location.search).get('tonswapSwaps') === 'orders'); function selectOrders(show) { const url = new URL(window.location.href); if (show) url.searchParams.set('tonswapSwaps', 'orders'); else url.searchParams.delete('tonswapSwaps'); window.history.replaceState(window.history.state, '', url); setOrders(show); } return ( ); } function TonswapProtocolStatus() { const { t, locale } = useLang(); const [refresh, setRefresh] = useState(0); const [data, setData] = useState({ status: 'checking' }); useEffect(() => { const controller = new AbortController(); const { signal } = controller; async function load() { try { const [manifest, page] = await Promise.all([ readJson(MANIFEST, signal), readResponse(TONSWAP_SITE, signal).then(response => response.text()).catch(() => null), ]); releaseTokens(manifest); if (typeof manifest.releaseId !== 'string' || !/^[a-z0-9-]{1,100}$/.test(manifest.releaseId) || typeof manifest.manifestHash !== 'string' || !/^[a-f0-9]{64}$/.test(manifest.manifestHash)) { throw new Error('Unexpected Tonswap release identity'); } const verified = manifest.releaseId === SCCP_DISABLED_RELEASE.id && manifest.manifestHash === SCCP_DISABLED_RELEASE.hash && page?.includes('src="./assets/' + SCCP_DISABLED_RELEASE.webEntry + '"'); if (!signal.aborted) setData({ status: verified ? 'disabled' : 'unverified', release: manifest.releaseId, checkedAt: new Date(), }); } catch { if (!signal.aborted) setData({ status: 'error' }); } } load(); return () => controller.abort(); }, [refresh]); const checking = data.status === 'checking'; const ton = t('tonswap.testnet'); const directions = [[ton, 'SORA'], ['SORA', ton]]; const badge = { disabled: ['warn', 'tonswap.sccp.noRoute'], unverified: ['', 'tonswap.sccp.unverified'], error: ['', 'tonswap.unavailable'], }[data.status]; const checked = data.checkedAt && new Intl.DateTimeFormat(locale, { timeStyle: 'short' }).format(data.checkedAt); return (

    {t('tonswap.sccp.statusTitle')}

    {t('tonswap.sccp.statusDescription')}

    {checked && {t('tonswap.updated').replace('{time}', checked)}}

    {t('tonswap.sccp.title')}

    {t( 'tonswap.sccp.' + (data.status === 'unverified' ? 'unverifiedDetail' : data.status) )}

    {data.status === 'disabled' && {t('tonswap.sccp.noActive')}}
    {badge && }
    ); } function TonswapSection() { const t = useT(); const [view, setView] = useState(() => { const requested = new URLSearchParams(window.location.search).get('tonswapView'); return ['swaps', 'wallets', 'perps', 'options', 'launchpad', 't3', 'status'].includes(requested) ? requested : 'pools'; }); function selectView(next) { const url = new URL(window.location.href); if (next === 'pools') url.searchParams.delete('tonswapView'); else url.searchParams.set('tonswapView', next); window.history.replaceState(window.history.state, '', url); setView(next); } return (
    {t('tonswap.testAssets')}
    {view === 't3' && } {view === 'perps' && } {view === 'options' && } {view === 'launchpad' && } {view === 'status' && }
    ); } window.TonswapSection = TonswapSection; })();