Summary

Survivorship bias problem

Right now, we have a big problem with newcomers that wants to start developing on TON.

I surveyed the community of ~5000 devs in four chats in June. And I got around 40 responses. But every one of those responses is from someone who has passed a series of hurdles and becomes a developer in the ecosystem. Even from these heroes, the most common problem I've heard of was "documentation."

Feel free to read the answers here:

• https://workflowy.com/s/ton-builders-read-on/FFpB7q4NvpqndwO5

And how many of these unfortunate souls didn't pass and settle in as dead listeners in dev chats? We don't know.

All who came from the development fields said where they have pain and what they need to fix. And how many of those people didn't come and were swept away by the complexity of the current TON ecosystem?

If we imagine that every newbie is Mario, then the lack of a clever way to learn blockchain is a hole that 99% of little Mario falls into.

When I want to START, on ton.org or in the current documentation, even "DOWNLOAD" a TON binaries is already a quest! It's a hole. Many tired after-work developers are buried here, and no one remembers their names.

Context

The first thing I want to bring to the ecosystem is a GETTING STARTED project for anyone who wants to play with TON over the weekend.

I want to start tiny and put a "Download" button for the most tired, where Kahneman's "System 1" will carry a person on waves of automatisms to the "Wow, I get it! How cool is that? Where's that complicated blockchain?"

This is the pain that worries me personally. The lack of a competent, unfocused path that even a tired after-work developer will follow. The ideal result looks like that:

I want to be sure that the person won't get blown away, distracted, have 3 links to 5 repositories, 8 versions of binary that are all out of date, and that the guy won't fall into some whitepaper along the way, where he will die. This is what I want to do.

Goals

• Build a straight way for anyone who wants to start developing in TON
• Build a user-friendly and scalable interface for new developers instead of old-school documentation for hardcore engineers
• Build a Knowledge Hub that developers will love so that they will improve it over time because of its value

Deliverables

Plan Minimum

• Created Getting Started in accessible language and step-by-step action, where TON binaries are downloaded, the first project is created, a wallet is tied up, and NFT is obtained from the blockchain.
• Obtained a development environment for TON-func-fift on output, where documentation is the point of departure to any problem.

Plan Maximum

• Getting Started.
• Environment set up.
• Collected links to critical resources and tutorials on:
  • Web Usage Examples
  • Smart-Contracts Development
  • Debug & Testing

Definition of Done

• create an open-source repository
• choose documentation engine
• improve styles of documentation pages to become user-friendly even for my mom
• create hypothesis journeys for different types of developers (zero, regular, advanced, etc.)
• create visually new documentation experience with all the stuff from old documentation but user-friendly
• host on test domain as MVP to make closed beta
• improve with feedback after 10+ live interviews with devs from the community
• clarify a structure and journeys with interviews experience and experts from the community
• build the final version with an understanding of the actual needs of different kinds of developers the

Reward

• Standard TON Footstep NFT
• 6000 TON
• New Generation of Happy Developers :)

Total: $10800

Summary

We need to add FunC grammar to highlight.js so we can:

• Highlight FunC code
• Autodetect FunC code with some precision
• Use existing JS ecosystem to do that

Later we can add more languages to the mix.

Context

No response

Goals

• Provide a way to highlight and autodetect FunC code in JavaScript ecosystem

Deliverables

• Fully set up repository with grammar / testing / building infrastructure: https://github.com/highlightjs/highlightjs-func
• NPM package: https://www.npmjs.com/package/highlightjs-func

Definition of Done

• npm package with custom grammar is published: https://www.npmjs.com/package/highlightjs-func

Reward

• 900 TON

Total: $1200

Summary

Develop smart contract for shuffling NFT's

Context

We want to add some game mechanics to NFT's on TON.
One of the things that come up to mind is NFT ruffle mechanics.

Basic mechanics are pretty simple:

• Bob chooses NFT(s) he would play with
• Alice finds Bob's game on marketplace
• Alice offers her NFT(s) to Bob
• One Bob & Alice agree on NFT's game starts
• Smart contract shuffle's NFT's between Alice & Bob

FYI: this grand is funded by Getgems & TON Frogs NFT

Goals

• develop smart contract which allows users shuffle NFT's

Deliverables

• contract itsels
• tests
• docs

Detailed technical requirements could be found here: https://telegra.ph/NFT-raffle-contract-Product-Description--Technical-requirements-09-07

Definition of Done

• NFT marketplaces on TON are able to implement NFT shuffle mechanics on top of this contract

Reward

• 2000 TON

Total: $2600

Summary

Robust solution for distributing testnet TONs to developers.

Context

Current faucet bot is under constant attempts to drain it and CAPTCHA solution affects user experience perspective.

Goals

• Come up with a plan for a reliable and robust testnet TON distribution
• Provide a bot, website or any other means to fund developers with test TONs

Deliverables

• Plan for fighting misusage attempts
• Service capable of distributing TON on testnet, which is capable of working under constant malicious usage attempts

Definition of Done

• Developers are able to get 1 TON under less than 1 minute

Reward

• Standard TON Footsteps NFT
• 2500 USD equivalent in TON

Summary

Example article and supplementary code for launching a telegram bot capable of accepting payments in TON.

Context

Bots are great for providing use cases for TON and we want to encourage people to build more of them. That's why we need a clear tutorial showing how to start accepting payments in TON.

Goals

• Provide a deployable example of Telegram bot capable of accepting payments through TON.
• Make sure code is covered with comments and sufficient documentation is provided for junior developers to handle bot deploy and code reusage.
• Provide clear instructions on how to switch between mainnet and testnet.

Deliverables

• repository with bot code and documentation
• instructions on how to set up and test bot locally

Definition of Done

[ ] Bot can be run from the code provided in the repository
[ ] Bot accepts payments on testnet
[ ] Bot accepts payments on mainnet

Reward

• Standard TON Footstep NFT
• 777 Toncoin

Total: $1100

Summary

We need to add syntax highlight of Fift, FunC, TL-B to prism.js so syntax on https://www.tonspace.co/develop/func/overview/ is highlighted.

Context

No response

Goals

• Add FunC highlighter
• Add Fift highlighter
• Add TL-B highlighter

Deliverables

PR to prism.js

Definition of Done

• PRs are sent

I am not going to commit to get this merged at this point, because, quoting https://github.com/PrismJS/prism

We are currently working on PrismJS/prism#3531 and will only accept security-relevant PRs for the time being.
Once work on Prism v2 is sufficiently advanced, we will accept PRs again. This will be announced on our Discussion page and mentioned in the PrismJS/prism#3531.

There's nothing I can do to get it merged right now. But, I will get this merged after v2 is released.

Reward

3 * 500$ = 1500$ worth of TON on the moment of footstep completion

