Currently, popular TON wallet applications like TonKeeper and TONHUB do not support adding a passphrase to the mnemonic seed phrase when creating or restoring a wallet.

This means that if you develop a wallet application that allows users to generate a wallet using a mnemonic seed phrase and an additional passphrase, users may not be able to restore their wallets in TonKeeper or TONHUB directly.

However, you can still create your wallet application with the seed + passphrase featur...

In order to ensure that the first transaction has been processed and the wallet has received the TON coins before attempting to send the jetton, you should wait for a confirmation of the first transaction.

The amount of time it takes for a transaction to be confirmed can vary depending on factors such as network congestion and transaction fees. Generally, you should wait for at least one confirmation, which typically takes around 1-2 minutes on the TON network.

When sending the TON ...

In FunC world, you can type this to get the result:

var e = 123;
e~dump();

Using the **'getTransactions' **method would be a recommended approach for checking if a specific message was received by a particular address.

The TON JS Examples repository on Github offers helpful resources, including a JavaScript code snippet that can be used to retrieve a list of transactions for a specific address.

The code example can be found at
https://github.com/toncenter/examples
https://gist.github.com/slavafomin/1bcb401b5dc336bb4f9a2005b1660cbd.

The short answer is no. EVM and TVM are fundamentally different, so it's not possible to directly transfer your Solidity code to TVM. However, it's possible that in the future, tools will be developed to enable the compilation of ABI bytecode to TL-B based on TVM.

For more information on the basic concepts and a comparison of the two blockchains, you can find additional details here: https://blog.ton.org/six-unique-aspects-of-ton-blockchain-that-will-surprise-solidity-developers.

For a ...

It seems that the Jetton contracts are functioning correctly on TonWeb, so the issue is likely due to an error in the code deployed by the person asking the question.

Perhaps they made a mistake during the deployment process, or there could be an issue with their code. To resolve the problem, it's recommended that they carefully review their code and study the official Jetton contracts on TonWeb to identify any differences.

Through a thorough debugging process, they can identify the...

For the short answer, yes. Smart contracts are written in FunC, then compiled into Fift, and deployed on the blockchain. They can later be interacted with using either Fift or a wrapper SDK.

On the other hand, there are always 4 arguments on stack when recv_internal is called.

By declaring recv_internal with less than 4 arguments you force FunC to ignore most deep variables (they still will be there, but your code will be unaware for the whole TVM execution).

here are the ...

The error message suggests that there is an issue with the transaction id hash size. The hash being used in the request might not be the expected size, causing the server to respond with an error.

One possible solution is to encode the parameters in the request, including the transaction hash, to ensure that the values are being properly passed to the server.

Additionally, double-checking the length and format of the transaction hash could also help to identify any issues.

...

subwallet_id is not the same as workchain_id in the TON network.

Instead, subwallet_id is a property of a contract that enables the creation of multiple wallets using the same key pair. The primary purpose of subwallet_ids is to allow for the creation of multiple wallets with a single key pair.

To clarify further, subwallet_id is a concept that is specific to the TON network and is used within a contract to create multiple wallets. By using subwallet_id, the contract can differenti...

Great question. The short answer is no.

Because each NFT owner is locally recorded, it means you need to send a transaction to each NFT.

But luckily, you can still use a series of CLI commands to send multiple transactions to reset each NFT's owner.

Be aware that the difference between EVM and TVM is that the TON network supports sharding your contract in a scalable way. If you launch a collection with a maximum of 10,000 in circulation, then you will have 10,001 contracts: one ...

Good question. Essentially, you cannot do that if you're using another data source to store the metadata outside the TON Blockchain. This is because the metadata, which includes the content of each NFT, can be easily manipulated by the project team.

