What are Best Practices to debug smart contract?

For example I deploy smartcontract to testnet, but something wrong and ton bounce back.

Code is huge, and i dont know where to start debugging.

Can I start local node and read logs, or stdout or something?

I advice you this! https://github.com/Naltox/ton-contract-executor

It allows you to query public smart contracts and execute stuff locally

The best practice is to use ton-contract-executor. If you're familiar with Solidity, this is very similar to what hardhat does. It runs the TVM in Javascript so your tests are very fast and 100% free.

This project shows a working setup for this on a simple contract: https://github.com/ton-defi-org/tonstarter-contracts

You can enable debug mode in ton-contract-executor and then you can add DEBUG prints from inside your FunC code, here is an example: https://github.com/ton-defi-org/tonstarter-contracts/blob/main/contracts/main.fc#L57

Going another step through a contract is not a problem, it's a feature. It makes the system modular and separates the wallet authentication concern (single signer vs multi-sig for example) from the dapp concerns. If Ethereum had made a similar decision you would be able to see people using multi-sig wallets for defi apps there.. which is a big headache currently

I was confused by some repositories like

https://github.com/ton-blockchain/func-contest1-tests/blob/master/tests/tests/tests-1.fc

and this 😅
https://github.com/raiym/astonished/blob/master/smartcontract/test/lottery-test-suite.fif

But i found
https://github.com/ton-defi-org/tonstarter-contracts/blob/main/test/deposit.spec.ts

And it is js-spec-hardhat style, that great news, thanks 😌😌

These are similar to writing your tests in Solidity. I know that many people tried this years ago on Ethereum and everybody concluded it’s not a good idea and nobody does it today

I don’t think we need to reinvent the wheel here, there are established practices for effective smart contract development and those include writing tests in JavaScript. This is by far the most effective and efficient method

In tonweb what is send mode?

FunC is a difficult sandboxed language due to security concerns of managing money on-chain. Much like Solidity. I would only use it to write the code that runs on-chain (the contract itself). Peripherals like a test suite can run anywhere, why would I use the most difficult secure language to write them? JavaScript is by far the easiest most popular language in the world, it’s a natural choice for anything that doesn’t run on-chain.

And regarding Fift, I think you can safely ignore its existence altogether. I haven’t seen one relevant use-case so far that justifies the time it takes to learn it. You simply don’t need it for anything.

The straightforward stack is very simple:

On-chain code - FunC

Everything else (test suites, build and deploy scripts, client apps, telegram bots, backends) - TypeScript

> You simply don’t need it for anything.

I don't thinks so. I could develop native blockchian indexer (in c++ ton sources) only because I've learned Fift before. In my opinion - fift is good for quick experiments and understanding the work of TON.

Toncli helps using fift for interacting with blockchain for parsing and fast MVP developing.

> The straightforward stack is very simple:

Don't think so. Using tonlibjson you can interact with TVM / TON stuff in any language. So actually you can use any language you want. (Go, Python, Etc.)

Also tests can be written on Func itself https://github.com/disintar/toncli/blob/master/docs/advanced/func_tests_new.md it's very simple with new version of toncli & new tests engine.

Would we be able to run @disintar faster without fift & toncli and using typescript?

Maybe.

Would it be just as fun, cool and educational?

Unlikely.

Will be cooler and more fun 😂

Of course you can use any language.. the question what is the most effective. There is soooo much to learn. We don’t need to overkill people with learning things that aren’t a must.

You want your teams to focus on learning 2 environments well and reuse this knowledge for multiple products. You will be able to ship faster in higher quality.

You’re not going to build your client in Python. And if you already know a good testing framework on JavaScript might as well reuse it for other parts.

I actually think it’s much more educational too. So people can focus on the important things and not on boilerplate :)

In the current scenario, typescript is a very complex setup, the improvement of which will greatly slow down "growth".

Fift is much closer to the TON sources and allows you to experiment and introduce improvements faster.

The improvement of TON is much easier through the improvement of fift than through typescript, which has a very distant relationship to the TON sources.

Show me the contributing activity to the TON sources from your typescripters? If you look at the core TON repo improvement, you will see that these people are using fift.

So I would be careful with the choice of "important things"

I think if the core people would switch to improving infra like ton-contract-executor and improving the TypeScript stack, it would do much good to the ecosystem

TypeScript is no longer a complex setup, you have starter projects already set up

I don't think so. Fift is very close to the TON sources and allows you to understand them more accurately, as well as quickly make improvements.

Whereas ton-contract-executor is a very far thing from the sources, although it is really good.

Normally you don’t want your app developers working in the opcode/bytecode level. We have abstractions for a reason

But of course there is no right answer, it’s all a question of personal taste ❤️❤️

Here is a relatively complex multi-contract AMM with client and contracts and bot, with the stack I believe in, without toncli and without fift: https://github.com/tonswap

