FunC 0.4.6

In this release of FunC two compiler bugs were fixed. Both manifest in unusual conditions and scanning onchain history for last months didn't revealed any manifestation in the wild. So apparently existing contracts are safe thanks to culture of thorough integrational testing in developer community!
Great job 👍

Still, if you are deploying a new contracts we recommend you to switch to new compiler version.

1) First bug is related to try/catch construction, where inside try branch a function that modifies c1/с3 is called. That may happen in case of non-trivial branching in this child function or using set_c3. How to check.

2) Second bug is related to storing function into variable. In this case, in FunC <=0.4.5 impure modifier of this functions was dropped.

MaraTON Challenge 1: A Major Programming Competition will start tomorrow

MaraTON Challenge 1, a competition for TON programmers co-hosted by Codeforces and TON Core, will start tomorrow. MaraTON I focuses on practical challenges inspired by the TON blockchain. Don’t worry — no prior knowledge of TON is needed! The contest is designed to help you learn as you go.

📅 Starts: Monday, December 23
📅 Ends: Monday, January 13

Total Prize Pool: Over 50,000 USDT
Rewards for top performers during the contest and for final rankings!

Registration is open to everyone — sign up now!

TonTech team is developing infrastructure projects like Liteserver and is eager to improve them.
To better understand the current needs, they launched a survey.
Please share the needs you feel are and will be helpful for your product with the Infrastructure Developer Survey.

👉https://forms.gle/D9ZWAo1qMnNrio3dA

Introducing Unit-Testing in Tolk with Jest

Tolk developers rejoice! Unit-testing for smart contracts just got easier. While sandbox offers E2E testing, it’s far from ideal for unit-testing.

Now, with the Jest-Tolk runner, unit-testing in Tolk is a reality. Seamlessly integrate with Jest and streamline your testing workflow today.

Explore the tool!

GitHub: tonkite/jest-tolk
NPM: @tonkite/jest-tolk

Upgrade your smart contract testing game now!

Two months of absence: what was going on?

Two months have passed since the announcement of Tolk. You might be wondered, what was going on and why there we no releases yet.

Throughout all November, I've been working on the vision of the future. My goal was to "visualize" what Tolk v1.0 should look like. What's the language we're all targeting to, so that it solves lots of practical problems, avoids manual cells/slices manipulation, provides sufficient mechanisms for ABI generation, but still being zero overhead. I have created a giant roadmap (40 PDF pages!) describing the vision, and how, step by step, we're going to reach it.

Throughout all December, I've been constantly working on the compiler's kernel. As you know, Tolk is a fork of FunC. FunC compiler internals are very challenging to be extended and modified. The way FunC looks like is just a mirror of its internal implementation. Heading towards the future, I had to partially "untangle" this "legacy FunC core", so that in the future, it will be able to "interbreed" with features it was not originally designed for.

Currently I am done with this preparation. Tolk v0.7 has just been released. It contains a fully rewritten semantic analysis kernel (though almost invisible to the end user, huh).

✅ Notable changes in Tolk v0.7:
1. Under the hood: refactor and revamp compiler internals. AST-level semantic analysis kernel
2. Under the hood: rewrite the type system from Hindley-Milner to static typing
3. Clear and readable error messages on type mismatch
4. Generic functions fun f<T>(...) and instantiations like f<int>(...)
5. The bool type
6. Type casting via value as T

PR on GitHub with detailed info. IDE plugins are updated accordingly.

BTW, a new version of blueprint was also released. You can now update compilers (Tolk / FunC / Tact) independently, they became peer dependencies.

P.S. I'll uncover the details about planned Tolk v1.0 quite soon.

🔨Dev tools updates

Recently new versions of blueprint, sandbox, test-utils, and create-ton have been released. The most important (and breaking) change is the fact that since blueprint v0.28.0 compilers (func-js, tolk, tact) have become peer dependencies. This means that you can pick and choose any compiler version that you need, as long as its API is compatible with what blueprint expects, but this also means that you need to have them listed in your package.json. If you're creating a new project using create-ton, it will add compiler dependencies automatically. If not and if you're upgrading blueprint in an old project, you will have to install compilers yourself, you can use the template's package.json for reference.

Changes to sandbox and test-utils include better support for extra currencies, which might be of use due to the recent developments in TON.

Telegram and TON Make it Exclusive!

All mini-app developers in Telegram will now exclusively use TON as their blockchain infrastructure. All mini-apps that do not currently use TON should migrate within the next 30 days. TON Connect - TON's Wallet authentication protocol in Telegram - will be the sole wallet connect protocol for every Telegram Mini App, excluding bridging scenarios.

Telegram and TON have updated their documentation, and TON Foundation is giving TG Ads grants to projects who will migrate within the next 30 days to help them get a good start in TON Ecosystem. Check out the grant program and developer guidelines here!

To learn more about this step forward head over to our latest blog article.  

🚀 Tact v1.5 Audited by Trail of Bits

The security audit for Tact v1.5 has been completed by Trail of Bits, a leading Web3 security firm.

✅ No high-severity vulnerabilities were found.

