Intro to Sui

Programmable Transaction Blocks are one of Sui’s most powerful core developer primitives. For conventional blockchains, the fundamental unit of execution is a transaction which is typically simplistic and close to the virtual machine (VM) execution. On Sui, the fundamental unit of execution is elevated to the level of a complex, composable sequence of transactions.

Programmable Transaction Blocks are heterogeneous and can access any public on-chain Move function across all smart contracts. Within a single Programmable Transaction Block, typed outputs from earlier on-chain Move calls can be chained as typed inputs to later on-chain Move calls. These types can be arbitrary Sui objects that carry a rich set of attributes and properties. A single Programmable Transaction Block can extract a Player object from a smart contract wallet, use it to make a move in a Game, then send a Badge object won by the move to a multi-game TrophyCase, all without publishing any new smart contract code. There can be up to 1024 heterogeneous transactions in a single Programmable Transaction Block, making its compositionality nearly unbounded.

Chained transactions in a Programmable Transaction Block execute and fail atomically, meaning they can not be partially processed. This provides a convenient and intuitive programming model, as well as strong guarantees for payment or finance oriented applications.

Programmable Transaction Blocks leverage gas smashing to simplify coin management. Dust coins, remainder amounts of negligible value, are merged at the end of execution before transaction results are returned.

Most blockchain transactions are simple transactions, such as asset transfers, peer-to-peer payments, and minting NFTs. As each simple transaction is independent, they do not need to be completed in any particular order. Rather, they can be processed in parallel.

Sui is designed to optimize for these common, simple transactions. On other blockchains, every transaction, no matter what it is, must enter into a total-ordered list and be verified and processed through global consensus. This typical design can create a bottleneck in the network, reducing the processing speed of individual transactions (latency) and the total number of transactions that can be processed at a time (throughput).

Sui uses an algorithm known as “Byzantine Consistent Broadcast” to reduce the bottleneck and maintain low latency and high throughput. A requestor or proxy can proactively talk to validators to facilitate processing without consensus, resulting in near-instant finality without diminished security. This enables parallel transaction submission and execution on a massive scale.

Complex transactions must be sequenced and go through consensus to be finalized. On Sui, the consensus engine consists of two parts, Narwhal and Tusk. Narwhal is the holding pen for transactions (mempool) that ensures the data is available for processing by the validators. Tusk is the mechanism by which all transactions involving shared objects are ordered.Some assets have shared ownership, meaning multiple accounts must authenticate a transaction that changes data related to the object. These transactions are considered complex and must be validated through consensus.

Sui scales horizontally to meet increased network demand on the network. Validators can add more computing power to increase their performance as needed, and reduce it when not needed. Even with high network traffic, Sui's tokenomics model is designed to keep gas fees low and stable. Validators are incentivized to add this capacity because they earn more gas fees instead of higher fees.

Sui's scalability is not limited to transaction processing. Storage is also low-cost and horizontally scalable. This enables developers to define complex assets with rich attributes that live directly on-chain instead of introducing layers of indirection into off-chain storage to save on gas fees.

Move is the native programming language for Sui. It was designed to incorporate everything a blockchain developer would need to create performant, secure, feature-rich applications.

Move is based on the Move language which was specifically designed to improve upon flaws in other smart contract programming languages. Move addresses two key issues in smart contract design: representation of digital assets and safe operations over them. Move has first-class abstractions of assets and access control that improve both the safety of smart contracts and the productivity of smart contract programmers. Move builds on this achievement and adds language for blockchain-specific concepts such as accounts, transactions, time, and cryptography.