Newest
Stay updated with the latest posts.
Posts
2069How to recover SUI coins from an old wallet?
I've been trying to locate my SUI coins when setting up a new Slush account, but I don't see them. How can I verify if I'm using the correct phrase to import my old wallet?
- Sui
01
Mastering Move Language Concepts – Course #2
While Course #1 i've made before introduced you to the basics of writing smart contracts in Move and building simple dApps on the Sui blockchain, this course focuses on deepening your understanding of the Move language itself — from its powerful type system to advanced patterns like generics, events, modules, and access control mechanisms. By the end of this course, you’ll be able to: Write modular, reusable, and secure Move code Use generics, abilities, and resource types effectively Implement fine-grained access control using capabilities Emit and listen to events for off-chain integration Work with complex data structures like tables and vectors Understand how Move differs from other smart contract languages like Solidity Let’s dive into the heart of the Move language! Step 1: Understanding Move’s Core Language Features Move is designed with safety and clarity in mind. Let's explore some of the most important features that make Move unique as a smart contract language. 1.1 Resource-Oriented Programming (Revisited) At the core of Move is the concept of resources, which are special types that cannot be copied or deleted unless explicitly allowed. This enforces safe handling of digital assets like tokens or NFTs. module examples::token { use sui::object::{Self, UID}; struct MyToken has key, store { id: UID, value: u64, } public fun mint(ctx: &mut TxContext): MyToken { MyToken { id: object::new(ctx), value: 100, } } } In this example: MyToken is a resource because it has the key ability. It can be stored (store) and uniquely identified by its id. It cannot be duplicated or dropped unless specified. This guarantees that each MyToken instance is uniquely owned and managed, preventing accidental duplication or deletion. 1.2 Abilities System Every type in Move has a set of abilities that define what operations it supports: | Ability | Meaning | |--------|---------| | copy | Can be duplicated | | drop | Can be discarded without destruction | | store | Can be stored in global storage | | key | Can be used as a struct with an ID field (i.e., an object) | Example: struct Example has copy, drop { value: u64 } Understanding these abilities is essential for designing secure and predictable smart contracts. Why Abilities Matter Abilities enforce strict rules at compile time. For instance: A struct with only key and store cannot be copied or dropped. You cannot return a non-droppable struct from a function unless it's stored or transferred. This prevents bugs like double-spending or accidental token loss. 1.3 Generics and Type Parameters Move supports generic types, allowing developers to write flexible and reusable code. module examples::storage { use sui::object::{Self, UID}; struct Box has key { id: UID, content: T, } public fun new_box(ctx: &mut TxContext, content: T): Box { Box { id: object::new(ctx), content, } } } Here, ` is a type parameter, making Box` work with any type while still being safe and efficient. Note: The phantom keyword indicates that T doesn’t affect the runtime representation of the struct — useful for abstract modeling. Step 2: Modular Development and Package Management As your Move projects grow in complexity, organizing your code becomes critical. 2.1 Creating and Publishing Move Packages A Move package contains one or more modules and defines dependencies. It's the unit of deployment and versioning in Move. Directory structure: sources/ place.move user.move Move.toml Define dependencies in Move.toml: [dependencies] Sui = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework" } MyLibrary = { local = "../my-library" } You can publish packages to the Sui network and reuse them across multiple dApps. 2.2 Reusing Existing Modules The Sui Framework provides battle-tested modules like coin, transfer, and tx_context. Always check what’s available before writing custom logic. For example, to transfer an object: use sui::transfer; public entry fun send_place(place: Place, recipient: address) { transfer::public_transfer(place, recipient); } Using standard libraries ensures safer, faster development and better interoperability. Step 3: Events and Off-Chain Communication To build real-world applications, your Move contracts need to communicate with off-chain systems like frontends or indexers. 3.1 Emitting Events Move allows emitting events that can be indexed by external services. use sui::event; struct PlaceCreated has drop { name: String, } public fun emit_place_created(name: String) { event::emit(PlaceCreated { name }); } This event will appear on the blockchain and can be picked up by explorers or indexing tools. 3.2 Listening to Events Use tools like Suiet Explorer, Subsquid, or the Sui JSON-RPC API to listen for emitted events and react accordingly in your application. In JavaScript/TypeScript: import { JsonRpcProvider } from '@mysten/sui.js'; const provider = new JsonRpcProvider('https://fullnode.devnet.sui.io'); const events = await provider.getEvents({ MoveEventType: '0x...::example::PlaceCreated' }); Step 4: Access Control and Security Patterns Security is paramount when dealing with smart contracts. Move provides several tools to implement robust access control. 4.1 Object Ownership Model Sui enforces ownership at the protocol level. Only the owner of an object can mutate or transfer it. public entry fun update_name(sweet_place: &mut SweetPlace, new_name: String) { sweet_place.name = new_name; } Only the current owner can call this function. 4.2 Capabilities Pattern For more granular permissions, use the capability pattern — create special objects that grant limited access to certain functions. struct AdminCap has key { id: UID } public entry fun grant_admin_cap(ctx: &mut TxContext) { let cap = AdminCap { id: object::new(ctx) }; transfer::public_transfer(cap, tx_context::sender(ctx)); } public entry fun restricted_action(_: &AdminCap) { // perform admin action } Now only users who hold the AdminCap can execute restricted_action. This pattern is widely used in DeFi and DAOs to delegate authority securely. Step 5: Working with Complex Data Structures Move supports structured data types that allow developers to model complex logic and relationships. 5.1 Vectors Vectors are used to store ordered collections of items of the same type. let names = vector[String::utf8(b"Alice"), String::utf8(b"Bob")]; They’re useful for storing lists of NFTs, user roles, or dynamic metadata. Example usage: vector::push_back(&mut names, String::utf8(b"Charlie")); 5.2 Tables (via Sui Standard Library) While Move doesn’t natively support maps or hash tables, Sui provides the Table type in its standard library. use sui::table::{Self, Table}; struct Registry has key { id: UID, entries: Table, } public fun add_entry(registry: &mut Registry, key: u64, value: String) { table::add(&mut registry.entries, key, value); } Use tables to manage large datasets efficiently. Step 6: Testing and Debugging Your Contracts Testing ensures your Move code behaves as expected under various conditions. 6.1 Unit Testing in Move Write unit tests directly in your Move modules using the testing framework. #[test] public fun test_create_sweet_place() { let ctx = tx_context::dummy(); create_sweet_place(&mut ctx, String::utf8(b"My House")); } Run tests with: sui move test 6.2 Using Sui Explorer After deploying your contract, use the Sui Explorer to inspect transactions, view object states, and debug issues. Step 7: Real-World Applications of Advanced Move Concepts Now that you understand the core language features, let’s explore how they apply to real-world scenarios. 7.1 NFT Minting Platform Create a platform that allows users to mint NFTs backed by Move resources, leveraging the ownership and resource models. 7.2 DAO Voting System Implement a decentralized autonomous organization (DAO) using Move for voting, proposals, and governance, using events and capabilities for secure actions. 7.3 Token Swaps and AMMs Build a decentralized exchange (DEX) using Move modules to represent liquidity pools and token swaps, using generics and tables for efficient state management.
- Sui
- Architecture
- Move
2
ArticleForSuiJun 30, 2025What Are Dynamic NFTs, and Why Does Sui Excel at Them?
The NFT space is evolving beyond static images and profile pictures (PFPs). The next frontier? Dynamic NFTs (dNFTs)—tokens that can change based on real-world data, user interactions, or on-chain events. While many blockchains support NFTs, Sui Network is uniquely positioned to power the future of dNFTs thanks to its innovative architecture. This article explores: What makes an NFT "dynamic"? Why Sui’s technology is perfect for dNFTs Real-world use cases today The future of interactive digital assets 1. What Are Dynamic NFTs? Unlike traditional NFTs (which are static and immutable), dynamic NFTs can update their: Metadata (e.g., a sports NFT that changes based on game stats) Appearance (e.g., an artwork that evolves over time) Utility (e.g., a loyalty NFT that unlocks new perks) How Do They Work? dNFTs use smart contract logic + external data inputs (oracles, user actions, etc.) to trigger changes. Example: A weather-sensitive NFT artwork that shifts colors based on real-time climate data. A game character NFT that levels up as you play. 2. Why Sui is the Best Blockchain for Dynamic NFTs While Ethereum and Solana also support dNFTs, Sui’s design offers key advantages: On-Chain Storage (No External Dependencies) Most blockchains store NFT metadata off-chain (e.g., IPFS), making dynamic updates clunky. Sui stores everything on-chain, enabling instant, trustless modifications. Move Language: Safe & Flexible Upgrades Ethereum’s Solidity requires complex proxy contracts for upgradable NFTs. Sui’s Move language allows native mutability—no clunky workarounds. Parallel Processing (Massive Scalability) Updating thousands of dNFTs at once? Ethereum struggles with congestion. Sui’s parallel execution handles millions of updates without slowdowns. Object-Centric Model (Granular Control) Each NFT is an independent object with customizable logic. Enables fine-tuned interactivity (e.g., only the owner can trigger changes). 3. Real-World Use Cases of dNFTs on Sui Gaming & Metaverse Evolving in-game items (e.g., a sword NFT that gains abilities with use). Cross-game interoperability (Sui’s objects can move between dApps). Example: Sui-based games like Panzerdogs use dNFTs for customizable avatars. Generative & Reactive Art AI-powered NFTs that shift style based on market trends. Collaborative art where collectors influence the final piece. Example: Art labs like Sui Gallery host dNFT exhibitions. Real-World Asset (RWA) Tracking Deed NFTs that update with property records. Certification badges that expire or renew automatically. Loyalty & Membership Programs Dynamic discount NFTs that improve with customer spending. VIP access passes that unlock new tiers over time. Example: Sui’s retail partners are testing dNFT loyalty programs. 4. The Future of dNFTs on Sui Expect to see: AI-integrated dNFTs (e.g., chatbots living in NFT avatars). DeFi-collateralized dNFTs (value adjusts based on market conditions). Fully on-chain games where every asset is a mutable dNFT. Conclusion: Sui is Building the Future of NFTs While static NFTs dominated 2021-2023, dynamic NFTs will rule the next bull run—and Sui’s tech makes it the ideal platform. With **on-chain storage, Move’s security, and unmatched scalability, Sui is poised to become the home of advanced dNFTs.
- Sui
- Architecture
5
ArticleBenjamin XDV232ForSuiJun 30, 2025Will AI Replace Human Developers in Web3?
The rapid advancement of AI-powered coding tools (like GitHub Copilot, ChatGPT, and Claude) has sparked debate: Will AI eventually replace Web3 developers? While AI is transforming how we build decentralized applications (dApps), the answer isn’t a simple yes or no. This article explores: How AI is already changing Web3 development Limitations of AI in blockchain coding The evolving role of human developers Who will dominate the future of Web3: AI, humans, or both? 1. How AI is Transforming Web3 Development AI is already assisting developers in key ways: Faster Smart Contract Writing Tools like ChatGPT and Warp AI (for Solana) can generate basic smart contract templates in seconds. Example: "Write a Solidity ERC-20 token contract with burn functionality." Automated Auditing & Bug Detection AI-powered tools (Certora, Slither) scan code for vulnerabilities like reentrancy attacks. Reduces $3B+ annual losses from DeFi hacks. Natural Language to Code Developers can describe logic in plain English, and AI converts it into Move (Sui), Solidity (Ethereum), or Rust (Solana). Optimizing Gas Fees & Deployment AI suggests gas-efficient transaction methods. Predicts best times to deploy contracts to avoid network congestion. 2. Why AI Won’t Fully Replace Web3 Developers (Yet) Despite these advances, AI still has critical limitations: Lack of Deep Blockchain Understanding AI can replicate existing code but struggles with novel cryptographic solutions (e.g., zero-knowledge proofs). Often hallucinates incorrect logic in complex smart contracts. No Intuition for Security Risks AI may miss subtle attack vectors that human auditors catch. Example: An AI might not foresee a governance exploit in a DAO. Inability to Innovate Most AI tools remix existing code rather than invent new consensus mechanisms or tokenomics models. True blockchain breakthroughs (like Ethereum’s PoS transition) still require human ingenuity. Legal & Ethical Blind Spots AI can’t navigate regulatory gray areas (e.g., securities laws for token launches). Ethical decisions (e.g., decentralization vs. scalability trade-offs) need human judgment. 3. The Future: AI as a Co-Pilot, Not a Replacement The most likely scenario? AI augments developers but doesn’t replace them. Junior Devs Will Leverage AI Routine tasks (boilerplate contracts, unit tests) will be automated. Entry-level devs must upskill in security and architecture to stay relevant. Senior Devs Will Focus on Innovation Top engineers will design new protocols, optimize L1/L2 systems, and tackle unsolved problems (e.g., MEV resistance). New Roles Will Emerge "AI Smart Contract Trainers" – Fine-tuning models for blockchain-specific tasks. "Hybrid Auditor" – Combining AI tools with manual review. Conclusion: AI is a Tool, Not a Takeover AI will disrupt low-level coding jobs but won’t eliminate the need for skilled Web3 developers. Instead, the industry will shift: Average devs who rely on copy-paste coding risk obsolescence. Elite devs who master AI + deep blockchain expertise will thrive. Final Verdict: Short-term (2024-2026): AI handles 30-50% of boilerplate coding. Long-term (2030+): Humans and AI co-create smarter, safer dApps.
- Sui
- Move
4- Expert Q&A0xduckmove618ForSuiJun 30, 2025
Is the testnet server down?
0|pictor-node | SuiHTTPStatusError: Unexpected status code: 503 0|pictor-node | at SuiHTTPTransport.request (/home/ubuntu/pictor-backend-nodejs/node_modules/@mysten/sui/src/client/http-transport.ts:113:10) 0|pictor-node | at processTicksAndRejections (node:internal/process/task_queues:105:5) 0|pictor-node | at SuiClient.getNormalizedMoveFunction (/home/ubuntu/pictor-backend-nodejs/node_modules/@mysten/sui/src/client/client.ts:397:10) 0|pictor-node | at /home/ubuntu/pictor-backend-nodejs/node_modules/@mysten/sui/src/experimental/transports/json-rpc-resolver.ts:267:17 0|pictor-node | at async Promise.all (index 0) 0|pictor-node | at normalizeInputs (/home/ubuntu/pictor-backend-nodejs/node_modules/@mysten/sui/src/experimental/transports/json-rpc-resolver.ts:264:3) 0|pictor-node | at resolveTransactionData (/home/ubuntu/pictor-backend-nodejs/node_modules/@mysten/sui/src/experimental/transports/json-rpc-resolver.ts:33:3) 0|pictor-node | at /home/ubuntu/pictor-backend-nodejs/node_modules/@mysten/sui/src/transactions/resolve.ts:68:3 0|pictor-node | at /home/ubuntu/pictor-backend-nodejs/node_modules/@mysten/sui/src/transactions/Transaction.ts:764:5 0|pictor-node | at _Transaction.runPlugins_fn (/home/ubuntu/pictor-backend-nodejs/node_modules/@mysten/sui/src/transactions/Transaction.ts:786:3) { 0|pictor-node | status: 503, 0|pictor-node | statusText: 'Service Unavailable' 0|pictor-node | } `
- Sui
- Architecture
11 - Expert Q&ABenjamin XDV232ForSuiJun 30, 2025
What Are Common Security Pitfalls in Sui Move Development?
I’m auditing a Sui Move smart contract and want to avoid critical vulnerabilities. From reviewing past exploits, I’ve seen: access control issues, arithmetic overflows, reentrancy risks, frontrunning, improper object ownership Questions: What are the most critical Sui Move vulnerabilities to watch for? How does Move’s ownership model prevent/differ from traditional reentrancy? Are there Sui-specific attack vectors (e.g., object spoofing)?
- Sui
- Architecture
52Best Answer 
AI’s Impact on Decentralized Applications (dApps)
AI is revolutionizing dApps, enhancing smart contracts, DeFi, and blockchain ecosystems—while raising questions about security and decentralization. Key AI Innovations in dApps Smarter Smart Contracts – AI enables adaptive contracts that optimize fees, detect exploits, and adjust to market conditions (e.g., Fetch.ai). AI-Powered DeFi – Improves risk management, fraud detection, and automated portfolio strategies (e.g., Numerai). Decentralized AI Marketplaces – Blockchain allows transparent, incentivized AI model trading (e.g., Bittensor). AI Oracles – Enhances data accuracy for dApps by validating and processing complex inputs (e.g., DIA). AI-Generated NFTs & Gaming – Creates dynamic NFTs and adaptive in-game experiences (e.g., Alethea AI). Challenges in AI-Powered dApps Centralization Risks Most AI models require massive computational power, often relying on centralized cloud providers (e.g., AWS, Google Cloud). This contradicts blockchain’s decentralization ethos, creating potential single points of failure. Solutions like decentralized compute networks (e.g., Akash, Gensyn) aim to address this but are still in early stages. Regulatory Uncertainty If an AI-driven smart contract makes a faulty decision (e.g., incorrect liquidation in DeFi), who is liable—the developer, the AI model, or the DAO? Governments may impose strict rules on AI-powered financial applications, potentially stifling innovation. Compliance becomes complex when AI operates across multiple jurisdictions. High Costs of On-Chain AI Training and running AI models on-chain is prohibitively expensive due to gas fees and storage limitations. Emerging solutions like zero-knowledge machine learning (zkML) and off-chain AI with on-chain verification could reduce costs. Layer-2 scaling solutions may help, but efficiency remains a challenge. Future Possibilities for AI in dApps Autonomous DAOs Governed by AI AI could replace human voting in DAOs, making decisions based on real-time data analysis. Example: An AI DAO managing a DeFi protocol could auto-adjust interest rates or security parameters without proposals. Self-Optimizing Blockchains AI-driven consensus mechanisms could dynamically adjust block size, fees, or security protocols for efficiency. Networks might "learn" from past attacks (e.g., 51% attacks) to prevent future exploits. AI-Curated DeFi Protocols DeFi platforms could use AI to auto-rebalance liquidity pools, predict crashes, or blacklist malicious actors. Example: An AI-powered lending protocol could adjust collateral requirements in real time based on market volatility.
- Sui
5- Expert Q&AForSuiJun 30, 2025
How to Create a Liquidity Pool in Sui Move?
I'm building a DeFi protocol on Sui and need to implement a basic liquidity pool (like Uniswap-style AMM) in Move. I'm struggling with: Storing LP tokens – How to handle dynamic supply and balances? Deposits/Withdrawals – Ensuring atomic swaps and proper math. Fee mechanism – Where to deduct fees without breaking invariants? Frontrunning protection – Is there a built-in way to handle slippage? What I've tried: Basic two-token pool using Table for balances. Manual LP mint/burn logic. Fixed 0.3% fee on swaps. Issues encountered: "Arithmetic overflow" when calculating liquidity. Reentrancy risks – Can Sui Move prevent this? LP token accuracy – Decimals handling feels hacky. Questions: What’s the correct architecture for a Sui liquidity pool? How to implement safe math for swaps/deposits? Are there Sui-specific optimizations (vs. EVM AMMs)? How to make the pool composable with other DeFi protocols?
- Sui
51Best Answer 
Common Sui Blockchain Errors: Object Locking & Faucet Rate Limits
When developing or testing applications on the Sui blockchain, developers often run into two common issues: Object locking errors during transaction execution Rate-limited faucet requests when trying to obtain test tokens This article explains both problems in detail and provides actionable solutions to help you avoid frustration during development. 1. Error: Objects Reserved for Another Transaction 🔍 What It Means You may encounter an error like this: JsonRpcError: Failed to sign transaction by a quorum of validators because one or more of its objects is reserved for another transaction. This means one or more objects (e.g., gas coins or shared objects) involved in your transaction are currently locked by a previously submitted transaction — even if it hasn’t completed yet. Sui uses optimistic concurrency control, which locks objects until a transaction is finalized or expires (~30–60 seconds). If multiple transactions attempt to use the same object before finalization, they will fail with this error. How to Check If an Object Is Available Use the sui_getObject RPC method to inspect the object status: curl --location --request POST 'https://fullnode.testnet.sui.io:443' \ --header 'Content-Type: application/json' \ --data-raw '{ "jsonrpc": "2.0", "id": 1, "method": "sui_getObject", "params": [""] }' If the response contains "status": "Locked" or "owner": "locked", wait before using the object again. Best Practices to Avoid Object Locking Issues Wait for Finalization Before Submitting New Transactions Use waitForTransaction from the SDK: import { JsonRpcProvider } from '@mysten/sui.js'; const provider = new JsonRpcProvider('https://fullnode.testnet.sui.io:443'); await provider.waitForTransaction(''); Use Multiple Gas Coins To avoid contention, split your gas coin: sui client split-coin --coin-id --amounts Then use a different gas coin for each transaction. Retry with Exponential Backoff When encountering lock errors, retry after increasing delays (e.g., 1s, 2s, 4s). Monitor via Explorer Use Sui Explorer to track the status of the locking transaction by digest. 2. Error: 429 Too Many Requests – Faucet Rate Limiting What It Means When requesting test tokens from the Sui faucet, you may see: API Error: 429 POST /v2/gas - “429 Too Many Requests” This indicates that you’ve exceeded the rate limit — usually due to too many requests from the same IP address or account within a 24-hour window. Solutions Try Alternative Faucets The official faucet (faucet.testnet.sui.io) has strict limits. You can try alternative services: https://faucet.n1stake.com/ https://faucet.sui.io These faucets often have more lenient policies or separate rate limits. Reuse Test Accounts Instead of creating new accounts every time, reuse existing ones to reduce faucet requests. Run a Local Testnet For heavy development/testing, consider running your own local Sui network: sui start --local-rpc-address This gives you full control over gas and avoids external dependencies.
- Sui
- Transaction Processing
5How Does Sui Prevent Smart Contract Hacks?
Smart contract hacks have plagued the blockchain industry, with over $3 billion lost in 2023 alone due to exploits in platforms like Ethereum. Sui Network, designed with security as a priority, introduces several key innovations to minimize these risks. This article explores: 🔒 Sui’s built-in security features 💡 How the Move language prevents common exploits 🛡️ Comparison with Ethereum’s vulnerabilities 🚀 Why Sui could become the safest smart contract platform 1. The Move Programming Language: A Security-First Approach Sui uses Move, a language originally developed for Facebook’s Diem blockchain, designed specifically for secure asset management. Key Security Benefits of Move: No Unchecked External Calls – Prevents reentrancy attacks (like the $60M DAO hack on Ethereum). Strong Typing & Ownership Rules – Eliminates accidental fund loss due to coding errors. Formal Verification Support – Allows mathematical proof of contract correctness. Example: In Ethereum, a simple typo can drain funds. In Move, the compiler rejects unsafe code before deployment. 2. Object-Centric Model: Isolating Vulnerabilities Unlike Ethereum’s shared-state model (where one bug can affect many contracts), Sui’s object-based storage limits exploit propagation: Each asset (coin, NFT, etc.) is a distinct object with strict ownership rules. Contracts can’t arbitrarily modify unrelated data. Impact: Even if a contract is compromised, the damage is contained, unlike Ethereum’s composability risks (e.g., the $325M Wormhole bridge hack). 3. No "Gas Griefing" Attacks On Ethereum, attackers can spam contracts with high-gas transactions to block legitimate users (e.g., Denial-of-Service attacks). Sui’s Solution: Fixed low-cost transactions (no gas auctions). Parallel execution prevents network-wide congestion. 4. On-Chain Security Monitoring Sui’s validators actively monitor for suspicious activity: Transaction pre-checks – Reject obviously malicious requests. Real-time analytics – Flag abnormal behavior (e.g., sudden large withdrawals). 5. Real-World Safety Record (So Far) Sui has had zero major hacks since mainnet launch (2023). Ethereum averages 2-3 major DeFi exploits monthly. Case Study: A Sui-based DEX (Cetus) has processed $1B+ trades without security incidents—unlike Ethereum DEXs, which frequently suffer exploits. 6. Future-Proofing: Formal Verification & Audits Sui encourages: Formal verification – Mathematically proving contracts are bug-free. Multi-audit requirements – Major projects must pass 3+ audits. Conclusion: Is Sui the Most Secure Smart Contract Platform? While no system is 100% hack-proof, Sui’s Move language + object model + parallel execution make it far less vulnerable than Ethereum today. The Bottom Line: For developers – Move reduces human error risks. For users – Lower chance of losing funds to exploits. For institutions – Enterprise-grade security builds trust. **What’s Next? Will Ethereum adopt Move-like features? Can Sui maintain its clean security record as adoption grows?** Share your thoughts below
- Sui
6
- 2565
- 1780
- 701
- 618
- 595
- 496
- 402
- 397
- 369
- 360