Standard token contracts can be found on the main GitHub profile of the TON blockchain. You can generally look for FunC smart contracts on the TON blockchain and TON foundation profiles.

There are also some snippets that users provide, such as the FunC snippets provided by TonoxDeFi on GitHub.

You can use the tonweb-contract component of the TonWeb package.

First, create your contract class:

import {Contract} from 'web3-eth-contract';

export class MyContract extends Contract {
    constructor(provider, options) {
				// insert the bytes of your code here
        options.code = hexToBytes('abcd..');
        super(provider, options);

				// add definitions of the functions of the contract
        this.method.myMethod = ...
    }

    // @override
   ...

There are two parts to this question. The first is ensuring that you don't encounter the "out of gas" error.

You can try to estimate a transaction's gas fee by first calling the http-api's estimateFee endpoint. You can see how TON Center does it on their documentation site. Essentially, you want to provide details about the transaction that you will send to see how much gas the transaction could cost or if it will fail.
...

"MessageAny" is a type that refers to type Message.

https://github.com/ton-blockchain/ton/blob/master/crypto/block/block.tlb#L155

You are likely referring to the tondev tool which has since been renamed to everdev. While both Everscale and TON use the TVM, they are in reality different blockchains that have since gone their separate development paths. You cannot use the tondev or everdev tools to deploy a smart contract to TON.

I recommend using the Blueprint tool at ton-community/Blueprint...

I'm not aware of one from a smart contract perspective, though it could be a very cool idea.

TON Rocket Pay has a few services which might be what you're looking for:
https://pay.ton-rocket.com/api/#/subscriptions

You need an API key to overcome this limitation. The @tonapibot will give you one, as described on the toncenter website.

Once you get to production, it's best to run your own instance.

The code is law, and the law says no. I imagine that this is to ensure that domains are held by people who are "alive".

Here is the code for reference.

    if (op == op::dns_balance_release) { ;; release domain
        throw_unless(414, (now() - last_fill_up_time > one_year) & (cell_null?(auction)));
        int min_price = get_min_price(domain.begin_pars...

It is not possible to use MetaMask when using TON because TON is not an EVM-based blockchain.

Also, when you import a private key or mnemonic into an application like MetaMask or MyTonWallet, you are not necessarily "transferring" to a different wallet. They're all the same account, just being displayed in a different user interface.

Any node in the TON network has its own ADNL address. It's like IP addresses on the Internet; they are public keys for the network to utilize. It's more like personal information.

You can read more here:

https://ton.org/docs/learn/networking/adnl#:~:text=An%20ADNL%20Address%20is%20essentially,intended%20for%20the%20recipient%20address

There are many explorers available for TON. You can see them all here:
https://ton.app/explorers

I personally like Tonscan, because it allows you to view smart contract opcodes. It's used by most developers.

dTon is also nice because it also displays some data about the blockchain overall, if you're looking for macro-level data, similar to the Etherscan counterparts.

Probably not through using the CLI, but you can debug directly within the script using dump_stack:

() dump_stack() impure asm "DUMPSTK";

https://ton.org/docs/develop/func/stdlib/#debug-primitives

Here are two open source wallets:

• TonWhales - iOS/Android
• MyTonWallet - iOS/Android/Chrome

Additionally, the staking contract is open source for you to interface with in any way you desire.

If you mean running your own node, then there are multiple flavors of API:

https://toncenter.com/api/v2/

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

https://tonapi.io/swagger-ui

If you mean something like Ganache for TON, then there's the TON contract executor:

https://github.com/ton-community/ton-contract-executor

Like @<1485940136469336064|Daniil Sedov> mentioned, there is currently no publicly known bridge between TON and Everscale Network. You can track all of the bridges on TON with the following link:

https://ton.app/bridges

The official bridge currently includes bridging between Ethereum and Binance.

I believe the now field will help you. For example:

const buyResult = await buyer.send({
    to: sale.address,
    value: price + toNano('1'),
    sendMode: SendMode.PAY_GAS_SEPARATELY,
		now: 1682370000
})

There are two ways. The first, currently experimental, allows you to run locally. Don't do this for production:

pip install ton-http-api
source ~/.bash_profile
ton-http-api

The second is through Docker:

mkdir private
curl -sL https://ton-blockchain.github.io/global.config.json > private/mainnet.json
curl -sL https://ton-blockchain.github.io/testnet-global.config.json > private/testnet.json
./configure.py
docker-compose build
docker-compose up -d

...

The tl-parser utility can be found here:

https://github.com/vysheng/tl-parser

You'll have to compile and install it, but the bash script should work afterwards.

I believe that other TVM projects use PHP heavily, but TON does not. There are PHP community extensions that are available for you to use, but they are still in development:

https://github.com/olifanton/ton

It will allow you to interact with wallets:

https://github.com/olifanton/ton/blob/main/src/Olifanton/Ton/Contracts/Wallets/V4/WalletV4.php

For example, where variable $kp is the keypair and variable $transport is a structure defined by the SDK that essentially acts as a provid...

The official TON documentation can be found here:
https://ton.org/docs

If you're getting started with TON, a recent tutorial has been made available here:
https://ton-community.github.io/tutorials/01-wallet/

The endpoint on http-api that you're looking for is likely /tryLocateTx:

https://toncenter.com/api/v2/#/transactions/get_try_locate_tx_tryLocateTx_get

https://ton.org/docs/develop/func/stdlib#uncons

uncons works with lists, not regular tuples.

As of version 3.0:

1. Go to the "Settings" menu
2. Rapidly tap the "Version" value at the bottom of the settings. 5 quick taps should open up the Dev Menu.
3. Click "Switch to Testnet"
4. Select "TESTNET"

To a certain degree you can attempt to develop smart contracts on Windows, yes. You can install the TON CLI on Windows with python:

pip install toncli

https://ton.org/docs/develop/smart-contracts/sdk/toncli#windows

Remember that TON is by-and-large a community led project, with much of the infrastructure being decentralized. Unix based systems are nearly the norm in many developer communities. I strongly recommend using WSL (Windows Subsystem for Linux) if you intend ...

The main repository for TON exists on GitHub, and is written in C++:

https://github.com/ton-blockchain/ton/tree/master/crypto/vm

Fift has some documentation on the official site:

• https://ton.org/docs/develop/fift-and-tvm-assembly
• https://ton.org/docs/develop/fift-deep-dive

Refer to TIP-62 and the get_nft_content option which should return the "full" metadata:

https://github.com/ton-blockchain/TIPs/issues/62

As far as I am aware, FunC and the other languages do not have a logo yet. FunC is a very niche language that has a small community of developers, and has yet to adopt true branding.

All branding related to TON can be found on its website:

https://ton.org/en/brand-assets

One way that might be helpful is through an indexer: https://github.com/tonindexer/anton

You could get information by running a query on the indexer like this, which gets information for address EQDYo6otRICNYyM2SAcS1mzTUvm1dsN5LCteE7DjeYfKgA4C:

https://anton.tools/api/v0/accounts?latest=true&interface=nft_item&owner_address=EQDYo6otRICNYyM2SAcS1mzTUvm1dsN5LCteE7DjeYfKgA4C&minter_address=EQAOQdwdw8kGftJCSFgOErM1mBjYPe4DBPq8-AhF6vr9si5N&order=DESC&limit=10

While there isn't anything as robust as the tools that you've described, I do believe that there are a couple of tools that can help you along.

The first is ton-indexer, which doesn't have an official graphical interface yet but can be used for analyzing and querying blockchain data in a way that a typical endpoint cannot.

The next is Blueprint, which can act as your test environment to replay transacti...