Я кстати тут что подумал:
Для индексера как выглядит работа с блоком: берём бок, декодируем в дерево ячеек, потом анмаршалим ячейки в структуры, потом сохраняем в базу и дропаем все что декоднули.
Выглядит так что на такой паттерн работы круто ложатся арены. Создаешь арену, в ней куча мусора из битстрингов, указателей и массивов. Потом берёшь и всю арену удаляешь.
O Идея хорошая, можно в опции добавить арену для целлов и если передана то из нее аллочить целлы во время парса а потом юзер сам всю арену и дропнет сейчас есть в BOCParseOptions опция NoCopyPayload, при использовании не копирует байты боди а просто указывает на сам boc, если в комбо с ареной то почти без давления на gc получится к след версии думаю добавлю)
📚 tonutils-abi-go v1.0.0 released!
A code generator that turns Tolk contract ABI files into type-safe tonutils-go wrappers, so Go services can interact with contracts using native-looking methods. Generates code for data types, get methods, constants and errors for language native usage.
Generated code examples:
Jetton Minter
Network Config
Generated code usage is very easy:
data, _ := tlb.ToCell(wrappers.MinterStorage{
TotalSupply: tlb.MustFromDecimal("9000.55", 6),
AdminAddress: admin,
NextAdminAddress: nil,
JettonWalletCode: walletCode,
MetadataURI: "https://example.com/jetton.json",
})
addr, _, _, err := w.DeployContractWaitTransaction(
ctx,
tlb.MustFromTON("0.05"),
cell.BeginCell().EndCell(),
code,
data,
)
client := config.NewConfig(api, address.MustParseAddr(configAddress))
seqno, _ := client.RunMethodSeqno(ctx, block)
log.Printf("seqno: %s", seqno)
4 · 666 · Фотография
нажмите — покажем
нажмите — покажем
💎 gton v0.3.2 beta version released!
Fully Go-native TON full node implementation with an alternative resource efficient architecture, powered by tonutils-go. It provides node functionality and liteserver API, focused on fast synchronization and reliable data serving for services, backends, indexers, wallets, and other TON infrastructure.
Validator functionality is not included - gton is built as an efficient API access point for TON.
15 · 830 · 💎 gton v0.4.0 beta version released!
Archival node sync form zero state support, reduced block broadcasts apply latency (faster new blocks availability), faster archival blocks download, configurable liteserver rate limits, multiple performance optimizations.
Changelog:
* Added archive node sync from zero support
* Improved archive downloads: peer pinning, cooldowns, retries, hedged downloads, and checkpoint backpressure.
* Improved broadcast flow: hot masterchain/shard caches, delayed compressed decode, and multi-block pending queues per chain.
* Added liteserver configurable rate limits: per-IP request limits, connection limits, keep-alive timeout.
* Improved live sync latency with priority masterchain broadcasts and faster catch-up from cached full blocks.
* Hardened state checkpoints: non-zero states now must be saved together with full block and proof artifacts.
* State snapshots no longer persist state-only checkpoints without block artifacts.
* Block history lookups now return only blocks with served-full artifacts.
* Hardened block metadata validation against forged served-full flags and direct next refs.
* Fixed checkpoint completion so older flushes do not drop newer applied states.
* Optimized liteserver `sendMessage`, account proof cache, block data loading, and non-final state cell lookup.
* Added configurable large-BOC read workers and persistent-state BOC batch size.
* Reduced Pebble cell-store allocations by reusing write batches.
* Improved liteserver errors parity with the C++ node.
* Metrics now expose applied masterchain progress separately from persisted state.
* Changed several defaults in config.
* Updated `tonutils-go`.
7 · 562 · 💎 gton v0.5.1 beta version released!
Static node extensions and hooks support, liteserver refactored as a built-in extension, shared live-view store for liteserver and extensions, optional sync cutoff mode, checked external message flow, configurable local sendMessage fanout, storage/index migration, and multiple p2p, metrics, and storage reliability improvements.
Changelog:
* Added static extension support through `gton.RunNode`, `NodeOptions.Extension`, and `service/hooks`.
* Added extension hooks for applied blocks, received blocks, and accepted external messages.
* Added extension capabilities for read-only live state access, checked external message sending, logging, and metrics.
* Added `example_extension` with apply logger and live transaction replay checker examples.
* Refactored liteserver into `api/liteserver` and wired the default liteserver as a static extension.
* Moved shared live liteserver storage/query logic into `service/liveview` for reuse by extensions.
* Added `ton.sync_until` to sync up to a UNIX block-time cutoff, then switch p2p offline while keeping local liteserver data available.
* Added `liteserver.send_message_broadcast_fanout` to tune local external-message broadcast fanout.
* Added TVM-based external message admission before local and overlay rebroadcast.
* Improved local `sendMessage` rebroadcasting with dedicated queues, configurable fanout and dedup, lag-aware fanout reduction.
* Added lazy state cell load metrics split by state window, decoded cache, and Pebble.
* Added incremental storage artifact metrics for archive packages and persistent state files.
* Improved p2p peer maintenance, peer warmup, pending peer promotion, and public-shard peer advertisement.
* Improved custom fixed overlay handling with lighter warmup and stricter advertised peer validation.
* Hardened archive package pruning to avoid deleting packages still pending sync.
* Hardened block metadata and block history indexes with full block-id hash validation.
* A
4 · 451 · 🚀 tonutils-go v1.18.0 released!
Multiple optimizations, QUIC transport, two-step overlay broadcasts, ADNL/RLDP observability and lifecycle improvements, liteserver backpressure, TVM global versions 14 and 15, reusable transaction execution contexts, and broad TL, TLB, cell, BoC, proof, and emulation performance improvements.
Changelog:
* Added `adnl/quic` transport with client, server, gateway, multi-identity support, and a runnable QUIC example.
* Added QUIC address support to DHT.
* Added simple and FEC two-step overlay broadcasts with sending helpers, relaying, resource limits, delivered-message caches, validation hooks, and statistics.
* Added FEC broadcast relay state and improved overlay broadcast validation, certificate caching, and peer handling.
* Expanded the DHT server with query admission, query result, and store hooks.
* Added DHT routing-table statistics, signed node construction, stored-key enumeration, and expired-value cleanup.
* Improved DHT bucket maintenance, value republishing, node discovery, peer validation, and concurrent request handling.
* Disabled legacy DHT reverse-connection requests; they now return an explicit error.
* Reworked ADNL channel initialization, reinitialization, idle recovery, address updates, multipart limits, and peer lifecycle handling.
* Added ADNL `Ping`, `SendNop`, and per-peer traffic, channel, sequence, and reinitialization statistics.
* Improved RLDP transfer scheduling, receive processing, congestion control, memory usage, timeout handling, and large-transfer performance.
* Added detailed RLDP transfer and congestion statistics.
* Reworked lite server request handling with bounded per-client write queues, batched responses, query prechecks, and explicit `ServerBusy` errors.
* Replaced liteserver `SetMessageHandler` and `ServerClient.Send` with query-scoped `SetQueryHandler` and `ServerClient.Answer`.
* Added version-aware TVM opcode dispatch and global version 14 and 15 behavior, with historical execution covera
2 · 278 · 💎 gton v0.6.0 version released!
Built-in ton-http-api compatible HTTP API, block-finality broadcast support, TVM v15, optimized liteserver query execution, and major sync, P2P, cache, proof generation, and storage performance and reliability improvements.
Changelog:
* Added an optional built-in HTTP API extension with `/api/v2` GET, POST, and JSON-RPC support.
* Added `tonNode.blockFinalityBroadcast` support with simplex validator signature verification.
* Added independent caching and assembly of block candidates and finality broadcasts, regardless of arrival order.
* Added a bounded concurrent liteserver query dispatcher with fast paths, backlog shedding, cancellation handling, and larger per-connection response queues.
* Added `liteserver.limits.max_waits_per_ip` to limit parked `waitMasterchainSeqno` requests.
* Added full-block-identity response caching and shared in-flight computation for deterministic liteserver proofs, configuration, and shard data.
* Expanded shared block-proof construction and validation logic for reuse by liteserver, HTTP API, and broadcast processing.
* Added TVM v15 support and exposed the shared TVM instance to static extensions.
* Prioritized masterchain broadcasts in live-head sync
* Improved get-method execution, fee estimation, and external-message checking and broadcasting.
* Offloaded broadcast decompression and decoding to bounded workers with decoded-result caching.
* Added early rejection of already applied masterchain broadcasts and improved broadcast deduplication, payload reuse, and stale-message handling.
* Added active health probes and recovery for fixed custom overlays.
* Hardened peer endpoint identity, connection replacement, and stale peer cleanup.
* Reworked archive peer discovery and scouting with evidence-based admission, bounded DHT probing, per-demand health, retry backoff, and valuable peer reserves.
* Improved archive download sessions with shard-local peer selection, bounded retries, comparative hedging, su
2 · 210 · 💎 gton v0.7.0 version released!
QUIC transport and Plumtree broadcasts support, lower P2P and storage overhead, TVM optimizations and faster liteserver responses.
The node now opens QUIC on UDP ADNL port + 1000; make sure port is exposed through firewall/NAT.
Changelog:
#### Public broadcasts and P2P
* Added QUIC-based Plumtree delivery for public broadcasts, with FEC recovery for more reliable block propagation.
* Improved public broadcast routing to reduce duplicate traffic, bound memory usage, and isolate slow peers.
* Improved QUIC connectivity with cached routes, protected dialing, retry backoff, and cleanup of stale connections.
* Added persistent public-peer caching and a broader peer directory, allowing faster recovery after restart without keeping too many active connections.
* Hardened block broadcast processing: invalid and already-applied blocks are dropped early, while large payloads are decoded in bounded workers.
* Prioritized masterchain broadcast decoding so shard traffic does not delay the live masterchain head.
* Improved handling of out-of-order broadcasts by retrying valid payloads once their required predecessor state becomes available.
#### Synchronization and storage
* Avoided duplicate masterchain state preparation when several synchronization paths process the same block.
* Added early shard preparation so shard work can complete before its masterchain block is committed.
* Improved state-cell caching to keep large updates from blocking readers and other appliers for long periods.
* Improved archive catch-up by preparing the next archive window while the current one is being applied.
* Reworked archive import workers to prioritize active synchronization over background prefetch.
* Kept live block updates responsive when many recent blocks are still waiting to be saved.
* Reduced work and memory churn when publishing a block together with its state, especially on nodes with long block histories.
* Reduced temporary allocations while bu
4 · 395 ·