Nodectl Update v0.3.0 & Helm Update v0.2.0

Control got sharper. Visibility got deeper.

Nodectl Update v0.3.0

What’s inside:

— REST API authentication
Login, token revocation, auth middleware, login rate limiting, token-based access, and new auth / api login CLI commands.

— Election status dashboard
Election lifecycle tracking, stake totals, and election metadata in both API and CLI.

— Validator keys listing
Validator keys, election IDs, timestamps, statuses, key IDs, and ADNL addresses available in both API and CLI.

— Kubernetes DNS support
Control server addresses can use internal DNS names, not just IPs.

— Swagger auth support
Swagger UI includes Bearer token authentication with an Authorize button.

— New flags for filtering and output
--filter=<name> for elections and validators, plus --format=json|table for config list commands.

Also improved:

Bounceable wallet addresses in config wallet ls, smoother endpoint round-robin, safer wallet listing when TON API is unavailable, auth hot reload, and extended version output

Full changelog: https://github.com/RSquad/ton-rust-node/releases/tag/nodectl%2Fv0.3.0

Helm Update v0.2.0

What’s inside:

— Flexible Service & Network settings
Adds service.nodePort, service.clusterIP, service.loadBalancerIP, and service.externalTrafficPolicy for fine-grained networking.

— NetworkPolicy Update
networkPolicy.allowCIDRs has been removed. Use networkPolicy.allowFrom instead, which supports standard selectors (ipBlock, podSelector, namespaceSelector).

Full changelog: https://github.com/RSquad/ton-rust-node/releases/tag/helm%2Fnodectl%2Fv0.2.0

TON AI Agent Hackathon is closed ⭐

150+ submissions. Wallet integrations, agent coordination protocols, escrow primitives, voice agents, freelance marketplaces, trading bots. Builders came in with everything.

Judging underway. Results next week.

👉 View the submissions here

TON Community | TON Builders | TON Hubs | X | YouTube | LinkedIn | TON.org

🫧 Tolk v1.3: moving toward a general-purpose language

After the previous post, this release may feel less surprising — but still a bit unusual.

The reason is simple: Tolk is no longer evolving only as a contract language. It is becoming a foundation for the toolchain I described earlier.

This release focuses on features beyond contracts — introducing general-purpose capabilities needed for libraries and frameworks.

✅ Notable changes in Tolk v1.3:

1. Type array<T> — dynamically sized arrays backed by TVM tuples.
2. Type unknown — a TVM primitive with unknown contents.
3. Type lisp_list<T> — nested two-element tuples (FunC-style).
4. Type string — text chunks backed by snaked cells, with StringBuilder for concatenation.
5. Compile-time string methods: "str".crc32(), "str".sha256(), etc.
6. Null coalescing operator — ?? like in TypeScript.
7. Import path mappings — import "@third_party/utils".
8. Compile-time reflection via @stdlib/reflection.
9. Custom serializers now support structures and generics.
10. The compiler now reports multiple errors at once.
11. Focused on stability — fixed dozens of minor issues found by LLM fuzzing.
12. Extensive internal refactoring towards being stateless and multi-threaded.

PR on GitHub with detailed info.

✔ Arrays: redesigned tuples

Working with TVM tuples has been fully redesigned. There is now array<T> — a dynamically sized container:

// array<int>
var numbers = [1, 2, 3];

// array<Point?>
var optPoints = [
    Point { x: 10, y: 20 },
    Point { x: 30, y: 40 },
    null,
];

- methods push, get(idx), etc.
- any T, including sub-arrays like array<array<int>>
- automatically serialized into snake cells
- max size: 255 (TVM limitation)

✔ The `unknown` type

Raw TVM tuple exists, but it's no longer built-in. It's just an array... of something unknown:

type tuple = array<unknown>

The unknown gives access to the untyped TVM stack, fully integrated into the type system.

✔ The `string` type

TVM has no strings — only binary slices. Strings were always just a convention over binary data.

Now Tolk has strings built-in.

// string
val str = "hello";

- strings are cells (not slices)
- long strings are snake cells under the hood
- methods calculateLength, equalTo, etc.
- on-chain/off-chain encoding for jettons and NFTs to comply with TEPs

StringBuilder encapsulates cell manipulation:

StringBuilder.create()  
    .append(content.commonContent)  
    .append(individualNftContent)  
    .build()

By the way, compile-time functions now look cleaner: "str".crc32() and so on.

✔ Import path mappings

The import statement now accepts @aliases:

import "@common/jettons"
import "@third_party/math-lib"