When we finish improving ton-contract-executor and wrapping it like hardhat, unify the api between tonweb and ton npm, this will be so elegant you could eat off of it :)

idk

just 2 tests counter smart contract

on js mocha spec

https://github.com/ton-defi-org/tonstarter-contracts/blob/main/test/counter.spec.ts

and counter test on func

https://github.com/ton-blockchain/func-contest1-tests/blob/master/tests/tests/tests-1.fc

any js, ruby, python, hardhat, truffle, anchor coder knows how read and write specs without reading documentation

why did you make a dex that support trades only for ton/token pairs?

Good question, it’s the correct first version IMO:

1. Jettons are sharded to multi contracts so Jetton to Jetton swaps create too many messages that become hard to reason about. I believe smart contracts need to be kept simple so people could review and understand them. TON coin is native so you can handle it without extra messages so it simplifies the flow.

2. Liquidity pairs for the benefit of the ecosystem should be encouraged to be paired with TON coin to increase demand for TON coin. It’s much better for us than people doing pairs with USDC for example.

3. Most popular pairs on Uniswap de-facto pair with ETH.

4. You can swap between any two tokens with multi hop. And there’s going to be less price impact if we concentrate liquidity in the main pairs with TON and always go through them.

It wasn’t done out of laziness :)

ahahah

understood, still native-token pairs feels like uniswap v1

The client will support swapping any two tokens, don’t worry. The pairs are an implementation detail of how we split liquidity internally

+ jetton-to-jetton are pretty easy to do

Yea, TON blockchain is very different from Ethereum that runs everything atomically. Less messages is better IMO

i have a different opinion, 9 messages is not such a big number

Hard to understand

Less chance for security vulnerabilities

even if there are more messages the logic is still the same

If I understand well, 9 messages means that the swap would take at least 9 different blocks ?

Yes

no

And you need to explore 9 different pages in a block explorer to understand what happened

Messages are asynchronous, you can’t assume they will be handled in the same block

but i cant assume it will be handled in different block, too

Your code should assume that to avoid vulnerabilities, that’s what I meant

yes it make sense, really

im also totally for the kiss logic

ok so in minimum 1 block and in an unknown max of blocks 👍

Also I think concentrating liquidity will be better for price impact

Max 9 different but you don’t know when

well soon you will be able to test our dex, so feel free to write your opinion

👍👍👍

We can audit each other

9 messages for one swap?

(Sorry)

mandatory for jetton-to-jetton pairs

I have a jetton-to-jetton contract but it uses less than 9 messages

@dariolol how are you doing tests? are you open source?

ts and ton-executor, for now its close source

I hope you will open source before release

What's the easiest way to run a lite client and retrieving basic info from blockchain?

Some great library or smth

If you deploy a "dex" contract manually for each pair with an init method, it could be reduced. If you make something like uniswap and so on, you need more transactions

https://github.com/xssnick/tonutils-go if you like golang

Thx for direction! Is there something on node or python?

Yes, tonweb for example, on js

But i think it uses api to interact with ton

yes it uses https://toncenter.com/api/v2/jsonRPC :(

Haven’t used any of them but maybe:

https://github.com/toncenter/ton-http-api

https://github.com/toncenter/pytonlib

Maybe these will be helpful too:

https://github.com/ton-foundation/ton-api-v4

https://github.com/ton-foundation/ton-lite-client

Everscale code is assume is their weird solidity thing? Or is it FunC?

It uses the same logic as func

The only weird thing they added is await

Well, with await everything is easy 🙃

The problem is the hardencoded value for gas usage by the contract

Thats why a dex shouldn't use native ton, since gas price could change

You should read network config and use that to compute a dynamic value for the gas usage

need to hardencode the value of gas, not the value of TON required to pay for gas

Pytonlib gives me this error on client.init(). Is it a common issue?

Hi, maybe you use old version? Try to pip3 install -U pytonlib

It works great on ubuntu but not on windows. I'm investigating more

One more problem could be in Windows PATH max length. This path seems long enough. Did you extended PATH max length when installing python (there was a checkbox in an installer)?

maybe better use WSL

Or Docker with Ubuntu

I used wsl thx. Temporary solution tho

Btw, it would be good to get some tech details on this issue to solve the problem in the library

I'll open an issue later

Thx a lot!

Hello once again. Did you installed OpenSSL for win64? If not, then could you please try to install it. Here is the instruction: https://github.com/toncenter/ton-http-api#local-run-experimental

A missing library is included in FileNotFound error in windows and it’s the most unclear error which took a lot of time to me😅

Thing is I checked that file directory and the file actually was there. Anyway i'm reinstalling openssl and i'll let you know

The previous time I forgot about this thing. Hope it will work

Note, that the 1.1.1 version is required. With 3.0 it won’t work🙃

Probably that's what happened. Now it works. I probably installed another ver by mistake

Sry for wasting ur time

No problem, glad to help!🙂