🔧 Some bugs and points of improvement were discovered and addressed in a new Tact v1.5.4 bugfix release.

Thanks to Trail of Bits for their thorough review!

The report can be accessed at the Trail of Bits GitHub repo: https://github.com/trailofbits/publications/blob/master/reviews/2025-01-ton-studio-tact-compiler-securityreview.pdf

⚡️ In the meantime we continue to improve Tact with new language features, gas optimizations (a lot of those lately!), and enhancements to the compiler’s reliability. This ensures a secure and efficient development experience on TON Blockchain.

👉 Upgrade to Tact 1.5.4, if not already: https://docs.tact-lang.org/book/compile/#upgrades

🍲 cooking with great care for performance and users
♨️ @tact_kitchen

TON Core: Report for December-January

48 updates, from small to huge. Moving along the roadmap: first part of the Accelerator, new tools for validators, TVM sidechains, new versions of TOLK and API, support for extra currencies and BTC Teleport, and other.

https://telegra.ph/TON-Core-Dec-Jan-2025-Updates-02-02

Tolk v0.8: preparation for structures

A new version of Tolk was released several days ago. We're starting a way to eventually implement structures with auto packing to/from cells. This will take several steps (each publicly released), it's the first one.

✅ Notable changes in Tolk v0.8:
1. Syntax tensorVar.0 and tupleVar.0, both for reading and writing
2. Allow cell, slice, etc. to be valid identifiers

PR on GitHub with detailed info.

Using syntax `tensorVar.{i}` and `tupleVar.{i}`, you can access tensors/tuples by indices without unpacking them.

It works for tensors:

var t = (5, someSlice, someBuilder);   // 3 stack slots
t.0                     // 5
t.0 = 10;               // t is now (10, ...)
t.0 += 1;               // t is now (11, ...)
increment(mutate t.0);  // t is now (12, ...)
t.0.increment();        // t is now (13, ...)

t.1         // slice
t.100500    // compilation error

It works for tuples (does asm INDEX/SETINDEX under the hood):

var t = [5, someSlice, someBuilder];   // 1 tuple on a stack with 3 items
t.0                     // "0 INDEX", reads 5
t.0 = 10;               // "0 SETINDEX", t is now [10, ...]
t.0 += 1;               // "0 INDEX" to read 10, "0 SETINDEX" to write 11
increment(mutate t.0);  // also, the same way
t.0.increment();        // also, the same way

t.1         // "1 INDEX", it's slice
t.100500    // compilation error

It works for nesting var.{i}.{j}. It works for nested tensors, nested tuples, tuples nested into tensors. It works for mutate. It works for globals.

Why is this essential?

In the future, we'll have structures, declared like this:

struct User {
    id: int;
    name: slice;
}

Structures will be stored like tensors on a stack:

var u: User = { id: 5, name: "" };
// u is actually 2 slots on a stack, the same as
var u: (int, slice) = (5, "");

fun getUser(): User { ... }
// on a stack, the same as
fun getUser(): (int, slice) { ... }

It means, that `obj.{field}` is exactly the same as `tensorVar.{i}`:

var u: User = ...;   // u: (int, slice) = ...
u.id;                // u.0
u.id = 10;           // u.0 = 10

Same goes for nested objects:

struct Storage {
    lastUpdated: int;
    owner: User;
}

s.lastUpdated        // s.0
s.owner.id           // s.1.0

So, implementing indexed access for tensors/tuples covering all scenarios is a direct step towards structures.

🚀 Bring TON to ElizaOS – Join the Bounty Program!

TON Blockchain is launching a bounty program to develop the TON Plugin within ElizaOS! This is your chance to contribute to a cutting-edge AI framework and integrate TON into autonomous AI agents.

$20,000 in prizes is up for grabs! Contribute by implementing key features and earn rewards for successfully merged pull requests.

💡 How to participate: take on one of the open issues:
👉 List of open TON Plugin bounties

⚡ Act fast! Don’t miss out on this opportunity to bring TON and AI together!

📝 TON devs — we need your feedback!

Building on TON? Tell us what works (and what doesn’t) in a quick survey on:

• Developing on TON, tooling, programming languages (FunC, Tact, Tolk), TMAs, guides

Fill it out, drop your wallet & claim an exclusive reputation SBT!

Make your voice count. 

Support for extra-currencies in local ton-http-api

In ton-http-api v2.0.53, which you can install by yourself on your server, support for extra-currencies and a number of other improvements have been made.

Recall that earlier support for extra-currencies was made in the public Toncenter V2 and Toncenter V3 APIs.

https://github.com/toncenter/ton-http-api/releases/tag/v2.0.53

Improved Metadata API

Last month we started providing metadata for Jettons and NFTs in the V3 API.

We are pleased to report a number of improvements:

— The metadata now enters the API in advance as soon as the token appears on the network. In the previous implementation, the metadata was indexed the first time the token was requested.

— Images and JSON are now proxied via toncenter.com. 3 image sizes are available, as well as original non-proxied urls for JSON and images. IPFS is supported.
Using a proxy increases security (you don't make requests to third-party hosting) and speed of downloading resources.