This is similar to widely used path mappings in TypeScript.

✔ Compile-time reflection

Many additions in v1.3 make sense not for contracts, but for frameworks. For example, take a look at one of reflect features:

fun log(msg: string, loc: SourceLocation = reflect.sourceLocation()) {
     debug.print(loc.lineNo);
}

fun demo() {
     log("a");    // prints K — current line no
     log("b");    // prints K+1
}

Why is this useful? It allows errors to point to the original call site — for example, expect(...) in tests — by carrying source location at compile time.

⚙️ A huge portion of internal refactoring

A lot of work has been done inside the compiler core, peephole optimizations, and memory management.

Final result: tolk compiler is now thread-safe and re-invokable within a single process. It will be embedded into an external toolchain written in Rust, communicating via FFI.

... And more

Dozens of independent improvements. Combined, they cover the requirements not only for contracts, but for abstract libraries and the upcoming toolchain.

Feel free to check the description on GitHub.

🌳 And one more thing! Wallet-v5, compiled with Tolk v1.3, reduces gas usage by 30% compared to FunC. As of Tolk v1.0, the savings were "only" 20%. Take a look at new benchmarks.

🚀 The AI Hackathon review period has been extended until April 3.

The results exceeded all expectations: over 160 submissions, 4x the previous contest.

The volume and variety of projects submitted have genuinely impressed us. A strong mix of thoughtful, creative, and technically impressive work from across the ecosystem.

We definitely didn’t expect that. So, we are extending the review period to April 3 to ensure we have enough time to review every submission thoroughly.

While you wait, two new features just dropped on the Identity platform:

🔹Makers. Add your teammates to submission. Everyone gets the participation badge.
🔹Comments. Talk about projects. Feedback, questions, discussion, all on submission pages.

Thank you for the energy, creativity, and effort you brought to this hackathon.

Keep building! ✨😎

TON Community | TON Builders | TON Dev News | TON Hubs | X | YouTube | LinkedIn | TON.org

Sub-Second mainnet activation starts

The public bug bounty contest for the TON Sub-Second update has been completed.

We thank all participants for their work and valuable feedback. The corresponding changes have already been applied to the codebase. No major consensus changes were required.

The final contest results and reward distribution will be announced later.

This contest was the final stage of testing before mainnet activation. Prior to that, the update had already passed internal testing by TON Core and extended testing in testnet.

We are now starting the activation of the Sub-Second update in TON mainnet.

For additional reliability, activation will be performed in 3 stages:

Update plan:

March 31 (today): Upgrade validator nodes to the version supporting the latest consensus changes.

April 2: Vote to activate the new consensus on the basechain and enable a moderate block rate increase.

April 7: Vote to fully activate fast consensus on both the basechain and masterchain and then upgrade validator nodes.

The Sub-Second update is a major protocol upgrade comprising a substantial number of changes.

Despite comprehensive testing, validators are advised to maintain heightened operational readiness during the next two weeks, from March 31 to April 12.

The TON Core team will remain available throughout the deployment and is prepared to respond promptly to any situations.

TON Developer Communities

Building on TON? Join the official dev chats to get help, share feedback, and connect with other builders:
→ English
→ Russian
→ Chinese

More resources at TON Builders Portal

See you there 🚀

TON Rust Node v0.4.0: Ready for Simplex & QUIC

Back with a major v0.4.0 release, ensuring your setup is ready for TON's latest network-wide upgrades.

Archival mode is live, featuring the CellsDB cache and stable shard split/merge handling. Core logic is fixed: direct TON config queries and corrected fee accounting.

Read the Changelog: https://github.com/RSquad/ton-rust-node/releases/tag/node%2Fv0.4.0

Mainnet validators

Tomorrow, April 8, at 14:00 UTC, we ask validators to set aside time to vote on the following proposal:

— Vote to change Config Parameter 30, to activate Catchain 2.0 in both masterchain and basechain with block production rate of 400ms.

In addition to improving network performance from a UX speed perspective, this change is also expected, based on the current network configuration, to increase total validator rewards. However, the final validation APY cannot be determined in advance, as it depends on the dynamic relationship between the total staked amount and the reward pool.

Voting is now live on mainnet for a change to config parameter 30 and the activation of Catchain 2.0, a new sub-second consensus with ~400ms block-time.

This is a fundamental change to our blockchain, allowing validators to communicate internally with each other using QUIC protocol.

There is a website where you can track the validator voting progress in real time:
https://vote.lagus.cooking/

Fingers crossed.

TONAPI now supports Streaming API for sub-second finality

