Consider I have a highload wallet smart contract deployed to the TON network and I send an external message to it in order to deliver 100 value transfers to different accounts in the network by using a [send_raw_message](https://www.tonspace.co/develop/func/stdlib#send_raw_message) function (like a crypto exchange scenario). The contract is using a **seqno** mechanism in order to prevent double processing of the same external message. So, if after sending the transaction I observe that contract's **seqno** has increased by one, can I be sure that all 100 transfers were also successfully completed or will be guaranteedly completed in the near future (next or so block)? Of course I'm the only one who can send external messages to the contract. Or do I need to actually confirm delivery of each of the 100 transfers to their destination wallets? According to the [TON white paper](https://ton-blockchain.github.io/docs/ton.pdf) (section **2.4. Messages Between Shardchains**) TON should ensure exactly-once delivery. However, I'm interested if this actually works in practice.

Consider I have a highload wallet smart contract deployed to the TON network and I send an external message to it in order to deliver 100 value transfers to different accounts in the network by using a [send_raw_message](https://www.tonspace.co/develop/func/stdlib#send_raw_message) function (crypto exchange scenario). The contract is using a **seqno** mechanism in order to prevent double processing of the same external message. So, if after sending the transaction I observe that contract's **seqno** has increased by one, can I be sure that all 100 transfers were also successfully completed or will be guaranteedly completed in the near future (next or so block)? Of course I'm the only one who can send external messages to the contract. Or do I need to actually confirm delivery of each of the 100 transfers to their destination wallets? According to the [TON white paper](https://ton-blockchain.github.io/docs/ton.pdf) (section **2.4. Messages Between Shardchains**) TON should ensure exactly-once delivery. However, I'm interested if this actually works in practice.

Consider I have a highload wallet smart contract deployed to the TON network and I send an external message to it in order to deliver 100 value transfers to different accounts in the network by using a [send_raw_message](https://ton.org/docs/#/func/stdlib?id=send_raw_message) function (crypto exchange scenario). The contract is using a **seqno** mechanism in order to prevent double processing of the same external message. So, if after sending the transaction I observe that contract's **seqno** has increased by one, can I be sure that all 100 transfers were also successfully completed or will be guaranteedly completed in the near future (next or so block)? Of course I'm the only one who can send external messages to the contract. Or do I need to actually confirm delivery of each of the 100 transfers to their destination wallets? According to the [TON white paper](https://ton-blockchain.github.io/docs/ton.pdf) (section **2.4. Messages Between Shardchains**) TON should ensure exactly-once delivery. However, I'm interested if this actually works in practice.

Consider I have a highload wallet smart contract deployed to the TON network and I send an external message to it in order to deliver 100 value transfers to different accounts in the network by using a [send_raw_message](https://ton.org/docs/#/func/stdlib?id=send_raw_message) function (crypto exchange scenario). The contract is using a **seqno** mechanism in order to prevent double processing of the same external message. So, if after sending the transaction I observe that contract's **seqno** has increased by one, can I be sure that all 100 transfers were also successfully completed or will be guaranteedly completed in the near future (next or so block)? Of course I'm the only one who can send external messages to the contract. According to the [TON white paper](https://ton-blockchain.github.io/docs/ton.pdf) (section **2.4. Messages Between Shardchains**) TON should ensure exactly-once delivery. However, I'm interested if this actually works in practice.

Consider I have a highload wallet smart contract deployed to the TON network and I send an external message to it in order to deliver 100 value transfers to different accounts in the network by using a [send_raw_message](https://ton.org/docs/#/func/stdlib?id=send_raw_message) function (crypto exchange scenario). The contract is using a **seqno** mechanism in order to prevent double processing of the same external message. So, if after sending the transaction I observe that contract's **seqno** has increased by one, can I be sure that all 100 transfers were also successfully completed or will be guaranteedly completed in the near future (next or so block)? Of course I'm the only one who can send external messages to the contract. According to the TON white paper (section **2.4. Messages Between Shardchains**) TON should ensure exactly-once delivery. However, I'm interested if this actually works in practice.

Consider I have a highload wallet smart contract deployed to the TON network and I send an external message to it in order to deliver 100 value transfers to different accounts in the network by using a [send_raw_message](https://ton.org/docs/#/func/stdlib?id=send_raw_message) function (crypto exchange scenario). The contract is using a **seqno** mechanism in order to prevent double processing of the same external message. So, if after sending the transaction I observe that contract's **seqno** has increased by one, can I be sure that all 100 transfers were also successfully completed or will be guaranteedly completed in the near future (next or so block)? According to the TON white paper (section **2.4. Messages Between Shardchains**) TON should ensure exactly-once delivery. However, I'm interested if this actually works in practice.