This repository (https://github.com/disintar/DTN/blob/main/notes/onchain-reveal.md) presents an alternative way to implement an on-chain method for revealing the NFT content, which is more transparent and fair.

You can also refer to the NFT ...

You can using something like:

const a = "Ef8zMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzM0vF"a

You need to create a function which returns a splice. Something like this

slice fun_name() asm “x{0055bb} PUSHSLICE”

and then execute a function when you need a slice:

.store_slice(fun_name())

For more information, can check here
https://ton.org/docs/develop/func/literals_identifiers

Hi, so if you like, I highly recommend you using the NFT repo here that using Tact language for the NFT!

• It's more easy to learn.
• There is as simply as just pull the repo and run yarn to install library the deploy the contract.

https://github.com/howardpen9/nft-standard-template, enjoy!

It looks like the initial transaction requested through /getTransactions is not in the masterchain (workchain=-1). You can try using /getBlockTransactions to look for the transaction in the basechain (workchain=0).

First, use /lookupBlock to find the block number corresponding to the transaction's Unix time, and then use /getBlockTransactions to search for the transaction in the block with the corresponding sequence number in each shard.

In the specific case mentioned, the tran...

There is no one-size-fits-all answer to these questions, as the best approach may vary depending on the specific requirements and constraints of the dApp you are building. However, there are some general guidelines and best practices that can be followed when developing a dApp on TON.

One resource that may be helpful is a series of tutorials that provide step-by-step instructions for deploying contracts and writing FunC code. You can find these tutorials at https://ton-community.github.io/...

Theoretically, the TON blockchain can process over 15,000+ transactions per second and more, thanks to its high transaction throughput design and potential to scale to millions of transactions per second through multi-chain support for scalability.

The TON network enables sharding based on the ChainID naturally, with a large number of workchains available for use, as described in the Parameters that validators are running. You can check the following link for more details: https://to...

The addresses listed in the two sources are different because they are encoded differently. However, they are essentially the same address. To convert the address to a "canonical" non-user-friendly form, you can use the following code in JavaScript:

new TonWeb.Address('kf-kkdY_B7p-77TLn2hUhM6QidWrrsl8FYWCIvBMpZKprBtN').toString(false);

This will convert the address to the canonical form -1:a491d63f07ba7eefb4cb9f685484ce9089d5abaec97c15858222f04ca592a9ac,
which is...

Unfortunately, no.

But the best way for me is to open more Telegram accounts and call the bot from each account.

In TVM, memory limitations exist but may not be as strict as in the EVM. This is because the TVM is designed to be more efficient and flexible in terms of resource management. However, developers should still be mindful of resource usage when creating smart contracts for the Free TON platform.

Some considerations for memory usage in TVM:

Memory management: The TVM uses a more sophisticated memory model than the EVM, allowing for more efficient memory management. However, this doesn't me...

Yes, you can use many SDK/open source project shared with related way to acheive that.

• https://github.com/ton-foundation/ton-x
  This lib can give you a connect via qr code option support with tonhub mobile wallet

• More recently, TON community just launched the TON Connect 2.0, you can connect more better UX and working with the real-time performance of it.

Nonetheless, you can find the example with github online p...

Yes, you can.

Getgems.io shares a series of NFT contracts for fixed-sale, auction sale, and others, written in FunC code.

https://github.com/getgems-io/nft-contracts/tree/main/packages/contracts/sources

Good question! Professionals in the industry often discuss wallets in the context of BIP32 (also known as Bitcoin Improvement Proposal), which underlies the process of how wallets are generated from mnemonics.

To put it simply, you can refer to this TypeScript file to understand how we can generate a wallet address:

https://github.com/toncenter/tonweb-mnemonic/blob/master/src/functions/mnemonic-to-seed.ts

As you can see, pbkdf2Sha512 appears to be a combination of PBKDF2 (Passwor...

addr, is alias for 256u,: write 256uint.

Meanwhile full address serialization also include address format tag, workchain, 256bit part ans some additional fields.

Addr, consume from stack two elements: workchain and hash-part and handle this.

All account IDs have 256-bit address in the MasterChain and BaseChain (basic workchain).

Nowadays, only the Masterchain (workchain_id=-1) and occasionally the basic workchain (workchain_id=0) are running in the TON Blockchain.
...

To activate your wallet on the TON network, you will need to follow the activation process specific to the wallet you are using. The exact steps may vary depending on the wallet and the version of the TON network you are using.

It's worth noting that most wallets on the TON network, such as TonKeeper and TonHub, are now using the Wallet V4 smart contract. This is a new and updated version of the smart con...

To connect MyLocalTon using TonWeb, you'll need to follow these steps:

1. Install your own instance of TonCenter by following the instructions in the TonCenter GitHub repository: https://github.com/toncenter/ton-http-api#building-and-running

2. Configure your TonCenter instance to use your local TON network configuration, so it can connect to your LiteServer (LS). You can find the configuration instructions here: https://github.com/toncenter/ton-http-api#Configuration

3. Finally,...

Generally speaking, TON Storage is offline and its cost depends on the provider. On the other hand, for TON Cell, you should check the TON Storage fee.

It's important to note that TON Storage only ensures that storage providers don't receive payment if they don't store the file, but it doesn't guarantee that files are actually stored. TON Storage is more about availability than actual storage.

**As for the cost of storing data on TON, saving 1 MB of data for one year will cost approxima...

I would suggest using the JavaScript library for this: https://github.com/toncenter/tonweb.

For TON JS examples, please refer to https://github.com/toncenter/examples.

Alternatively, you could try using this Python library: https://github.com/kdimentionaltree/tApi. It is a part of TonCenter for single liteserver, and an example can be found in sandbox.ipynb.

Yes, any randomly generated 256 bits can be used as a seed to generate an Ed25519 private key. One possible method for generating a private key from such a seed is by using a cryptographic hash function such as SHA256.

The inflation rate for TON is not fixed and may vary depending on various factors such as network activity and the number of validators.

According to the TON whitepaper, the initial inflation rate was set at 0.6% per year, which is distributed among the validators as a reward for validating transactions and maintaining the network.

However, it's important to note that the inflation rate for TON may not be directly tied to the circulating supply or the initialized account balances. Ins...

Yes, it is possible to write your code directly in Fift to make it more cost-effective in terms of gas consumption. The reason is that Fift is a lower-level language than FunC, which means that it provides more fine-grained control over the code and allows for more efficient programming.

However, writing code directly in Fift requires more expertise and effort, as Fift is a stack-based language and has a steeper learning curve than FunC. Therefore, it may not be worth the effort for simple...