Sub-second finality is live on mainnet. If you're building on TONAPI, here's what's new.

TONAPI has added support for Streaming API (SSE + WebSocket), based on TON Center Streaming API v2. The interface is fully compatible, so you can use the official documentation as a reference.

What's available:
– SSE and WebSocket streaming endpoints
– Full transaction lifecycle: pending → confirmed → finalized → trace_invalidated
– Authorization via your existing Ton Console token

Endpoints:

Mainnet: 
https://tonapi.io/streaming/v2/sse 
https://tonapi.io/streaming/v2/ws

Testnet: 
https://testnet.tonapi.io/streaming/v2/sse 
https://testnet.tonapi.io/streaming/v2/ws

Documentation: Streaming API
Get your API key: Ton Console

TON Rust Node v0.5.0: Synced with C++ Node

Now up to date with the C++ implementation.

v0.5.0 adds Simplex consensus changes, optimizes network connections, and fixes transaction execution, LiteServer runSmcMethod, config params, and Merkle updates.

Read the Changelog: https://github.com/RSquad/ton-rust-node/releases/tag/node%2Fv0.5.0

TON Rust Node v0.5.1: LiteServer Response Fix

Response corrected. Block proof traversal optimized.

Fixes LiteServer response handling for listBlockTransactions so clients accept it correctly, while making block proof traversal more efficient.

Read the Changelog: https://github.com/RSquad/ton-rust-node/releases/tag/node%2Fv0.5.1

Nodectl v0.4.0 & Node v0.5.2: Adaptive Staking & Performance Optimization

Here with a major release focused on validator efficiency and smoother operations.

This update brings adaptive staking with adaptive_split50, multi-nominator pool support, built-in voting, and persistent ADNL addresses. Fast-sync over QUIC is more efficient, while fixed TVM stack serialization improves LiteServer stability.

Full changelogs:
▪️ https://github.com/RSquad/ton-rust-node/releases/tag/nodectl%2Fv0.4.0
▪️ https://github.com/RSquad/ton-rust-node/releases/tag/node%2Fv0.5.2

New for TON devs: Deep Smart Contract Audit Skill

A new audit skill for TON smart contracts is now live — powered by TON Symbolic Analyzer (TSA) and combining LLMs with formal methods.

What is TSA?
A symbolic execution engine that simulates contract behavior across many possible states to uncover non‑obvious bugs.

What the skill does:

• Explores real execution paths
• Analyzes smart contract code at the bytecode level
• Detects critical issues:
– Unauthorized fund withdrawal scenarios
– Incorrect handling of bounced messages
– Replay attack vulnerabilities

• Generates test cases
• TSA enable deep analysis for higher security coverage.
• Produces a structured audit report

⚙️ It is free and powerful smart contract audit skill for all TON developers!

More details:
🔗 https://tonsec.dev/smart-contract-audit-agent
Includes a case study showing how it reproduced a real DEX vulnerability.

We're closing GraphQL endpoint at Jun 1.

We have to admit that, despite our best efforts to preserve the ecosystem, times have changed and our team needs to move on to other areas and opportunities.

If you use the GraphQL or Assets API endpoints, please find another data provider and switch to them by 1 June. The @dassets_bot portfolio will also cease to function on 1 June.

As for providing access to Liteservers, we will continue to provide access and no changes are expected for Liteservers at @dtontech_bot.

It has been an honour for our team to work on TON over the past 5 years. It has been a very interesting and enjoyable time. We have met unique and legendary individuals, and have come a long way. But it is time to move on and build our own unicorn.

If you have any business proposals feel free to reach me at @tvorogme

dton.io team

How MCP enables on-chain actions for agents on TON

We publicly announced Agentic Wallets on TON — an open, self-custodial standard that lets agents manage assets through dedicated wallets. But just having a wallet isn’t enough. For an agent to use TON, it needs to be able to find and connect tools for interacting with the blockchain.

That’s why we built mcp.ton.org — a simple entry point for connecting AI agents to TON. MCP gives agents access to tools for working with the blockchain, while skills provide ready-to-use instructions. A user copies a single command, and the agent gets a ready way to work with the blockchain. All skills are open and available in the ton-org/skills.

Now developers have a ready-to-use execution layer for agents on TON. After connecting MCP and installing skills, an agent can check balances, send transactions, swap tokens, work with NFTs and execute more advanced scenarios like buying xStocks or managing Agentic Wallets. All actions are built from reusable primitives and executed through MCP, which allows developers to move directly to building agent logic.

Connect MCP and give your agent access to actions on TON