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.

Here is one example of how the Kotlin package does so:

https://github.com/andreypfau/ton-kotlin/blob/f0f2e7e05bc46d48fcbf6cef75249eea46890c7a/ton-block/src/commonMain/kotlin/org/ton/block/AddrStd.kt#L108

import org.ton.crypto.base64
import org.ton.crypto.base64url

fun convert(address: String): String {
	val raw = try {
			base64url(address)
	} catch (E: Exception) {
			base64(address)
	}
	return raw;
}

It depends on whether or not a transaction is internal or external.

If a transaction is internal, it depends on the bounce flag. If the address that the internal transaction is directed to is bounceable, then that 10 TON amount minus gas will be returned to the original address. The transaction will still be recoreded in the blockchain.

If a transaction is external, then it depends on the accept call in the code. If the t...

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

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

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
   ...

Easiest way to resolve this is by simply downloading a precompiled binary:

https://github.com/ton-defi-org/ton-binaries

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.

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.
...

A boc is not limited in size, in fact the whole blockchain state is a cell with a bunch of cells wrapped within them. Everything is a cell!

An external message is limited by 64kb, which may limit the size of a boc that you're trying to create with your smart contract logic. You can see this defined in the lite client, but it is subject to change:

https://github.com/ton-blockchain/ton/blob/db3619ed310484fcfa4e3565be8e10458f9f2f5f/validator/impl/external-message.hpp#L40

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...

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

There is a difference between technically possible and realistically possible. As long as you fulfill all of the tech requirements of a validator, then yes you could technically run a validator.

However, a realistic long-term solution requires a proper server and a data-center. Consumer PCs are not designed for such workload and stability. You do not want to pay for downtime with your TON stake.

There is no need for Ethereum-like proxy contracts in TON. Contracts in TON can upgrade its code without changing its address.

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 ...

You can use the raw address: 0:0000000000000000000000000000000000000000000000000000000000000000

Just make sure that you turn off the bounce flag, whose address is: UQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJKZ

I used the TON address converter to help answer this question: https://ton.org/address/

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

The following is copied from the Tonkeeper News, which is relevant to the question at hand:

End-to-end security with TON Connect

Blockchains directly enable people to control their financial assets by using a so-called “non-custodial” or “unhosted” wallet: an application that keeps a cryptographic key securely on your device. This key is used to authorize transfers of coins and tokens, protecting your account from unexpected or fraudulent charges. Your account exists solely on the b...

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...

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

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

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

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

I believe this question was more or less answered in another question by
Vladimir Plotvinov. You can view it here:

https://answers.ton.org/question/1538089852979908608/

For sake of visibility, I'll repost his answer:

You recieve a "-13" exit code. API called lite-server and receive some result it's why you got 200 OK. -13 exit code I would say it means method_id not found on smartcontract (but I can't find this remark in documentation).

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"

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

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...

This is the right track, you do need to check 0. And you are loading in op correctly. But the way that you work with the comment is incorrect.

The characters are coded within UTF-8, so using load_uint will not work as expected, since it expects binary encoding.

Instead, you will have to parse it:

() recv_internal(int balance, int msg_value, cell in_msg_full, slice in_msg_body) {
	int op = in_msg_body~load_uint(32);
	
	if (op == 0) {
		;; load in the first 8 bits b...

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 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
})

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/

You can use send_raw_message(cell msg, int mode) within the smart contract to act as the deletion of the smart contract.

This is because mode 128 will "carry all the remaining balance of the current smart contract instead of the value originally indicated in the message", essentially removing all of the TON from the smart contract. Mode 32 will cause the "current account must be destroyed if its resulting balance is zero", wh...

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.