Total: $1500

Summary

In its current form, there's no argument that FunC is difficult to work with. One of the primary reasons it's difficult for new developers is that its standard library is very low level and doesn't provide enough abstractions. This can be solved by creating a set of reusable libraries in FunC that will provide developers with common contract services with simple API. Think of these as optional extensions to the standard FunC library.

This concept is not new. In the Ethereum ecosystem https://www.openzeppelin.com/ provides a very similar service. Whenever a Solidity developer needs to implement some complex pattern, such as proxy contract for supporting code upgrades, they would not try to implement this from scratch. They would simply go to OpenZepplin, download a ready-made library in Solidity that contains the complex implementation and embed it in their project. You can say that OpenZeppelin abstracts away the complexities of the proxy pattern by wrapping it with simpler API.

We can do the same for common tasks that are complicated in FunC.

Context

There's a common complaint in the TON ecosystem that FunC is too complicated. I see many developers comparing it to Solidity and asking why has TON chosen such a complex language for its smart contracts. To be honest, I disagree with this claim. FunC is not much more complicated than Solidity. I believe new developers get this feeling just because the FunC ecosystem is immature and this can be heavily improved by adding a few footsteps. This one for example.

I saw a proposal in the community to dance around FunC by creating a transpiler from JavaScript or Python to FunC that will allow new developers to write their smart contracts in "easy languages" like JavaScript and Python instead. Will such an idea really make contract development on TON much easier? I don't think so. FunC syntax is pretty much identical to regular C, and JavaScript syntax was taken from C as well. I don't think this is where the complexity comes from.

A lot of the complexity comes from the lack of abstractions in FunC. Consider the code needed to check if an incoming internal message is a bounced message:

int flags = cs~load_uint(4); ;; int_msg_info$0 ihr_disabled:Bool bounce:Bool bounced:Bool
if (flags & 1) {
    ;; handle bounced message here
}

In most contracts this piece of code appears as is, here's an example from Jetton official standard. What is a new developer supposed to understand from looking at this code?

Now imagine that there was a FunC common library for parsing internal messages with abstracted API that looks like this:

int flags = parse_message_flags(cs);
if (is_bounced(flags)) {
  ;; handle bounced message here
}

This would be so much easier to understand, because all the non-interesting implementation details like the const values of the flags or the bit structure of the incoming message are hidden away inside the library.

Now I'm pretty experienced with FunC and when I look at code that looks like this, I can't do much except scratch my head in wonder. WTF. This is not because FunC is complicated. It's because there are bunch of abstractions missing and I'm looking at internal encoding of messages that I don't really care about as a "regular" developer.

Abstractions are not a new idea. When we implemented TonWeb, we put a lot of abstractions in place to create readable API and hide message encoding details from most developers. Here's an example.

Goals

• Review existing FunC contracts and look for repeating complex patterns that are candidates for abstraction.
• Divide these patterns into families - for example one family can be message encoding.
• Create a collection of FunC libraries that developers can import into their code for performing basic tasks in each family.
• The libraries will abstract away implementation details (like how the messages are actually encoded) and help developers focus on the major things such as their own logic.
• Create an environment where developers could collaborate on improving these libraries since the community will need to develop them together. This can even be a GitHub repo dedicated for the purpose on the official TON GitHub org. Since these libraries will be used in smart contracts, changes will have to be reviewed by our best FunC experts.
• Make these libraries easy to learn with proper documentation.

Deliverables

• An initial set of FunC importable libraries for different common topics.
• Simple and easy to understand API that abstracts away the complex implementation details.
• A place where these libraries are published and maintained.
• PRs to take some of our common contracts (like Jetton, NFT) and make them rely on the libraries instead to simplify their existing code.
• Clear documentation for each library that explains every function and shows example usage.

Definition of Done

[ ] Deliverables part is delivered

Reward

• Standard TON Footstep NFT
• I think some grant is due since this task is delicate

Summary

Develop smart contract for selling NFT's for Jettons

Context

Currently only smart-contract for NFT sales by TON's are available.
Since we already have standard for custom tokens on the network (Jettons) it would be great to develop smart contracts to allow users to buy NFT's for Jettons.

Goals

• develop smart contract that allows to sell NFT's for Jettons

Deliverables

• contract itself
• tests
• docs

You can find detailed technical description here: https://telegra.ph/NFT-Sales-for-Jettons-contract-Product-Description--Technical-requirements-10-21

Note: this grand is funded by Getgems

Definition of Done

• NFT marketplaces on TON are able to implement NFT sales for Jettons using this contract

Reward

• 2800 TON

Total: $4750

Summary

