Articles

Educational materials & tutorials about Sui

Earn Your Share of 1000 Sui

Gain Reputation Points & Get Rewards for Helping the Sui Community Grow.

Posts

277

D.D N10
Aug 27, 2025
Article
How Sui's unique architecture is designed to solve common blockchain bottlenecks.
If you're exploring how Sui compares to traditional blockchains, you’ll quickly notice that its design focuses on solving performance and scalability issues that older systems struggle with. Most blockchains, like Bitcoin and Ethereum, use an account-based model where transactions are processed one after another. This sequential processing creates bottlenecks, especially when many users interact with the network at the same time. Sui takes a different approach by using an object-based model, which allows it to process multiple transactions in parallel as long as they don’t touch the same object. This means you can build apps that respond faster and scale more easily. You also benefit from Sui’s unique consensus mechanism. Instead of applying consensus to every transaction, Sui only uses it when necessary—specifically for shared objects. For simple transfers or updates to owned objects, the network can finalize transactions instantly. This hybrid model gives you both speed and security, which is ideal if you're building real-time applications like games, marketplaces, or social platforms. Another key difference is how Sui handles smart contracts. While Ethereum uses Solidity, Sui relies on Move, a language designed for secure asset management. Move treats assets as resources that can’t be copied or lost, which helps prevent common bugs and exploits. You’ll find that Move’s strict rules make your code safer and easier to audit, especially when dealing with financial or ownership logic. Sui also improves the user experience by offering predictable gas fees. Instead of fluctuating wildly during high traffic, fees are managed through a market-based system where users bid for execution. This gives you more control over costs and helps your app stay affordable for users. If you're coming from another blockchain ecosystem, you’ll need to adjust to Sui’s object-centric mindset. Instead of thinking in terms of accounts and balances, you’ll work with objects that have unique IDs, owners, and states. This model is more flexible and lets you build complex systems with fine-grained control over behavior and access.
- Sui
- Architecture
0
D.D N10
Aug 27, 2025
Article
How Sui's unique architecture enables high-performance decentralized applications
If you're trying to understand what makes Sui different from other blockchains, you need to look at how it handles scalability and performance. Sui is built to process transactions in parallel, which means it doesn’t have to wait for one transaction to finish before starting another. This is possible because Sui uses an object-based model where each asset or data point is treated as a separate object with its own ownership and state. When two transactions don’t touch the same object, they can be executed at the same time without conflict. This design helps you avoid the bottlenecks that slow down traditional blockchains like Ethereum. You also benefit from Sui’s ability to scale horizontally. Instead of relying on a single chain to handle all activity, Sui spreads the load across multiple validators and uses a consensus mechanism only when necessary. For example, if you’re sending tokens between wallets and those tokens are not shared objects, the transaction can be finalized instantly without going through full consensus. This makes Sui ideal for applications that need fast response times, like games or social platforms. Another advantage you’ll notice is how Sui handles gas fees. Instead of fixed fees or unpredictable spikes, Sui uses a market-based system where users bid for execution. This keeps fees stable and gives you more control over transaction costs. If you’re building an app, this means your users won’t be surprised by sudden fee increases during peak times. When you start developing on Sui, you’ll interact with its object-centric model through the Move programming language. Move is designed to be safe and flexible, and Sui adds features like dynamic fields and object ownership to make it even more powerful. You’ll write modules that define how objects behave, and you’ll deploy them using the Sui CLI or SDK. This gives you full control over your app’s logic and data flow. Here’s a basic example of how you might define a simple token object in Move: module example::Token { struct Token has key { id: UID, value: u64, owner: address, } public fun mint(owner: address, value: u64): Token { Token { id: UID::new(), value, owner, } } public fun transfer(token: &mut Token, new_owner: address) { token.owner = new_owner; } public fun get_value(token: &Token): u64 { token.value } } This module lets you mint a token, transfer it to a new owner, and check its value. You can build on this to create more complex behaviors like staking, burning, or locking tokens.
- Sui
- Architecture
0
D.D N10
Aug 27, 2025
Article
Getting Started with the Sui Blockchain: What You Need to Know
If you're new to Sui, you're stepping into a blockchain ecosystem designed for speed, scalability, and developer flexibility. Sui is a Layer 1 blockchain built by Mysten Labs that uses a unique object-based data model and the Move programming language to power decentralized applications. Unlike traditional blockchains that rely on account-based systems, Sui treats everything as an object, which allows it to process transactions in parallel and scale horizontally. To get started, you need to understand how Sui differs from other blockchains. Most chains like Ethereum process transactions sequentially, which can slow things down and increase fees. Sui avoids this by allowing independent transactions to be executed simultaneously. This is possible because each object in Sui has a unique ID and ownership, so the system can easily determine whether two transactions conflict or not. One of the first challenges you might face is understanding how assets are represented. In Sui, assets are objects with defined properties and behaviors. You don’t just send tokens—you interact with objects that can evolve, be transferred, or modified. This opens up new possibilities for building complex applications like games, marketplaces, and social platforms. Another hurdle is learning the Move language. Move was originally developed for Facebook’s Libra project and is designed to be safe and flexible. Sui extends Move with features like dynamic fields and object ownership, which makes it easier to build secure and modular smart contracts. If you’re coming from Solidity or Rust, you’ll need to adjust to Move’s strict type system and resource-oriented programming model. To start building, you’ll want to install the Sui CLI and connect to a testnet. The CLI lets you create wallets, send transactions, and deploy packages. You’ll also need the Sui SDK, which provides tools for integrating with the blockchain from your app. Once you’ve set up your environment, you can begin writing Move modules and testing them locally. Here’s a simple example of a Move module that defines a basic counter object: module example::Counter { struct Counter has key { value: u64, } public fun create(): Counter { Counter { value: 0 } } public fun increment(counter: &mut Counter) { counter.value = counter.value + 1; } public fun get_value(counter: &Counter): u64 { counter.value } } This module creates a counter object, lets you increment it, and retrieve its value. You can deploy this to Sui and interact with it using the CLI or SDK. As you build, you’ll run into questions about gas fees, validator roles, and transaction finality. Sui uses a unique consensus model that separates simple and complex transactions. Simple transactions that don’t involve shared objects can be finalized almost instantly, while complex ones go through a Byzantine Fault Tolerant (BFT) consensus process. This hybrid approach keeps the network fast and secure. To manage gas fees, Sui uses a market-based system where users bid for execution. This keeps fees predictable and fair, especially during high demand. Validators play a key role in maintaining the network, and you can stake SUI tokens to support them and earn rewards.
- Sui
- Move
0
D’versacy 59
Aug 26, 2025
Article
Wallet Integration and UX Patterns using Sui SDKs 🚀
Are you struggling to integrate wallet connections and design a seamless user experience for signing operations? 🤔 Do you want to learn how to create a user-friendly flow that minimizes errors and rejections? 📊 Look no further! In this article, we'll provide a step-by-step approach to integrate wallet adapters, design user flows, and handle errors gracefully. Choose Wallet Adapter Pattern 🔌 Use established wallet adapters or write a thin adapter layer that normalizes wallet APIs (connect, sign, send). Typical Front-end Flow 📈 Connect wallet and request account(s) 🔗 Show human-readable summary of the transaction (amounts, object moves) 📝 Request signature with signTransactionBlock 🔒 Submit and show pending state + final effects ⏱️ Error & Retry UX 🔄 Provide clear messages for gas/insufficient funds 💸 Offer “retry with increased gas” automatically or with user confirmation 🔁 Allow “simulate” transactions to show estimated costs before asking to sign 🔍 Security Considerations 🔒 Never send raw private keys to backend 🚫 Use signMessage for off-chain proof-of-ownership rather than sending txs unnecessarily 🔑 Best Practices 💡 By following these step-by-step guidelines, you'll be able to: Create a seamless user experience for wallet connections and signing operations Handle errors and rejections gracefully Ensure security and transparency in your application Happy building!
- SDKs and Developer Tools
1
acher1018
Aug 26, 2025
Article
Getting Started with Sui: Your First Smart Contract
When you start building on Sui, the first thing you’ll notice is how different it feels from EVM-based chains like Ethereum. Instead of a global state, Sui works with objects — and these objects can represent tokens, NFTs, accounts, or even entire applications. Your smart contracts are written in Move, a language designed for safety and asset management. Steps: Install Sui CLI and check version: curl -s https://get.sui.io | sh sui --version Create a new Move package: sui move new hello_sui Example contract: module hello_sui::hello { use sui::tx_context; public entry fun say_hello(name: vector, ctx: &mut tx_context::TxContext) { tx_context::log_utf8(ctx, name); } } Build and deploy: sui move build sui client publish --gas-budget 10000 Call function: sui client call --function say_hello --module hello --package --args "Hello Sui!" Pro Tip: Start small, test your publishing pipeline, then build more complex apps.
- Sui
- NFT Ecosystem
- Move
2
acher1018
Aug 26, 2025
Article
Getting Started with Sui: Your First Smart Contract
When you start building on Sui, the first thing you’ll notice is how different it feels from EVM-based chains like Ethereum. Instead of a global state, Sui works with objects — and these objects can represent tokens, NFTs, accounts, or even entire applications. Your smart contracts are written in Move, a language designed for safety and asset management. Steps: Install Sui CLI and check version: curl -s https://get.sui.io | sh sui --version Create a new Move package: sui move new hello_sui Example contract: module hello_sui::hello { use sui::tx_context; public entry fun say_hello(name: vector, ctx: &mut tx_context::TxContext) { tx_context::log_utf8(ctx, name); } } Build and deploy: sui move build sui client publish --gas-budget 10000 Call function: sui client call --function say_hello --module hello --package --args "Hello Sui!" Pro Tip: Start small, test your publishing pipeline, then build more complex apps.
- Sui
- NFT Ecosystem
- Move
2
D’versacy 59
Aug 26, 2025
Article
Debugging & Local Tracing Tools for Sui: A Developer's Toolkit
Are you tired of dealing with non-obvious reverts and cryptic Move panic messages? 😩 Do you want to learn how to debug Move code and transaction behavior quickly? 🔍 Look no further! In this article, we'll provide step-by-step debug strategies and tools to diagnose Move code and runtime execution problems. Reproduce Locally 📍 Start a local devnet and use deterministic test accounts. Use sui move test with verbose flags to see failing test details. Use Move Abort Codes and Custom Error Messages 📝 Add abort with meaningful error codes or use assert with message macros. Map error codes to descriptions in docs for frontends to show user-friendly messages. Instrumentation 🔍 Add event emissions in Move for critical state transitions. Listen for events using provider.getEvents in TypeScript for easy tracing. Transaction Inspection 🔎 Read transaction effects (gas used, mutated objects) after submission. Compare expected mutated object versions with actual ones to find which operation failed. Advanced Tracing 🔝 Use commit-level logs or a debugger that steps into Move execution (if supported). Automate capture of full transaction payload + effects for failing CI tests. Debug Like a Pro 💡 By following these step-by-step debug strategies and using the right tools, you'll be able to: Identify and fix issues quickly Improve your Move code and transaction behavior Provide better user experiences with user-friendly error messages Happy debugging!
- SDKs and Developer Tools
0
Neeola25
Aug 26, 2025
Article
Addressing Network Outages and Downtime in Sui Blockchain
Network outages in blockchain systems like Sui can disrupt transactions, staking, and overall user experience, leading to lost opportunities and frustration. Sui, a Layer-1 blockchain designed for high-speed transactions, has experienced occasional downtime, such as a 2-hour halt in November 2024 due to a bug in transaction scheduling logic. This issue stemmed from software bugs in the consensus or execution layers, common in emerging blockchains pushing for scalability. While Sui boasts 100% uptime in normal operations, these rare events highlight the need for robust monitoring and redundancy. Outages can result from validator coordination failures, software updates, or external attacks, affecting DeFi protocols, NFTs, and dApps. Understanding the root causes—such as Mysticeti consensus glitches or execution bottlenecks—is key to prevention. For users, this means delayed transactions or failed wallet syncs; for developers, it can halt deployments. Step-by-step solution to mitigate and recover from network outages: Monitor Network Status Proactively: Start by subscribing to official Sui channels like the Sui Foundation’s Twitter or Discord for real-time alerts. Use tools like Sui Explorer or third-party monitors (e.g., from Shinami or BlockVision) to check block production rates. If downtime is detected (e.g., no new blocks for >5 minutes), avoid initiating transactions to prevent failures. Diversify Wallet and Node Usage: If you’re a user, switch to multiple wallets like Sui Wallet or Ethos, which often have built-in failover. For developers running nodes, set up a multi-region validator setup using AWS or Google Cloud, ensuring geographic diversity to bypass localized issues. Configure auto-failover scripts in your node software to reroute to healthy validators. Implement Retry Mechanisms in dApps: Developers should build exponential backoff retries in SDK integrations. For example, using the Sui TypeScript SDK, wrap transaction submissions in a try-catch loop with delays (e.g., 1s, 2s, 4s retries). Test this on Testnet to simulate outages. Engage Community and Validators: During an outage, join Sui’s forums or Telegram for community-driven fixes. If staking, redelegate to validators with high uptime (check Nakamoto coefficient, currently 18 for Sui). Post-outage, review validator reports to vote on governance proposals for protocol upgrades. Post-Outage Recovery: Once resolved (Sui outages typically fix in hours, as in the 2024 incident), resubmit failed transactions via wallet resend features. Audit your smart contracts for any state inconsistencies using Sui’s object-centric model to verify ownership. Prevent Future Issues: Contribute to Sui’s open-source repo on GitHub by reporting bugs. Adopt best practices like using Mysticeti’s fast consensus for non-shared objects to reduce execution delays. For long-term, integrate SCION security protocol (live on Testnet since 2024) to guard against routing attacks causing downtime. By following these steps, users can minimize impact, turning outages from crises into manageable events. Sui’s focus on parallel execution and object model reduces outage frequency compared to chains like Solana, but vigilance remains essential.
- Sui
- Transaction Processing
0
Neeola25
Aug 26, 2025
Article
Fixing Wallet Sync Errors and Data Outdated Issues in Sui
Wallet sync errors, like “Sync error (data might be outdated)” or RPC method not found, plague Sui users, especially during high activity or updates. These stem from mismatched chain states, outdated software, or node connection issues, as reported in early 2023. They prevent viewing balances, NFTs, or executing tx, frustrating new adopters. Sui’s object model requires accurate syncing for ownership verification. Step-by-step solution: Update Wallet Software: Enable Developer Mode in Sui Wallet and check for updates. Restart app post-update. Clear Cache and Resync: In wallet settings, clear cache or force resync. Switch RPC endpoints if default fails (use custom like Shinami). Check Network Connection: Ensure stable internet; use VPN if regional blocks. Test on Testnet first. Merge Objects if Needed: Fragmented coins cause sync lags—merge via wallet UI. Switch Wallets: Try alternatives like Ethos or Ledger for comparison. Report and Monitor: If persistent, report on Sui forums. Use explorers for manual checks. Wallet sync errors, like “Sync error (data might be outdated)” or RPC method not found, plague Sui users, especially during high activity or updates. These stem from mismatched chain states, outdated software, or node connection issues, as reported in early 2023. They prevent viewing balances, NFTs, or executing tx, frustrating new adopters. Sui’s object model requires accurate syncing for ownership verification. Step-by-step solution: Update Wallet Software: Enable Developer Mode in Sui Wallet and check for updates. Restart app post-update. Clear Cache and Resync: In wallet settings, clear cache or force resync. Switch RPC endpoints if default fails (use custom like Shinami). Check Network Connection: Ensure stable internet; use VPN if regional blocks. Test on Testnet first. Merge Objects if Needed: Fragmented coins cause sync lags—merge via wallet UI. Switch Wallets: Try alternatives like Ethos or Ledger for comparison. Report and Monitor: If persistent, report on Sui forums. Use explorers for manual checks.
- Sui
- SDKs and Developer Tools
- Security Protocols
0
D’versacy 59
Aug 26, 2025
Article
Mastering Transaction Construction and Signing with the SDK 🚀
Are you tired of dealing with errors when constructing transactions manually? 🤔 Do you want to learn how to build safe, composable transactions that can be executed reliably from your frontend or backend? 💻 Look no further! In this article, we'll dive into the world of transaction building with the SDK and provide you with step-by-step best practices and examples. Understanding Transaction Primitives 📚 Before we begin, let's cover the basics: Single-call transactions: Simple transactions that perform a single operation. Transaction blocks: Composed multiple operations that can be executed together. The Building Pattern 🔨 Here's a step-by-step guide to building transactions: Fetch necessary objects 📦 (e.g., coin, target object). Create transaction block 📝 (use SDK helper or raw payload). Set gas object and budget ⛽️ explicitly. Add signer(s) 👥 and required signatures (for multi-sig scenarios). Simulate locally 🤖 if SDK supports dry-run (to estimate gas). Submit and watch effects 📊. Example Skeleton 💻 Here's a TypeScript pseudo example: const tx = new TransactionBlock(); tx.moveCall({ target: "0x...::module::function", typeArgs: [], arguments: [arg1, arg2] }); tx.setGasBudget(1000); const signed = await wallet.signTransactionBlock({ transactionBlock: tx }); const resp = await provider.executeTransactionBlock({ transactionBlock: signed }); Error Patterns & Fixes 🚨 Don't get caught off guard by these common errors: Object not found: Fetch latest object refs, ensure object hasn’t been moved. Insufficient gas: Bump budget; estimate beforehand. Signature mismatch: Ensure signer account exactly matches object owner. Best Practices 💡 To ensure safe and reliable transactions: Use atomic transaction blocks for multi-step operations to avoid partial states. Always validate returned effects (success/failure, mutated objects). Keep transactions small: Cheaper, easier to reason about. By following these best practices and understanding transaction primitives, you'll be well on your way to building safe, composable transactions with the SDK. Happy building! 🚀 Summary 📝 Understand transaction primitives (single-call transactions and transaction blocks) Follow the building pattern (fetch objects, create transaction block, set gas, add signers, simulate locally, submit and watch effects) Use best practices (atomic transaction blocks, validate returned effects, keep transactions small) With these tips and tricks, you'll be a pro at transaction construction and signing with the SDK in no time!
- SDKs and Developer Tools
0