Call for TON Society (https://society.ton.org/) blog posts covering wide variety of topics.

Context

Provide a platform for teams or independent devs to share insights or updates about their work on TON.

Goals

Increase visibility for teams or independent devs, increase insightful content in English, and incentivize knowledge sharing.

Deliverables

Write the post via markdown on Secret Github Gist and share the link via email ([email protected]) or Telegram (https://t.me/tonsociety_chat). If accepted, review committee will add it to TON Society Blog.

Definition of Done

Shared Secret Github Gist link via email or Telegram channel.

Reward

TON Footstep NFT
Discretionary Toncoin reward for high developer value-add posts

Summary

The framework must support:

1. CRUD wallets
2. Creation of Jettons (supporter of tokens/coins based on TON)
3. Creation of NFTs
4. Sending tokens/coins/nft to addresses
5. Smart contracts for breeding NFT and NFT changes

This framework will be very convenient for all creators of projects on TON, such as Games and Services.

Context

This framework is critically needed. Current documentation and frameworks are very far behind similar on other networks. (for example, solana py)

Goals

Simplification and acceleration of work with the TON network when creating projects.

Deliverables

The task is considered completed after the creation of a working version of the framework that implements all the steps indicated above.

Definition of Done

[ ] Repository created

[ ] Text files submitted

Reward

Standard TON Footstep NFT
Honor

Summary

Cover all the methods of browsing TON Sites:

• ton.run
• Browser extensions
• Connect to a public proxy through device settings
• Run your own proxy
  Explain their pros and cons, provide useful links.

Context

Currently, there are no such article on Tonspace or any other source. Users can't easily find information about connecting to TON Proxy and browsing TON Sites.

Goals

• Cover "How to open any TON Site" article

Deliverables

• Ready article for tonspace.co

Definition of Done

• "How to open any TON Site" article covered
• PR accepted in tonspace.co repository

Reward

• Standard TON Footstep NFT
• 100 TON

Total: $170

Summary

We are developing a wrapped Toncoin (wTON) in a jetton format, which will serve as a universal intermediary for exchanging TON-based jettons (tokens) in any trading pairs on TON-based DEXs, and will be used in other TON-based applications.

Our next (and big) goal is not only to program a wTON smart contract, but to create the wTON everyone is happy with.

The benefits of a universally adopted wTON (compared to lots of different wTONs, which have been already created and/or will be created in the future) are as follows:

• Consensus of interested participants
• No financial risks for the end users (e.g. avoid other wTONs which might be scam ones)
• No ecosystem fragmentation
• A single standard API and a single standard set of features

Context

Implementation of a wrapped TON contract doesn't require a lot of effort. As a matter of fact, several implementations already exist. The problem is that numerous different wTONs created by different developers bare lots of risks:

• Financial risks: there is no guarantee that a particular wTON doesn't hold security vulnerabilities left deliberately or by mistake. Getting security audits and certifications of the same quality for all the many wTONs is unrealistic.
• Ecosystem fragmentation and no single API: this is a real problem for developers who are building products that will have to use a variety of wTONs. Imagine a wallet developer who wants to correctly display the total amount of wTON, including regular and all kinds of wrapped ones.
• No parity of features: each wTON will have its own unique set of features, which will lead to additional hassle with support.

The solution could be a standard, universally adopted, audited and certified wTON with a set of features that fits the needs of most developers. Of course, it won't prevent creating other wrapped TON contracts, but most likely developers will prefer to use a widely used, universally adopted and community-led wTON if there is one.

We have already implemented these features:

• Wrap/unwrap functionality
• Conformance to Fungible Token Standard TIP-74

Goals

To create wrapped Toncoin, which will serve as a universal intermediary for exchanging TON-based jettons (tokens) in any trading pairs on TON-based DEXs, and will be used in other TON-based applications.

Our next (and big) goal is not only to program a wTON smart contract, but to create the wTON everyone is happy with.

Deliverables

Source code which will include these features:

• Custom payload for minting/burning transactions.
• Support for query_id parameter similar to TEP-74.
• Better gas management via reserves which will allow not to use any hardcoded fees in the code.

Definition of Done

GitHub repository with the source code.

Reward

5000$ in TON equivalent

Summary

Implement TON-specific lexer for pygments, popular python library used for hightlighting syntaxes. This will enable syntax highlighting at learnxinyminutes.

Context

No response

Goals

• FunC, Fift and TL-b are supported in pygments
• FunC, Fift and TL-b are highlighted at learnxinyminutes & other python-based projects

Deliverables

• Write pygments lexer for FunC
• Write lexer for Fift
• Write Lexer for TL-b
• Contribute to pygments

Definition of Done

Learn FunC in 15 minutes page has a right syntax highlighting with local Pygments & learnxinyminutes repos

Reward

• 600 TON
• Standard TON Footstep NFT

Total: $800

Summary

Provide a migration path for jettons to new contracts.

Context

TEP-89 introduced discoverable jetton minters.
This means that previously deployed jettons are not discoverable and have to deploy an auxiliary contract for adding such capability.
We suggest to support a migration path such that non-discoverable jettons can be migrated to a new (discoverable) minter.

Such a migration solution will also serve further extensions to the jetton protocol in the future.

Suggested Flow

A migration contract will be deployed such that it is linked to a certain minter contract.
Holders of the outdated jetton can send their jettons to the migration contract and receive new jettons instead.

Goals

Come up with a full solution to the migration path, including a contract interface & implementation as well as a UI.

Deliverables

• A PR to jetton.live with UI operating the migration (https://github.com/ton-defi-org/jetton-deployer-webclient)
• Documentation stating out the solution logic. Attack vectors should be specified and resolved.
• TL-B schemas for operations and storage
• Github repo with contract (latest stable func version using latest syntax)
• Full tests (typescript, sandbox)
• Full blueprint-style contract wrapper
• Code for deploying the contract (typescript)

Technical instructions

• Compiles under func 0.4.1
• Uses latest syntax: consts, include and pragma directives
• Opcodes are CRC32 hashes
• Gas-efficient
• 100% Test coverage (using sandbox)

Definition of Done

The contract is deployable and provides a migration path between minters

Reward

5000$ in TON equivalent paid out by these milestones:

• 20% - complete detailed solution documentation specifying logic, interfaces and TL-B schemes.
• 40% - contract implementation with tests, deployment code
• 40% - PR for UI

This grant is funded by Orbs as part of its ecosystem grant program.

Summary

Cover the process of minting a fungible token on TON for new developers in the ecosystem.

• Describe Jetton Deployer Contracts and how they work
• Describe Jetton Deployer WebClient and how it works
• Deploy first tokens by the user of the tutorial
• Help to see the user's token balance in his wallet

Context

I describe in the most detailed and simple way for mastering how to make your own token in the blockchain TON.
The description includes a multi-level explanation of the material in different ways of implementation.

Goals

• Submit an article about creating your token

Deliverables

• Ready article for tonspace.co

Definition of Done

• Article "Mint your first Jetton" covered
• PR accepted in tonspace.co repository

Reward

• Standard TON Footstep NFT
• 100 TON

Total: $160

Summary

We suggest delivering a clear article on how to calculate fees on TON.

Context

It is unclear how fee works now and what happens when transactions are sent.

Goals

• Provide an article on how to calculate fees on TON with examples.
• Make sure person with little or no blockchain literacy understands how fees work on TON.

Deliverables

• An article in a form of a draft or GitHub repository

Definition of Done

[ ] Person with no or little blockchain literacy able to understand how fees work on TON

Reward

• Standard TON Footstep NFT

Summary

Tokens that can be controlled by multiple parties without listing all those parties in token's contract (to decrease fees.

Context

There are cases when the right of controlling NFT or jettons has to be granted to some smart-contract, but logically the token owner remains same. For example, in P2P exchanges without intermediaries people may wish to transfer their tokens not instantly but with some delay; in this case they may schedule a message on timer, but then they need to make token trust the timer. Transferring tokens to timer's contract is not safe because if timer breaks, token will become inaccessible.

Goals

I propose to create a new standard: ACT. Token owner would send an authorization message (its structure needs to be decided) to smart-contract he allows to control the token; when that smart-contract needs to send a message to token, it sends it along with Merkle proof of existence of that authorization message.

Deliverables

• create format of authorization and deauthorization messages
• decide how authorized contract would create Merkle proof
• solve problems with Merkle proof creating in FunC, possibly write a documentation page for that
• create sample AC (authorized-controllable) NFT
• create sample AC jetton
• propose a TEP

Definition of Done

• TEP created
• TEP merged
• A jetton or any NFT in mainnet is authorized-controllable

Reward

• Standard TON Footstep NFT
• (to be decided)

Summary

Evolve existing VS Code extension functionality.

Context

We have existing extension, but it needs to be improved to support more use-cases and modern FunC syntax.

Goals

• involve existing VS Code extension

Deliverables

• implement new FunC syntax functionality (includes & strings)
• includes file tree analysis
• refactoring functions and variables
• variable type inference
• better type suggestions
• auto-formatting
• snippets for opcodes
• smart auto-complete

Definition of Done

VS Code users should be able to easily write & refactor FunC code with help of this extension.
Work should be done in two month after start.

Reward

• 4000 TON's

Total: $5600

Summary

I am trying to get nice ton domains, to be in a next future in good position for TON explorer…but if i get a good name, other people with with much more money can get it for auction.
I think the open network need innovative people that believe in platform but these people can lose hope and be angry, because other companies/person with ONLY money, get all they want…and get the idea of good ideas( dns) people.
My idea consist in give 1-5% in TON coin to the final price in auction to first person who got the “idea”.
Doing this i think that much many people would invest 10 TON in many “good names” …looking for some money.
The open network would get a lot of new dns names, and a lot of rich companies/persons to get it.
With more and more names, TON will be much bigger, and growing will be faster.
I trust in project and want to collaborate. Thanks.

Context

Many people we are trying to get good ton domains, thinking a lot ant trying to be innovative…but many people only need to have money to adquire in auction all domains they want

Goals

Only idea

Deliverables

Idea

Definition of Done

Idea

Reward

4000

Summary

TON might benefit from getting a cookbook with clear recipes for solving some common tasks.

Context

Cookbooks are common in software development: these are collections of actionable and practical tips & tricks on how to execute certain concepts. This question on Quora contains a great explanation of what cookbook is.

Regarding the blockchain there are a couple of good examples: Ethereum and Solana ones.

Inspiration: examples from the community

To understand which exactly FunC examples developers need was launched a feedback form in google document for everyone from the community:

https://docs.google.com/document/d/1l5865CZ2IzjD1r054rYPaPkNCBaUVVt2iEy9bWJGZqA/edit#

Everyone is welcome! If you don't see necessary things just add them to the list.

Goals

• Deliver TON cookbook containing recipes on the questions which are frequently asked by the community

Deliverables

• To write examples, you should decide where to write them. We provided a page in the TON Documentation for that:

https://ton.org/docs/develop/func/cookbook

Definition of Done

• Any junior developer without prior blockchain development experience is able to get quick onboarding to TON
• Any junior developer is able to set up TON developer environment and submit a hello world contract

Reward

• Standard TON Footsteps NFT

Basic examples

Total: $1225 for 49 examples

Advanced examples

Total: $450 for 9 examples

Important

• 25 USD (50 USD for advanced examples) equivalent in TON for every high-quality func example covered from the initial list.

How to participate?

• Please, respond to this message with a list of examples you want to cover, so I'll add you as assigned to them

Summary

Enhancing TON Wallet by adding several key functionalities.

Context

TON Wallet is the only cross-platform open source wallet on the TON blockchain, but it lacks important features such as jetton, NFT, staking, purchasing and biometric authentication. It needs much improvement to be comparable to the wallets of major blockchains such as Ethereum and Solana.

Goals

• Adding support for jetton, NFT, staking, purchasing and biometric authentication to TON Wallet (all platforms).

Deliverables

• Updated and working version for all platforms.

Definition of Done

[ ] Update of official repositories and binary version.

Reward

• 10000 TON (?)

Summary

Repeat #8 but in Node js

Context

Bots are great for providing use cases for TON and we want to encourage people to build more of them. That's why we need a clear tutorial showing how to start accepting payments in TON.

Goals

• Provide a deployable example of Telegram bot capable of accepting payments through TON.
• Make sure code is covered with comments and sufficient documentation is provided for junior developers to handle bot deploy and code reusage.
• Provide clear instructions on how to switch between mainnet and testnet.

Deliverables

• repository with bot code and documentation
• instructions on how to set up and test bot locally

Definition of Done

[ ] Bot can be run from the code provided in the repository
[ ] Bot accepts payments on testnet
[ ] Bot accepts payments on mainnet
[ ] Article hosted on tonspace

Reward

• Standard TON Footstep NFT
• 777 Toncoin

Total: $1150

Summary

We need to add Fift language support to https://github.com/highlightjs/highlightjs-func

Context

No response

Goals

• Fift is highlighted by highlight.js
• Fift is autodetected by highlight.js

Deliverables

• highlight-func npm package

Definition of Done

• highlight-func npm package released with Fift support

Reward

• $1000 worth of TON on the moment of footstep completion

Total: $1000

Summary

Let's be honest - to get into TON programming is quite a hustle. Documentation is great, but there is lack of hands-on tutorials and "speaking heads" when it comes to programming meaningful smartcontracts, NFTs or dApps for TON. I'm on my learning path, but I've decided to walk the extra mile and produce media content from my learning process. I will plan, produce and distribute a series of videos along with text tutorials that will get a new-comer into this programming field.

Context

I'm quite an experienced developer in classical fields like backend and frontend developments. However, learning to program for TON is quite hard for me. I want to make this much more friendly. I'm also a person who needs to see the whole process end-to-end in order to make the first steps. Recording my footsteps into an organized series of materials can be a great resource for the community.

Goals

• record a series of tutorial videos with outlining all the moments that are not clear for me in the process
• organise Q&A sessions with experienced developers and record our conversations to provide new-comers with ready-made answers
• produce text tutorials based on those videos, to equip those who are more reading type of people

Deliverables

Self-onboarding series (currently planning on 10 videos)
In this series of videos, every video will contain a tutorial on a certain topic that I’ve recently learned as well as rising the questions that I’ve encountered during the learning process. Each tutorial video will be then followed by a Q&A session video with some experienced TON developer from the community, who will answer the questions and guide me further.
Average video length - 60-70 mins.
Every video tutorial is going to have a text version published on Medium.com

1. Environment setup & first “Hello world” smart contract based on https://github.com/romanovichim/TonFunClessons_Eng
   [Video is already published https://www.youtube.com/watch?v=RbIt8bjvvjE]
   + video Q&A with a pro smart contracts developer
   [Script is ready. Negotiating a Q&A session with Narek Abovyan from TonTech]
2. Programming a simple smartcontract with the tonstarter-contracts (TypeSript) approach
   In this video I will program a simple smartcontract and write a number of tests for it.
   + video Q&A with a pro - Agreed to have a call with Tal Kol as he is an ambassador of this approach.
3. Programming a dApp that will interact with a simple smartcontract from browser [as an example I can provide another video I've published on programming a TonHub extension - Youtube Link
   + video Q&A with a pro
4. Programming a ReactNative application that interacts with TON smartcontract
   This video is different from 3rd one, because I want to outline that Web3 is not just browser, but can also involve a mobile application. Will be helpfull as I’m going to overview known libraries for RN.
   + video Q&A with a pro
5. Setting up own API instance of communicating with TON blockchain.
   + video Q&A with a pro

I plan to prepare and publish 1-2 videos per week. So overall project might take 2-3 months to finish.

Contentful series (currently planning on 5 videos)

As oppose to the Self-onboarding series, Contenfull videos are going to be much shorter (20-30 min) and each video is going to cover very focused information on specific topic. The content of this video will be basically a mix of what I’ve learned by myself and what I’ve learned from pro TON developers during Q&A sessions.

1. TypeScript vs ton-cli approaches
Pros & Cons, Resources, Tools

2. Authentification for dApps
TonHub, TonKeeper

3. Writing tests for TON smartcontracts
Outlining the importance of writing the tests, approaches

4. How to read the TON's whitepaper?
+Why is there so many WPs? Durov’s WPs vs Ton Foundation WP
+Outlining practical parts of the WP that are required to understand for programing for TON
+Outlining core conceptual parts of the WP
+Which parts of TON’s WP are already implemented and which are yet to come?
While preparing for this video I will have a series of conversations with experienced crypto folks to make sure my material is not superficial.

5. Usefull tools, APIs, Resources

Definition of Done

15 videos according to topics announced in the Deliverables block, published on YouTube with text versions published on Medium.com and Dev.to

Reward

I'm setting up an expected reward based on my workload and salary at my main full-time job.

Preparing a single video takes me 1.5-3 days. I make approx. $ 200 / day at my job.
I think to count for example $300 (in TON equivalent) per video. $300 * 15 videos = $4,500. And of course we divide this by 3 as I'll deliver this over 3 months maximum.

So I would round it up to 4000 TONs ($5600 if the rate is $1.4/TON) then I could buy a good microphone, webcam and light, to provide a better quality of videos. But I'm open to your offers.

Suggested milestones:

1. 5 videos by November 1 - $1500
2. 5 videos by December 1 - $1500
3. 5 videos by January 1 - $2600

All the videos will be produced and published in the order according to the list order above.

Summary

Smart contracts for Soulbound NFT's

Context

So-called soulbound NFT’s are such NFT’s that are only owned by single person and should not be sold or transferred.
Original idea was described in this article from Vitalik Buterin http://vitalik.ca/general/2022/01/26/soulbound.html

I think TON needs this kind of NFT's to be on the cutting edge of crypto world.

FYI: this grand is funded by Getgems & ton punks

Goals

• develop SBT smart contract's and code for interacting with them

Deliverables

• SBT collection smart contract with NFT-item smart contract
• Single SBT NFT smart contract
• tests
• docs

Technical requirements could be found here: https://telegra.ph/TON-SBT-Contract-Product--Technical-requirements-07-11

Definition of Done

• TON NFT marketplaces & creators are able to create soulbound NFT's

Reward

• 1000 TON's

Total: $1200

Summary

Add TON support to the most popular hardware wallets: Ledger and Trezor.

Context

Non-custodial wallets are extremely important to the ecosystem of any blockchain. In particular, cold wallets such as hardware wallets are fundamental missing pieces for TON.

Goals

Adding support for Ledger (open source plugins) and Trezor (open source wallet).

Deliverables

Support for production-ready hardware wallets.

Definition of Done

[ ] Updating of official repositories. In the case of Ledger there is already a working plugin written by one of the TON core developers.

Reward

2500$ in TON equivalent (?)

Summary

Teach FunC smart contract developers how to manage gas in the contracts they're writing.

Context

TON contract gas model is very unique and quite different from the EVM model. Contract developers must design a gas strategy. If they won't do this well, the contract can run out of TON balance for rent and be removed. Messages that the contract sends might not have enough gas and be rejected. This is an advanced topic, not an introductory one.

Goals

• Help FunC developers write better smart contracts.
• Help FunC developers avoid gas handling mistakes in their code.
• Target audience - experienced FunC developers that already know FunC basics.
• Help teams that are actively working on contracts mature faster and become production ready.

Deliverables

A markdown article in a form of a GitHub gist or GitHub repository

Definition of Done

• A well-written article about the general idea and motivation behind TON's gas model for smart contracts.
• Article lists pit falls where developers can make a gas mistake and render their contract un-usable.
• Article gives best practices (do's and don'ts) for handling gas in FunC. Example: How much balance should be left for paying rent (storage fees)? How are storage fees calculated and what is the storage fee per cell per year.
• Article shows all of the above in practice with multiple hands-on code examples.

Reward

• Standard TON Footstep NFT
• 400$ in TON equivalent

Summary

zero-knowledge proofs (zk-snark) protocol for private transactions on a workchain (private workchain).

Context

Support private workchains for companies similar to Hyperledger, VeChain or Corda.

Goals

• Implement zk-snark protocol.

Deliverables

• Repository with working implementation of the zk-snark protocol on workchain.
• Documentation about how to deploy a private workchain.

Definition of Done

[] Working private workchain example.

Reward

• 35000 USD equivalent in TON
• 12500 USD equivalent in TON extra if the implementation is delivered in less than 2 months

Describe TON Footsteps NFT concept

Summary

TON Footsteps need to be connected with blockchain, thus a person responsible for helping TON to make a single footstep, will get a single NFT delivered to their TON address.

Context

• Such NFT should contain link to a TON Footstep description.
• The process of issuance should be automated.
• Such NFTs ideally should be SBTs (bound to the address without an option to sell or transfer NFT to other account).

Goals

• Create a trace of footsteps on TON master chain.

Deliverables

• Title and description of TON Footstep NFT.
• Suggested picture / visual representation of such NFT.
• Description of the process of minting such NFTs.

Definition of Done

• Title and description are present
• Visual representation is aesthetically pleasant
• Description of the process states when and how TON Footstep NFT gets minted

Reward

• Standard TON Footstep NFT

Summary

Cover the process of creating a simple Telegram WebApp that retrieves some information from the TON blockchain.

This tutorial was requested by ton.org/docs:
ton-community/ton-docs#20

Context

Currently there are no simple and understandable tutorials for creating web apps in docs.
It may be too difficult for beginners to create their first web app interacting with the TON blockchain.

Goals

Cover the process of creating a simple Telegram WebApp that retrieves some information from the TON blockchain

• Describe the process of creating the bot and WebApp in Telegram
• Create a meaningful goal for the end user to be interested in finishing tutorial
• Use ready-to-use libraries for TWA (tonstarter-twa or twa-dev/boilerplate)
• Describe the process of receiving the first information from the blockchain with one of the SDKs

Deliverables

• Example web app
• Tutorial covering how to create such web app

Definition of Done

• Ready tutorial for ton.org/docs
• PR accepted in ton-docs repository

Reward

• Standard TON Footstep NFT
• 750$ in TON equivalent

Summary

We need to add Tlb language support to https://github.com/highlightjs/highlightjs-func

Context

No response

Goals

• Tlb is highlighted by highlight.js
• Tlb is autodetected by highlight.js

Deliverables

• highlight-func npm package

Definition of Done

• highlight-func npm package released with Tlb support

Reward

• 600$ worth of TON on the moment of footstep completion

Total: $600

Summary

Tutorial allowing minting single NFT without help of 3rd parties, just with a bare CLIs and general environment for FunC / development on TON.

Context

There is no tutorial on how to mint standalone NFT in TON without using help of any 3rd party. With this Footstep we suggest creating tutorial and / or corresponding repository with all the code and tools required to mint a single NFT on the mainnet and testnet.

Goals

• Create tooling / code for minting single NFT
• Cover it with extensive documentation
• Provide comprehensive README, so the repository can be used on its own and/or
• Write a tutorial for using such a repository, so a mediocre developer capable to set up FunC / TON development environment is able to mint NFT following this tutorial

Deliverables

• Repository with tools to mint standalone NFT
• Tutorial covering how to mint standalone NFT

Definition of Done

[ ] Suggested tools allow minting standalone NFT following the instructions
[ ] Developers are able to find information on how to set up initial environment and to mint NFT

Reward

• Standard TON Footstep NFT
• 777 Toncoin

Total: $1250

Summary

Library that would be essential for TON projects that need production ready solution to index TON blockchain.

Context

When it comes to working with data from the blockchain and you need a some way to store, parse, subscribe to a blocks, a transactions, a messages then your choices are pretty limited.

Here's the ways (at least the ones that I found):

1. Start your own Liteserver
2. Connect to one of the existing Liteservers
3. Use one of the free services like TON HTTP API

The first option is not really an option for most of the developers. Cause you need to run a full node which you need to maintain and infrastructure costs are not cheap.
The second option's major drawback is that you need to trust the Liteserver you're connecting to. And service provider need to scale their infrastructure to support all the users.
And same goes for the third option. You need to trust the service you're using and service provider need to scale their infrastructure to support all the users.

That kind of problem faced by a team from Pagoda Indexer from NEAR ecosystem.

And they came up with a solution which involves AWS S3 and consists of a pair of libraries: NEAR Lake Indexer and NEAR Lake Framework.

NEAR Lake Indexer is a library that allows you to connect to the blockchain and store the data in AWS S3.
NEAR Lake Framework is a library companion to NEAR Lake Indexer that allows you to connect to the AWS S3 and parse the data.

What got me interested in this solution is that availability is handled by AWS S3 and with Requester Pays option cost would be fixated for the provider and end users by would pay by themselves for the data they're using.

Goals

• Provide a fundamental library for future (or existing) TON projects that would need to store and parse blockchain data

Deliverables

• Create a library that would allow to connect to the blockchain (Liteserver) and store the data in AWS S3.
• Create a library that would allow to connect to the AWS S3 and fetch the data

Definition of Done

[] TON Lake Indexer, which meets the goal requirement and open source
[] TON Lake Framework (Rust version), which meets the goal requirement, open source and crate available on crates.io: Rust Packages Registry
[] TON Lake Framework (JS/TS version), which meets the goal requirement, open source and package available on npm

Reward

• Standard TON Footstep NFT
• 7000 TON

Summary

Develop smart-contract for swapping NFT's

Context

Sometimes users don’t want to sell their NFT but are ready to exchange it for other NFT(s).
This is exactly what we want to achieve here.

FYI: this grand is funded by Getgems & Tegro NFT

Goals

• develop smart contract which allows users to swap their NFT's

Deliverables

• contract itsels
• tests
• docs

Technical requirements could be found here: https://telegra.ph/NFT-swap-Contract-Product-Description--Technical-requirements-08-24

Definition of Done

• NFT marketplaces on TON are able to implement NFT swap mechanics on top of this contract

Reward

• 2000 TON

Total: $3700

Summary

Write article about the most famous explorers in the community. Help the new developer decide which explorer is the best for him. At least we need:

• The best explorer for development
• The best explorer for everyday use
• The best explorer to work with NFTs

Context

No response

Goals

• Provide article about explorers

Deliverables

• Ready article for tonspace.co

Definition of Done

• Article "Explorers" covered
• PR accepted in tonspace.co repository

Reward

• Standart TON Footstep NFT
• 100 TON

Total: $170

Summary

We need to create a project that can parse TL-B files into abtract syntax trees.

Context

This is needed for other tools:

• Code generators
• Linters
• etc

Goals

• Create a PEG grammar based on ohm library

Deliverables

• npm package with the full language grammar

Definition of Done

• npm package with the working parser is submitted

Reward

• 2000$ worth of TON on the moment of footstep completion

Total: $2000

Summary

Spam is a hard problem to solve. Bad actors are taking advantage of TON's low transaction fees to exploit iconic mechanics of web3, such as NFT airdrops.

These unwanted NFTs often claim to give users a free gift/NFT if they click a link in the description. Clicking the link leads the users to a site where typically one of two things happen:

1. Users are asked to approve a transaction to “mint” or “claim” a free NFT, but instead they lose their funds.
2. They are asked to input their seed phrase, which results in a total loss of funds.

These scams are becoming increasingly more sophisticated. For instance, after a contract address and domain is identified as malicious, scammers can change the metadata of an NFT. It can feel like an endless game of whack-a-mole, but one we’re committed to winning.

Context

To remove unwanted wallet spam, simply select the NFT you want to burn in the Collectables Tab, and select the Burn Token.

Goals

Protect users from unwanted nft spam. And the NFT with a broken smart contract.

Deliverables

Burn and "delete" - Introducing NFT Burning.

Definition of Done

Create and integrate Smart contract - Burn NFTs.

Reward

100-1000 TON from our team. And up to 250-2500 TON, for integration into the Uniton wallet.

Summary

Timer smart-contract built natively on TON without any external messaging that will allow users of The Open Network to schedule messages to some time in future.

Context

This service can be used by NFT creators to run presales and auctions reliably, or by DAOs wishing to conduct some elections or collect votes on a proposal (limiting token holders' time to vote but not forcing everyone to make decision).

Program sending external messages can break at any time (for example, if network connection is lost); this timer is going to work as long as TON itself.

There will be possibility to deploy one's own timer contract - for example, for purposes of debugging message chains (so others' messages don't fill up transactions list), or if other contracts almost run out of gas when trying to process messages. As the deployer is the one filling up contract's balance, ones who join the existing timer give that person a small reward.

Goals

Allow TON users to schedule arbitrary messages to some time in future.

Deliverables

• Simple scheduler contract (storing all messages in single contract; similar to https://github.com/EmelyanenkoK/ton_scheduler, but written myself) able to transfer user-specified amount of TON with arbitrary payload, pausing when it doesn't have any messages remaining
  EQDpVsvhlIxDGO3qZtPfrChaiKzlkVt6Rs-6J4Xd8BKIgQK7
schedule#_ fwd_nton:uint64 time:uint32 dest:^MsgAddressInt body:^Any = Msg;
• Purchasing domain for timer (stabletimer.ton on mainnet)
• Implementing multi-message timer with ability to schedule several messages to a single moment of time
• Implementing algorithm for price calculation (that is, storage fee, scheduling cost and reward to the bell deployer)
• Web UI for interacting with existing timers and deploying new ones

Definition of Done

• Timer source code published and possibly transferred to TON repository
• Example timer deployed and working (no messages handled incorrectly because of timer bugs within 3 days of launch)
• Web interface for scheduling messages available
• Integration/ability to construct common messages like token transfers/ability to parse ton:// transfer link and convert that into message to timer (usually ton://transfer links care about sender; token transfers do so even more so they can't be controlled by timer)

Reward

• Standard TON Footstep NFT
• $2000 in TON equivalent

Total: $2000

Summary

Describe in «human» terms for a mass audience the upcoming TON blockchain plans with use cases.

Context

The blockchain team has ambitious plans that are difficult for the non-tech person to understand — this creates a barrier to new users and projects, especially those coming from other blockchains.

Goals

• Provide an article about TON blockchain plan explained with examples
• Make sure a person with little or no technical knowledge of blockchain understands what TON is aiming for

Deliverables

• An article in a form of a draft or GitHub repository
• Each article should cover one of the following topics:
  -- TON Blockchain (general)
  -- TON Nominators
  -- TON Payments

  -- TON Proxy
  -- TON Sites
  -- TON Storage
  -- Bitcoin & EVM Crosschain

Definition of Done

• A well-written articles about TON's milestones
• Examples of how the new TON features will be used by the community / projects
• Comparison of improvements from the TON roadmap with plans for other popular blockchains

Reward

• Standard TON Footstep NFT
• TBD

Summary

CLI tool for fast and easy setup for TON smart-contract developers. The best analogy is the Hardhat from the Ethereum world.

Context

At this stage there is no such tool for setting up a new smart contract project with easy deployment, testing and debugging using JS/TS, which are standard in crypto world. We have toncli which is a good product, but since its core philosophy is to use Fift & FunC for deploying scripts, testing, etc - it's not that easy for new developers to quickly jump in.

Goals

• Come up with a tool that would help developers to jump into TON smart contracts development as fast as possible
• Lower the bar for SMC developers in TON
• Make it easy for solidity developers to start working with TON

Deliverables

• CLI tool itself with functionality:
• TypeScript supported project template for developing contracts in TON with the FunC language.
• Clear testing scenarios, easy way to deploy a smart contract with an example in the project template.
• Integration of ton and ton-contract-executor libraries.
• Modern examples of developing code in FunC
• Tool should be fully covered with docs
• Took the best from toncli and try to be better and more easy to use
• e2e communication with the developer community at the release time

Definition of Done

Developers are able to setup an environment for developing smart contracts in TON and start experimenting in less than 1 hour.

Reward

• 12500 USD equivalent in TON

Summary

Website with stats about the mainnet.

Context

TON now lacks a single website / project to report blockchain stats like Solana bench or Etherscan/charts.

Goals

• Provide a reliable source of statistics regarding the TON Blockchain

Deliverables

• Working and functioning service with reasonable SLAs.

Definition of Done

[ ] Website is available online
[ ] Information on validators, transactions speed, volume etc. is displayed.

Reward

• Standard TON Footstep NFT
• 7500 USD equivalent in TON

Total: $7500

Summary

Add information about toncoin to trust wallet assets repository https://github.com/trustwallet/assets/tree/master/blockchains

Context

Trust Wallet assets repository is used to provide information about crypto coins for a large number of applications. Adding toncoin to this repository would allow these applications to use information about toncoin such as website domain, logo, name, symbol, etc.

Goals

Merge pull request with information about toncoin into trust wallet assets repository

Deliverables

An ability to see toncoin in trust wallet assets repository

Definition of Done

[] Merged pull request with information about toncoin repository in trust wallet

Reward

• Standard Footstep NFT
• 200 TON

Total: $340

Summary

A blockchain is designed to work extremely efficiently with its own internal data but is unaware of external data such as real world exchange rates, or other data not on the blockchain.

Context

A blockchain cannot retrieve data from an external API, due to its internal processes. If nodes address an external API at different times, they may get different results and will never be able to reach consensus, since it is unclear which of these nodes should be trusted.

To resolve this issue, instead of the “pull” model (in which a blockchain reaches out to the real world for data) we can use the “push” model. Data suppliers write data to the blockchain for decentralized apps (dApps) to use.

Entities that save data to the blockchain are called blockchain oracles. But the problem is that all of them operate in a centralized way since they need to trust a single source of data. Overall, a system is only as decentralized as its most centralized element. Therefore, a decentralized app that uses data from a single oracle to make key decisions is in fact, highly centralized. Logically, by influencing the behavior of just one component, the oracle, you can influence the behavior of the entire app.

The idea of a decentralized oracle is an attractive solution, but there is no easy way to implement it.

Here are some solutions on how this issue could be resolved.

Goals

dAPP and smart-contracts

Simplest solution: multi-signature

The easiest solution is a multi-signature approach. Several users reach consensus and sign the same data. For instance, let’s say we want to receive data about the USD/EUR exchange rate and we have five oracles that need to agree on a consensus value (from outside the blockchain), sign the relevant transaction and send it to a blockchain account that will only accept it if it includes at least three signatures out of five.

But this approach has several issues:

If the oracles fail to reach consensus, the data simply won’t be sent to the blockchain
Data suppliers have no financial motivation
The oracle list is predetermined and limited.
To resolve these issues, we need to build a fully-fledged decentralized app, which operates as a marketplace for two kinds of participants:

Apps that need data

Oracles that can supply data for a reward.
Let’s formulate the main requirements for such a dApp and implement it using FUNC and the TON blockchain.

Requirements

OracleRepresenter

A contract, which would be deployed by the service provider and would store "calculation result".

Rules

Contract can be in one of the five phases: idle, supply, showdown, calculation, rewarding

Phases can circulate or not

OracleParticipant would be rewarded depending on how far they from "calculation result"

OracleParticipant

A contract, which can deployed by anyone who wants to participate in future calculations.

Rules

Would be tied to the specific OracleRepresenter, meaning it can participate in calculations for the specified OracleRepresenter

In supply phase it should provide hash of the value

In showdown phase it should provide the actual value

Deliverables

repository with code and documentation

instructions on how to set up and test app locally

Definition of Done

https://github.com/usdton/oracles

Reward

10000 USDL

Summary

Create a service for decentralized on-chain cheques

Context

Cheques are a popular and in-demand feature. People use them every day for different purposes.
But the problem is that all existing services for cheques are centralized and usually hosted on Telegram bots. People can't be sure that their coins are safe and nobody from the administration of the service will claim it. Centralization also means that user must hold coins on service's wallet so there are risks of losing funds in case of some hack or attack on a service.
Another problem of centralized cheques is that they usually don't work with custom tokens (Jettons or NFTs), or even if they do, the Jetton must be listed on their service in order to be used.

Decentralized and secure cheques built on-chain would solve these problems, while still remaining easy-to-use and cheap.

Goals

• Come up with the implementation of on-chain cheques
• Develop smart contract and user-friendly frontend

Deliverables

• Smart contract for on-chain cheques
• Front-end for creating and claiming cheques

Definition of Done

• Any user without knowledge about blockchain can create and claim a cheque using the service

Reward

• Standard TON Footsteps NFT
• 2000$ in TON equivalent

Summary

Cover which wallet contract types are in the TON Ecosystem and why they exist.

• Cover wallet contract + versions (v2,v3,v4, etc)
• Cover high-load contract
• Cover Lockup wallet contract
• Cover restricted wallet

Context

Currently, Wallet contracts article on Tonspace.co is empty

Goals

• Cover "Wallet Contracts" article

Deliverables

• Ready article for tonspace.co

Definition of Done

• "Wallet Contracts" article covered
• PR accepted in tonspace.co repository

Reward

• Standard TON Footstep NFT
• 100 TON

Total: $150

Summary

Time limited TON adress for rent NFT

Context

In real next future, museums, government or companies, will convert his fungible private art collections in NFT.

Goals

The real owners of NFT will lease or rent his NFT to any digital museums for expositions, but if you transfer NFT, now a day, you leave to be owner, if under contract you rent a contract, if there is problems, you cant recover your NFT.
If there are time limited adress, maybe we would be the first secure NFT transfer company…and exploring tranfers you can check the genuine NFT in museums or expositions. Maybe this idea can be good for biggest art owners who dont trust in NFT.

Deliverables

Idea

Definition of Done

Idea

Reward

as you consider.

Init the TON Footsteps workflow

Introduction

This proposal describes what we need to launch the TON Footsteps workflow.

Goals

• Provide a workflow to improve the TON ecosystem (articles, docs, tutorials, tools, etc.) by the community
• Make the proposal process simple, efficient, and transparent

Deliverables

• The list of the TON Footsteps
• Template of a proposal
• Instruction: How to propose a task
• Instruction: How to complete a task from the TON Footsteps list

Summary

Write a smart contract ("Verifier Registry") for forwarding signed messages to other contracts

Context

We run computations on off-chain nodes that produce data which needs to be stored on chain in various contracts.
In order for these contracts to accept the data, they require it to be signed by the off-chain nodes, each of which has a public/private keypair.
The verifier registry holds the list of keypairs and verifies signatures of arbitrary data passed on to the contracts downstream.

Flow

• An entity stakes a certain amount (10K TON) in the verifier registry contract, for which it receives the ability to store its verify configuration (node addresses, public keys for verification, multi-sig threshold)
• Once the configuration is in place, the entity can send a signed message and an address to forward the message to.
• The verifier contracts checks the signatures and forwards the message

Detailed spec can be found in this gist

Goals

Develop a smart contract ("Verifier Registry") for forwarding signed messages to other contracts

Deliverables

• Github repo with contract (func 0.2.0 using latest syntax)
• Full tests (typescript, tvm-contract-executor)
• Code for deploying the contract (typescript)

Definition of Done

The contract can be integrated to the Ton Source project (a smart contract that accepts messages only from the verifier registry)

Reward

• 2.000 TON

This grant is funded by Orbs as part of its ecosystem grant program.

Total: $2600

Summary

Explain to a new user in details how to run a TON Site from scratch.
Tutorial must cover these topics:

• How to run using Docker
• How to run by compiling from sources manually
• How to link website with TON DNS Domain

Context

Currently, there are no detailed tutorials about running TON Sites. Many devs are asking questions in chats and forums because they are having some problems with running the site.

Goals

• Write "How to run TON Site" tutorial

Deliverables

• Ready tutorial for tonspace.co

Definition of Done

• "How to run TON Site" tutorial is completed
• PR accepted in tonspace.co repository

Reward

• Standard TON Footstep NFT
• 200 TON

Total: $350

Summary

TON Dev Chat has many questions and complaints about smart-contract binaries (func, fift, lite-client). On every system binaries need their setup and dependencies to work appropriately (Windows, Debian, Ubuntu, MacOS x86, MacOS arm64). That provides complexity and tons of questions for new developers in the ecosystem and lower conversion to future smart-contracts developers.

Tal Kol already simplified the process with pre-built binaries. But it is still not enough to make your "first smart contract in one evening". If TON wants to provide a first-class experience for developers the process should be as simple as possible.

Tal Kol's experience could be used to make the releases versioning to split versions of TON binaries used by the one-line installer in the future. But today we could start from the MVP of the one-line installer.

Context

Solana

To resolve this issue, other blockchains already have "one-line installer" solutions like Solana Install Tool:

Geth

Or Geth for Ethereum:

TON Installer Tool

TON Installer Tool solution must provide a simple experience for anyone curious about TON and smart-contract development. It must help to avoid a problem where you have many binaries for many versions of OS, which you should update every 3 months!

Goals

• Provide a one-step environment setup experience of TON binaries for every potential smart-contract developer.
• Gather feedback from developers from the community using different types of systems (macOS, Linux, Windows)
• Be sure that all works fine by feedback from the community

Deliverables

• Create an MVP of a one-line installer for TON binaries from master branch of ton-blockchain
• Make an open-source repository that TON Community could improve in the future
• Create installer for macOS x86/arm64
• Create installer for Windows x86
• Create installer for Linux Debian/Ubuntu (16-22.04)
• Test every installer on new developers from the community and fix bugs from feedback

Definition of Done

• open-source one-line installer tool working on macOS x86/arm64 operating systems.
• open-source one-line installer tool working on Linux Debian/Ubuntu operating systems.
• open-source one-line installer tool working on Windows operating systems.
• applied one-line install used in onboarding every smart-contract developer (tonspace.co, ton.org/docs)

Reward

• Standard TON Footstep NFT
• Amount of TON — TBD